From 4454d892c641fca16fd1a16a99743cfc2c4f4987 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 11 Nov 2024 17:13:24 -0400 Subject: [PATCH 01/71] Update packages --- Cargo.toml | 6 +++--- libil2cpp/Cargo.toml | 6 ++++-- proc_macros/Cargo.toml | 4 ++-- proc_macros/src/hook.rs | 6 +++--- proc_macros/src/lib.rs | 4 ++-- rust-toolchain => rust-toolchain.toml | 0 6 files changed, 14 insertions(+), 12 deletions(-) rename rust-toolchain => rust-toolchain.toml (100%) diff --git a/Cargo.toml b/Cargo.toml index de78e2a6..04f36b1d 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 = [ diff --git a/libil2cpp/Cargo.toml b/libil2cpp/Cargo.toml index cf112a60..8f93c8a9 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,6 +24,8 @@ optional = true [features] default = [] +unity2022 = [] +unity2021 = [] unity2019 = [] unity2018 = [] cache = [] 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 From 19925a8d2911a76890f58f7ab2aeed4766ed2f46 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 11 Nov 2024 17:13:54 -0400 Subject: [PATCH 02/71] Generate types for Unity 2022, parameters are broken --- .vscode/settings.json | 2 +- libil2cpp/.gitignore | 3 + libil2cpp/generate_bindings.ps1 | 4 + libil2cpp/qpm.json | 27 + libil2cpp/qpm.shared.json | 47 + libil2cpp/src/class.rs | 2 + libil2cpp/src/lib.rs | 2 +- libil2cpp/src/method_info.rs | 2 + libil2cpp/src/raw/mod.rs | 2 + libil2cpp/src/raw/types_2022.rs | 8365 +++++++++++++++++++++++++++++++ libil2cpp/src/ty.rs | 15 + libil2cpp/wrapper.h | 7 + 12 files changed, 8476 insertions(+), 2 deletions(-) create mode 100644 libil2cpp/.gitignore create mode 100644 libil2cpp/generate_bindings.ps1 create mode 100644 libil2cpp/qpm.json create mode 100644 libil2cpp/qpm.shared.json create mode 100644 libil2cpp/src/raw/types_2022.rs create mode 100644 libil2cpp/wrapper.h diff --git a/.vscode/settings.json b/.vscode/settings.json index 639f597b..9769dd7f 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,6 +1,6 @@ { "rust-analyzer.cargo.features": [ - "unity2019", + "unity2022", "serde" ], "rust-analyzer.imports.granularity.group": "module" 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/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..323ac4a1 100644 --- a/libil2cpp/src/class.rs +++ b/libil2cpp/src/class.rs @@ -8,6 +8,8 @@ use crate::{ Return, Returned, ThisParameter, Type, WrapRaw, }; +#[cfg(feature = "unity2022")] +type FieldInfoSlice<'a> = &'a [FieldInfo]; #[cfg(feature = "unity2019")] type FieldInfoSlice<'a> = &'a [FieldInfo]; #[cfg(feature = "unity2018")] diff --git a/libil2cpp/src/lib.rs b/libil2cpp/src/lib.rs index 38ca659a..135265a4 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 = "unity2022", feature = "unity2019", feature = "unity2018")))] compile_error!("No Unity version selected"); #[cfg(feature = "trace")] diff --git a/libil2cpp/src/method_info.rs b/libil2cpp/src/method_info.rs index 0fda69b3..5a7d5fe2 100644 --- a/libil2cpp/src/method_info.rs +++ b/libil2cpp/src/method_info.rs @@ -10,6 +10,8 @@ use crate::{ Returned, ThisArgument, WrapRaw, }; +#[cfg(feature = "unity2022")] +type ParameterInfoSlice<'a> = &'a [ParameterInfo]; #[cfg(feature = "unity2019")] type ParameterInfoSlice<'a> = &'a [ParameterInfo]; #[cfg(feature = "unity2018")] diff --git a/libil2cpp/src/raw/mod.rs b/libil2cpp/src/raw/mod.rs index a9271a03..f905479a 100644 --- a/libil2cpp/src/raw/mod.rs +++ b/libil2cpp/src/raw/mod.rs @@ -5,6 +5,8 @@ mod functions; +#[cfg_attr(feature = "unity2022", path = "types_2022.rs")] +#[cfg_attr(feature = "unity2021", path = "types_2021.rs")] #[cfg_attr(feature = "unity2019", path = "types_2019.rs")] #[cfg_attr(feature = "unity2018", path = "types_2018.rs")] mod types; diff --git a/libil2cpp/src/raw/types_2022.rs b/libil2cpp/src/raw/types_2022.rs new file mode 100644 index 00000000..16865503 --- /dev/null +++ b/libil2cpp/src/raw/types_2022.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..5ba0982c 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 = "unity2019", feature = "unity2018"))] fn eq(&self, other: &Self) -> bool { unsafe { self.raw().data.klassIndex == other.raw().data.klassIndex } } + + #[cfg(feature = "unity2022")] + fn eq(&self, other: &Self) -> bool { + unsafe { self.raw().data.__klassIndex == other.raw().data.__klassIndex } + } } impl Eq for Il2CppType {} @@ -78,8 +84,14 @@ 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 = "unity2022", repr(i32))] #[cfg_attr(feature = "unity2019", repr(u32))] #[cfg_attr(feature = "unity2018", repr(i32))] pub enum Builtin { @@ -93,6 +105,9 @@ macro_rules! builtins { #[doc = "Whether the type represents the given [`Builtin`]"] #[inline] pub fn is_builtin(&self, builtin: Builtin) -> bool { + #[cfg(feature = "unity2022")] + { self.raw().type_() == builtin as i32 } + #[cfg(feature = "unity2019")] { self.raw().type_() == builtin as u32 } 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" From 07ca2771499162dd49df5bbed9caf3f842595dfa Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 11 Nov 2024 18:02:01 -0400 Subject: [PATCH 03/71] Make ParameterInfo wrap Il2CppType --- libil2cpp/src/lib.rs | 3 +++ libil2cpp/src/parameter_info_stub.rs | 36 ++++++++++++++++++++++++++++ 2 files changed, 39 insertions(+) create mode 100644 libil2cpp/src/parameter_info_stub.rs diff --git a/libil2cpp/src/lib.rs b/libil2cpp/src/lib.rs index 135265a4..6a19a849 100644 --- a/libil2cpp/src/lib.rs +++ b/libil2cpp/src/lib.rs @@ -96,6 +96,9 @@ mod exception; mod field_info; mod method_info; mod object; + +#[cfg_attr(any(feature = "unity2018", feature = "unity2019"), path = "parameter_info.rs")] +#[cfg_attr(any(feature = "unity2022"), path = "parameter_info_stub.rs")] mod parameter_info; pub mod raw; mod string; diff --git a/libil2cpp/src/parameter_info_stub.rs b/libil2cpp/src/parameter_info_stub.rs new file mode 100644 index 00000000..8eac785e --- /dev/null +++ b/libil2cpp/src/parameter_info_stub.rs @@ -0,0 +1,36 @@ +use std::borrow::Cow; +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; +} From 5ddc8e89c74a9393be5afa99f45af131ef750b84 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 11 Nov 2024 18:02:12 -0400 Subject: [PATCH 04/71] Update detour to retour fork --- inline_hook/Cargo.toml | 2 +- inline_hook/src/detour.rs | 8 +++++++- inline_hook/src/lib.rs | 1 - 3 files changed, 8 insertions(+), 3 deletions(-) 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, From 168aafca8fd92647f37129a8012d7db746fafc78 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 11 Nov 2024 18:14:22 -0400 Subject: [PATCH 05/71] Rename Unity 2022, 2021, 2019 to ilc2pp_v31, 29, 24 respectively --- .vscode/settings.json | 2 +- Cargo.toml | 2 +- libil2cpp/Cargo.toml | 6 +- libil2cpp/src/class.rs | 4 +- libil2cpp/src/lib.rs | 6 +- libil2cpp/src/method_info.rs | 4 +- libil2cpp/src/raw/mod.rs | 6 +- libil2cpp/src/raw/types_2018.rs | 19721 ---------------- .../src/raw/{types_2019.rs => types_v24.rs} | 0 .../src/raw/{types_2022.rs => types_v31.rs} | 0 libil2cpp/src/ty.rs | 12 +- 11 files changed, 21 insertions(+), 19742 deletions(-) rename libil2cpp/src/raw/{types_2019.rs => types_v24.rs} (100%) rename libil2cpp/src/raw/{types_2022.rs => types_v31.rs} (100%) diff --git a/.vscode/settings.json b/.vscode/settings.json index 9769dd7f..1475a492 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,6 +1,6 @@ { "rust-analyzer.cargo.features": [ - "unity2022", + "il2cpp_v24", "serde" ], "rust-analyzer.imports.granularity.group": "module" diff --git a/Cargo.toml b/Cargo.toml index 04f36b1d..bedd7943 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -34,7 +34,7 @@ tracing-subscriber = { version = "0.3", features = [ [features] default = ["util", "cache"] -unity2019 = ["libil2cpp/unity2019"] +il2cpp_v24 = ["libil2cpp/il2cpp_v24"] unity2018 = ["libil2cpp/unity2018"] util = ["tracing", "tracing-error", "tracing-subscriber", "paranoid-android"] cache = ["libil2cpp/cache"] diff --git a/libil2cpp/Cargo.toml b/libil2cpp/Cargo.toml index 8f93c8a9..c26a34af 100644 --- a/libil2cpp/Cargo.toml +++ b/libil2cpp/Cargo.toml @@ -24,9 +24,9 @@ optional = true [features] default = [] -unity2022 = [] -unity2021 = [] -unity2019 = [] +il2cpp_v31 = [] +il2cpp_v29 = [] +il2cpp_v24 = [] unity2018 = [] cache = [] trace = ["tracing"] diff --git a/libil2cpp/src/class.rs b/libil2cpp/src/class.rs index 323ac4a1..d9726f3a 100644 --- a/libil2cpp/src/class.rs +++ b/libil2cpp/src/class.rs @@ -8,9 +8,9 @@ use crate::{ Return, Returned, ThisParameter, Type, WrapRaw, }; -#[cfg(feature = "unity2022")] +#[cfg(feature = "il2cpp_v31")] type FieldInfoSlice<'a> = &'a [FieldInfo]; -#[cfg(feature = "unity2019")] +#[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 6a19a849..13271ab0 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 = "unity2022", feature = "unity2019", feature = "unity2018")))] +#[cfg(not(any(feature = "il2cpp_v31", feature = "il2cpp_v24", feature = "unity2018")))] compile_error!("No Unity version selected"); #[cfg(feature = "trace")] @@ -97,8 +97,8 @@ mod field_info; mod method_info; mod object; -#[cfg_attr(any(feature = "unity2018", feature = "unity2019"), path = "parameter_info.rs")] -#[cfg_attr(any(feature = "unity2022"), path = "parameter_info_stub.rs")] +#[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; diff --git a/libil2cpp/src/method_info.rs b/libil2cpp/src/method_info.rs index 5a7d5fe2..f9d1f090 100644 --- a/libil2cpp/src/method_info.rs +++ b/libil2cpp/src/method_info.rs @@ -10,9 +10,9 @@ use crate::{ Returned, ThisArgument, WrapRaw, }; -#[cfg(feature = "unity2022")] +#[cfg(feature = "il2cpp_v31")] type ParameterInfoSlice<'a> = &'a [ParameterInfo]; -#[cfg(feature = "unity2019")] +#[cfg(feature = "il2cpp_v24")] type ParameterInfoSlice<'a> = &'a [ParameterInfo]; #[cfg(feature = "unity2018")] type ParameterInfoSlice<'a> = &'a [&'static ParameterInfo]; diff --git a/libil2cpp/src/raw/mod.rs b/libil2cpp/src/raw/mod.rs index f905479a..854f6be8 100644 --- a/libil2cpp/src/raw/mod.rs +++ b/libil2cpp/src/raw/mod.rs @@ -5,9 +5,9 @@ mod functions; -#[cfg_attr(feature = "unity2022", path = "types_2022.rs")] -#[cfg_attr(feature = "unity2021", path = "types_2021.rs")] -#[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_2018.rs b/libil2cpp/src/raw/types_2018.rs index 93c20520..e69de29b 100644 --- a/libil2cpp/src/raw/types_2018.rs +++ b/libil2cpp/src/raw/types_2018.rs @@ -1,19721 +0,0 @@ -#![allow(warnings)] -/* automatically generated by rust-bindgen */ - -#[repr(C)] -#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] -pub struct __BindgenBitfieldUnit { - storage: Storage, - align: [Align; 0], -} -impl __BindgenBitfieldUnit { - #[inline] - pub const fn new(storage: Storage) -> Self { - Self { storage, align: [] } - } -} -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); - } - } -} -#[repr(C)] -#[derive(Default)] -pub struct __IncompleteArrayField(::std::marker::PhantomData, [T; 0]); -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] { - ::std::slice::from_raw_parts(self.as_ptr(), len) - } - #[inline] - pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { - ::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") - } -} -pub const NET_4_0: u32 = 1; -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 _HAS_CXX17: u32 = 0; -pub const _HAS_CXX20: u32 = 0; -pub const _HAS_NODISCARD: u32 = 0; -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 _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE: u32 = 1; -pub const _CRT_BUILD_DESKTOP_APP: 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 _MAX_ITOSTR_BASE16_COUNT: u32 = 9; -pub const _MAX_ITOSTR_BASE10_COUNT: u32 = 12; -pub const _MAX_ITOSTR_BASE8_COUNT: u32 = 12; -pub const _MAX_ITOSTR_BASE2_COUNT: u32 = 33; -pub const _MAX_LTOSTR_BASE16_COUNT: u32 = 9; -pub const _MAX_LTOSTR_BASE10_COUNT: u32 = 12; -pub const _MAX_LTOSTR_BASE8_COUNT: u32 = 12; -pub const _MAX_LTOSTR_BASE2_COUNT: u32 = 33; -pub const _MAX_ULTOSTR_BASE16_COUNT: u32 = 9; -pub const _MAX_ULTOSTR_BASE10_COUNT: u32 = 11; -pub const _MAX_ULTOSTR_BASE8_COUNT: u32 = 12; -pub const _MAX_ULTOSTR_BASE2_COUNT: u32 = 33; -pub const _MAX_I64TOSTR_BASE16_COUNT: u32 = 17; -pub const _MAX_I64TOSTR_BASE10_COUNT: u32 = 21; -pub const _MAX_I64TOSTR_BASE8_COUNT: u32 = 23; -pub const _MAX_I64TOSTR_BASE2_COUNT: u32 = 65; -pub const _MAX_U64TOSTR_BASE16_COUNT: u32 = 17; -pub const _MAX_U64TOSTR_BASE10_COUNT: u32 = 21; -pub const _MAX_U64TOSTR_BASE8_COUNT: u32 = 23; -pub const _MAX_U64TOSTR_BASE2_COUNT: u32 = 65; -pub const CHAR_BIT: u32 = 8; -pub const SCHAR_MIN: i32 = -128; -pub const SCHAR_MAX: u32 = 127; -pub const UCHAR_MAX: u32 = 255; -pub const CHAR_MIN: i32 = -128; -pub const CHAR_MAX: u32 = 127; -pub const MB_LEN_MAX: u32 = 5; -pub const SHRT_MIN: i32 = -32768; -pub const SHRT_MAX: u32 = 32767; -pub const USHRT_MAX: u32 = 65535; -pub const INT_MIN: i32 = -2147483648; -pub const INT_MAX: u32 = 2147483647; -pub const UINT_MAX: u32 = 4294967295; -pub const LONG_MIN: i32 = -2147483648; -pub const LONG_MAX: u32 = 2147483647; -pub const ULONG_MAX: u32 = 4294967295; -pub const EXIT_SUCCESS: u32 = 0; -pub const EXIT_FAILURE: u32 = 1; -pub const _WRITE_ABORT_MSG: u32 = 1; -pub const _CALL_REPORTFAULT: u32 = 2; -pub const _OUT_TO_DEFAULT: u32 = 0; -pub const _OUT_TO_STDERR: u32 = 1; -pub const _OUT_TO_MSGBOX: u32 = 2; -pub const _REPORT_ERRMODE: u32 = 3; -pub const RAND_MAX: u32 = 32767; -pub const _CVTBUFSIZE: u32 = 349; -pub const _MAX_PATH: u32 = 260; -pub const _MAX_DRIVE: u32 = 3; -pub const _MAX_DIR: u32 = 256; -pub const _MAX_FNAME: u32 = 256; -pub const _MAX_EXT: u32 = 256; -pub const _MAX_ENV: u32 = 32767; -pub const _CRT_INTERNAL_STDIO_SYMBOL_PREFIX: &'static [u8; 1usize] = b"\0"; -pub const _CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION: u32 = 1; -pub const _CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR: u32 = 2; -pub const _CRT_INTERNAL_PRINTF_LEGACY_WIDE_SPECIFIERS: u32 = 4; -pub const _CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY: u32 = 8; -pub const _CRT_INTERNAL_PRINTF_LEGACY_THREE_DIGIT_EXPONENTS: u32 = 16; -pub const _CRT_INTERNAL_SCANF_SECURECRT: u32 = 1; -pub const _CRT_INTERNAL_SCANF_LEGACY_WIDE_SPECIFIERS: u32 = 2; -pub const _CRT_INTERNAL_SCANF_LEGACY_MSVCRT_COMPATIBILITY: u32 = 4; -pub const BUFSIZ: u32 = 512; -pub const _NSTREAM_: u32 = 512; -pub const _IOB_ENTRIES: u32 = 3; -pub const EOF: i32 = -1; -pub const _IOFBF: u32 = 0; -pub const _IOLBF: u32 = 64; -pub const _IONBF: u32 = 4; -pub const L_tmpnam: u32 = 260; -pub const L_tmpnam_s: u32 = 260; -pub const SEEK_CUR: u32 = 1; -pub const SEEK_END: u32 = 2; -pub const SEEK_SET: u32 = 0; -pub const FILENAME_MAX: u32 = 260; -pub const FOPEN_MAX: u32 = 20; -pub const _SYS_OPEN: u32 = 20; -pub const TMP_MAX: u32 = 2147483647; -pub const TMP_MAX_S: u32 = 2147483647; -pub const _TMP_MAX_S: u32 = 2147483647; -pub const SYS_OPEN: u32 = 20; -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 WCHAR_MIN: u32 = 0; -pub const WCHAR_MAX: u32 = 65535; -pub const WINT_MIN: u32 = 0; -pub const WINT_MAX: u32 = 65535; -pub const IL2CPP_TARGET_ARM64: u32 = 1; -pub const IL2CPP_TARGET_ARMV7: u32 = 0; -pub const IL2CPP_BINARY_SECTION_NAME: &'static [u8; 8usize] = b".il2cpp\0"; -pub const IL2CPP_TARGET_ANDROID: u32 = 1; -pub const IL2CPP_PLATFORM_SUPPORTS_TIMEZONEINFO: u32 = 1; -pub const IL2CPP_TARGET_WINDOWS: u32 = 0; -pub const IL2CPP_TARGET_WINDOWS_DESKTOP: 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_JAVASCRIPT: u32 = 0; -pub const IL2CPP_TARGET_LINUX: 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_PLATFORM_SUPPORTS_SYSTEM_CERTIFICATES: u32 = 0; -pub const IL2CPP_PLATFORM_SUPPORTS_CUSTOM_SECTIONS: u32 = 0; -pub const IL2CPP_PLATFORM_SUPPORTS_CPU_INFO: u32 = 0; -pub const IL2CPP_PLATFORM_SUPPORTS_DEBUGGER_PRESENT: u32 = 0; -pub const IL2CPP_USE_STD_THREAD: u32 = 0; -pub const IL2CPP_THREADS_STD: u32 = 0; -pub const IL2CPP_SIZEOF_VOID_P: u32 = 8; -pub const IL2CPP_API_DYNAMIC_NO_DLSYM: u32 = 0; -pub const IL2CPP_ENABLE_PROFILER: u32 = 1; -pub const IL2CPP_EXCEPTION_DISABLED: u32 = 0; -pub const IL2CPP_CXX_ABI_MSVC: u32 = 0; -pub const IL2CPP_ENABLE_MONO_BUG_EMULATION: u32 = 1; -pub const IL2CPP_PAGE_SIZE: u32 = 4096; -pub const IL2CPP_DEBUG: u32 = 0; -pub const IL2CPP_DEVELOPMENT: u32 = 0; -pub const IL2CPP_THREAD_IMPL_HAS_COM_APARTMENTS: u32 = 0; -pub const IL2CPP_ENABLE_STACKTRACES: 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 IL2CPP_DIR_SEPARATOR: u8 = 47u8; -pub const IL2CPP_DISABLE_FULL_MESSAGES: u32 = 1; -pub const IL2CPP_USE_SEND_NOSIGNAL: u32 = 0; -pub const IL2CPP_SIZEOF_STRUCT_WITH_NO_INSTANCE_FIELDS: u32 = 1; -pub const IL2CPP_VALIDATE_FIELD_LAYOUT: 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 = 0; -pub const IL2CPP_POINTER_SPARE_BITS: u32 = 3; -pub const MAXIMUM_NESTED_GENERICS_EXCEPTION_MESSAGE : & 'static [ u8 ; 176usize ] = 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.\0" ; -pub const IL2CPP_USE_GENERIC_CPU_INFO: u32 = 1; -pub const PUBLIC_KEY_BYTE_LENGTH: u32 = 8; -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; -pub type va_list = *mut ::std::os::raw::c_char; -pub type __vcrt_bool = bool; -pub type wchar_t = ::std::os::raw::c_ushort; -extern "C" { - pub static mut __security_cookie: usize; -} -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; -#[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, -} -#[test] -fn bindgen_test_layout___crt_locale_data_public() { - assert_eq!( - ::std::mem::size_of::<__crt_locale_data_public>(), - 16usize, - concat!("Size of: ", stringify!(__crt_locale_data_public)) - ); - assert_eq!( - ::std::mem::align_of::<__crt_locale_data_public>(), - 8usize, - concat!("Alignment of ", stringify!(__crt_locale_data_public)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::<__crt_locale_data_public>()))._locale_pctype as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__crt_locale_data_public), - "::", - stringify!(_locale_pctype) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::<__crt_locale_data_public>()))._locale_mb_cur_max as *const _ - as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(__crt_locale_data_public), - "::", - stringify!(_locale_mb_cur_max) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::<__crt_locale_data_public>()))._locale_lc_codepage as *const _ - as usize - }, - 12usize, - concat!( - "Offset of field: ", - stringify!(__crt_locale_data_public), - "::", - stringify!(_locale_lc_codepage) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct __crt_locale_pointers { - pub locinfo: *mut __crt_locale_data, - pub mbcinfo: *mut __crt_multibyte_data, -} -#[test] -fn bindgen_test_layout___crt_locale_pointers() { - assert_eq!( - ::std::mem::size_of::<__crt_locale_pointers>(), - 16usize, - concat!("Size of: ", stringify!(__crt_locale_pointers)) - ); - assert_eq!( - ::std::mem::align_of::<__crt_locale_pointers>(), - 8usize, - concat!("Alignment of ", stringify!(__crt_locale_pointers)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__crt_locale_pointers>())).locinfo as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__crt_locale_pointers), - "::", - stringify!(locinfo) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__crt_locale_pointers>())).mbcinfo as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(__crt_locale_pointers), - "::", - stringify!(mbcinfo) - ) - ); -} -pub type _locale_t = *mut __crt_locale_pointers; -#[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, -} -#[test] -fn bindgen_test_layout__Mbstatet() { - assert_eq!( - ::std::mem::size_of::<_Mbstatet>(), - 8usize, - concat!("Size of: ", stringify!(_Mbstatet)) - ); - assert_eq!( - ::std::mem::align_of::<_Mbstatet>(), - 4usize, - concat!("Alignment of ", stringify!(_Mbstatet)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<_Mbstatet>()))._Wchar as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_Mbstatet), - "::", - stringify!(_Wchar) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<_Mbstatet>()))._Byte as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(_Mbstatet), - "::", - stringify!(_Byte) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<_Mbstatet>()))._State as *const _ as usize }, - 6usize, - concat!( - "Offset of field: ", - stringify!(_Mbstatet), - "::", - stringify!(_State) - ) - ); -} -pub type mbstate_t = _Mbstatet; -pub type time_t = __time64_t; -pub type rsize_t = usize; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct max_align_t { - pub __clang_max_align_nonce1: ::std::os::raw::c_longlong, - pub __clang_max_align_nonce2: f64, -} -#[test] -fn bindgen_test_layout_max_align_t() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(max_align_t)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(max_align_t)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).__clang_max_align_nonce1 as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(max_align_t), - "::", - stringify!(__clang_max_align_nonce1) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).__clang_max_align_nonce2 as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(max_align_t), - "::", - stringify!(__clang_max_align_nonce2) - ) - ); -} -pub type _CoreCrtSecureSearchSortCompareFunction = ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_void, - arg3: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, ->; -pub type _CoreCrtNonSecureSearchSortCompareFunction = ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, ->; -pub type _onexit_t = ::std::option::Option ::std::os::raw::c_int>; -pub type _purecall_handler = ::std::option::Option; -pub type _invalid_parameter_handler = ::std::option::Option< - unsafe extern "C" fn( - arg1: *const wchar_t, - arg2: *const wchar_t, - arg3: *const wchar_t, - arg4: ::std::os::raw::c_uint, - arg5: usize, - ), ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _div_t { - pub quot: ::std::os::raw::c_int, - pub rem: ::std::os::raw::c_int, -} -#[test] -fn bindgen_test_layout__div_t() { - assert_eq!( - ::std::mem::size_of::<_div_t>(), - 8usize, - concat!("Size of: ", stringify!(_div_t)) - ); - assert_eq!( - ::std::mem::align_of::<_div_t>(), - 4usize, - concat!("Alignment of ", stringify!(_div_t)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<_div_t>())).quot as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_div_t), - "::", - stringify!(quot) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<_div_t>())).rem as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(_div_t), - "::", - stringify!(rem) - ) - ); -} -pub type div_t = _div_t; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _ldiv_t { - pub quot: ::std::os::raw::c_long, - pub rem: ::std::os::raw::c_long, -} -#[test] -fn bindgen_test_layout__ldiv_t() { - assert_eq!( - ::std::mem::size_of::<_ldiv_t>(), - 8usize, - concat!("Size of: ", stringify!(_ldiv_t)) - ); - assert_eq!( - ::std::mem::align_of::<_ldiv_t>(), - 4usize, - concat!("Alignment of ", stringify!(_ldiv_t)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<_ldiv_t>())).quot as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_ldiv_t), - "::", - stringify!(quot) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<_ldiv_t>())).rem as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(_ldiv_t), - "::", - stringify!(rem) - ) - ); -} -pub type ldiv_t = _ldiv_t; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _lldiv_t { - pub quot: ::std::os::raw::c_longlong, - pub rem: ::std::os::raw::c_longlong, -} -#[test] -fn bindgen_test_layout__lldiv_t() { - assert_eq!( - ::std::mem::size_of::<_lldiv_t>(), - 16usize, - concat!("Size of: ", stringify!(_lldiv_t)) - ); - assert_eq!( - ::std::mem::align_of::<_lldiv_t>(), - 8usize, - concat!("Alignment of ", stringify!(_lldiv_t)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<_lldiv_t>())).quot as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_lldiv_t), - "::", - stringify!(quot) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<_lldiv_t>())).rem as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(_lldiv_t), - "::", - stringify!(rem) - ) - ); -} -pub type lldiv_t = _lldiv_t; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _LDOUBLE { - pub ld: [::std::os::raw::c_uchar; 10usize], -} -#[test] -fn bindgen_test_layout__LDOUBLE() { - assert_eq!( - ::std::mem::size_of::<_LDOUBLE>(), - 10usize, - concat!("Size of: ", stringify!(_LDOUBLE)) - ); - assert_eq!( - ::std::mem::align_of::<_LDOUBLE>(), - 1usize, - concat!("Alignment of ", stringify!(_LDOUBLE)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<_LDOUBLE>())).ld as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_LDOUBLE), - "::", - stringify!(ld) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _CRT_DOUBLE { - pub x: f64, -} -#[test] -fn bindgen_test_layout__CRT_DOUBLE() { - assert_eq!( - ::std::mem::size_of::<_CRT_DOUBLE>(), - 8usize, - concat!("Size of: ", stringify!(_CRT_DOUBLE)) - ); - assert_eq!( - ::std::mem::align_of::<_CRT_DOUBLE>(), - 8usize, - concat!("Alignment of ", stringify!(_CRT_DOUBLE)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<_CRT_DOUBLE>())).x as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_CRT_DOUBLE), - "::", - stringify!(x) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _CRT_FLOAT { - pub f: f32, -} -#[test] -fn bindgen_test_layout__CRT_FLOAT() { - assert_eq!( - ::std::mem::size_of::<_CRT_FLOAT>(), - 4usize, - concat!("Size of: ", stringify!(_CRT_FLOAT)) - ); - assert_eq!( - ::std::mem::align_of::<_CRT_FLOAT>(), - 4usize, - concat!("Alignment of ", stringify!(_CRT_FLOAT)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<_CRT_FLOAT>())).f as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_CRT_FLOAT), - "::", - stringify!(f) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _LONGDOUBLE { - pub x: f64, -} -#[test] -fn bindgen_test_layout__LONGDOUBLE() { - assert_eq!( - ::std::mem::size_of::<_LONGDOUBLE>(), - 8usize, - concat!("Size of: ", stringify!(_LONGDOUBLE)) - ); - assert_eq!( - ::std::mem::align_of::<_LONGDOUBLE>(), - 8usize, - concat!("Alignment of ", stringify!(_LONGDOUBLE)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<_LONGDOUBLE>())).x as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_LONGDOUBLE), - "::", - stringify!(x) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _LDBL12 { - pub ld12: [::std::os::raw::c_uchar; 12usize], -} -#[test] -fn bindgen_test_layout__LDBL12() { - assert_eq!( - ::std::mem::size_of::<_LDBL12>(), - 12usize, - concat!("Size of: ", stringify!(_LDBL12)) - ); - assert_eq!( - ::std::mem::align_of::<_LDBL12>(), - 1usize, - concat!("Alignment of ", stringify!(_LDBL12)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<_LDBL12>())).ld12 as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_LDBL12), - "::", - stringify!(ld12) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _iobuf { - pub _Placeholder: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout__iobuf() { - assert_eq!( - ::std::mem::size_of::<_iobuf>(), - 8usize, - concat!("Size of: ", stringify!(_iobuf)) - ); - assert_eq!( - ::std::mem::align_of::<_iobuf>(), - 8usize, - concat!("Alignment of ", stringify!(_iobuf)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<_iobuf>()))._Placeholder as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(_iobuf), - "::", - stringify!(_Placeholder) - ) - ); -} -pub type FILE = _iobuf; -pub type fpos_t = ::std::os::raw::c_longlong; -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; -#[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], -} -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 type Il2CppProfileFlags = i32; -pub const Il2CppProfileFileIOKind_IL2CPP_PROFILE_FILEIO_WRITE: Il2CppProfileFileIOKind = 0; -pub const Il2CppProfileFileIOKind_IL2CPP_PROFILE_FILEIO_READ: Il2CppProfileFileIOKind = 1; -pub type Il2CppProfileFileIOKind = i32; -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 type Il2CppGCEvent = i32; -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 type Il2CppStat = i32; -pub const Il2CppRuntimeUnhandledExceptionPolicy_IL2CPP_UNHANDLED_POLICY_LEGACY: - Il2CppRuntimeUnhandledExceptionPolicy = 0; -pub const Il2CppRuntimeUnhandledExceptionPolicy_IL2CPP_UNHANDLED_POLICY_CURRENT: - Il2CppRuntimeUnhandledExceptionPolicy = 1; -pub type Il2CppRuntimeUnhandledExceptionPolicy = i32; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppStackFrameInfo { - pub method: *const MethodInfo, -} -#[test] -fn bindgen_test_layout_Il2CppStackFrameInfo() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(Il2CppStackFrameInfo)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppStackFrameInfo)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).method as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStackFrameInfo), - "::", - stringify!(method) - ) - ); -} -#[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, - >, -} -#[test] -fn bindgen_test_layout_Il2CppMemoryCallbacks() { - assert_eq!( - ::std::mem::size_of::(), - 56usize, - concat!("Size of: ", stringify!(Il2CppMemoryCallbacks)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppMemoryCallbacks)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).malloc_func as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMemoryCallbacks), - "::", - stringify!(malloc_func) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aligned_malloc_func as *const _ - as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMemoryCallbacks), - "::", - stringify!(aligned_malloc_func) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free_func as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMemoryCallbacks), - "::", - stringify!(free_func) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aligned_free_func as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMemoryCallbacks), - "::", - stringify!(aligned_free_func) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).calloc_func as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMemoryCallbacks), - "::", - stringify!(calloc_func) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).realloc_func as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMemoryCallbacks), - "::", - stringify!(realloc_func) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aligned_realloc_func as *const _ - as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMemoryCallbacks), - "::", - stringify!(aligned_realloc_func) - ) - ); -} -pub type Il2CppChar = u16; -pub type Il2CppNativeChar = ::std::os::raw::c_char; -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_WorldChangedCallback = ::std::option::Option; -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 Il2CppMethodPointer = ::std::option::Option; -pub type il2cpp_array_size_t = usize; -pub type Il2CppMethodSlot = u32; -pub const kInvalidIl2CppMethodSlot: u32 = 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; -extern "C" { - pub static kIl2CppUInt64Max: u64; -} -extern "C" { - pub static kIl2CppUIntPtrMax: usize; -} -pub const ipv6AddressSize: ::std::os::raw::c_int = 16; -pub type il2cpp_hresult_t = i32; -extern "C" { - pub static mut kIl2CppNewLine: [Il2CppChar; 2usize]; -} -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 type Il2CppTypeEnum = i32; -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 InterfaceOffsetIndex = 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 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 type EncodedMethodIndex = u32; -pub const Il2CppMetadataUsage_kIl2CppMetadataUsageInvalid: Il2CppMetadataUsage = 0; -pub const Il2CppMetadataUsage_kIl2CppMetadataUsageTypeInfo: Il2CppMetadataUsage = 1; -pub const Il2CppMetadataUsage_kIl2CppMetadataUsageIl2CppType: Il2CppMetadataUsage = 2; -pub const Il2CppMetadataUsage_kIl2CppMetadataUsageMethodDef: Il2CppMetadataUsage = 3; -pub const Il2CppMetadataUsage_kIl2CppMetadataUsageFieldInfo: Il2CppMetadataUsage = 4; -pub const Il2CppMetadataUsage_kIl2CppMetadataUsageStringLiteral: Il2CppMetadataUsage = 5; -pub const Il2CppMetadataUsage_kIl2CppMetadataUsageMethodRef: Il2CppMetadataUsage = 6; -pub type Il2CppMetadataUsage = i32; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppTypeDefinitionMetadata { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union Il2CppRGCTXDefinitionData { - pub rgctxDataDummy: i32, - pub methodIndex: MethodIndex, - pub typeIndex: TypeIndex, - _bindgen_union_align: u32, -} -#[test] -fn bindgen_test_layout_Il2CppRGCTXDefinitionData() { - assert_eq!( - ::std::mem::size_of::(), - 4usize, - concat!("Size of: ", stringify!(Il2CppRGCTXDefinitionData)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppRGCTXDefinitionData)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rgctxDataDummy as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRGCTXDefinitionData), - "::", - stringify!(rgctxDataDummy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).methodIndex as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRGCTXDefinitionData), - "::", - stringify!(methodIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).typeIndex as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRGCTXDefinitionData), - "::", - stringify!(typeIndex) - ) - ); -} -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 type Il2CppRGCTXDataType = i32; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppRGCTXDefinition { - pub type_: Il2CppRGCTXDataType, - pub data: Il2CppRGCTXDefinitionData, -} -#[test] -fn bindgen_test_layout_Il2CppRGCTXDefinition() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(Il2CppRGCTXDefinition)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppRGCTXDefinition)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).type_ as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRGCTXDefinition), - "::", - stringify!(type_) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRGCTXDefinition), - "::", - stringify!(data) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppInterfaceOffsetPair { - pub interfaceTypeIndex: TypeIndex, - pub offset: i32, -} -#[test] -fn bindgen_test_layout_Il2CppInterfaceOffsetPair() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(Il2CppInterfaceOffsetPair)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppInterfaceOffsetPair)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).interfaceTypeIndex as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInterfaceOffsetPair), - "::", - stringify!(interfaceTypeIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).offset as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInterfaceOffsetPair), - "::", - stringify!(offset) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppTypeDefinition { - pub nameIndex: StringIndex, - pub namespaceIndex: StringIndex, - pub byvalTypeIndex: TypeIndex, - pub byrefTypeIndex: TypeIndex, - pub declaringTypeIndex: TypeIndex, - pub parentIndex: TypeIndex, - pub elementTypeIndex: TypeIndex, - pub rgctxStartIndex: RGCTXIndex, - pub rgctxCount: i32, - pub genericContainerIndex: GenericContainerIndex, - pub flags: u32, - pub fieldStart: FieldIndex, - pub methodStart: MethodIndex, - pub eventStart: EventIndex, - pub propertyStart: PropertyIndex, - pub nestedTypesStart: NestedTypeIndex, - pub interfacesStart: InterfacesIndex, - pub vtableStart: VTableIndex, - pub interfaceOffsetsStart: InterfacesIndex, - 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 bitfield: u32, - pub token: u32, -} -#[test] -fn bindgen_test_layout_Il2CppTypeDefinition() { - assert_eq!( - ::std::mem::size_of::(), - 100usize, - concat!("Size of: ", stringify!(Il2CppTypeDefinition)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppTypeDefinition)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nameIndex as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(nameIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).namespaceIndex as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(namespaceIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).byvalTypeIndex as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(byvalTypeIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).byrefTypeIndex as *const _ as usize - }, - 12usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(byrefTypeIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).declaringTypeIndex as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(declaringTypeIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).parentIndex as *const _ as usize - }, - 20usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(parentIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).elementTypeIndex as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(elementTypeIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rgctxStartIndex as *const _ as usize - }, - 28usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(rgctxStartIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).rgctxCount as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(rgctxCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).genericContainerIndex as *const _ - as usize - }, - 36usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(genericContainerIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).flags as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(flags) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).fieldStart as *const _ as usize }, - 44usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(fieldStart) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).methodStart as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(methodStart) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).eventStart as *const _ as usize }, - 52usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(eventStart) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).propertyStart as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(propertyStart) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).nestedTypesStart as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(nestedTypesStart) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).interfacesStart as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(interfacesStart) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtableStart as *const _ as usize - }, - 68usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(vtableStart) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).interfaceOffsetsStart as *const _ - as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(interfaceOffsetsStart) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).method_count as *const _ as usize - }, - 76usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(method_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).property_count as *const _ as usize - }, - 78usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(property_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).field_count as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(field_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).event_count as *const _ as usize - }, - 82usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(event_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).nested_type_count as *const _ as usize - }, - 84usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(nested_type_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtable_count as *const _ as usize - }, - 86usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(vtable_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).interfaces_count as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(interfaces_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).interface_offsets_count as *const _ - as usize - }, - 90usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(interface_offsets_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bitfield as *const _ as usize }, - 92usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(bitfield) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinition), - "::", - stringify!(token) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppFieldDefinition { - pub nameIndex: StringIndex, - pub typeIndex: TypeIndex, - pub token: u32, -} -#[test] -fn bindgen_test_layout_Il2CppFieldDefinition() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!("Size of: ", stringify!(Il2CppFieldDefinition)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppFieldDefinition)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nameIndex as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppFieldDefinition), - "::", - stringify!(nameIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).typeIndex as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppFieldDefinition), - "::", - stringify!(typeIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppFieldDefinition), - "::", - stringify!(token) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppFieldDefaultValue { - pub fieldIndex: FieldIndex, - pub typeIndex: TypeIndex, - pub dataIndex: DefaultValueDataIndex, -} -#[test] -fn bindgen_test_layout_Il2CppFieldDefaultValue() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!("Size of: ", stringify!(Il2CppFieldDefaultValue)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppFieldDefaultValue)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).fieldIndex as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppFieldDefaultValue), - "::", - stringify!(fieldIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).typeIndex as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppFieldDefaultValue), - "::", - stringify!(typeIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).dataIndex as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppFieldDefaultValue), - "::", - stringify!(dataIndex) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppFieldMarshaledSize { - pub fieldIndex: FieldIndex, - pub typeIndex: TypeIndex, - pub size: i32, -} -#[test] -fn bindgen_test_layout_Il2CppFieldMarshaledSize() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!("Size of: ", stringify!(Il2CppFieldMarshaledSize)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppFieldMarshaledSize)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).fieldIndex as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppFieldMarshaledSize), - "::", - stringify!(fieldIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).typeIndex as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppFieldMarshaledSize), - "::", - stringify!(typeIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).size as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppFieldMarshaledSize), - "::", - stringify!(size) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppFieldRef { - pub typeIndex: TypeIndex, - pub fieldIndex: FieldIndex, -} -#[test] -fn bindgen_test_layout_Il2CppFieldRef() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(Il2CppFieldRef)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppFieldRef)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).typeIndex as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppFieldRef), - "::", - stringify!(typeIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).fieldIndex as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppFieldRef), - "::", - stringify!(fieldIndex) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppParameterDefinition { - pub nameIndex: StringIndex, - pub token: u32, - pub typeIndex: TypeIndex, -} -#[test] -fn bindgen_test_layout_Il2CppParameterDefinition() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!("Size of: ", stringify!(Il2CppParameterDefinition)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppParameterDefinition)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).nameIndex as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppParameterDefinition), - "::", - stringify!(nameIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppParameterDefinition), - "::", - stringify!(token) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).typeIndex as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppParameterDefinition), - "::", - stringify!(typeIndex) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppParameterDefaultValue { - pub parameterIndex: ParameterIndex, - pub typeIndex: TypeIndex, - pub dataIndex: DefaultValueDataIndex, -} -#[test] -fn bindgen_test_layout_Il2CppParameterDefaultValue() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!("Size of: ", stringify!(Il2CppParameterDefaultValue)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppParameterDefaultValue)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).parameterIndex as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppParameterDefaultValue), - "::", - stringify!(parameterIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).typeIndex as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppParameterDefaultValue), - "::", - stringify!(typeIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).dataIndex as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppParameterDefaultValue), - "::", - stringify!(dataIndex) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppMethodDefinition { - pub nameIndex: StringIndex, - pub declaringType: TypeDefinitionIndex, - pub returnType: TypeIndex, - pub parameterStart: ParameterIndex, - pub genericContainerIndex: GenericContainerIndex, - pub methodIndex: MethodIndex, - pub invokerIndex: MethodIndex, - pub reversePInvokeWrapperIndex: MethodIndex, - pub rgctxStartIndex: RGCTXIndex, - pub rgctxCount: i32, - pub token: u32, - pub flags: u16, - pub iflags: u16, - pub slot: u16, - pub parameterCount: u16, -} -#[test] -fn bindgen_test_layout_Il2CppMethodDefinition() { - assert_eq!( - ::std::mem::size_of::(), - 52usize, - concat!("Size of: ", stringify!(Il2CppMethodDefinition)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppMethodDefinition)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).nameIndex as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodDefinition), - "::", - stringify!(nameIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).declaringType as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodDefinition), - "::", - stringify!(declaringType) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).returnType as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodDefinition), - "::", - stringify!(returnType) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).parameterStart as *const _ as usize - }, - 12usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodDefinition), - "::", - stringify!(parameterStart) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).genericContainerIndex as *const _ - as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodDefinition), - "::", - stringify!(genericContainerIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).methodIndex as *const _ as usize - }, - 20usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodDefinition), - "::", - stringify!(methodIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).invokerIndex as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodDefinition), - "::", - stringify!(invokerIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).reversePInvokeWrapperIndex - as *const _ as usize - }, - 28usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodDefinition), - "::", - stringify!(reversePInvokeWrapperIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rgctxStartIndex as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodDefinition), - "::", - stringify!(rgctxStartIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rgctxCount as *const _ as usize - }, - 36usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodDefinition), - "::", - stringify!(rgctxCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodDefinition), - "::", - stringify!(token) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).flags as *const _ as usize }, - 44usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodDefinition), - "::", - stringify!(flags) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iflags as *const _ as usize }, - 46usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodDefinition), - "::", - stringify!(iflags) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).slot as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodDefinition), - "::", - stringify!(slot) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).parameterCount as *const _ as usize - }, - 50usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodDefinition), - "::", - stringify!(parameterCount) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppEventDefinition { - pub nameIndex: StringIndex, - pub typeIndex: TypeIndex, - pub add: MethodIndex, - pub remove: MethodIndex, - pub raise: MethodIndex, - pub token: u32, -} -#[test] -fn bindgen_test_layout_Il2CppEventDefinition() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(Il2CppEventDefinition)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppEventDefinition)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nameIndex as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppEventDefinition), - "::", - stringify!(nameIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).typeIndex as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppEventDefinition), - "::", - stringify!(typeIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).add as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppEventDefinition), - "::", - stringify!(add) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).remove as *const _ as usize }, - 12usize, - concat!( - "Offset of field: ", - stringify!(Il2CppEventDefinition), - "::", - stringify!(remove) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).raise as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppEventDefinition), - "::", - stringify!(raise) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, - 20usize, - concat!( - "Offset of field: ", - stringify!(Il2CppEventDefinition), - "::", - stringify!(token) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppPropertyDefinition { - pub nameIndex: StringIndex, - pub get: MethodIndex, - pub set: MethodIndex, - pub attrs: u32, - pub token: u32, -} -#[test] -fn bindgen_test_layout_Il2CppPropertyDefinition() { - assert_eq!( - ::std::mem::size_of::(), - 20usize, - concat!("Size of: ", stringify!(Il2CppPropertyDefinition)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppPropertyDefinition)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).nameIndex as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPropertyDefinition), - "::", - stringify!(nameIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).get as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPropertyDefinition), - "::", - stringify!(get) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).set as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPropertyDefinition), - "::", - stringify!(set) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).attrs as *const _ as usize }, - 12usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPropertyDefinition), - "::", - stringify!(attrs) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPropertyDefinition), - "::", - stringify!(token) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppMethodSpec { - pub methodDefinitionIndex: MethodIndex, - pub classIndexIndex: GenericInstIndex, - pub methodIndexIndex: GenericInstIndex, -} -#[test] -fn bindgen_test_layout_Il2CppMethodSpec() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!("Size of: ", stringify!(Il2CppMethodSpec)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppMethodSpec)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).methodDefinitionIndex as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodSpec), - "::", - stringify!(methodDefinitionIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).classIndexIndex as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodSpec), - "::", - stringify!(classIndexIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).methodIndexIndex as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodSpec), - "::", - stringify!(methodIndexIndex) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppStringLiteral { - pub length: u32, - pub dataIndex: StringLiteralIndex, -} -#[test] -fn bindgen_test_layout_Il2CppStringLiteral() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(Il2CppStringLiteral)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppStringLiteral)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).length as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStringLiteral), - "::", - stringify!(length) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).dataIndex as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStringLiteral), - "::", - stringify!(dataIndex) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppGenericMethodIndices { - pub methodIndex: MethodIndex, - pub invokerIndex: MethodIndex, -} -#[test] -fn bindgen_test_layout_Il2CppGenericMethodIndices() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(Il2CppGenericMethodIndices)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppGenericMethodIndices)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).methodIndex as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGenericMethodIndices), - "::", - stringify!(methodIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).invokerIndex as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGenericMethodIndices), - "::", - stringify!(invokerIndex) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppGenericMethodFunctionsDefinitions { - pub genericMethodIndex: GenericMethodIndex, - pub indices: Il2CppGenericMethodIndices, -} -#[test] -fn bindgen_test_layout_Il2CppGenericMethodFunctionsDefinitions() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!( - "Size of: ", - stringify!(Il2CppGenericMethodFunctionsDefinitions) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(Il2CppGenericMethodFunctionsDefinitions) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).genericMethodIndex - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGenericMethodFunctionsDefinitions), - "::", - stringify!(genericMethodIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).indices as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGenericMethodFunctionsDefinitions), - "::", - stringify!(indices) - ) - ); -} -pub const kPublicKeyByteLength: ::std::os::raw::c_int = 8; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppAssemblyNameDefinition { - pub nameIndex: StringIndex, - pub cultureIndex: StringIndex, - pub hashValueIndex: StringIndex, - pub publicKeyIndex: StringIndex, - 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], -} -#[test] -fn bindgen_test_layout_Il2CppAssemblyNameDefinition() { - assert_eq!( - ::std::mem::size_of::(), - 52usize, - concat!("Size of: ", stringify!(Il2CppAssemblyNameDefinition)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppAssemblyNameDefinition)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).nameIndex as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyNameDefinition), - "::", - stringify!(nameIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).cultureIndex as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyNameDefinition), - "::", - stringify!(cultureIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).hashValueIndex as *const _ - as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyNameDefinition), - "::", - stringify!(hashValueIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).publicKeyIndex as *const _ - as usize - }, - 12usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyNameDefinition), - "::", - stringify!(publicKeyIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).hash_alg as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyNameDefinition), - "::", - stringify!(hash_alg) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).hash_len as *const _ as usize - }, - 20usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyNameDefinition), - "::", - stringify!(hash_len) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).flags as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyNameDefinition), - "::", - stringify!(flags) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).major as *const _ as usize - }, - 28usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyNameDefinition), - "::", - stringify!(major) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).minor as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyNameDefinition), - "::", - stringify!(minor) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).build as *const _ as usize - }, - 36usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyNameDefinition), - "::", - stringify!(build) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).revision as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyNameDefinition), - "::", - stringify!(revision) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).public_key_token as *const _ - as usize - }, - 44usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyNameDefinition), - "::", - stringify!(public_key_token) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppImageDefinition { - pub nameIndex: StringIndex, - pub assemblyIndex: AssemblyIndex, - pub typeStart: TypeDefinitionIndex, - pub typeCount: u32, - pub exportedTypeStart: TypeDefinitionIndex, - pub exportedTypeCount: u32, - pub entryPointIndex: MethodIndex, - pub token: u32, - pub customAttributeStart: CustomAttributeIndex, - pub customAttributeCount: u32, -} -#[test] -fn bindgen_test_layout_Il2CppImageDefinition() { - assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(Il2CppImageDefinition)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppImageDefinition)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nameIndex as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppImageDefinition), - "::", - stringify!(nameIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).assemblyIndex as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppImageDefinition), - "::", - stringify!(assemblyIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).typeStart as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppImageDefinition), - "::", - stringify!(typeStart) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).typeCount as *const _ as usize }, - 12usize, - concat!( - "Offset of field: ", - stringify!(Il2CppImageDefinition), - "::", - stringify!(typeCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).exportedTypeStart as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppImageDefinition), - "::", - stringify!(exportedTypeStart) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).exportedTypeCount as *const _ as usize - }, - 20usize, - concat!( - "Offset of field: ", - stringify!(Il2CppImageDefinition), - "::", - stringify!(exportedTypeCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).entryPointIndex as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppImageDefinition), - "::", - stringify!(entryPointIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, - 28usize, - concat!( - "Offset of field: ", - stringify!(Il2CppImageDefinition), - "::", - stringify!(token) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).customAttributeStart as *const _ - as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppImageDefinition), - "::", - stringify!(customAttributeStart) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).customAttributeCount as *const _ - as usize - }, - 36usize, - concat!( - "Offset of field: ", - stringify!(Il2CppImageDefinition), - "::", - stringify!(customAttributeCount) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppAssemblyDefinition { - pub imageIndex: ImageIndex, - pub token: u32, - pub referencedAssemblyStart: i32, - pub referencedAssemblyCount: i32, - pub aname: Il2CppAssemblyNameDefinition, -} -#[test] -fn bindgen_test_layout_Il2CppAssemblyDefinition() { - assert_eq!( - ::std::mem::size_of::(), - 68usize, - concat!("Size of: ", stringify!(Il2CppAssemblyDefinition)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppAssemblyDefinition)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).imageIndex as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyDefinition), - "::", - stringify!(imageIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyDefinition), - "::", - stringify!(token) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).referencedAssemblyStart as *const _ - as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyDefinition), - "::", - stringify!(referencedAssemblyStart) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).referencedAssemblyCount as *const _ - as usize - }, - 12usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyDefinition), - "::", - stringify!(referencedAssemblyCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aname as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyDefinition), - "::", - stringify!(aname) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppMetadataUsageList { - pub start: u32, - pub count: u32, -} -#[test] -fn bindgen_test_layout_Il2CppMetadataUsageList() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(Il2CppMetadataUsageList)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppMetadataUsageList)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).start as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMetadataUsageList), - "::", - stringify!(start) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).count as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMetadataUsageList), - "::", - stringify!(count) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppMetadataUsagePair { - pub destinationIndex: u32, - pub encodedSourceIndex: u32, -} -#[test] -fn bindgen_test_layout_Il2CppMetadataUsagePair() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(Il2CppMetadataUsagePair)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppMetadataUsagePair)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).destinationIndex as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMetadataUsagePair), - "::", - stringify!(destinationIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).encodedSourceIndex as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMetadataUsagePair), - "::", - stringify!(encodedSourceIndex) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppCustomAttributeTypeRange { - pub token: u32, - pub start: i32, - pub count: i32, -} -#[test] -fn bindgen_test_layout_Il2CppCustomAttributeTypeRange() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!("Size of: ", stringify!(Il2CppCustomAttributeTypeRange)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppCustomAttributeTypeRange)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).token as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCustomAttributeTypeRange), - "::", - stringify!(token) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).start as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCustomAttributeTypeRange), - "::", - stringify!(start) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).count as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCustomAttributeTypeRange), - "::", - stringify!(count) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppRange { - pub start: i32, - pub length: i32, -} -#[test] -fn bindgen_test_layout_Il2CppRange() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(Il2CppRange)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppRange)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).start as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRange), - "::", - stringify!(start) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).length as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRange), - "::", - stringify!(length) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppWindowsRuntimeTypeNamePair { - pub nameIndex: StringIndex, - pub typeIndex: TypeIndex, -} -#[test] -fn bindgen_test_layout_Il2CppWindowsRuntimeTypeNamePair() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(Il2CppWindowsRuntimeTypeNamePair)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(Il2CppWindowsRuntimeTypeNamePair) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).nameIndex as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppWindowsRuntimeTypeNamePair), - "::", - stringify!(nameIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).typeIndex as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppWindowsRuntimeTypeNamePair), - "::", - stringify!(typeIndex) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppGlobalMetadataHeader { - pub sanity: i32, - pub version: i32, - pub stringLiteralOffset: i32, - pub stringLiteralCount: i32, - pub stringLiteralDataOffset: i32, - pub stringLiteralDataCount: i32, - pub stringOffset: i32, - pub stringCount: i32, - pub eventsOffset: i32, - pub eventsCount: i32, - pub propertiesOffset: i32, - pub propertiesCount: i32, - pub methodsOffset: i32, - pub methodsCount: i32, - pub parameterDefaultValuesOffset: i32, - pub parameterDefaultValuesCount: i32, - pub fieldDefaultValuesOffset: i32, - pub fieldDefaultValuesCount: i32, - pub fieldAndParameterDefaultValueDataOffset: i32, - pub fieldAndParameterDefaultValueDataCount: i32, - pub fieldMarshaledSizesOffset: i32, - pub fieldMarshaledSizesCount: i32, - pub parametersOffset: i32, - pub parametersCount: i32, - pub fieldsOffset: i32, - pub fieldsCount: i32, - pub genericParametersOffset: i32, - pub genericParametersCount: i32, - pub genericParameterConstraintsOffset: i32, - pub genericParameterConstraintsCount: i32, - pub genericContainersOffset: i32, - pub genericContainersCount: i32, - pub nestedTypesOffset: i32, - pub nestedTypesCount: i32, - pub interfacesOffset: i32, - pub interfacesCount: i32, - pub vtableMethodsOffset: i32, - pub vtableMethodsCount: i32, - pub interfaceOffsetsOffset: i32, - pub interfaceOffsetsCount: i32, - pub typeDefinitionsOffset: i32, - pub typeDefinitionsCount: i32, - pub rgctxEntriesOffset: i32, - pub rgctxEntriesCount: i32, - pub imagesOffset: i32, - pub imagesCount: i32, - pub assembliesOffset: i32, - pub assembliesCount: i32, - pub metadataUsageListsOffset: i32, - pub metadataUsageListsCount: i32, - pub metadataUsagePairsOffset: i32, - pub metadataUsagePairsCount: i32, - pub fieldRefsOffset: i32, - pub fieldRefsCount: i32, - pub referencedAssembliesOffset: i32, - pub referencedAssembliesCount: i32, - pub attributesInfoOffset: i32, - pub attributesInfoCount: i32, - pub attributeTypesOffset: i32, - pub attributeTypesCount: i32, - pub unresolvedVirtualCallParameterTypesOffset: i32, - pub unresolvedVirtualCallParameterTypesCount: i32, - pub unresolvedVirtualCallParameterRangesOffset: i32, - pub unresolvedVirtualCallParameterRangesCount: i32, - pub windowsRuntimeTypeNamesOffset: i32, - pub windowsRuntimeTypeNamesSize: i32, - pub exportedTypeDefinitionsOffset: i32, - pub exportedTypeDefinitionsCount: i32, -} -#[test] -fn bindgen_test_layout_Il2CppGlobalMetadataHeader() { - assert_eq!( - ::std::mem::size_of::(), - 272usize, - concat!("Size of: ", stringify!(Il2CppGlobalMetadataHeader)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppGlobalMetadataHeader)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).sanity as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(sanity) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).version as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(version) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stringLiteralOffset as *const _ - as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(stringLiteralOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stringLiteralCount as *const _ - as usize - }, - 12usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(stringLiteralCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stringLiteralDataOffset - as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(stringLiteralDataOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stringLiteralDataCount - as *const _ as usize - }, - 20usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(stringLiteralDataCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stringOffset as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(stringOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stringCount as *const _ as usize - }, - 28usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(stringCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).eventsOffset as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(eventsOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).eventsCount as *const _ as usize - }, - 36usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(eventsCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).propertiesOffset as *const _ - as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(propertiesOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).propertiesCount as *const _ - as usize - }, - 44usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(propertiesCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).methodsOffset as *const _ - as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(methodsOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).methodsCount as *const _ as usize - }, - 52usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(methodsCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).parameterDefaultValuesOffset - as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(parameterDefaultValuesOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).parameterDefaultValuesCount - as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(parameterDefaultValuesCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).fieldDefaultValuesOffset - as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(fieldDefaultValuesOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).fieldDefaultValuesCount - as *const _ as usize - }, - 68usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(fieldDefaultValuesCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .fieldAndParameterDefaultValueDataOffset as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(fieldAndParameterDefaultValueDataOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .fieldAndParameterDefaultValueDataCount as *const _ as usize - }, - 76usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(fieldAndParameterDefaultValueDataCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).fieldMarshaledSizesOffset - as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(fieldMarshaledSizesOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).fieldMarshaledSizesCount - as *const _ as usize - }, - 84usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(fieldMarshaledSizesCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).parametersOffset as *const _ - as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(parametersOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).parametersCount as *const _ - as usize - }, - 92usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(parametersCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).fieldsOffset as *const _ as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(fieldsOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).fieldsCount as *const _ as usize - }, - 100usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(fieldsCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).genericParametersOffset - as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(genericParametersOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).genericParametersCount - as *const _ as usize - }, - 108usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(genericParametersCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).genericParameterConstraintsOffset - as *const _ as usize - }, - 112usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(genericParameterConstraintsOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).genericParameterConstraintsCount - as *const _ as usize - }, - 116usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(genericParameterConstraintsCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).genericContainersOffset - as *const _ as usize - }, - 120usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(genericContainersOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).genericContainersCount - as *const _ as usize - }, - 124usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(genericContainersCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).nestedTypesOffset as *const _ - as usize - }, - 128usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(nestedTypesOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).nestedTypesCount as *const _ - as usize - }, - 132usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(nestedTypesCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).interfacesOffset as *const _ - as usize - }, - 136usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(interfacesOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).interfacesCount as *const _ - as usize - }, - 140usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(interfacesCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtableMethodsOffset as *const _ - as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(vtableMethodsOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtableMethodsCount as *const _ - as usize - }, - 148usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(vtableMethodsCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).interfaceOffsetsOffset - as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(interfaceOffsetsOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).interfaceOffsetsCount as *const _ - as usize - }, - 156usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(interfaceOffsetsCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).typeDefinitionsOffset as *const _ - as usize - }, - 160usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(typeDefinitionsOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).typeDefinitionsCount as *const _ - as usize - }, - 164usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(typeDefinitionsCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rgctxEntriesOffset as *const _ - as usize - }, - 168usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(rgctxEntriesOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rgctxEntriesCount as *const _ - as usize - }, - 172usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(rgctxEntriesCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).imagesOffset as *const _ as usize - }, - 176usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(imagesOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).imagesCount as *const _ as usize - }, - 180usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(imagesCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).assembliesOffset as *const _ - as usize - }, - 184usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(assembliesOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).assembliesCount as *const _ - as usize - }, - 188usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(assembliesCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).metadataUsageListsOffset - as *const _ as usize - }, - 192usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(metadataUsageListsOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).metadataUsageListsCount - as *const _ as usize - }, - 196usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(metadataUsageListsCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).metadataUsagePairsOffset - as *const _ as usize - }, - 200usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(metadataUsagePairsOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).metadataUsagePairsCount - as *const _ as usize - }, - 204usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(metadataUsagePairsCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).fieldRefsOffset as *const _ - as usize - }, - 208usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(fieldRefsOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).fieldRefsCount as *const _ - as usize - }, - 212usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(fieldRefsCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).referencedAssembliesOffset - as *const _ as usize - }, - 216usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(referencedAssembliesOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).referencedAssembliesCount - as *const _ as usize - }, - 220usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(referencedAssembliesCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).attributesInfoOffset as *const _ - as usize - }, - 224usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(attributesInfoOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).attributesInfoCount as *const _ - as usize - }, - 228usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(attributesInfoCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).attributeTypesOffset as *const _ - as usize - }, - 232usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(attributeTypesOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).attributeTypesCount as *const _ - as usize - }, - 236usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(attributeTypesCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .unresolvedVirtualCallParameterTypesOffset as *const _ as usize - }, - 240usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(unresolvedVirtualCallParameterTypesOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .unresolvedVirtualCallParameterTypesCount as *const _ as usize - }, - 244usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(unresolvedVirtualCallParameterTypesCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .unresolvedVirtualCallParameterRangesOffset as *const _ as usize - }, - 248usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(unresolvedVirtualCallParameterRangesOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .unresolvedVirtualCallParameterRangesCount as *const _ as usize - }, - 252usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(unresolvedVirtualCallParameterRangesCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).windowsRuntimeTypeNamesOffset - as *const _ as usize - }, - 256usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(windowsRuntimeTypeNamesOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).windowsRuntimeTypeNamesSize - as *const _ as usize - }, - 260usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(windowsRuntimeTypeNamesSize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).exportedTypeDefinitionsOffset - as *const _ as usize - }, - 264usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(exportedTypeDefinitionsOffset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).exportedTypeDefinitionsCount - as *const _ as usize - }, - 268usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGlobalMetadataHeader), - "::", - stringify!(exportedTypeDefinitionsCount) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppArrayType() { - assert_eq!( - ::std::mem::size_of::(), - 32usize, - concat!("Size of: ", stringify!(Il2CppArrayType)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppArrayType)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).etype as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppArrayType), - "::", - stringify!(etype) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).rank as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppArrayType), - "::", - stringify!(rank) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).numsizes as *const _ as usize }, - 9usize, - concat!( - "Offset of field: ", - stringify!(Il2CppArrayType), - "::", - stringify!(numsizes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).numlobounds as *const _ as usize }, - 10usize, - concat!( - "Offset of field: ", - stringify!(Il2CppArrayType), - "::", - stringify!(numlobounds) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sizes as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppArrayType), - "::", - stringify!(sizes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).lobounds as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppArrayType), - "::", - stringify!(lobounds) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppGenericInst { - pub type_argc: u32, - pub type_argv: *mut *const Il2CppType, -} -#[test] -fn bindgen_test_layout_Il2CppGenericInst() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(Il2CppGenericInst)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppGenericInst)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).type_argc as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGenericInst), - "::", - stringify!(type_argc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).type_argv as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGenericInst), - "::", - stringify!(type_argv) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppGenericContext { - pub class_inst: *const Il2CppGenericInst, - pub method_inst: *const Il2CppGenericInst, -} -#[test] -fn bindgen_test_layout_Il2CppGenericContext() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(Il2CppGenericContext)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppGenericContext)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).class_inst as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGenericContext), - "::", - stringify!(class_inst) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).method_inst as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGenericContext), - "::", - stringify!(method_inst) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppGenericParameter { - pub ownerIndex: GenericContainerIndex, - pub nameIndex: StringIndex, - pub constraintsStart: GenericParameterConstraintIndex, - pub constraintsCount: i16, - pub num: u16, - pub flags: u16, -} -#[test] -fn bindgen_test_layout_Il2CppGenericParameter() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(Il2CppGenericParameter)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppGenericParameter)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).ownerIndex as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGenericParameter), - "::", - stringify!(ownerIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).nameIndex as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGenericParameter), - "::", - stringify!(nameIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).constraintsStart as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGenericParameter), - "::", - stringify!(constraintsStart) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).constraintsCount as *const _ as usize - }, - 10usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGenericParameter), - "::", - stringify!(constraintsCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).num as *const _ as usize }, - 12usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGenericParameter), - "::", - stringify!(num) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).flags as *const _ as usize }, - 14usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGenericParameter), - "::", - stringify!(flags) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppGenericContainer { - pub ownerIndex: i32, - pub type_argc: i32, - pub is_method: i32, - pub genericParameterStart: GenericParameterIndex, -} -#[test] -fn bindgen_test_layout_Il2CppGenericContainer() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(Il2CppGenericContainer)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppGenericContainer)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).ownerIndex as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGenericContainer), - "::", - stringify!(ownerIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).type_argc as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGenericContainer), - "::", - stringify!(type_argc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).is_method as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGenericContainer), - "::", - stringify!(is_method) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).genericParameterStart as *const _ - as usize - }, - 12usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGenericContainer), - "::", - stringify!(genericParameterStart) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppGenericClass { - pub typeDefinitionIndex: TypeDefinitionIndex, - pub context: Il2CppGenericContext, - pub cached_class: *mut Il2CppClass, -} -#[test] -fn bindgen_test_layout_Il2CppGenericClass() { - assert_eq!( - ::std::mem::size_of::(), - 32usize, - concat!("Size of: ", stringify!(Il2CppGenericClass)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppGenericClass)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).typeDefinitionIndex as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGenericClass), - "::", - stringify!(typeDefinitionIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).context as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGenericClass), - "::", - stringify!(context) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).cached_class as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGenericClass), - "::", - stringify!(cached_class) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppGenericMethod { - pub methodDefinition: *const MethodInfo, - pub context: Il2CppGenericContext, -} -#[test] -fn bindgen_test_layout_Il2CppGenericMethod() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(Il2CppGenericMethod)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppGenericMethod)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).methodDefinition as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGenericMethod), - "::", - stringify!(methodDefinition) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).context as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGenericMethod), - "::", - stringify!(context) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppType { - pub data: Il2CppType__bindgen_ty_1, - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u16>, - pub __bindgen_padding_0: u32, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union Il2CppType__bindgen_ty_1 { - pub dummy: *mut ::std::os::raw::c_void, - pub klassIndex: TypeDefinitionIndex, - pub type_: *const Il2CppType, - pub array: *mut Il2CppArrayType, - pub genericParameterIndex: GenericParameterIndex, - pub generic_class: *mut Il2CppGenericClass, - _bindgen_union_align: u64, -} -#[test] -fn bindgen_test_layout_Il2CppType__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(Il2CppType__bindgen_ty_1)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppType__bindgen_ty_1)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).dummy as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppType__bindgen_ty_1), - "::", - stringify!(dummy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).klassIndex as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppType__bindgen_ty_1), - "::", - stringify!(klassIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).type_ as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppType__bindgen_ty_1), - "::", - stringify!(type_) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).array as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppType__bindgen_ty_1), - "::", - stringify!(array) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).genericParameterIndex as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppType__bindgen_ty_1), - "::", - stringify!(genericParameterIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).generic_class as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppType__bindgen_ty_1), - "::", - stringify!(generic_class) - ) - ); -} -#[test] -fn bindgen_test_layout_Il2CppType() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(Il2CppType)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppType)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppType), - "::", - stringify!(data) - ) - ); -} -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, 6u8) 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, 6u8, val as u64) - } - } - #[inline] - pub fn byref(&self) -> ::std::os::raw::c_uint { - unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 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(30usize, 1u8, val as u64) - } - } - #[inline] - pub fn pinned(&self) -> ::std::os::raw::c_uint { - unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 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(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, - ) -> __BindgenBitfieldUnit<[u8; 4usize], u16> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u16> = - 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, 6u8, { - let num_mods: u32 = unsafe { ::std::mem::transmute(num_mods) }; - num_mods as u64 - }); - __bindgen_bitfield_unit.set(30usize, 1u8, { - let byref: u32 = unsafe { ::std::mem::transmute(byref) }; - byref as u64 - }); - __bindgen_bitfield_unit.set(31usize, 1u8, { - let pinned: u32 = unsafe { ::std::mem::transmute(pinned) }; - pinned as u64 - }); - __bindgen_bitfield_unit - } -} -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 type Il2CppCallConvention = i32; -pub const Il2CppCharSet_CHARSET_ANSI: Il2CppCharSet = 0; -pub const Il2CppCharSet_CHARSET_UNICODE: Il2CppCharSet = 1; -pub const Il2CppCharSet_CHARSET_NOT_SPECIFIED: Il2CppCharSet = 2; -pub type Il2CppCharSet = i32; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppNameToTypeDefinitionIndexHashTable { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct VirtualInvokeData { - pub methodPtr: Il2CppMethodPointer, - pub method: *const MethodInfo, -} -#[test] -fn bindgen_test_layout_VirtualInvokeData() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(VirtualInvokeData)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(VirtualInvokeData)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).methodPtr as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(VirtualInvokeData), - "::", - stringify!(methodPtr) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).method as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(VirtualInvokeData), - "::", - stringify!(method) - ) - ); -} -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; -pub type Il2CppTypeNameFormat = i32; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppDefaults { - pub corlib: *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 field_info_class: *mut Il2CppClass, - pub method_info_class: *mut Il2CppClass, - pub property_info_class: *mut Il2CppClass, - pub event_info_class: *mut Il2CppClass, - pub mono_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 version: *mut Il2CppClass, - pub culture_info: *mut Il2CppClass, - pub async_call_class: *mut Il2CppClass, - pub assembly_class: *mut Il2CppClass, - pub mono_assembly_class: *mut Il2CppClass, - pub assembly_name_class: *mut Il2CppClass, - pub mono_field_class: *mut Il2CppClass, - pub mono_method_class: *mut Il2CppClass, - pub mono_method_info_class: *mut Il2CppClass, - pub mono_property_info_class: *mut Il2CppClass, - pub parameter_info_class: *mut Il2CppClass, - pub mono_parameter_info_class: *mut Il2CppClass, - pub module_class: *mut Il2CppClass, - pub pointer_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, -} -#[test] -fn bindgen_test_layout_Il2CppDefaults() { - assert_eq!( - ::std::mem::size_of::(), - 784usize, - concat!("Size of: ", stringify!(Il2CppDefaults)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppDefaults)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).corlib as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(corlib) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).object_class as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(object_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).byte_class as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(byte_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).void_class as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(void_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).boolean_class as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(boolean_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sbyte_class as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(sbyte_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).int16_class as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(int16_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).uint16_class as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(uint16_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).int32_class as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(int32_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).uint32_class as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(uint32_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).int_class as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(int_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).uint_class as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(uint_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).int64_class as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(int64_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).uint64_class as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(uint64_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).single_class as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(single_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).double_class as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(double_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).char_class as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(char_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).string_class as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(string_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).enum_class as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(enum_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).array_class as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(array_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).delegate_class as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(delegate_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).multicastdelegate_class as *const _ as usize - }, - 168usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(multicastdelegate_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).asyncresult_class as *const _ as usize - }, - 176usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(asyncresult_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).manualresetevent_class as *const _ as usize - }, - 184usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(manualresetevent_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).typehandle_class as *const _ as usize }, - 192usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(typehandle_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).fieldhandle_class as *const _ as usize - }, - 200usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(fieldhandle_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).methodhandle_class as *const _ as usize - }, - 208usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(methodhandle_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).systemtype_class as *const _ as usize }, - 216usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(systemtype_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).monotype_class as *const _ as usize }, - 224usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(monotype_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).exception_class as *const _ as usize }, - 232usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(exception_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).threadabortexception_class as *const _ - as usize - }, - 240usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(threadabortexception_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).thread_class as *const _ as usize }, - 248usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(thread_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).internal_thread_class as *const _ as usize - }, - 256usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(internal_thread_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).appdomain_class as *const _ as usize }, - 264usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(appdomain_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).appdomain_setup_class as *const _ as usize - }, - 272usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(appdomain_setup_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).field_info_class as *const _ as usize }, - 280usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(field_info_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).method_info_class as *const _ as usize - }, - 288usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(method_info_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).property_info_class as *const _ as usize - }, - 296usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(property_info_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).event_info_class as *const _ as usize }, - 304usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(event_info_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mono_event_info_class as *const _ as usize - }, - 312usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(mono_event_info_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stringbuilder_class as *const _ as usize - }, - 320usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(stringbuilder_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stack_frame_class as *const _ as usize - }, - 328usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(stack_frame_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stack_trace_class as *const _ as usize - }, - 336usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(stack_trace_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).marshal_class as *const _ as usize }, - 344usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(marshal_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).typed_reference_class as *const _ as usize - }, - 352usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(typed_reference_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).marshalbyrefobject_class as *const _ as usize - }, - 360usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(marshalbyrefobject_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).generic_ilist_class as *const _ as usize - }, - 368usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(generic_ilist_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).generic_icollection_class as *const _ - as usize - }, - 376usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(generic_icollection_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).generic_ienumerable_class as *const _ - as usize - }, - 384usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(generic_ienumerable_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).generic_ireadonlylist_class as *const _ - as usize - }, - 392usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(generic_ireadonlylist_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).generic_ireadonlycollection_class as *const _ - as usize - }, - 400usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(generic_ireadonlycollection_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).runtimetype_class as *const _ as usize - }, - 408usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(runtimetype_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).generic_nullable_class as *const _ as usize - }, - 416usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(generic_nullable_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).il2cpp_com_object_class as *const _ as usize - }, - 424usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(il2cpp_com_object_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).attribute_class as *const _ as usize }, - 432usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(attribute_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).customattribute_data_class as *const _ - as usize - }, - 440usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(customattribute_data_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).version as *const _ as usize }, - 448usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(version) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).culture_info as *const _ as usize }, - 456usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(culture_info) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).async_call_class as *const _ as usize }, - 464usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(async_call_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).assembly_class as *const _ as usize }, - 472usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(assembly_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mono_assembly_class as *const _ as usize - }, - 480usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(mono_assembly_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).assembly_name_class as *const _ as usize - }, - 488usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(assembly_name_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mono_field_class as *const _ as usize }, - 496usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(mono_field_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mono_method_class as *const _ as usize - }, - 504usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(mono_method_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mono_method_info_class as *const _ as usize - }, - 512usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(mono_method_info_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mono_property_info_class as *const _ as usize - }, - 520usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(mono_property_info_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).parameter_info_class as *const _ as usize - }, - 528usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(parameter_info_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mono_parameter_info_class as *const _ - as usize - }, - 536usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(mono_parameter_info_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).module_class as *const _ as usize }, - 544usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(module_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pointer_class as *const _ as usize }, - 552usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(pointer_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).system_exception_class as *const _ as usize - }, - 560usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(system_exception_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).argument_exception_class as *const _ as usize - }, - 568usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(argument_exception_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wait_handle_class as *const _ as usize - }, - 576usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(wait_handle_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).safe_handle_class as *const _ as usize - }, - 584usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(safe_handle_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sort_key_class as *const _ as usize }, - 592usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(sort_key_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).dbnull_class as *const _ as usize }, - 600usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(dbnull_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).error_wrapper_class as *const _ as usize - }, - 608usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(error_wrapper_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).missing_class as *const _ as usize }, - 616usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(missing_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_type_class as *const _ as usize }, - 624usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(value_type_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).threadpool_wait_callback_class as *const _ - as usize - }, - 632usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(threadpool_wait_callback_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).threadpool_perform_wait_callback_method - as *const _ as usize - }, - 640usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(threadpool_perform_wait_callback_method) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mono_method_message_class as *const _ - as usize - }, - 648usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(mono_method_message_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).ireference_class as *const _ as usize }, - 656usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(ireference_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).ireferencearray_class as *const _ as usize - }, - 664usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(ireferencearray_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).ikey_value_pair_class as *const _ as usize - }, - 672usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(ikey_value_pair_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).key_value_pair_class as *const _ as usize - }, - 680usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(key_value_pair_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).windows_foundation_uri_class as *const _ - as usize - }, - 688usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(windows_foundation_uri_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).windows_foundation_iuri_runtime_class_class - as *const _ as usize - }, - 696usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(windows_foundation_iuri_runtime_class_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).system_uri_class as *const _ as usize }, - 704usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(system_uri_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).system_guid_class as *const _ as usize - }, - 712usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(system_guid_class) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).sbyte_shared_enum as *const _ as usize - }, - 720usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(sbyte_shared_enum) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).int16_shared_enum as *const _ as usize - }, - 728usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(int16_shared_enum) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).int32_shared_enum as *const _ as usize - }, - 736usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(int32_shared_enum) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).int64_shared_enum as *const _ as usize - }, - 744usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(int64_shared_enum) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).byte_shared_enum as *const _ as usize }, - 752usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(byte_shared_enum) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).uint16_shared_enum as *const _ as usize - }, - 760usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(uint16_shared_enum) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).uint32_shared_enum as *const _ as usize - }, - 768usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(uint32_shared_enum) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).uint64_shared_enum as *const _ as usize - }, - 776usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDefaults), - "::", - stringify!(uint64_shared_enum) - ) - ); -} -extern "C" { - pub static mut il2cpp_defaults: Il2CppDefaults; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct MemberInfo { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct CustomAttributesCache { - pub count: ::std::os::raw::c_int, - pub attributes: *mut *mut Il2CppObject, -} -#[test] -fn bindgen_test_layout_CustomAttributesCache() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(CustomAttributesCache)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(CustomAttributesCache)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).count as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(CustomAttributesCache), - "::", - stringify!(count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).attributes as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(CustomAttributesCache), - "::", - stringify!(attributes) - ) - ); -} -pub type CustomAttributesCacheGenerator = - ::std::option::Option; -pub const THREAD_STATIC_FIELD_OFFSET: ::std::os::raw::c_int = -1; -#[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, -} -#[test] -fn bindgen_test_layout_FieldInfo() { - assert_eq!( - ::std::mem::size_of::(), - 32usize, - concat!("Size of: ", stringify!(FieldInfo)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(FieldInfo)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(FieldInfo), - "::", - stringify!(name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).type_ as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(FieldInfo), - "::", - stringify!(type_) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).parent as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(FieldInfo), - "::", - stringify!(parent) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).offset as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(FieldInfo), - "::", - stringify!(offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, - 28usize, - concat!( - "Offset of field: ", - stringify!(FieldInfo), - "::", - stringify!(token) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_PropertyInfo() { - assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(PropertyInfo)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(PropertyInfo)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).parent as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(PropertyInfo), - "::", - stringify!(parent) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(PropertyInfo), - "::", - stringify!(name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).get as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(PropertyInfo), - "::", - stringify!(get) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).set as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(PropertyInfo), - "::", - stringify!(set) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).attrs as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(PropertyInfo), - "::", - stringify!(attrs) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, - 36usize, - concat!( - "Offset of field: ", - stringify!(PropertyInfo), - "::", - stringify!(token) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_EventInfo() { - assert_eq!( - ::std::mem::size_of::(), - 56usize, - concat!("Size of: ", stringify!(EventInfo)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(EventInfo)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(EventInfo), - "::", - stringify!(name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).eventType as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(EventInfo), - "::", - stringify!(eventType) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).parent as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(EventInfo), - "::", - stringify!(parent) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).add as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(EventInfo), - "::", - stringify!(add) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).remove as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(EventInfo), - "::", - stringify!(remove) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).raise as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(EventInfo), - "::", - stringify!(raise) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(EventInfo), - "::", - stringify!(token) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct ParameterInfo { - pub name: *const ::std::os::raw::c_char, - pub position: i32, - pub token: u32, - pub parameter_type: *const Il2CppType, -} -#[test] -fn bindgen_test_layout_ParameterInfo() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(ParameterInfo)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(ParameterInfo)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(ParameterInfo), - "::", - stringify!(name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).position as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(ParameterInfo), - "::", - stringify!(position) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, - 12usize, - concat!( - "Offset of field: ", - stringify!(ParameterInfo), - "::", - stringify!(token) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).parameter_type as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(ParameterInfo), - "::", - stringify!(parameter_type) - ) - ); -} -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, - ) -> *mut ::std::os::raw::c_void, ->; -pub const MethodVariableKind_kMethodVariableKind_This: MethodVariableKind = 0; -pub const MethodVariableKind_kMethodVariableKind_Parameter: MethodVariableKind = 1; -pub const MethodVariableKind_kMethodVariableKind_LocalVariable: MethodVariableKind = 2; -pub type MethodVariableKind = i32; -pub const SequencePointKind_kSequencePointKind_Normal: SequencePointKind = 0; -pub const SequencePointKind_kSequencePointKind_StepOut: SequencePointKind = 1; -pub type SequencePointKind = i32; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppMethodExecutionContextInfo { - pub typeIndex: TypeIndex, - pub nameIndex: i32, - pub scopeIndex: i32, -} -#[test] -fn bindgen_test_layout_Il2CppMethodExecutionContextInfo() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!("Size of: ", stringify!(Il2CppMethodExecutionContextInfo)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(Il2CppMethodExecutionContextInfo) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).typeIndex as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodExecutionContextInfo), - "::", - stringify!(typeIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).nameIndex as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodExecutionContextInfo), - "::", - stringify!(nameIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).scopeIndex as *const _ - as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodExecutionContextInfo), - "::", - stringify!(scopeIndex) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppMethodExecutionContextInfoIndex { - pub tableIndex: i8, - pub startIndex: i32, - pub count: i32, -} -#[test] -fn bindgen_test_layout_Il2CppMethodExecutionContextInfoIndex() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!( - "Size of: ", - stringify!(Il2CppMethodExecutionContextInfoIndex) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(Il2CppMethodExecutionContextInfoIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).tableIndex as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodExecutionContextInfoIndex), - "::", - stringify!(tableIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).startIndex as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodExecutionContextInfoIndex), - "::", - stringify!(startIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).count as *const _ - as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodExecutionContextInfoIndex), - "::", - stringify!(count) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppMethodScope { - pub startOffset: i32, - pub endOffset: i32, -} -#[test] -fn bindgen_test_layout_Il2CppMethodScope() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(Il2CppMethodScope)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppMethodScope)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).startOffset as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodScope), - "::", - stringify!(startOffset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).endOffset as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodScope), - "::", - stringify!(endOffset) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppMethodHeaderInfo { - pub codeSize: i32, - pub startScope: i32, - pub numScopes: i32, -} -#[test] -fn bindgen_test_layout_Il2CppMethodHeaderInfo() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!("Size of: ", stringify!(Il2CppMethodHeaderInfo)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppMethodHeaderInfo)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).codeSize as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodHeaderInfo), - "::", - stringify!(codeSize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).startScope as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodHeaderInfo), - "::", - stringify!(startScope) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).numScopes as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodHeaderInfo), - "::", - stringify!(numScopes) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppSequencePointIndex { - pub tableIndex: u8, - pub index: i32, -} -#[test] -fn bindgen_test_layout_Il2CppSequencePointIndex() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(Il2CppSequencePointIndex)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppSequencePointIndex)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).tableIndex as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSequencePointIndex), - "::", - stringify!(tableIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).index as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSequencePointIndex), - "::", - stringify!(index) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppSequencePointSourceFile { - pub file: *const ::std::os::raw::c_char, - pub hash: [u8; 16usize], -} -#[test] -fn bindgen_test_layout_Il2CppSequencePointSourceFile() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(Il2CppSequencePointSourceFile)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppSequencePointSourceFile)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).file as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSequencePointSourceFile), - "::", - stringify!(file) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).hash as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSequencePointSourceFile), - "::", - stringify!(hash) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppTypeSourceFilePair { - pub klassIndex: TypeIndex, - pub sourceFileIndex: i32, -} -#[test] -fn bindgen_test_layout_Il2CppTypeSourceFilePair() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(Il2CppTypeSourceFilePair)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppTypeSourceFilePair)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).klassIndex as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeSourceFilePair), - "::", - stringify!(klassIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).sourceFileIndex as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeSourceFilePair), - "::", - stringify!(sourceFileIndex) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppSequencePoint { - pub methodDefinitionIndex: MethodIndex, - pub catchTypeIndex: TypeIndex, - pub sourceFileIndex: i32, - pub lineStart: i32, - pub lineEnd: i32, - pub columnStart: i32, - pub columnEnd: i32, - pub ilOffset: i32, - pub kind: SequencePointKind, - pub isActive: u8, - pub id: i32, - pub tryDepth: u8, -} -#[test] -fn bindgen_test_layout_Il2CppSequencePoint() { - assert_eq!( - ::std::mem::size_of::(), - 48usize, - concat!("Size of: ", stringify!(Il2CppSequencePoint)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppSequencePoint)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).methodDefinitionIndex as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSequencePoint), - "::", - stringify!(methodDefinitionIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).catchTypeIndex as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSequencePoint), - "::", - stringify!(catchTypeIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).sourceFileIndex as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSequencePoint), - "::", - stringify!(sourceFileIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).lineStart as *const _ as usize }, - 12usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSequencePoint), - "::", - stringify!(lineStart) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).lineEnd as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSequencePoint), - "::", - stringify!(lineEnd) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).columnStart as *const _ as usize }, - 20usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSequencePoint), - "::", - stringify!(columnStart) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).columnEnd as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSequencePoint), - "::", - stringify!(columnEnd) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).ilOffset as *const _ as usize }, - 28usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSequencePoint), - "::", - stringify!(ilOffset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).kind as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSequencePoint), - "::", - stringify!(kind) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).isActive as *const _ as usize }, - 36usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSequencePoint), - "::", - stringify!(isActive) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).id as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSequencePoint), - "::", - stringify!(id) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).tryDepth as *const _ as usize }, - 44usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSequencePoint), - "::", - stringify!(tryDepth) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppDebuggerMetadataRegistration { - pub methodExecutionContextInfos: *mut *mut Il2CppMethodExecutionContextInfo, - pub methodExecutionContextInfoIndexes: *mut Il2CppMethodExecutionContextInfoIndex, - pub methodScopes: *mut Il2CppMethodScope, - pub methodHeaderInfos: *mut Il2CppMethodHeaderInfo, - pub sequencePointSourceFiles: *mut Il2CppSequencePointSourceFile, - pub numSequencePoints: i32, - pub sequencePointIndexes: *mut Il2CppSequencePointIndex, - pub sequencePoints: *mut *mut Il2CppSequencePoint, - pub numTypeSourceFileEntries: i32, - pub typeSourceFiles: *mut Il2CppTypeSourceFilePair, - pub methodExecutionContextInfoStrings: *mut *const ::std::os::raw::c_char, -} -#[test] -fn bindgen_test_layout_Il2CppDebuggerMetadataRegistration() { - assert_eq!( - ::std::mem::size_of::(), - 88usize, - concat!("Size of: ", stringify!(Il2CppDebuggerMetadataRegistration)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!( - "Alignment of ", - stringify!(Il2CppDebuggerMetadataRegistration) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .methodExecutionContextInfos as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDebuggerMetadataRegistration), - "::", - stringify!(methodExecutionContextInfos) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .methodExecutionContextInfoIndexes as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDebuggerMetadataRegistration), - "::", - stringify!(methodExecutionContextInfoIndexes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).methodScopes as *const _ - as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDebuggerMetadataRegistration), - "::", - stringify!(methodScopes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).methodHeaderInfos - as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDebuggerMetadataRegistration), - "::", - stringify!(methodHeaderInfos) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).sequencePointSourceFiles - as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDebuggerMetadataRegistration), - "::", - stringify!(sequencePointSourceFiles) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).numSequencePoints - as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDebuggerMetadataRegistration), - "::", - stringify!(numSequencePoints) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).sequencePointIndexes - as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDebuggerMetadataRegistration), - "::", - stringify!(sequencePointIndexes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).sequencePoints - as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDebuggerMetadataRegistration), - "::", - stringify!(sequencePoints) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).numTypeSourceFileEntries - as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDebuggerMetadataRegistration), - "::", - stringify!(numTypeSourceFileEntries) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).typeSourceFiles - as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDebuggerMetadataRegistration), - "::", - stringify!(typeSourceFiles) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .methodExecutionContextInfoStrings as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDebuggerMetadataRegistration), - "::", - stringify!(methodExecutionContextInfoStrings) - ) - ); -} -#[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, - _bindgen_union_align: u64, -} -#[test] -fn bindgen_test_layout_Il2CppRGCTXData() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(Il2CppRGCTXData)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppRGCTXData)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).rgctxDataDummy as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRGCTXData), - "::", - stringify!(rgctxDataDummy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).method as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRGCTXData), - "::", - stringify!(method) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).type_ as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRGCTXData), - "::", - stringify!(type_) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).klass as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRGCTXData), - "::", - stringify!(klass) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct MethodInfo { - pub methodPointer: Il2CppMethodPointer, - pub invoker_method: InvokerMethod, - pub name: *const ::std::os::raw::c_char, - pub klass: *mut Il2CppClass, - pub return_type: *const Il2CppType, - pub parameters: *const ParameterInfo, - 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_1: __BindgenBitfieldUnit<[u8; 1usize], u8>, - pub __bindgen_padding_0: u32, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union MethodInfo__bindgen_ty_1 { - pub rgctx_data: *const Il2CppRGCTXData, - pub methodDefinition: *const Il2CppMethodDefinition, - _bindgen_union_align: u64, -} -#[test] -fn bindgen_test_layout_MethodInfo__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(MethodInfo__bindgen_ty_1)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(MethodInfo__bindgen_ty_1)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rgctx_data as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(MethodInfo__bindgen_ty_1), - "::", - stringify!(rgctx_data) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).methodDefinition as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(MethodInfo__bindgen_ty_1), - "::", - stringify!(methodDefinition) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union MethodInfo__bindgen_ty_2 { - pub genericMethod: *const Il2CppGenericMethod, - pub genericContainer: *const Il2CppGenericContainer, - _bindgen_union_align: u64, -} -#[test] -fn bindgen_test_layout_MethodInfo__bindgen_ty_2() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(MethodInfo__bindgen_ty_2)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(MethodInfo__bindgen_ty_2)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).genericMethod as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(MethodInfo__bindgen_ty_2), - "::", - stringify!(genericMethod) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).genericContainer as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(MethodInfo__bindgen_ty_2), - "::", - stringify!(genericContainer) - ) - ); -} -#[test] -fn bindgen_test_layout_MethodInfo() { - assert_eq!( - ::std::mem::size_of::(), - 80usize, - concat!("Size of: ", stringify!(MethodInfo)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(MethodInfo)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).methodPointer as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(MethodInfo), - "::", - stringify!(methodPointer) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).invoker_method as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(MethodInfo), - "::", - stringify!(invoker_method) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(MethodInfo), - "::", - stringify!(name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).klass as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(MethodInfo), - "::", - stringify!(klass) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).return_type as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(MethodInfo), - "::", - stringify!(return_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).parameters as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(MethodInfo), - "::", - stringify!(parameters) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(MethodInfo), - "::", - stringify!(token) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).flags as *const _ as usize }, - 68usize, - concat!( - "Offset of field: ", - stringify!(MethodInfo), - "::", - stringify!(flags) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iflags as *const _ as usize }, - 70usize, - concat!( - "Offset of field: ", - stringify!(MethodInfo), - "::", - stringify!(iflags) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).slot as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(MethodInfo), - "::", - stringify!(slot) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).parameters_count as *const _ as usize }, - 74usize, - concat!( - "Offset of field: ", - stringify!(MethodInfo), - "::", - stringify!(parameters_count) - ) - ); -} -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 is_marshaled_from_native(&self) -> u8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) } - } - #[inline] - pub fn set_is_marshaled_from_native(&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, - is_marshaled_from_native: u8, - ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> = - 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 is_marshaled_from_native: u8 = - unsafe { ::std::mem::transmute(is_marshaled_from_native) }; - is_marshaled_from_native as u64 - }); - __bindgen_bitfield_unit - } -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppRuntimeInterfaceOffsetPair { - pub interfaceType: *mut Il2CppClass, - pub offset: i32, -} -#[test] -fn bindgen_test_layout_Il2CppRuntimeInterfaceOffsetPair() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(Il2CppRuntimeInterfaceOffsetPair)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!( - "Alignment of ", - stringify!(Il2CppRuntimeInterfaceOffsetPair) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).interfaceType as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRuntimeInterfaceOffsetPair), - "::", - stringify!(interfaceType) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).offset as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRuntimeInterfaceOffsetPair), - "::", - stringify!(offset) - ) - ); -} -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; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppIUnknown { - _unused: [u8; 0], -} -pub type CreateCCWFunc = - ::std::option::Option *mut Il2CppIUnknown>; -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppInteropData() { - assert_eq!( - ::std::mem::size_of::(), - 56usize, - concat!("Size of: ", stringify!(Il2CppInteropData)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppInteropData)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).delegatePInvokeWrapperFunction as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInteropData), - "::", - stringify!(delegatePInvokeWrapperFunction) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).pinvokeMarshalToNativeFunction as *const _ - as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInteropData), - "::", - stringify!(pinvokeMarshalToNativeFunction) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).pinvokeMarshalFromNativeFunction - as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInteropData), - "::", - stringify!(pinvokeMarshalFromNativeFunction) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).pinvokeMarshalCleanupFunction as *const _ - as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInteropData), - "::", - stringify!(pinvokeMarshalCleanupFunction) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).createCCWFunction as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInteropData), - "::", - stringify!(createCCWFunction) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).guid as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInteropData), - "::", - stringify!(guid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).type_ as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInteropData), - "::", - stringify!(type_) - ) - ); -} -#[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 typeDefinition: *const Il2CppTypeDefinition, - 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 initializationExceptionGCHandle: u32, - pub cctor_started: u32, - pub cctor_finished: u32, - pub cctor_thread: u64, - pub genericContainerIndex: GenericContainerIndex, - pub instance_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_1: __BindgenBitfieldUnit<[u8; 2usize], u8>, - pub vtable: __IncompleteArrayField, -} -#[test] -fn bindgen_test_layout_Il2CppClass() { - assert_eq!( - ::std::mem::size_of::(), - 296usize, - concat!("Size of: ", stringify!(Il2CppClass)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppClass)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).image as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(image) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).gc_desc as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(gc_desc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).namespaze as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(namespaze) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).byval_arg as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(byval_arg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).this_arg as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(this_arg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).element_class as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(element_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).castClass as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(castClass) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).declaringType as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(declaringType) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).parent as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(parent) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).generic_class as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(generic_class) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).typeDefinition as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(typeDefinition) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).interopData as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(interopData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).klass as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(klass) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).fields as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(fields) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).events as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(events) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).properties as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(properties) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).methods as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(methods) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nestedTypes as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(nestedTypes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).implementedInterfaces as *const _ as usize - }, - 168usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(implementedInterfaces) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).interfaceOffsets as *const _ as usize }, - 176usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(interfaceOffsets) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).static_fields as *const _ as usize }, - 184usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(static_fields) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).rgctx_data as *const _ as usize }, - 192usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(rgctx_data) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).typeHierarchy as *const _ as usize }, - 200usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(typeHierarchy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).initializationExceptionGCHandle as *const _ - as usize - }, - 208usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(initializationExceptionGCHandle) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).cctor_started as *const _ as usize }, - 212usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(cctor_started) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).cctor_finished as *const _ as usize }, - 216usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(cctor_finished) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).cctor_thread as *const _ as usize }, - 224usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(cctor_thread) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).genericContainerIndex as *const _ as usize - }, - 232usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(genericContainerIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).instance_size as *const _ as usize }, - 236usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(instance_size) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).actualSize as *const _ as usize }, - 240usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(actualSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).element_size as *const _ as usize }, - 244usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(element_size) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).native_size as *const _ as usize }, - 248usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(native_size) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).static_fields_size as *const _ as usize }, - 252usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(static_fields_size) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_static_fields_size as *const _ as usize - }, - 256usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(thread_static_fields_size) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_static_fields_offset as *const _ as usize - }, - 260usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(thread_static_fields_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).flags as *const _ as usize }, - 264usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(flags) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, - 268usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(token) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).method_count as *const _ as usize }, - 272usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(method_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).property_count as *const _ as usize }, - 274usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(property_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).field_count as *const _ as usize }, - 276usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(field_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).event_count as *const _ as usize }, - 278usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(event_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nested_type_count as *const _ as usize }, - 280usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(nested_type_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vtable_count as *const _ as usize }, - 282usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(vtable_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).interfaces_count as *const _ as usize }, - 284usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(interfaces_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).interface_offsets_count as *const _ as usize - }, - 286usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(interface_offsets_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).typeHierarchyDepth as *const _ as usize }, - 288usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(typeHierarchyDepth) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).genericRecursionDepth as *const _ as usize - }, - 289usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(genericRecursionDepth) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).rank as *const _ as usize }, - 290usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(rank) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).minimumAlignment as *const _ as usize }, - 291usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(minimumAlignment) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).packingSize as *const _ as usize }, - 292usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(packingSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vtable as *const _ as usize }, - 296usize, - concat!( - "Offset of field: ", - stringify!(Il2CppClass), - "::", - stringify!(vtable) - ) - ); -} -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 valuetype(&self) -> u8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } - } - #[inline] - pub fn set_valuetype(&mut self, val: u8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub fn initialized(&self) -> u8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) } - } - #[inline] - pub fn set_initialized(&mut self, val: u8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(2usize, 1u8, val as u64) - } - } - #[inline] - pub fn enumtype(&self) -> u8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) } - } - #[inline] - pub fn set_enumtype(&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_inited(&self) -> u8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 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(7usize, 1u8, val as u64) - } - } - #[inline] - pub fn has_finalize(&self) -> u8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 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(8usize, 1u8, val as u64) - } - } - #[inline] - pub fn has_cctor(&self) -> u8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 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(9usize, 1u8, val as u64) - } - } - #[inline] - pub fn is_blittable(&self) -> u8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 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(10usize, 1u8, val as u64) - } - } - #[inline] - pub fn is_import_or_windows_runtime(&self) -> u8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 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(11usize, 1u8, val as u64) - } - } - #[inline] - pub fn is_vtable_initialized(&self) -> u8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 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(12usize, 1u8, val as u64) - } - } - #[inline] - pub fn has_initialization_error(&self) -> u8 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u8) } - } - #[inline] - pub fn set_has_initialization_error(&mut self, val: u8) { - unsafe { - let val: u8 = ::std::mem::transmute(val); - self._bitfield_1.set(13usize, 1u8, val as u64) - } - } - #[inline] - pub fn new_bitfield_1( - initialized_and_no_error: u8, - valuetype: u8, - initialized: u8, - enumtype: u8, - is_generic: u8, - has_references: u8, - 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, - has_initialization_error: u8, - ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> = - 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 valuetype: u8 = unsafe { ::std::mem::transmute(valuetype) }; - valuetype as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let initialized: u8 = unsafe { ::std::mem::transmute(initialized) }; - initialized as u64 - }); - __bindgen_bitfield_unit.set(3usize, 1u8, { - let enumtype: u8 = unsafe { ::std::mem::transmute(enumtype) }; - enumtype 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_inited: u8 = unsafe { ::std::mem::transmute(size_inited) }; - size_inited as u64 - }); - __bindgen_bitfield_unit.set(8usize, 1u8, { - let has_finalize: u8 = unsafe { ::std::mem::transmute(has_finalize) }; - has_finalize as u64 - }); - __bindgen_bitfield_unit.set(9usize, 1u8, { - let has_cctor: u8 = unsafe { ::std::mem::transmute(has_cctor) }; - has_cctor as u64 - }); - __bindgen_bitfield_unit.set(10usize, 1u8, { - let is_blittable: u8 = unsafe { ::std::mem::transmute(is_blittable) }; - is_blittable as u64 - }); - __bindgen_bitfield_unit.set(11usize, 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(12usize, 1u8, { - let is_vtable_initialized: u8 = unsafe { ::std::mem::transmute(is_vtable_initialized) }; - is_vtable_initialized as u64 - }); - __bindgen_bitfield_unit.set(13usize, 1u8, { - let has_initialization_error: u8 = - unsafe { ::std::mem::transmute(has_initialization_error) }; - has_initialization_error as u64 - }); - __bindgen_bitfield_unit - } -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppTypeDefinitionSizes() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(Il2CppTypeDefinitionSizes)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppTypeDefinitionSizes)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).instance_size as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinitionSizes), - "::", - stringify!(instance_size) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).native_size as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinitionSizes), - "::", - stringify!(native_size) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).static_fields_size as *const _ - as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinitionSizes), - "::", - stringify!(static_fields_size) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_static_fields_size - as *const _ as usize - }, - 12usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypeDefinitionSizes), - "::", - stringify!(thread_static_fields_size) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppDomain { - pub domain: *mut Il2CppAppDomain, - pub setup: *mut Il2CppAppDomainSetup, - pub default_context: *mut Il2CppAppContext, - 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, -} -#[test] -fn bindgen_test_layout_Il2CppDomain() { - assert_eq!( - ::std::mem::size_of::(), - 48usize, - concat!("Size of: ", stringify!(Il2CppDomain)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppDomain)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).domain as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDomain), - "::", - stringify!(domain) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).setup as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDomain), - "::", - stringify!(setup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).default_context as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDomain), - "::", - stringify!(default_context) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).friendly_name as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDomain), - "::", - stringify!(friendly_name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).domain_id as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDomain), - "::", - stringify!(domain_id) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).threadpool_jobs as *const _ as usize }, - 36usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDomain), - "::", - stringify!(threadpool_jobs) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).agent_info as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDomain), - "::", - stringify!(agent_info) - ) - ); -} -#[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 hash_value: *const ::std::os::raw::c_char, - pub public_key: *const ::std::os::raw::c_char, - 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], -} -#[test] -fn bindgen_test_layout_Il2CppAssemblyName() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(Il2CppAssemblyName)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppAssemblyName)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyName), - "::", - stringify!(name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).culture as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyName), - "::", - stringify!(culture) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).hash_value as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyName), - "::", - stringify!(hash_value) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).public_key as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyName), - "::", - stringify!(public_key) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).hash_alg as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyName), - "::", - stringify!(hash_alg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).hash_len as *const _ as usize }, - 36usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyName), - "::", - stringify!(hash_len) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).flags as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyName), - "::", - stringify!(flags) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).major as *const _ as usize }, - 44usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyName), - "::", - stringify!(major) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).minor as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyName), - "::", - stringify!(minor) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).build as *const _ as usize }, - 52usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyName), - "::", - stringify!(build) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).revision as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyName), - "::", - stringify!(revision) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).public_key_token as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssemblyName), - "::", - stringify!(public_key_token) - ) - ); -} -#[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 typeStart: TypeDefinitionIndex, - pub typeCount: u32, - pub exportedTypeStart: TypeDefinitionIndex, - pub exportedTypeCount: u32, - pub customAttributeStart: CustomAttributeIndex, - pub customAttributeCount: u32, - pub entryPointIndex: MethodIndex, - pub nameToClassHashTable: *mut Il2CppNameToTypeDefinitionIndexHashTable, - pub token: u32, - pub dynamic: u8, -} -#[test] -fn bindgen_test_layout_Il2CppImage() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(Il2CppImage)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppImage)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppImage), - "::", - stringify!(name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nameNoExt as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppImage), - "::", - stringify!(nameNoExt) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).assembly as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppImage), - "::", - stringify!(assembly) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).typeStart as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppImage), - "::", - stringify!(typeStart) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).typeCount as *const _ as usize }, - 28usize, - concat!( - "Offset of field: ", - stringify!(Il2CppImage), - "::", - stringify!(typeCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).exportedTypeStart as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppImage), - "::", - stringify!(exportedTypeStart) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).exportedTypeCount as *const _ as usize }, - 36usize, - concat!( - "Offset of field: ", - stringify!(Il2CppImage), - "::", - stringify!(exportedTypeCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).customAttributeStart as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppImage), - "::", - stringify!(customAttributeStart) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).customAttributeCount as *const _ as usize - }, - 44usize, - concat!( - "Offset of field: ", - stringify!(Il2CppImage), - "::", - stringify!(customAttributeCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).entryPointIndex as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppImage), - "::", - stringify!(entryPointIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).nameToClassHashTable as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppImage), - "::", - stringify!(nameToClassHashTable) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppImage), - "::", - stringify!(token) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).dynamic as *const _ as usize }, - 68usize, - concat!( - "Offset of field: ", - stringify!(Il2CppImage), - "::", - stringify!(dynamic) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppAssembly() { - assert_eq!( - ::std::mem::size_of::(), - 96usize, - concat!("Size of: ", stringify!(Il2CppAssembly)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppAssembly)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).image as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssembly), - "::", - stringify!(image) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssembly), - "::", - stringify!(token) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).referencedAssemblyStart as *const _ as usize - }, - 12usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssembly), - "::", - stringify!(referencedAssemblyStart) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).referencedAssemblyCount as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssembly), - "::", - stringify!(referencedAssemblyCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aname as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAssembly), - "::", - stringify!(aname) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppCodeGenOptions { - pub enablePrimitiveValueTypeGenericSharing: u8, -} -#[test] -fn bindgen_test_layout_Il2CppCodeGenOptions() { - assert_eq!( - ::std::mem::size_of::(), - 1usize, - concat!("Size of: ", stringify!(Il2CppCodeGenOptions)) - ); - assert_eq!( - ::std::mem::align_of::(), - 1usize, - concat!("Alignment of ", stringify!(Il2CppCodeGenOptions)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).enablePrimitiveValueTypeGenericSharing - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCodeGenOptions), - "::", - stringify!(enablePrimitiveValueTypeGenericSharing) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppCodeRegistration { - pub methodPointersCount: u32, - pub methodPointers: *const Il2CppMethodPointer, - pub reversePInvokeWrapperCount: u32, - pub reversePInvokeWrappers: *const Il2CppMethodPointer, - pub genericMethodPointersCount: u32, - pub genericMethodPointers: *const Il2CppMethodPointer, - pub invokerPointersCount: u32, - pub invokerPointers: *const InvokerMethod, - pub customAttributeCount: CustomAttributeIndex, - pub customAttributeGenerators: *const CustomAttributesCacheGenerator, - pub unresolvedVirtualCallCount: u32, - pub unresolvedVirtualCallPointers: *const Il2CppMethodPointer, - pub interopDataCount: u32, - pub interopData: *mut Il2CppInteropData, -} -#[test] -fn bindgen_test_layout_Il2CppCodeRegistration() { - assert_eq!( - ::std::mem::size_of::(), - 112usize, - concat!("Size of: ", stringify!(Il2CppCodeRegistration)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppCodeRegistration)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).methodPointersCount as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCodeRegistration), - "::", - stringify!(methodPointersCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).methodPointers as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCodeRegistration), - "::", - stringify!(methodPointers) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).reversePInvokeWrapperCount - as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCodeRegistration), - "::", - stringify!(reversePInvokeWrapperCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).reversePInvokeWrappers as *const _ - as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCodeRegistration), - "::", - stringify!(reversePInvokeWrappers) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).genericMethodPointersCount - as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCodeRegistration), - "::", - stringify!(genericMethodPointersCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).genericMethodPointers as *const _ - as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCodeRegistration), - "::", - stringify!(genericMethodPointers) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).invokerPointersCount as *const _ - as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCodeRegistration), - "::", - stringify!(invokerPointersCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).invokerPointers as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCodeRegistration), - "::", - stringify!(invokerPointers) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).customAttributeCount as *const _ - as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCodeRegistration), - "::", - stringify!(customAttributeCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).customAttributeGenerators as *const _ - as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCodeRegistration), - "::", - stringify!(customAttributeGenerators) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).unresolvedVirtualCallCount - as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCodeRegistration), - "::", - stringify!(unresolvedVirtualCallCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).unresolvedVirtualCallPointers - as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCodeRegistration), - "::", - stringify!(unresolvedVirtualCallPointers) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).interopDataCount as *const _ as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCodeRegistration), - "::", - stringify!(interopDataCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).interopData as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCodeRegistration), - "::", - stringify!(interopData) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppMetadataRegistration() { - assert_eq!( - ::std::mem::size_of::(), - 128usize, - concat!("Size of: ", stringify!(Il2CppMetadataRegistration)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppMetadataRegistration)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).genericClassesCount as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMetadataRegistration), - "::", - stringify!(genericClassesCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).genericClasses as *const _ - as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMetadataRegistration), - "::", - stringify!(genericClasses) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).genericInstsCount as *const _ - as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMetadataRegistration), - "::", - stringify!(genericInstsCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).genericInsts as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMetadataRegistration), - "::", - stringify!(genericInsts) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).genericMethodTableCount - as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMetadataRegistration), - "::", - stringify!(genericMethodTableCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).genericMethodTable as *const _ - as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMetadataRegistration), - "::", - stringify!(genericMethodTable) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).typesCount as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMetadataRegistration), - "::", - stringify!(typesCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).types as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMetadataRegistration), - "::", - stringify!(types) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).methodSpecsCount as *const _ - as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMetadataRegistration), - "::", - stringify!(methodSpecsCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).methodSpecs as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMetadataRegistration), - "::", - stringify!(methodSpecs) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).fieldOffsetsCount as *const _ - as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMetadataRegistration), - "::", - stringify!(fieldOffsetsCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).fieldOffsets as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMetadataRegistration), - "::", - stringify!(fieldOffsets) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).typeDefinitionsSizesCount - as *const _ as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMetadataRegistration), - "::", - stringify!(typeDefinitionsSizesCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).typeDefinitionsSizes as *const _ - as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMetadataRegistration), - "::", - stringify!(typeDefinitionsSizes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).metadataUsagesCount as *const _ - as usize - }, - 112usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMetadataRegistration), - "::", - stringify!(metadataUsagesCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).metadataUsages as *const _ - as usize - }, - 120usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMetadataRegistration), - "::", - stringify!(metadataUsages) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppRuntimeStats { - pub new_object_count: u64, - pub initialized_class_count: u64, - pub method_count: u64, - pub class_static_data_size: u64, - pub generic_instance_count: u64, - pub generic_class_count: u64, - pub inflated_method_count: u64, - pub inflated_type_count: u64, - pub enabled: u8, -} -#[test] -fn bindgen_test_layout_Il2CppRuntimeStats() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(Il2CppRuntimeStats)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppRuntimeStats)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).new_object_count as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRuntimeStats), - "::", - stringify!(new_object_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).initialized_class_count as *const _ - as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRuntimeStats), - "::", - stringify!(initialized_class_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).method_count as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRuntimeStats), - "::", - stringify!(method_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).class_static_data_size as *const _ - as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRuntimeStats), - "::", - stringify!(class_static_data_size) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).generic_instance_count as *const _ - as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRuntimeStats), - "::", - stringify!(generic_instance_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).generic_class_count as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRuntimeStats), - "::", - stringify!(generic_class_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).inflated_method_count as *const _ - as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRuntimeStats), - "::", - stringify!(inflated_method_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).inflated_type_count as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRuntimeStats), - "::", - stringify!(inflated_type_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).enabled as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRuntimeStats), - "::", - stringify!(enabled) - ) - ); -} -extern "C" { - pub static mut il2cpp_runtime_stats: Il2CppRuntimeStats; -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppPerfCounters() { - assert_eq!( - ::std::mem::size_of::(), - 264usize, - concat!("Size of: ", stringify!(Il2CppPerfCounters)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppPerfCounters)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).jit_methods as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(jit_methods) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).jit_bytes as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(jit_bytes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).jit_time as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(jit_time) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).jit_failures as *const _ as usize }, - 12usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(jit_failures) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).exceptions_thrown as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(exceptions_thrown) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).exceptions_filters as *const _ as usize - }, - 20usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(exceptions_filters) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).exceptions_finallys as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(exceptions_finallys) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).exceptions_depth as *const _ as usize - }, - 28usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(exceptions_depth) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aspnet_requests_queued as *const _ - as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(aspnet_requests_queued) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aspnet_requests as *const _ as usize - }, - 36usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(aspnet_requests) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).gc_collections0 as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(gc_collections0) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).gc_collections1 as *const _ as usize - }, - 44usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(gc_collections1) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).gc_collections2 as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(gc_collections2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).gc_promotions0 as *const _ as usize - }, - 52usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(gc_promotions0) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).gc_promotions1 as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(gc_promotions1) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).gc_promotion_finalizers as *const _ - as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(gc_promotion_finalizers) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).gc_gen0size as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(gc_gen0size) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).gc_gen1size as *const _ as usize }, - 68usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(gc_gen1size) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).gc_gen2size as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(gc_gen2size) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).gc_lossize as *const _ as usize }, - 76usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(gc_lossize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).gc_fin_survivors as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(gc_fin_survivors) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).gc_num_handles as *const _ as usize - }, - 84usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(gc_num_handles) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).gc_allocated as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(gc_allocated) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).gc_induced as *const _ as usize }, - 92usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(gc_induced) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).gc_time as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(gc_time) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).gc_total_bytes as *const _ as usize - }, - 100usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(gc_total_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).gc_committed_bytes as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(gc_committed_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).gc_reserved_bytes as *const _ as usize - }, - 108usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(gc_reserved_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).gc_num_pinned as *const _ as usize - }, - 112usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(gc_num_pinned) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).gc_sync_blocks as *const _ as usize - }, - 116usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(gc_sync_blocks) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).remoting_calls as *const _ as usize - }, - 120usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(remoting_calls) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).remoting_channels as *const _ as usize - }, - 124usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(remoting_channels) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).remoting_proxies as *const _ as usize - }, - 128usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(remoting_proxies) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).remoting_classes as *const _ as usize - }, - 132usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(remoting_classes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).remoting_objects as *const _ as usize - }, - 136usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(remoting_objects) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).remoting_contexts as *const _ as usize - }, - 140usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(remoting_contexts) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).loader_classes as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(loader_classes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).loader_total_classes as *const _ as usize - }, - 148usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(loader_total_classes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).loader_appdomains as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(loader_appdomains) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).loader_total_appdomains as *const _ - as usize - }, - 156usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(loader_total_appdomains) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).loader_assemblies as *const _ as usize - }, - 160usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(loader_assemblies) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).loader_total_assemblies as *const _ - as usize - }, - 164usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(loader_total_assemblies) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).loader_failures as *const _ as usize - }, - 168usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(loader_failures) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).loader_bytes as *const _ as usize }, - 172usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(loader_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).loader_appdomains_uloaded as *const _ - as usize - }, - 176usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(loader_appdomains_uloaded) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_contentions as *const _ as usize - }, - 180usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(thread_contentions) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_queue_len as *const _ as usize - }, - 184usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(thread_queue_len) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_queue_max as *const _ as usize - }, - 188usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(thread_queue_max) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_num_logical as *const _ as usize - }, - 192usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(thread_num_logical) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_num_physical as *const _ as usize - }, - 196usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(thread_num_physical) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_cur_recognized as *const _ - as usize - }, - 200usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(thread_cur_recognized) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_num_recognized as *const _ - as usize - }, - 204usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(thread_num_recognized) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).interop_num_ccw as *const _ as usize - }, - 208usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(interop_num_ccw) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).interop_num_stubs as *const _ as usize - }, - 212usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(interop_num_stubs) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).interop_num_marshals as *const _ as usize - }, - 216usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(interop_num_marshals) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).security_num_checks as *const _ as usize - }, - 220usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(security_num_checks) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).security_num_link_checks as *const _ - as usize - }, - 224usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(security_num_link_checks) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).security_time as *const _ as usize - }, - 228usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(security_time) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).security_depth as *const _ as usize - }, - 232usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(security_depth) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).unused as *const _ as usize }, - 236usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(unused) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).threadpool_workitems as *const _ as usize - }, - 240usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(threadpool_workitems) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).threadpool_ioworkitems as *const _ - as usize - }, - 248usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(threadpool_ioworkitems) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).threadpool_threads as *const _ as usize - }, - 256usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(threadpool_threads) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).threadpool_iothreads as *const _ as usize - }, - 260usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPerfCounters), - "::", - stringify!(threadpool_iothreads) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppWaitHandle { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct MonitorData { - _unused: [u8; 0], -} -pub type Il2CppVTable = Il2CppClass; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppObject { - pub __bindgen_anon_1: Il2CppObject__bindgen_ty_1, - pub monitor: *mut MonitorData, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union Il2CppObject__bindgen_ty_1 { - pub klass: *mut Il2CppClass, - pub vtable: *mut Il2CppVTable, - _bindgen_union_align: u64, -} -#[test] -fn bindgen_test_layout_Il2CppObject__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(Il2CppObject__bindgen_ty_1)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppObject__bindgen_ty_1)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).klass as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppObject__bindgen_ty_1), - "::", - stringify!(klass) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtable as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppObject__bindgen_ty_1), - "::", - stringify!(vtable) - ) - ); -} -#[test] -fn bindgen_test_layout_Il2CppObject() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(Il2CppObject)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppObject)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).monitor as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppObject), - "::", - stringify!(monitor) - ) - ); -} -pub type il2cpp_array_lower_bound_t = i32; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppArrayBounds { - pub length: il2cpp_array_size_t, - pub lower_bound: il2cpp_array_lower_bound_t, -} -#[test] -fn bindgen_test_layout_Il2CppArrayBounds() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(Il2CppArrayBounds)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppArrayBounds)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).length as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppArrayBounds), - "::", - stringify!(length) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).lower_bound as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppArrayBounds), - "::", - stringify!(lower_bound) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppArray { - pub obj: Il2CppObject, - pub bounds: *mut Il2CppArrayBounds, - pub max_length: il2cpp_array_size_t, -} -#[test] -fn bindgen_test_layout_Il2CppArray() { - assert_eq!( - ::std::mem::size_of::(), - 32usize, - concat!("Size of: ", stringify!(Il2CppArray)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppArray)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppArray), - "::", - stringify!(obj) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bounds as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppArray), - "::", - stringify!(bounds) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).max_length as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppArray), - "::", - stringify!(max_length) - ) - ); -} -#[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>, -} -#[test] -fn bindgen_test_layout_Il2CppArraySize() { - assert_eq!( - ::std::mem::size_of::(), - 32usize, - concat!("Size of: ", stringify!(Il2CppArraySize)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppArraySize)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppArraySize), - "::", - stringify!(obj) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bounds as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppArraySize), - "::", - stringify!(bounds) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).max_length as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppArraySize), - "::", - stringify!(max_length) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vector as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppArraySize), - "::", - stringify!(vector) - ) - ); -} -pub const kIl2CppSizeOfArray: usize = 32; -pub const kIl2CppOffsetOfArrayBounds: usize = 16; -pub const kIl2CppOffsetOfArrayLength: usize = 24; -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppString() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(Il2CppString)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppString)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppString), - "::", - stringify!(object) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).length as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppString), - "::", - stringify!(length) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).chars as *const _ as usize }, - 20usize, - concat!( - "Offset of field: ", - stringify!(Il2CppString), - "::", - stringify!(chars) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppReflectionType { - pub object: Il2CppObject, - pub type_: *const Il2CppType, -} -#[test] -fn bindgen_test_layout_Il2CppReflectionType() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(Il2CppReflectionType)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppReflectionType)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionType), - "::", - stringify!(object) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).type_ as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionType), - "::", - stringify!(type_) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppReflectionRuntimeType { - pub type_: Il2CppReflectionType, - pub type_info: *mut Il2CppObject, - pub genericCache: *mut Il2CppObject, - pub serializationCtor: *mut Il2CppObject, -} -#[test] -fn bindgen_test_layout_Il2CppReflectionRuntimeType() { - assert_eq!( - ::std::mem::size_of::(), - 48usize, - concat!("Size of: ", stringify!(Il2CppReflectionRuntimeType)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppReflectionRuntimeType)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).type_ as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionRuntimeType), - "::", - stringify!(type_) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).type_info as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionRuntimeType), - "::", - stringify!(type_info) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).genericCache as *const _ - as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionRuntimeType), - "::", - stringify!(genericCache) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).serializationCtor as *const _ - as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionRuntimeType), - "::", - stringify!(serializationCtor) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppReflectionMonoType { - pub type_: Il2CppReflectionRuntimeType, -} -#[test] -fn bindgen_test_layout_Il2CppReflectionMonoType() { - assert_eq!( - ::std::mem::size_of::(), - 48usize, - concat!("Size of: ", stringify!(Il2CppReflectionMonoType)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppReflectionMonoType)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).type_ as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMonoType), - "::", - stringify!(type_) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppReflectionEvent { - pub object: Il2CppObject, - pub cached_add_event: *mut Il2CppObject, -} -#[test] -fn bindgen_test_layout_Il2CppReflectionEvent() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(Il2CppReflectionEvent)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppReflectionEvent)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionEvent), - "::", - stringify!(object) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).cached_add_event as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionEvent), - "::", - stringify!(cached_add_event) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppReflectionMonoEvent { - pub event: Il2CppReflectionEvent, - pub reflectedType: *mut Il2CppReflectionType, - pub eventInfo: *const EventInfo, -} -#[test] -fn bindgen_test_layout_Il2CppReflectionMonoEvent() { - assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(Il2CppReflectionMonoEvent)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppReflectionMonoEvent)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).event as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMonoEvent), - "::", - stringify!(event) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).reflectedType as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMonoEvent), - "::", - stringify!(reflectedType) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).eventInfo as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMonoEvent), - "::", - stringify!(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, -} -#[test] -fn bindgen_test_layout_Il2CppReflectionMonoEventInfo() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(Il2CppReflectionMonoEventInfo)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppReflectionMonoEventInfo)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).declaringType as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMonoEventInfo), - "::", - stringify!(declaringType) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).reflectedType as *const _ - as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMonoEventInfo), - "::", - stringify!(reflectedType) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).name as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMonoEventInfo), - "::", - stringify!(name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).addMethod as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMonoEventInfo), - "::", - stringify!(addMethod) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).removeMethod as *const _ - as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMonoEventInfo), - "::", - stringify!(removeMethod) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).raiseMethod as *const _ - as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMonoEventInfo), - "::", - stringify!(raiseMethod) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).eventAttributes as *const _ - as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMonoEventInfo), - "::", - stringify!(eventAttributes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).otherMethods as *const _ - as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMonoEventInfo), - "::", - stringify!(otherMethods) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppReflectionField() { - assert_eq!( - ::std::mem::size_of::(), - 56usize, - concat!("Size of: ", stringify!(Il2CppReflectionField)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppReflectionField)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionField), - "::", - stringify!(object) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).klass as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionField), - "::", - stringify!(klass) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).field as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionField), - "::", - stringify!(field) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionField), - "::", - stringify!(name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).type_ as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionField), - "::", - stringify!(type_) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).attrs as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionField), - "::", - stringify!(attrs) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppReflectionProperty { - pub object: Il2CppObject, - pub klass: *mut Il2CppClass, - pub property: *const PropertyInfo, -} -#[test] -fn bindgen_test_layout_Il2CppReflectionProperty() { - assert_eq!( - ::std::mem::size_of::(), - 32usize, - concat!("Size of: ", stringify!(Il2CppReflectionProperty)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppReflectionProperty)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionProperty), - "::", - stringify!(object) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).klass as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionProperty), - "::", - stringify!(klass) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).property as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionProperty), - "::", - stringify!(property) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppReflectionMethod { - pub object: Il2CppObject, - pub method: *const MethodInfo, - pub name: *mut Il2CppString, - pub reftype: *mut Il2CppReflectionType, -} -#[test] -fn bindgen_test_layout_Il2CppReflectionMethod() { - assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(Il2CppReflectionMethod)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppReflectionMethod)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMethod), - "::", - stringify!(object) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).method as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMethod), - "::", - stringify!(method) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMethod), - "::", - stringify!(name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).reftype as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMethod), - "::", - stringify!(reftype) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppReflectionGenericMethod { - pub base: Il2CppReflectionMethod, -} -#[test] -fn bindgen_test_layout_Il2CppReflectionGenericMethod() { - assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(Il2CppReflectionGenericMethod)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppReflectionGenericMethod)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).base as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionGenericMethod), - "::", - stringify!(base) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppMethodInfo() { - assert_eq!( - ::std::mem::size_of::(), - 32usize, - concat!("Size of: ", stringify!(Il2CppMethodInfo)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppMethodInfo)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).parent as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodInfo), - "::", - stringify!(parent) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).ret as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodInfo), - "::", - stringify!(ret) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).attrs as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodInfo), - "::", - stringify!(attrs) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).implattrs as *const _ as usize }, - 20usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodInfo), - "::", - stringify!(implattrs) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).callconv as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodInfo), - "::", - stringify!(callconv) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppPropertyInfo() { - assert_eq!( - ::std::mem::size_of::(), - 48usize, - concat!("Size of: ", stringify!(Il2CppPropertyInfo)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppPropertyInfo)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).parent as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPropertyInfo), - "::", - stringify!(parent) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).declaringType as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPropertyInfo), - "::", - stringify!(declaringType) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPropertyInfo), - "::", - stringify!(name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).get as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPropertyInfo), - "::", - stringify!(get) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).set as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPropertyInfo), - "::", - stringify!(set) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).attrs as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppPropertyInfo), - "::", - stringify!(attrs) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppReflectionParameter { - pub object: Il2CppObject, - pub ClassImpl: *mut Il2CppReflectionType, - pub DefaultValueImpl: *mut Il2CppObject, - pub MemberImpl: *mut Il2CppObject, - pub NameImpl: *mut Il2CppString, - pub PositionImpl: i32, - pub AttrsImpl: u32, - pub MarshalAsImpl: *mut Il2CppObject, -} -#[test] -fn bindgen_test_layout_Il2CppReflectionParameter() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(Il2CppReflectionParameter)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppReflectionParameter)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).object as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionParameter), - "::", - stringify!(object) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).ClassImpl as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionParameter), - "::", - stringify!(ClassImpl) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).DefaultValueImpl as *const _ - as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionParameter), - "::", - stringify!(DefaultValueImpl) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).MemberImpl as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionParameter), - "::", - stringify!(MemberImpl) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).NameImpl as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionParameter), - "::", - stringify!(NameImpl) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).PositionImpl as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionParameter), - "::", - stringify!(PositionImpl) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).AttrsImpl as *const _ as usize - }, - 52usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionParameter), - "::", - stringify!(AttrsImpl) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).MarshalAsImpl as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionParameter), - "::", - stringify!(MarshalAsImpl) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppReflectionModule() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(Il2CppReflectionModule)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppReflectionModule)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionModule), - "::", - stringify!(obj) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).image as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionModule), - "::", - stringify!(image) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).assembly as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionModule), - "::", - stringify!(assembly) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).fqname as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionModule), - "::", - stringify!(fqname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionModule), - "::", - stringify!(name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).scopename as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionModule), - "::", - stringify!(scopename) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).is_resource as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionModule), - "::", - stringify!(is_resource) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, - 60usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionModule), - "::", - stringify!(token) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppReflectionAssemblyName() { - assert_eq!( - ::std::mem::size_of::(), - 112usize, - concat!("Size of: ", stringify!(Il2CppReflectionAssemblyName)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppReflectionAssemblyName)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).obj as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssemblyName), - "::", - stringify!(obj) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).name as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssemblyName), - "::", - stringify!(name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).codebase as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssemblyName), - "::", - stringify!(codebase) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).major as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssemblyName), - "::", - stringify!(major) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).minor as *const _ as usize - }, - 36usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssemblyName), - "::", - stringify!(minor) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).build as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssemblyName), - "::", - stringify!(build) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).revision as *const _ as usize - }, - 44usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssemblyName), - "::", - stringify!(revision) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).cultureInfo as *const _ - as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssemblyName), - "::", - stringify!(cultureInfo) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).flags as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssemblyName), - "::", - stringify!(flags) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).hashalg as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssemblyName), - "::", - stringify!(hashalg) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).keypair as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssemblyName), - "::", - stringify!(keypair) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).publicKey as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssemblyName), - "::", - stringify!(publicKey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).keyToken as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssemblyName), - "::", - stringify!(keyToken) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).versioncompat as *const _ - as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssemblyName), - "::", - stringify!(versioncompat) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).version as *const _ as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssemblyName), - "::", - stringify!(version) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).processor_architecture - as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssemblyName), - "::", - stringify!(processor_architecture) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).contentType as *const _ - as usize - }, - 108usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssemblyName), - "::", - stringify!(contentType) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppReflectionAssembly { - pub object: Il2CppObject, - pub assembly: *const Il2CppAssembly, - pub resolve_event_holder: *mut Il2CppObject, - pub evidence: *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, -} -#[test] -fn bindgen_test_layout_Il2CppReflectionAssembly() { - assert_eq!( - ::std::mem::size_of::(), - 96usize, - concat!("Size of: ", stringify!(Il2CppReflectionAssembly)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppReflectionAssembly)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssembly), - "::", - stringify!(object) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).assembly as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssembly), - "::", - stringify!(assembly) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).resolve_event_holder as *const _ - as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssembly), - "::", - stringify!(resolve_event_holder) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).evidence as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssembly), - "::", - stringify!(evidence) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).minimum as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssembly), - "::", - stringify!(minimum) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).optional as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssembly), - "::", - stringify!(optional) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).refuse as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssembly), - "::", - stringify!(refuse) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).granted as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssembly), - "::", - stringify!(granted) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).denied as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssembly), - "::", - stringify!(denied) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).from_byte_array as *const _ - as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssembly), - "::", - stringify!(from_byte_array) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionAssembly), - "::", - stringify!(name) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppReflectionMarshal() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(Il2CppReflectionMarshal)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppReflectionMarshal)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMarshal), - "::", - stringify!(object) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).count as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMarshal), - "::", - stringify!(count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).type_ as *const _ as usize }, - 20usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMarshal), - "::", - stringify!(type_) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).eltype as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMarshal), - "::", - stringify!(eltype) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).guid as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMarshal), - "::", - stringify!(guid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mcookie as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMarshal), - "::", - stringify!(mcookie) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).marshaltype as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMarshal), - "::", - stringify!(marshaltype) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).marshaltyperef as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMarshal), - "::", - stringify!(marshaltyperef) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).param_num as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMarshal), - "::", - stringify!(param_num) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).has_size as *const _ as usize - }, - 68usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionMarshal), - "::", - stringify!(has_size) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppReflectionPointer { - pub object: Il2CppObject, - pub data: *mut ::std::os::raw::c_void, - pub type_: *mut Il2CppReflectionType, -} -#[test] -fn bindgen_test_layout_Il2CppReflectionPointer() { - assert_eq!( - ::std::mem::size_of::(), - 32usize, - concat!("Size of: ", stringify!(Il2CppReflectionPointer)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppReflectionPointer)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionPointer), - "::", - stringify!(object) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionPointer), - "::", - stringify!(data) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).type_ as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppReflectionPointer), - "::", - stringify!(type_) - ) - ); -} -#[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 cached_culture_info: *mut Il2CppArray, - pub name: *mut Il2CppChar, - pub name_len: ::std::os::raw::c_int, - 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 *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 synch_cs: *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 interrupt_on_stop: *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 unused2: usize, - pub last: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_Il2CppInternalThread() { - assert_eq!( - ::std::mem::size_of::(), - 288usize, - concat!("Size of: ", stringify!(Il2CppInternalThread)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppInternalThread)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(obj) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).lock_thread_id as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(lock_thread_id) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).handle as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).native_handle as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(native_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).cached_culture_info as *const _ - as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(cached_culture_info) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).name_len as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(name_len) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).state as *const _ as usize }, - 60usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(state) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).abort_exc as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(abort_exc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).abort_state_handle as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(abort_state_handle) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).tid as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(tid) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).debugger_thread as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(debugger_thread) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).static_data as *const _ as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(static_data) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).runtime_thread_info as *const _ - as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(runtime_thread_info) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).current_appcontext as *const _ as usize - }, - 112usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(current_appcontext) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).root_domain_thread as *const _ as usize - }, - 120usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(root_domain_thread) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::()))._serialized_principal as *const _ - as usize - }, - 128usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(_serialized_principal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::()))._serialized_principal_version - as *const _ as usize - }, - 136usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(_serialized_principal_version) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).appdomain_refs as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(appdomain_refs) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).interruption_requested as *const _ - as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(interruption_requested) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).synch_cs as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(synch_cs) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).threadpool_thread as *const _ as usize - }, - 168usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(threadpool_thread) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_interrupt_requested as *const _ - as usize - }, - 169usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(thread_interrupt_requested) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).stack_size as *const _ as usize }, - 172usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(stack_size) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).apartment_state as *const _ as usize - }, - 176usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(apartment_state) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).critical_region_level as *const _ - as usize - }, - 180usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(critical_region_level) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).managed_id as *const _ as usize }, - 184usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(managed_id) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).small_id as *const _ as usize }, - 188usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(small_id) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).manage_callback as *const _ as usize - }, - 192usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(manage_callback) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).interrupt_on_stop as *const _ as usize - }, - 200usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(interrupt_on_stop) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).flags as *const _ as usize }, - 208usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(flags) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_pinning_ref as *const _ as usize - }, - 216usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(thread_pinning_ref) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).abort_protected_block_count as *const _ - as usize - }, - 224usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(abort_protected_block_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).priority as *const _ as usize }, - 232usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(priority) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).owned_mutexes as *const _ as usize - }, - 240usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(owned_mutexes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).suspended as *const _ as usize }, - 248usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(suspended) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).self_suspended as *const _ as usize - }, - 256usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(self_suspended) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_state as *const _ as usize - }, - 264usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(thread_state) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).unused2 as *const _ as usize }, - 272usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(unused2) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).last as *const _ as usize }, - 280usize, - concat!( - "Offset of field: ", - stringify!(Il2CppInternalThread), - "::", - stringify!(last) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppIOSelectorJob { - pub object: Il2CppObject, - pub operation: i32, - pub callback: *mut Il2CppObject, - pub state: *mut Il2CppObject, -} -#[test] -fn bindgen_test_layout_Il2CppIOSelectorJob() { - assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(Il2CppIOSelectorJob)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppIOSelectorJob)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppIOSelectorJob), - "::", - stringify!(object) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).operation as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppIOSelectorJob), - "::", - stringify!(operation) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).callback as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppIOSelectorJob), - "::", - stringify!(callback) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).state as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppIOSelectorJob), - "::", - stringify!(state) - ) - ); -} -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; -pub type Il2CppCallType = i32; -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppMethodMessage() { - assert_eq!( - ::std::mem::size_of::(), - 88usize, - concat!("Size of: ", stringify!(Il2CppMethodMessage)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppMethodMessage)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodMessage), - "::", - stringify!(obj) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).method as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodMessage), - "::", - stringify!(method) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).args as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodMessage), - "::", - stringify!(args) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).names as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodMessage), - "::", - stringify!(names) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).arg_types as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodMessage), - "::", - stringify!(arg_types) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).ctx as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodMessage), - "::", - stringify!(ctx) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).rval as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodMessage), - "::", - stringify!(rval) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).exc as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodMessage), - "::", - stringify!(exc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).async_result as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodMessage), - "::", - stringify!(async_result) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).call_type as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMethodMessage), - "::", - stringify!(call_type) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppAppDomainSetup() { - assert_eq!( - ::std::mem::size_of::(), - 168usize, - concat!("Size of: ", stringify!(Il2CppAppDomainSetup)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppAppDomainSetup)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomainSetup), - "::", - stringify!(object) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).application_base as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomainSetup), - "::", - stringify!(application_base) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).application_name as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomainSetup), - "::", - stringify!(application_name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).cache_path as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomainSetup), - "::", - stringify!(cache_path) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).configuration_file as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomainSetup), - "::", - stringify!(configuration_file) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).dynamic_base as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomainSetup), - "::", - stringify!(dynamic_base) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).license_file as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomainSetup), - "::", - stringify!(license_file) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).private_bin_path as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomainSetup), - "::", - stringify!(private_bin_path) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).private_bin_path_probe as *const _ - as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomainSetup), - "::", - stringify!(private_bin_path_probe) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).shadow_copy_directories as *const _ - as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomainSetup), - "::", - stringify!(shadow_copy_directories) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).shadow_copy_files as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomainSetup), - "::", - stringify!(shadow_copy_files) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).publisher_policy as *const _ as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomainSetup), - "::", - stringify!(publisher_policy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).path_changed as *const _ as usize - }, - 97usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomainSetup), - "::", - stringify!(path_changed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).loader_optimization as *const _ - as usize - }, - 100usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomainSetup), - "::", - stringify!(loader_optimization) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).disallow_binding_redirects as *const _ - as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomainSetup), - "::", - stringify!(disallow_binding_redirects) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).disallow_code_downloads as *const _ - as usize - }, - 105usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomainSetup), - "::", - stringify!(disallow_code_downloads) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).activation_arguments as *const _ - as usize - }, - 112usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomainSetup), - "::", - stringify!(activation_arguments) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).domain_initializer as *const _ as usize - }, - 120usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomainSetup), - "::", - stringify!(domain_initializer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).application_trust as *const _ as usize - }, - 128usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomainSetup), - "::", - stringify!(application_trust) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).domain_initializer_args as *const _ - as usize - }, - 136usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomainSetup), - "::", - stringify!(domain_initializer_args) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).disallow_appbase_probe as *const _ - as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomainSetup), - "::", - stringify!(disallow_appbase_probe) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).configuration_bytes as *const _ - as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomainSetup), - "::", - stringify!(configuration_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).serialized_non_primitives as *const _ - as usize - }, - 160usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomainSetup), - "::", - stringify!(serialized_non_primitives) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppThread() { - assert_eq!( - ::std::mem::size_of::(), - 80usize, - concat!("Size of: ", stringify!(Il2CppThread)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppThread)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppThread), - "::", - stringify!(obj) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).internal_thread as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppThread), - "::", - stringify!(internal_thread) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).start_obj as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppThread), - "::", - stringify!(start_obj) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pending_exception as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppThread), - "::", - stringify!(pending_exception) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).principal as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppThread), - "::", - stringify!(principal) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).principal_version as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppThread), - "::", - stringify!(principal_version) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).delegate as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppThread), - "::", - stringify!(delegate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).executionContext as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppThread), - "::", - stringify!(executionContext) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).executionContextBelongsToOuterScope as *const _ - as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Il2CppThread), - "::", - stringify!(executionContextBelongsToOuterScope) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppException() { - assert_eq!( - ::std::mem::size_of::(), - 136usize, - concat!("Size of: ", stringify!(Il2CppException)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppException)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppException), - "::", - stringify!(object) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).className as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppException), - "::", - stringify!(className) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).message as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppException), - "::", - stringify!(message) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::()))._data as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppException), - "::", - stringify!(_data) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).inner_ex as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppException), - "::", - stringify!(inner_ex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::()))._helpURL as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppException), - "::", - stringify!(_helpURL) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).trace_ips as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppException), - "::", - stringify!(trace_ips) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).stack_trace as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppException), - "::", - stringify!(stack_trace) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).remote_stack_trace as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Il2CppException), - "::", - stringify!(remote_stack_trace) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).remote_stack_index as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Il2CppException), - "::", - stringify!(remote_stack_index) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::()))._dynamicMethods as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Il2CppException), - "::", - stringify!(_dynamicMethods) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).hresult as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Il2CppException), - "::", - stringify!(hresult) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).source as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Il2CppException), - "::", - stringify!(source) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).safeSerializationManager as *const _ - as usize - }, - 112usize, - concat!( - "Offset of field: ", - stringify!(Il2CppException), - "::", - stringify!(safeSerializationManager) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).captured_traces as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(Il2CppException), - "::", - stringify!(captured_traces) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).native_trace_ips as *const _ as usize - }, - 128usize, - concat!( - "Offset of field: ", - stringify!(Il2CppException), - "::", - stringify!(native_trace_ips) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppSystemException { - pub base: Il2CppException, -} -#[test] -fn bindgen_test_layout_Il2CppSystemException() { - assert_eq!( - ::std::mem::size_of::(), - 136usize, - concat!("Size of: ", stringify!(Il2CppSystemException)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppSystemException)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).base as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSystemException), - "::", - stringify!(base) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppArgumentException { - pub base: Il2CppException, - pub argName: *mut Il2CppString, -} -#[test] -fn bindgen_test_layout_Il2CppArgumentException() { - assert_eq!( - ::std::mem::size_of::(), - 144usize, - concat!("Size of: ", stringify!(Il2CppArgumentException)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppArgumentException)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).base as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppArgumentException), - "::", - stringify!(base) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).argName as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(Il2CppArgumentException), - "::", - stringify!(argName) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppTypedRef() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(Il2CppTypedRef)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppTypedRef)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).type_ as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypedRef), - "::", - stringify!(type_) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypedRef), - "::", - stringify!(value) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).klass as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppTypedRef), - "::", - stringify!(klass) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppDelegate { - pub object: Il2CppObject, - pub method_ptr: Il2CppMethodPointer, - pub invoke_impl: InvokerMethod, - pub target: *mut Il2CppObject, - pub method: *const MethodInfo, - pub delegate_trampoline: *mut ::std::os::raw::c_void, - pub extraArg: isize, - pub method_code: *mut *mut u8, - pub method_info: *mut Il2CppReflectionMethod, - pub original_method_info: *mut Il2CppReflectionMethod, - pub data: *mut Il2CppObject, - pub method_is_virtual: u8, -} -#[test] -fn bindgen_test_layout_Il2CppDelegate() { - assert_eq!( - ::std::mem::size_of::(), - 104usize, - concat!("Size of: ", stringify!(Il2CppDelegate)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppDelegate)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDelegate), - "::", - stringify!(object) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).method_ptr as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDelegate), - "::", - stringify!(method_ptr) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).invoke_impl as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDelegate), - "::", - stringify!(invoke_impl) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).target as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDelegate), - "::", - stringify!(target) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).method as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDelegate), - "::", - stringify!(method) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).delegate_trampoline as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDelegate), - "::", - stringify!(delegate_trampoline) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).extraArg as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDelegate), - "::", - stringify!(extraArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).method_code as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDelegate), - "::", - stringify!(method_code) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).method_info as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDelegate), - "::", - stringify!(method_info) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).original_method_info as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDelegate), - "::", - stringify!(original_method_info) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDelegate), - "::", - stringify!(data) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).method_is_virtual as *const _ as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDelegate), - "::", - stringify!(method_is_virtual) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppMulticastDelegate { - pub delegate: Il2CppDelegate, - pub delegates: *mut Il2CppArray, -} -#[test] -fn bindgen_test_layout_Il2CppMulticastDelegate() { - assert_eq!( - ::std::mem::size_of::(), - 112usize, - concat!("Size of: ", stringify!(Il2CppMulticastDelegate)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppMulticastDelegate)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).delegate as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMulticastDelegate), - "::", - stringify!(delegate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).delegates as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMulticastDelegate), - "::", - stringify!(delegates) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppMarshalByRefObject { - pub obj: Il2CppObject, - pub identity: *mut Il2CppObject, -} -#[test] -fn bindgen_test_layout_Il2CppMarshalByRefObject() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(Il2CppMarshalByRefObject)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppMarshalByRefObject)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMarshalByRefObject), - "::", - stringify!(obj) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).identity as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppMarshalByRefObject), - "::", - stringify!(identity) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppAppDomain { - pub mbr: Il2CppMarshalByRefObject, - pub data: *mut Il2CppDomain, -} -#[test] -fn bindgen_test_layout_Il2CppAppDomain() { - assert_eq!( - ::std::mem::size_of::(), - 32usize, - concat!("Size of: ", stringify!(Il2CppAppDomain)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppAppDomain)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mbr as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomain), - "::", - stringify!(mbr) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppDomain), - "::", - stringify!(data) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppStackFrame() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(Il2CppStackFrame)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppStackFrame)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStackFrame), - "::", - stringify!(obj) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).il_offset as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStackFrame), - "::", - stringify!(il_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).native_offset as *const _ as usize }, - 20usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStackFrame), - "::", - stringify!(native_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).methodAddress as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStackFrame), - "::", - stringify!(methodAddress) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).methodIndex as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStackFrame), - "::", - stringify!(methodIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).method as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStackFrame), - "::", - stringify!(method) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).filename as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStackFrame), - "::", - stringify!(filename) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).line as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStackFrame), - "::", - stringify!(line) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).column as *const _ as usize }, - 60usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStackFrame), - "::", - stringify!(column) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).internal_method_name as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStackFrame), - "::", - stringify!(internal_method_name) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppDateTimeFormatInfo() { - assert_eq!( - ::std::mem::size_of::(), - 376usize, - concat!("Size of: ", stringify!(Il2CppDateTimeFormatInfo)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppDateTimeFormatInfo)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(obj) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).CultureData as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(CultureData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).Name as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(Name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).LangName as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(LangName) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).CompareInfo as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(CompareInfo) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).CultureInfo as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(CultureInfo) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).AMDesignator as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(AMDesignator) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).PMDesignator as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(PMDesignator) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).DateSeparator as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(DateSeparator) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).GeneralShortTimePattern as *const _ - as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(GeneralShortTimePattern) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).GeneralLongTimePattern as *const _ - as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(GeneralLongTimePattern) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).TimeSeparator as *const _ as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(TimeSeparator) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).MonthDayPattern as *const _ - as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(MonthDayPattern) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).DateTimeOffsetPattern as *const _ - as usize - }, - 112usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(DateTimeOffsetPattern) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).Calendar as *const _ as usize - }, - 120usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(Calendar) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).FirstDayOfWeek as *const _ as usize - }, - 128usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(FirstDayOfWeek) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).CalendarWeekRule as *const _ - as usize - }, - 132usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(CalendarWeekRule) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).FullDateTimePattern as *const _ - as usize - }, - 136usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(FullDateTimePattern) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).AbbreviatedDayNames as *const _ - as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(AbbreviatedDayNames) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).ShortDayNames as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(ShortDayNames) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).DayNames as *const _ as usize - }, - 160usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(DayNames) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).AbbreviatedMonthNames as *const _ - as usize - }, - 168usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(AbbreviatedMonthNames) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).MonthNames as *const _ as usize - }, - 176usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(MonthNames) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).GenitiveMonthNames as *const _ - as usize - }, - 184usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(GenitiveMonthNames) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).GenitiveAbbreviatedMonthNames - as *const _ as usize - }, - 192usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(GenitiveAbbreviatedMonthNames) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).LeapYearMonthNames as *const _ - as usize - }, - 200usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(LeapYearMonthNames) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).LongDatePattern as *const _ - as usize - }, - 208usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(LongDatePattern) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).ShortDatePattern as *const _ - as usize - }, - 216usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(ShortDatePattern) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).YearMonthPattern as *const _ - as usize - }, - 224usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(YearMonthPattern) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).LongTimePattern as *const _ - as usize - }, - 232usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(LongTimePattern) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).ShortTimePattern as *const _ - as usize - }, - 240usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(ShortTimePattern) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).YearMonthPatterns as *const _ - as usize - }, - 248usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(YearMonthPatterns) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).ShortDatePatterns as *const _ - as usize - }, - 256usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(ShortDatePatterns) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).LongDatePatterns as *const _ - as usize - }, - 264usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(LongDatePatterns) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).ShortTimePatterns as *const _ - as usize - }, - 272usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(ShortTimePatterns) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).LongTimePatterns as *const _ - as usize - }, - 280usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(LongTimePatterns) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).EraNames as *const _ as usize - }, - 288usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(EraNames) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).AbbrevEraNames as *const _ as usize - }, - 296usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(AbbrevEraNames) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).AbbrevEnglishEraNames as *const _ - as usize - }, - 304usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(AbbrevEnglishEraNames) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).OptionalCalendars as *const _ - as usize - }, - 312usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(OptionalCalendars) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).readOnly as *const _ as usize - }, - 320usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(readOnly) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).FormatFlags as *const _ as usize - }, - 324usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(FormatFlags) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).CultureID as *const _ as usize - }, - 328usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(CultureID) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).UseUserOverride as *const _ - as usize - }, - 332usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(UseUserOverride) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).UseCalendarInfo as *const _ - as usize - }, - 333usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(UseCalendarInfo) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).DataItem as *const _ as usize - }, - 336usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(DataItem) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).IsDefaultCalendar as *const _ - as usize - }, - 340usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(IsDefaultCalendar) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).DateWords as *const _ as usize - }, - 344usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(DateWords) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).FullTimeSpanPositivePattern - as *const _ as usize - }, - 352usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(FullTimeSpanPositivePattern) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).FullTimeSpanNegativePattern - as *const _ as usize - }, - 360usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(FullTimeSpanNegativePattern) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).dtfiTokenHash as *const _ as usize - }, - 368usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDateTimeFormatInfo), - "::", - stringify!(dtfiTokenHash) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppNumberFormatInfo() { - assert_eq!( - ::std::mem::size_of::(), - 216usize, - concat!("Size of: ", stringify!(Il2CppNumberFormatInfo)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppNumberFormatInfo)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(obj) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).numberGroupSizes as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(numberGroupSizes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).currencyGroupSizes as *const _ - as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(currencyGroupSizes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).percentGroupSizes as *const _ - as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(percentGroupSizes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).positiveSign as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(positiveSign) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).negativeSign as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(negativeSign) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).numberDecimalSeparator as *const _ - as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(numberDecimalSeparator) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).numberGroupSeparator as *const _ - as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(numberGroupSeparator) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).currencyGroupSeparator as *const _ - as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(currencyGroupSeparator) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).currencyDecimalSeparator as *const _ - as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(currencyDecimalSeparator) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).currencySymbol as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(currencySymbol) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).ansiCurrencySymbol as *const _ - as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(ansiCurrencySymbol) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).naNSymbol as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(naNSymbol) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).positiveInfinitySymbol as *const _ - as usize - }, - 112usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(positiveInfinitySymbol) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).negativeInfinitySymbol as *const _ - as usize - }, - 120usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(negativeInfinitySymbol) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).percentDecimalSeparator as *const _ - as usize - }, - 128usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(percentDecimalSeparator) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).percentGroupSeparator as *const _ - as usize - }, - 136usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(percentGroupSeparator) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).percentSymbol as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(percentSymbol) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).perMilleSymbol as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(perMilleSymbol) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).nativeDigits as *const _ as usize - }, - 160usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(nativeDigits) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).dataItem as *const _ as usize }, - 168usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(dataItem) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).numberDecimalDigits as *const _ - as usize - }, - 172usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(numberDecimalDigits) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).currencyDecimalDigits as *const _ - as usize - }, - 176usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(currencyDecimalDigits) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).currencyPositivePattern as *const _ - as usize - }, - 180usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(currencyPositivePattern) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).currencyNegativePattern as *const _ - as usize - }, - 184usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(currencyNegativePattern) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).numberNegativePattern as *const _ - as usize - }, - 188usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(numberNegativePattern) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).percentPositivePattern as *const _ - as usize - }, - 192usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(percentPositivePattern) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).percentNegativePattern as *const _ - as usize - }, - 196usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(percentNegativePattern) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).percentDecimalDigits as *const _ - as usize - }, - 200usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(percentDecimalDigits) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).digitSubstitution as *const _ - as usize - }, - 204usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(digitSubstitution) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).readOnly as *const _ as usize }, - 208usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(readOnly) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).useUserOverride as *const _ as usize - }, - 209usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(useUserOverride) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).isInvariant as *const _ as usize - }, - 210usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(isInvariant) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).validForParseAsNumber as *const _ - as usize - }, - 211usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(validForParseAsNumber) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).validForParseAsCurrency as *const _ - as usize - }, - 212usize, - concat!( - "Offset of field: ", - stringify!(Il2CppNumberFormatInfo), - "::", - stringify!(validForParseAsCurrency) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppCultureData() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(Il2CppCultureData)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppCultureData)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureData), - "::", - stringify!(obj) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).AMDesignator as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureData), - "::", - stringify!(AMDesignator) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).PMDesignator as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureData), - "::", - stringify!(PMDesignator) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).TimeSeparator as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureData), - "::", - stringify!(TimeSeparator) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).LongTimePatterns as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureData), - "::", - stringify!(LongTimePatterns) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).ShortTimePatterns as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureData), - "::", - stringify!(ShortTimePatterns) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).FirstDayOfWeek as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureData), - "::", - stringify!(FirstDayOfWeek) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).CalendarWeekRule as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureData), - "::", - stringify!(CalendarWeekRule) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppCalendarData() { - assert_eq!( - ::std::mem::size_of::(), - 136usize, - concat!("Size of: ", stringify!(Il2CppCalendarData)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppCalendarData)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCalendarData), - "::", - stringify!(obj) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).NativeName as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCalendarData), - "::", - stringify!(NativeName) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).ShortDatePatterns as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCalendarData), - "::", - stringify!(ShortDatePatterns) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).YearMonthPatterns as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCalendarData), - "::", - stringify!(YearMonthPatterns) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).LongDatePatterns as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCalendarData), - "::", - stringify!(LongDatePatterns) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).MonthDayPattern as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCalendarData), - "::", - stringify!(MonthDayPattern) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).EraNames as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCalendarData), - "::", - stringify!(EraNames) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).AbbreviatedEraNames as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCalendarData), - "::", - stringify!(AbbreviatedEraNames) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).AbbreviatedEnglishEraNames as *const _ - as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCalendarData), - "::", - stringify!(AbbreviatedEnglishEraNames) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).DayNames as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCalendarData), - "::", - stringify!(DayNames) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).AbbreviatedDayNames as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCalendarData), - "::", - stringify!(AbbreviatedDayNames) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).SuperShortDayNames as *const _ as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCalendarData), - "::", - stringify!(SuperShortDayNames) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).MonthNames as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCalendarData), - "::", - stringify!(MonthNames) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).AbbreviatedMonthNames as *const _ - as usize - }, - 112usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCalendarData), - "::", - stringify!(AbbreviatedMonthNames) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).GenitiveMonthNames as *const _ as usize - }, - 120usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCalendarData), - "::", - stringify!(GenitiveMonthNames) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).GenitiveAbbreviatedMonthNames as *const _ - as usize - }, - 128usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCalendarData), - "::", - stringify!(GenitiveAbbreviatedMonthNames) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppCultureInfo() { - assert_eq!( - ::std::mem::size_of::(), - 208usize, - concat!("Size of: ", stringify!(Il2CppCultureInfo)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppCultureInfo)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(obj) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).is_read_only as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(is_read_only) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).lcid as *const _ as usize }, - 20usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(lcid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).parent_lcid as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(parent_lcid) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).datetime_index as *const _ as usize - }, - 28usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(datetime_index) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).number_index as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(number_index) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).default_calendar_type as *const _ as usize - }, - 36usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(default_calendar_type) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).use_user_override as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(use_user_override) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).number_format as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(number_format) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).datetime_format as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(datetime_format) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).textinfo as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(textinfo) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).englishname as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(englishname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nativename as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(nativename) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iso3lang as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(iso3lang) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iso2lang as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(iso2lang) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).win3lang as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(win3lang) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).territory as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(territory) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).native_calendar_names as *const _ as usize - }, - 128usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(native_calendar_names) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).compareinfo as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(compareinfo) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).text_info_data as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(text_info_data) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).dataItem as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(dataItem) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).calendar as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(calendar) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).parent_culture as *const _ as usize - }, - 168usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(parent_culture) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).constructed as *const _ as usize }, - 176usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(constructed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).cached_serialized_form as *const _ - as usize - }, - 184usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(cached_serialized_form) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).cultureData as *const _ as usize }, - 192usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(cultureData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).isInherited as *const _ as usize }, - 200usize, - concat!( - "Offset of field: ", - stringify!(Il2CppCultureInfo), - "::", - stringify!(isInherited) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppRegionInfo() { - assert_eq!( - ::std::mem::size_of::(), - 96usize, - concat!("Size of: ", stringify!(Il2CppRegionInfo)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppRegionInfo)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRegionInfo), - "::", - stringify!(obj) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).geo_id as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRegionInfo), - "::", - stringify!(geo_id) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iso2name as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRegionInfo), - "::", - stringify!(iso2name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iso3name as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRegionInfo), - "::", - stringify!(iso3name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).win3name as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRegionInfo), - "::", - stringify!(win3name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).english_name as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRegionInfo), - "::", - stringify!(english_name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).native_name as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRegionInfo), - "::", - stringify!(native_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).currency_symbol as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRegionInfo), - "::", - stringify!(currency_symbol) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iso_currency_symbol as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRegionInfo), - "::", - stringify!(iso_currency_symbol) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).currency_english_name as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRegionInfo), - "::", - stringify!(currency_english_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).currency_native_name as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Il2CppRegionInfo), - "::", - stringify!(currency_native_name) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppSafeHandle() { - assert_eq!( - ::std::mem::size_of::(), - 32usize, - concat!("Size of: ", stringify!(Il2CppSafeHandle)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppSafeHandle)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).base as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSafeHandle), - "::", - stringify!(base) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).handle as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSafeHandle), - "::", - stringify!(handle) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).state as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSafeHandle), - "::", - stringify!(state) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).owns_handle as *const _ as usize }, - 28usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSafeHandle), - "::", - stringify!(owns_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).fullyInitialized as *const _ as usize - }, - 29usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSafeHandle), - "::", - stringify!(fullyInitialized) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppStringBuilder() { - assert_eq!( - ::std::mem::size_of::(), - 48usize, - concat!("Size of: ", stringify!(Il2CppStringBuilder)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppStringBuilder)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStringBuilder), - "::", - stringify!(object) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).chunkChars as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStringBuilder), - "::", - stringify!(chunkChars) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).chunkPrevious as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStringBuilder), - "::", - stringify!(chunkPrevious) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).chunkLength as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStringBuilder), - "::", - stringify!(chunkLength) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).chunkOffset as *const _ as usize }, - 36usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStringBuilder), - "::", - stringify!(chunkOffset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).maxCapacity as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStringBuilder), - "::", - stringify!(maxCapacity) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppSocketAddress() { - assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(Il2CppSocketAddress)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppSocketAddress)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).base as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSocketAddress), - "::", - stringify!(base) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).m_Size as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSocketAddress), - "::", - stringify!(m_Size) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSocketAddress), - "::", - stringify!(data) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).m_changed as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSocketAddress), - "::", - stringify!(m_changed) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).m_hash as *const _ as usize }, - 36usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSocketAddress), - "::", - stringify!(m_hash) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppSortKey() { - assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(Il2CppSortKey)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppSortKey)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).base as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSortKey), - "::", - stringify!(base) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).str as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSortKey), - "::", - stringify!(str) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).key as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSortKey), - "::", - stringify!(key) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).options as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSortKey), - "::", - stringify!(options) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).lcid as *const _ as usize }, - 36usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSortKey), - "::", - stringify!(lcid) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppErrorWrapper { - pub base: Il2CppObject, - pub errorCode: i32, -} -#[test] -fn bindgen_test_layout_Il2CppErrorWrapper() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(Il2CppErrorWrapper)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppErrorWrapper)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).base as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppErrorWrapper), - "::", - stringify!(base) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errorCode as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppErrorWrapper), - "::", - stringify!(errorCode) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppAsyncResult() { - assert_eq!( - ::std::mem::size_of::(), - 88usize, - concat!("Size of: ", stringify!(Il2CppAsyncResult)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppAsyncResult)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).base as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAsyncResult), - "::", - stringify!(base) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).async_state as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAsyncResult), - "::", - stringify!(async_state) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).handle as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAsyncResult), - "::", - stringify!(handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).async_delegate as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAsyncResult), - "::", - stringify!(async_delegate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAsyncResult), - "::", - stringify!(data) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).object_data as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAsyncResult), - "::", - stringify!(object_data) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).sync_completed as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAsyncResult), - "::", - stringify!(sync_completed) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).completed as *const _ as usize }, - 57usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAsyncResult), - "::", - stringify!(completed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).endinvoke_called as *const _ as usize - }, - 58usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAsyncResult), - "::", - stringify!(endinvoke_called) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).async_callback as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAsyncResult), - "::", - stringify!(async_callback) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).execution_context as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAsyncResult), - "::", - stringify!(execution_context) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).original_context as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAsyncResult), - "::", - stringify!(original_context) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppAsyncCall() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(Il2CppAsyncCall)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppAsyncCall)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).base as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAsyncCall), - "::", - stringify!(base) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).msg as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAsyncCall), - "::", - stringify!(msg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).cb_method as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAsyncCall), - "::", - stringify!(cb_method) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).cb_target as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAsyncCall), - "::", - stringify!(cb_target) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).state as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAsyncCall), - "::", - stringify!(state) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).res as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAsyncCall), - "::", - stringify!(res) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).out_args as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAsyncCall), - "::", - stringify!(out_args) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppExceptionWrapper { - pub ex: *mut Il2CppException, -} -#[test] -fn bindgen_test_layout_Il2CppExceptionWrapper() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(Il2CppExceptionWrapper)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppExceptionWrapper)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).ex as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppExceptionWrapper), - "::", - stringify!(ex) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppIOAsyncResult() { - assert_eq!( - ::std::mem::size_of::(), - 48usize, - concat!("Size of: ", stringify!(Il2CppIOAsyncResult)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppIOAsyncResult)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).base as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppIOAsyncResult), - "::", - stringify!(base) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).callback as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppIOAsyncResult), - "::", - stringify!(callback) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).state as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppIOAsyncResult), - "::", - stringify!(state) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).wait_handle as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppIOAsyncResult), - "::", - stringify!(wait_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).completed_synchronously as *const _ - as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppIOAsyncResult), - "::", - stringify!(completed_synchronously) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).completed as *const _ as usize }, - 41usize, - concat!( - "Offset of field: ", - stringify!(Il2CppIOAsyncResult), - "::", - stringify!(completed) - ) - ); -} -#[doc = " Corresponds to Mono's internal System.Net.Sockets.Socket.SocketAsyncResult"] -#[doc = " 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, -} -#[test] -fn bindgen_test_layout_Il2CppSocketAsyncResult() { - assert_eq!( - ::std::mem::size_of::(), - 168usize, - concat!("Size of: ", stringify!(Il2CppSocketAsyncResult)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppSocketAsyncResult)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).base as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSocketAsyncResult), - "::", - stringify!(base) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).socket as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSocketAsyncResult), - "::", - stringify!(socket) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).operation as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSocketAsyncResult), - "::", - stringify!(operation) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).delayedException as *const _ - as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSocketAsyncResult), - "::", - stringify!(delayedException) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).endPoint as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSocketAsyncResult), - "::", - stringify!(endPoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).buffer as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSocketAsyncResult), - "::", - stringify!(buffer) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).offset as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSocketAsyncResult), - "::", - stringify!(offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).size as *const _ as usize }, - 92usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSocketAsyncResult), - "::", - stringify!(size) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).socket_flags as *const _ as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSocketAsyncResult), - "::", - stringify!(socket_flags) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).acceptSocket as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSocketAsyncResult), - "::", - stringify!(acceptSocket) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).addresses as *const _ as usize - }, - 112usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSocketAsyncResult), - "::", - stringify!(addresses) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).port as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSocketAsyncResult), - "::", - stringify!(port) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).buffers as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSocketAsyncResult), - "::", - stringify!(buffers) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).reuseSocket as *const _ as usize - }, - 136usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSocketAsyncResult), - "::", - stringify!(reuseSocket) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).currentAddress as *const _ as usize - }, - 140usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSocketAsyncResult), - "::", - stringify!(currentAddress) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).acceptedSocket as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSocketAsyncResult), - "::", - stringify!(acceptedSocket) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).total as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSocketAsyncResult), - "::", - stringify!(total) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).error as *const _ as usize }, - 156usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSocketAsyncResult), - "::", - stringify!(error) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).endCalled as *const _ as usize - }, - 160usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSocketAsyncResult), - "::", - stringify!(endCalled) - ) - ); -} -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; -pub type Il2CppResourceLocation = i32; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppManifestResourceInfo { - pub object: Il2CppObject, - pub assembly: *mut Il2CppReflectionAssembly, - pub filename: *mut Il2CppString, - pub location: u32, -} -#[test] -fn bindgen_test_layout_Il2CppManifestResourceInfo() { - assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(Il2CppManifestResourceInfo)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppManifestResourceInfo)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).object as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppManifestResourceInfo), - "::", - stringify!(object) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).assembly as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppManifestResourceInfo), - "::", - stringify!(assembly) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).filename as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppManifestResourceInfo), - "::", - stringify!(filename) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).location as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppManifestResourceInfo), - "::", - stringify!(location) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppAppContext() { - assert_eq!( - ::std::mem::size_of::(), - 32usize, - concat!("Size of: ", stringify!(Il2CppAppContext)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppAppContext)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppContext), - "::", - stringify!(obj) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).domain_id as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppContext), - "::", - stringify!(domain_id) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).context_id as *const _ as usize }, - 20usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppContext), - "::", - stringify!(context_id) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).static_data as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppAppContext), - "::", - stringify!(static_data) - ) - ); -} -#[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(Copy, Clone)] -pub union Il2CppDecimal__bindgen_ty_1 { - pub u: Il2CppDecimal__bindgen_ty_1__bindgen_ty_1, - pub signscale: u16, - _bindgen_union_align: u16, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppDecimal__bindgen_ty_1__bindgen_ty_1 { - pub scale: u8, - pub sign: u8, -} -#[test] -fn bindgen_test_layout_Il2CppDecimal__bindgen_ty_1__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::(), - 2usize, - concat!( - "Size of: ", - stringify!(Il2CppDecimal__bindgen_ty_1__bindgen_ty_1) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 1usize, - concat!( - "Alignment of ", - stringify!(Il2CppDecimal__bindgen_ty_1__bindgen_ty_1) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).scale as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDecimal__bindgen_ty_1__bindgen_ty_1), - "::", - stringify!(scale) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).sign as *const _ - as usize - }, - 1usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDecimal__bindgen_ty_1__bindgen_ty_1), - "::", - stringify!(sign) - ) - ); -} -#[test] -fn bindgen_test_layout_Il2CppDecimal__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::(), - 2usize, - concat!("Size of: ", stringify!(Il2CppDecimal__bindgen_ty_1)) - ); - assert_eq!( - ::std::mem::align_of::(), - 2usize, - concat!("Alignment of ", stringify!(Il2CppDecimal__bindgen_ty_1)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).u as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDecimal__bindgen_ty_1), - "::", - stringify!(u) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).signscale as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDecimal__bindgen_ty_1), - "::", - stringify!(signscale) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union Il2CppDecimal__bindgen_ty_2 { - pub v: Il2CppDecimal__bindgen_ty_2__bindgen_ty_1, - pub Lo64: u64, - _bindgen_union_align: u64, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppDecimal__bindgen_ty_2__bindgen_ty_1 { - pub Lo32: u32, - pub Mid32: u32, -} -#[test] -fn bindgen_test_layout_Il2CppDecimal__bindgen_ty_2__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(Il2CppDecimal__bindgen_ty_2__bindgen_ty_1) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(Il2CppDecimal__bindgen_ty_2__bindgen_ty_1) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).Lo32 as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDecimal__bindgen_ty_2__bindgen_ty_1), - "::", - stringify!(Lo32) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).Mid32 as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDecimal__bindgen_ty_2__bindgen_ty_1), - "::", - stringify!(Mid32) - ) - ); -} -#[test] -fn bindgen_test_layout_Il2CppDecimal__bindgen_ty_2() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(Il2CppDecimal__bindgen_ty_2)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppDecimal__bindgen_ty_2)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).v as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDecimal__bindgen_ty_2), - "::", - stringify!(v) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).Lo64 as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDecimal__bindgen_ty_2), - "::", - stringify!(Lo64) - ) - ); -} -#[test] -fn bindgen_test_layout_Il2CppDecimal() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(Il2CppDecimal)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppDecimal)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).reserved as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDecimal), - "::", - stringify!(reserved) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).u as *const _ as usize }, - 2usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDecimal), - "::", - stringify!(u) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).Hi32 as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDecimal), - "::", - stringify!(Hi32) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).v as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDecimal), - "::", - stringify!(v) - ) - ); -} -#[repr(C)] -#[repr(align(4))] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppDouble { - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize], u32>, -} -#[test] -fn bindgen_test_layout_Il2CppDouble() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(Il2CppDouble)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppDouble)) - ); -} -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], u32> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize], u32> = - 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 - } -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union Il2CppDouble_double { - pub s: Il2CppDouble, - pub d: f64, - _bindgen_union_align: u64, -} -#[test] -fn bindgen_test_layout_Il2CppDouble_double() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(Il2CppDouble_double)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppDouble_double)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).s as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDouble_double), - "::", - stringify!(s) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).d as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppDouble_double), - "::", - stringify!(d) - ) - ); -} -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; -pub type Il2CppDecimalCompareResult = i32; -#[repr(C)] -#[repr(align(4))] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppSingle { - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u32>, -} -#[test] -fn bindgen_test_layout_Il2CppSingle() { - assert_eq!( - ::std::mem::size_of::(), - 4usize, - concat!("Size of: ", stringify!(Il2CppSingle)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppSingle)) - ); -} -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], u32> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u32> = - 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 - } -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union Il2CppSingle_float { - pub s: Il2CppSingle, - pub f: f32, - _bindgen_union_align: u32, -} -#[test] -fn bindgen_test_layout_Il2CppSingle_float() { - assert_eq!( - ::std::mem::size_of::(), - 4usize, - concat!("Size of: ", stringify!(Il2CppSingle_float)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppSingle_float)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).s as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSingle_float), - "::", - stringify!(s) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).f as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSingle_float), - "::", - stringify!(f) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppGuid { - pub data1: u32, - pub data2: u16, - pub data3: u16, - pub data4: [u8; 8usize], -} -#[test] -fn bindgen_test_layout_Il2CppGuid() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(Il2CppGuid)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppGuid)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data1 as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGuid), - "::", - stringify!(data1) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data2 as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGuid), - "::", - stringify!(data2) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data3 as *const _ as usize }, - 6usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGuid), - "::", - stringify!(data3) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data4 as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppGuid), - "::", - stringify!(data4) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppSafeArrayBound { - pub element_count: u32, - pub lower_bound: i32, -} -#[test] -fn bindgen_test_layout_Il2CppSafeArrayBound() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(Il2CppSafeArrayBound)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppSafeArrayBound)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).element_count as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSafeArrayBound), - "::", - stringify!(element_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).lower_bound as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSafeArrayBound), - "::", - stringify!(lower_bound) - ) - ); -} -#[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], -} -#[test] -fn bindgen_test_layout_Il2CppSafeArray() { - assert_eq!( - ::std::mem::size_of::(), - 32usize, - concat!("Size of: ", stringify!(Il2CppSafeArray)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppSafeArray)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).dimension_count as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSafeArray), - "::", - stringify!(dimension_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).features as *const _ as usize }, - 2usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSafeArray), - "::", - stringify!(features) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).element_size as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSafeArray), - "::", - stringify!(element_size) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).lock_count as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSafeArray), - "::", - stringify!(lock_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSafeArray), - "::", - stringify!(data) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bounds as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppSafeArray), - "::", - stringify!(bounds) - ) - ); -} -#[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(Copy, Clone)] -pub union Il2CppWin32Decimal__bindgen_ty_1 { - pub s: Il2CppWin32Decimal__bindgen_ty_1__bindgen_ty_1, - pub signscale: u16, - _bindgen_union_align: u16, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppWin32Decimal__bindgen_ty_1__bindgen_ty_1 { - pub scale: u8, - pub sign: u8, -} -#[test] -fn bindgen_test_layout_Il2CppWin32Decimal__bindgen_ty_1__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::(), - 2usize, - concat!( - "Size of: ", - stringify!(Il2CppWin32Decimal__bindgen_ty_1__bindgen_ty_1) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 1usize, - concat!( - "Alignment of ", - stringify!(Il2CppWin32Decimal__bindgen_ty_1__bindgen_ty_1) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).scale - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppWin32Decimal__bindgen_ty_1__bindgen_ty_1), - "::", - stringify!(scale) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).sign - as *const _ as usize - }, - 1usize, - concat!( - "Offset of field: ", - stringify!(Il2CppWin32Decimal__bindgen_ty_1__bindgen_ty_1), - "::", - stringify!(sign) - ) - ); -} -#[test] -fn bindgen_test_layout_Il2CppWin32Decimal__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::(), - 2usize, - concat!("Size of: ", stringify!(Il2CppWin32Decimal__bindgen_ty_1)) - ); - assert_eq!( - ::std::mem::align_of::(), - 2usize, - concat!( - "Alignment of ", - stringify!(Il2CppWin32Decimal__bindgen_ty_1) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).s as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppWin32Decimal__bindgen_ty_1), - "::", - stringify!(s) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).signscale as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppWin32Decimal__bindgen_ty_1), - "::", - stringify!(signscale) - ) - ); -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union Il2CppWin32Decimal__bindgen_ty_2 { - pub s2: Il2CppWin32Decimal__bindgen_ty_2__bindgen_ty_1, - pub lo64: u64, - _bindgen_union_align: u64, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppWin32Decimal__bindgen_ty_2__bindgen_ty_1 { - pub lo32: u32, - pub mid32: u32, -} -#[test] -fn bindgen_test_layout_Il2CppWin32Decimal__bindgen_ty_2__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(Il2CppWin32Decimal__bindgen_ty_2__bindgen_ty_1) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(Il2CppWin32Decimal__bindgen_ty_2__bindgen_ty_1) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).lo32 - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppWin32Decimal__bindgen_ty_2__bindgen_ty_1), - "::", - stringify!(lo32) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mid32 - as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppWin32Decimal__bindgen_ty_2__bindgen_ty_1), - "::", - stringify!(mid32) - ) - ); -} -#[test] -fn bindgen_test_layout_Il2CppWin32Decimal__bindgen_ty_2() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(Il2CppWin32Decimal__bindgen_ty_2)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!( - "Alignment of ", - stringify!(Il2CppWin32Decimal__bindgen_ty_2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).s2 as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppWin32Decimal__bindgen_ty_2), - "::", - stringify!(s2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).lo64 as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppWin32Decimal__bindgen_ty_2), - "::", - stringify!(lo64) - ) - ); -} -#[test] -fn bindgen_test_layout_Il2CppWin32Decimal() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(Il2CppWin32Decimal)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppWin32Decimal)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).reserved as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppWin32Decimal), - "::", - stringify!(reserved) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).u as *const _ as usize }, - 2usize, - concat!( - "Offset of field: ", - stringify!(Il2CppWin32Decimal), - "::", - stringify!(u) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).hi32 as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppWin32Decimal), - "::", - stringify!(hi32) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).u2 as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppWin32Decimal), - "::", - stringify!(u2) - ) - ); -} -pub type IL2CPP_VARIANT_BOOL = i16; -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; -pub type Il2CppVarType = i32; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppVariant { - pub n1: Il2CppVariant__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union Il2CppVariant__bindgen_ty_1 { - pub n2: Il2CppVariant__bindgen_ty_1___tagVARIANT, - pub decVal: Il2CppWin32Decimal, - _bindgen_union_align: [u64; 3usize], -} -#[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(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, - _bindgen_union_align: [u64; 2usize], -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1___tagBRECORD() { - assert_eq!( - ::std::mem::size_of::( - ), - 16usize, - concat!( - "Size of: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1___tagBRECORD) - ) - ); - assert_eq!( - ::std::mem::align_of::( - ), - 8usize, - concat!( - "Alignment of ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1___tagBRECORD) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::< - Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1___tagBRECORD, - >())) - .pvRecord as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1___tagBRECORD), - "::", - stringify!(pvRecord) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::< - Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1___tagBRECORD, - >())) - .pRecInfo as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1___tagBRECORD), - "::", - stringify!(pRecInfo) - ) - ); -} -#[test] -fn bindgen_test_layout_Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!( - "Size of: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!( - "Alignment of ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).llVal - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(llVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).lVal - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(lVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bVal - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(bVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iVal - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(iVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .fltVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(fltVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .dblVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(dblVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .boolVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(boolVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).scode - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(scode) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).cyVal - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(cyVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).date - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(date) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .bstrVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(bstrVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .punkVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(punkVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .pdispVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(pdispVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .parray as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(parray) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).pbVal - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(pbVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).piVal - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(piVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).plVal - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(plVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .pllVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(pllVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .pfltVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(pfltVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .pdblVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(pdblVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .pboolVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(pboolVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .pscode as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(pscode) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .pcyVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(pcyVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).pdate - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(pdate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .pbstrVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(pbstrVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .ppunkVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(ppunkVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .ppdispVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(ppdispVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .pparray as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(pparray) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .pvarVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(pvarVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).byref - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(byref) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).cVal - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(cVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).uiVal - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(uiVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).ulVal - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(ulVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .ullVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(ullVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .intVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(intVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .uintVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(uintVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .pdecVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(pdecVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).pcVal - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(pcVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .puiVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(puiVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .pulVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(pulVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .pullVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(pullVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .pintVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(pintVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())) - .puintVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(puintVal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).n4 - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), - "::", - stringify!(n4) - ) - ); -} -#[test] -fn bindgen_test_layout_Il2CppVariant__bindgen_ty_1___tagVARIANT() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!( - "Size of: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!( - "Alignment of ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).type_ as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT), - "::", - stringify!(type_) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).reserved1 - as *const _ as usize - }, - 2usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT), - "::", - stringify!(reserved1) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).reserved2 - as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT), - "::", - stringify!(reserved2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).reserved3 - as *const _ as usize - }, - 6usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT), - "::", - stringify!(reserved3) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).n3 as *const _ - as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT), - "::", - stringify!(n3) - ) - ); -} -#[test] -fn bindgen_test_layout_Il2CppVariant__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(Il2CppVariant__bindgen_ty_1)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppVariant__bindgen_ty_1)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).n2 as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1), - "::", - stringify!(n2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).decVal as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant__bindgen_ty_1), - "::", - stringify!(decVal) - ) - ); -} -#[test] -fn bindgen_test_layout_Il2CppVariant() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(Il2CppVariant)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppVariant)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).n1 as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppVariant), - "::", - stringify!(n1) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppFileTime { - pub low: u32, - pub high: u32, -} -#[test] -fn bindgen_test_layout_Il2CppFileTime() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(Il2CppFileTime)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppFileTime)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).low as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppFileTime), - "::", - stringify!(low) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).high as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(Il2CppFileTime), - "::", - stringify!(high) - ) - ); -} -#[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, -} -#[test] -fn bindgen_test_layout_Il2CppStatStg() { - assert_eq!( - ::std::mem::size_of::(), - 80usize, - concat!("Size of: ", stringify!(Il2CppStatStg)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppStatStg)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStatStg), - "::", - stringify!(name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).type_ as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStatStg), - "::", - stringify!(type_) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).size as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStatStg), - "::", - stringify!(size) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mtime as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStatStg), - "::", - stringify!(mtime) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).ctime as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStatStg), - "::", - stringify!(ctime) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).atime as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStatStg), - "::", - stringify!(atime) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mode as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStatStg), - "::", - stringify!(mode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).locks as *const _ as usize }, - 52usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStatStg), - "::", - stringify!(locks) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).clsid as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStatStg), - "::", - stringify!(clsid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).state as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStatStg), - "::", - stringify!(state) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).reserved as *const _ as usize }, - 76usize, - concat!( - "Offset of field: ", - stringify!(Il2CppStatStg), - "::", - stringify!(reserved) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppHString__ { - pub unused: ::std::os::raw::c_int, -} -#[test] -fn bindgen_test_layout_Il2CppHString__() { - assert_eq!( - ::std::mem::size_of::(), - 4usize, - concat!("Size of: ", stringify!(Il2CppHString__)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(Il2CppHString__)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).unused as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppHString__), - "::", - stringify!(unused) - ) - ); -} -pub type Il2CppHString = *mut Il2CppHString__; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct Il2CppHStringHeader { - pub Reserved: Il2CppHStringHeader__bindgen_ty_1, -} -#[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], - _bindgen_union_align: [u64; 3usize], -} -#[test] -fn bindgen_test_layout_Il2CppHStringHeader__bindgen_ty_1() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(Il2CppHStringHeader__bindgen_ty_1)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!( - "Alignment of ", - stringify!(Il2CppHStringHeader__bindgen_ty_1) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).Reserved1 as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppHStringHeader__bindgen_ty_1), - "::", - stringify!(Reserved1) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).Reserved2 as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppHStringHeader__bindgen_ty_1), - "::", - stringify!(Reserved2) - ) - ); -} -#[test] -fn bindgen_test_layout_Il2CppHStringHeader() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(Il2CppHStringHeader)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppHStringHeader)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).Reserved as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppHStringHeader), - "::", - stringify!(Reserved) - ) - ); -} -pub const Il2CppWindowsRuntimeTypeKind_kTypeKindPrimitive: Il2CppWindowsRuntimeTypeKind = 0; -pub const Il2CppWindowsRuntimeTypeKind_kTypeKindMetadata: Il2CppWindowsRuntimeTypeKind = 1; -pub const Il2CppWindowsRuntimeTypeKind_kTypeKindCustom: Il2CppWindowsRuntimeTypeKind = 2; -pub type Il2CppWindowsRuntimeTypeKind = i32; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Il2CppWindowsRuntimeTypeName { - pub typeName: Il2CppHString, - pub typeKind: Il2CppWindowsRuntimeTypeKind, -} -#[test] -fn bindgen_test_layout_Il2CppWindowsRuntimeTypeName() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(Il2CppWindowsRuntimeTypeName)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Il2CppWindowsRuntimeTypeName)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).typeName as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Il2CppWindowsRuntimeTypeName), - "::", - stringify!(typeName) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).typeKind as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Il2CppWindowsRuntimeTypeName), - "::", - stringify!(typeKind) - ) - ); -} -#[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 type __builtin_va_list = *mut ::std::os::raw::c_char; 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_2022.rs b/libil2cpp/src/raw/types_v31.rs similarity index 100% rename from libil2cpp/src/raw/types_2022.rs rename to libil2cpp/src/raw/types_v31.rs diff --git a/libil2cpp/src/ty.rs b/libil2cpp/src/ty.rs index 5ba0982c..a78d7415 100644 --- a/libil2cpp/src/ty.rs +++ b/libil2cpp/src/ty.rs @@ -56,12 +56,12 @@ unsafe impl WrapRaw for Il2CppType { } impl PartialEq for Il2CppType { - #[cfg(any(feature = "unity2019", feature = "unity2018"))] + #[cfg(any(feature = "il2cpp_v24", feature = "unity2018"))] fn eq(&self, other: &Self) -> bool { unsafe { self.raw().data.klassIndex == other.raw().data.klassIndex } } - #[cfg(feature = "unity2022")] + #[cfg(feature = "il2cpp_v31")] fn eq(&self, other: &Self) -> bool { unsafe { self.raw().data.__klassIndex == other.raw().data.__klassIndex } } @@ -91,8 +91,8 @@ macro_rules! builtins { #[doc = "Builtin C# types"] #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] - #[cfg_attr(feature = "unity2022", repr(i32))] - #[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 { $( @@ -105,10 +105,10 @@ macro_rules! builtins { #[doc = "Whether the type represents the given [`Builtin`]"] #[inline] pub fn is_builtin(&self, builtin: Builtin) -> bool { - #[cfg(feature = "unity2022")] + #[cfg(feature = "il2cpp_v31")] { self.raw().type_() == builtin as i32 } - #[cfg(feature = "unity2019")] + #[cfg(feature = "il2cpp_v24")] { self.raw().type_() == builtin as u32 } #[cfg(feature = "unity2018")] From 30fe3cd4dd42e550003ef26d09aeed227e835ed5 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 11 Nov 2024 18:17:17 -0400 Subject: [PATCH 06/71] Bring back types 2018 --- libil2cpp/src/raw/types_2018.rs | 19721 ++++++++++++++++++++++++++++++ 1 file changed, 19721 insertions(+) diff --git a/libil2cpp/src/raw/types_2018.rs b/libil2cpp/src/raw/types_2018.rs index e69de29b..93c20520 100644 --- a/libil2cpp/src/raw/types_2018.rs +++ b/libil2cpp/src/raw/types_2018.rs @@ -0,0 +1,19721 @@ +#![allow(warnings)] +/* automatically generated by rust-bindgen */ + +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, + align: [Align; 0], +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage, align: [] } + } +} +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); + } + } +} +#[repr(C)] +#[derive(Default)] +pub struct __IncompleteArrayField(::std::marker::PhantomData, [T; 0]); +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] { + ::std::slice::from_raw_parts(self.as_ptr(), len) + } + #[inline] + pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { + ::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") + } +} +pub const NET_4_0: u32 = 1; +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 _HAS_CXX17: u32 = 0; +pub const _HAS_CXX20: u32 = 0; +pub const _HAS_NODISCARD: u32 = 0; +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 _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE: u32 = 1; +pub const _CRT_BUILD_DESKTOP_APP: 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 _MAX_ITOSTR_BASE16_COUNT: u32 = 9; +pub const _MAX_ITOSTR_BASE10_COUNT: u32 = 12; +pub const _MAX_ITOSTR_BASE8_COUNT: u32 = 12; +pub const _MAX_ITOSTR_BASE2_COUNT: u32 = 33; +pub const _MAX_LTOSTR_BASE16_COUNT: u32 = 9; +pub const _MAX_LTOSTR_BASE10_COUNT: u32 = 12; +pub const _MAX_LTOSTR_BASE8_COUNT: u32 = 12; +pub const _MAX_LTOSTR_BASE2_COUNT: u32 = 33; +pub const _MAX_ULTOSTR_BASE16_COUNT: u32 = 9; +pub const _MAX_ULTOSTR_BASE10_COUNT: u32 = 11; +pub const _MAX_ULTOSTR_BASE8_COUNT: u32 = 12; +pub const _MAX_ULTOSTR_BASE2_COUNT: u32 = 33; +pub const _MAX_I64TOSTR_BASE16_COUNT: u32 = 17; +pub const _MAX_I64TOSTR_BASE10_COUNT: u32 = 21; +pub const _MAX_I64TOSTR_BASE8_COUNT: u32 = 23; +pub const _MAX_I64TOSTR_BASE2_COUNT: u32 = 65; +pub const _MAX_U64TOSTR_BASE16_COUNT: u32 = 17; +pub const _MAX_U64TOSTR_BASE10_COUNT: u32 = 21; +pub const _MAX_U64TOSTR_BASE8_COUNT: u32 = 23; +pub const _MAX_U64TOSTR_BASE2_COUNT: u32 = 65; +pub const CHAR_BIT: u32 = 8; +pub const SCHAR_MIN: i32 = -128; +pub const SCHAR_MAX: u32 = 127; +pub const UCHAR_MAX: u32 = 255; +pub const CHAR_MIN: i32 = -128; +pub const CHAR_MAX: u32 = 127; +pub const MB_LEN_MAX: u32 = 5; +pub const SHRT_MIN: i32 = -32768; +pub const SHRT_MAX: u32 = 32767; +pub const USHRT_MAX: u32 = 65535; +pub const INT_MIN: i32 = -2147483648; +pub const INT_MAX: u32 = 2147483647; +pub const UINT_MAX: u32 = 4294967295; +pub const LONG_MIN: i32 = -2147483648; +pub const LONG_MAX: u32 = 2147483647; +pub const ULONG_MAX: u32 = 4294967295; +pub const EXIT_SUCCESS: u32 = 0; +pub const EXIT_FAILURE: u32 = 1; +pub const _WRITE_ABORT_MSG: u32 = 1; +pub const _CALL_REPORTFAULT: u32 = 2; +pub const _OUT_TO_DEFAULT: u32 = 0; +pub const _OUT_TO_STDERR: u32 = 1; +pub const _OUT_TO_MSGBOX: u32 = 2; +pub const _REPORT_ERRMODE: u32 = 3; +pub const RAND_MAX: u32 = 32767; +pub const _CVTBUFSIZE: u32 = 349; +pub const _MAX_PATH: u32 = 260; +pub const _MAX_DRIVE: u32 = 3; +pub const _MAX_DIR: u32 = 256; +pub const _MAX_FNAME: u32 = 256; +pub const _MAX_EXT: u32 = 256; +pub const _MAX_ENV: u32 = 32767; +pub const _CRT_INTERNAL_STDIO_SYMBOL_PREFIX: &'static [u8; 1usize] = b"\0"; +pub const _CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION: u32 = 1; +pub const _CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR: u32 = 2; +pub const _CRT_INTERNAL_PRINTF_LEGACY_WIDE_SPECIFIERS: u32 = 4; +pub const _CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY: u32 = 8; +pub const _CRT_INTERNAL_PRINTF_LEGACY_THREE_DIGIT_EXPONENTS: u32 = 16; +pub const _CRT_INTERNAL_SCANF_SECURECRT: u32 = 1; +pub const _CRT_INTERNAL_SCANF_LEGACY_WIDE_SPECIFIERS: u32 = 2; +pub const _CRT_INTERNAL_SCANF_LEGACY_MSVCRT_COMPATIBILITY: u32 = 4; +pub const BUFSIZ: u32 = 512; +pub const _NSTREAM_: u32 = 512; +pub const _IOB_ENTRIES: u32 = 3; +pub const EOF: i32 = -1; +pub const _IOFBF: u32 = 0; +pub const _IOLBF: u32 = 64; +pub const _IONBF: u32 = 4; +pub const L_tmpnam: u32 = 260; +pub const L_tmpnam_s: u32 = 260; +pub const SEEK_CUR: u32 = 1; +pub const SEEK_END: u32 = 2; +pub const SEEK_SET: u32 = 0; +pub const FILENAME_MAX: u32 = 260; +pub const FOPEN_MAX: u32 = 20; +pub const _SYS_OPEN: u32 = 20; +pub const TMP_MAX: u32 = 2147483647; +pub const TMP_MAX_S: u32 = 2147483647; +pub const _TMP_MAX_S: u32 = 2147483647; +pub const SYS_OPEN: u32 = 20; +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 WCHAR_MIN: u32 = 0; +pub const WCHAR_MAX: u32 = 65535; +pub const WINT_MIN: u32 = 0; +pub const WINT_MAX: u32 = 65535; +pub const IL2CPP_TARGET_ARM64: u32 = 1; +pub const IL2CPP_TARGET_ARMV7: u32 = 0; +pub const IL2CPP_BINARY_SECTION_NAME: &'static [u8; 8usize] = b".il2cpp\0"; +pub const IL2CPP_TARGET_ANDROID: u32 = 1; +pub const IL2CPP_PLATFORM_SUPPORTS_TIMEZONEINFO: u32 = 1; +pub const IL2CPP_TARGET_WINDOWS: u32 = 0; +pub const IL2CPP_TARGET_WINDOWS_DESKTOP: 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_JAVASCRIPT: u32 = 0; +pub const IL2CPP_TARGET_LINUX: 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_PLATFORM_SUPPORTS_SYSTEM_CERTIFICATES: u32 = 0; +pub const IL2CPP_PLATFORM_SUPPORTS_CUSTOM_SECTIONS: u32 = 0; +pub const IL2CPP_PLATFORM_SUPPORTS_CPU_INFO: u32 = 0; +pub const IL2CPP_PLATFORM_SUPPORTS_DEBUGGER_PRESENT: u32 = 0; +pub const IL2CPP_USE_STD_THREAD: u32 = 0; +pub const IL2CPP_THREADS_STD: u32 = 0; +pub const IL2CPP_SIZEOF_VOID_P: u32 = 8; +pub const IL2CPP_API_DYNAMIC_NO_DLSYM: u32 = 0; +pub const IL2CPP_ENABLE_PROFILER: u32 = 1; +pub const IL2CPP_EXCEPTION_DISABLED: u32 = 0; +pub const IL2CPP_CXX_ABI_MSVC: u32 = 0; +pub const IL2CPP_ENABLE_MONO_BUG_EMULATION: u32 = 1; +pub const IL2CPP_PAGE_SIZE: u32 = 4096; +pub const IL2CPP_DEBUG: u32 = 0; +pub const IL2CPP_DEVELOPMENT: u32 = 0; +pub const IL2CPP_THREAD_IMPL_HAS_COM_APARTMENTS: u32 = 0; +pub const IL2CPP_ENABLE_STACKTRACES: 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 IL2CPP_DIR_SEPARATOR: u8 = 47u8; +pub const IL2CPP_DISABLE_FULL_MESSAGES: u32 = 1; +pub const IL2CPP_USE_SEND_NOSIGNAL: u32 = 0; +pub const IL2CPP_SIZEOF_STRUCT_WITH_NO_INSTANCE_FIELDS: u32 = 1; +pub const IL2CPP_VALIDATE_FIELD_LAYOUT: 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 = 0; +pub const IL2CPP_POINTER_SPARE_BITS: u32 = 3; +pub const MAXIMUM_NESTED_GENERICS_EXCEPTION_MESSAGE : & 'static [ u8 ; 176usize ] = 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.\0" ; +pub const IL2CPP_USE_GENERIC_CPU_INFO: u32 = 1; +pub const PUBLIC_KEY_BYTE_LENGTH: u32 = 8; +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; +pub type va_list = *mut ::std::os::raw::c_char; +pub type __vcrt_bool = bool; +pub type wchar_t = ::std::os::raw::c_ushort; +extern "C" { + pub static mut __security_cookie: usize; +} +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; +#[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, +} +#[test] +fn bindgen_test_layout___crt_locale_data_public() { + assert_eq!( + ::std::mem::size_of::<__crt_locale_data_public>(), + 16usize, + concat!("Size of: ", stringify!(__crt_locale_data_public)) + ); + assert_eq!( + ::std::mem::align_of::<__crt_locale_data_public>(), + 8usize, + concat!("Alignment of ", stringify!(__crt_locale_data_public)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__crt_locale_data_public>()))._locale_pctype as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__crt_locale_data_public), + "::", + stringify!(_locale_pctype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__crt_locale_data_public>()))._locale_mb_cur_max as *const _ + as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__crt_locale_data_public), + "::", + stringify!(_locale_mb_cur_max) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::<__crt_locale_data_public>()))._locale_lc_codepage as *const _ + as usize + }, + 12usize, + concat!( + "Offset of field: ", + stringify!(__crt_locale_data_public), + "::", + stringify!(_locale_lc_codepage) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __crt_locale_pointers { + pub locinfo: *mut __crt_locale_data, + pub mbcinfo: *mut __crt_multibyte_data, +} +#[test] +fn bindgen_test_layout___crt_locale_pointers() { + assert_eq!( + ::std::mem::size_of::<__crt_locale_pointers>(), + 16usize, + concat!("Size of: ", stringify!(__crt_locale_pointers)) + ); + assert_eq!( + ::std::mem::align_of::<__crt_locale_pointers>(), + 8usize, + concat!("Alignment of ", stringify!(__crt_locale_pointers)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__crt_locale_pointers>())).locinfo as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__crt_locale_pointers), + "::", + stringify!(locinfo) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__crt_locale_pointers>())).mbcinfo as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__crt_locale_pointers), + "::", + stringify!(mbcinfo) + ) + ); +} +pub type _locale_t = *mut __crt_locale_pointers; +#[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, +} +#[test] +fn bindgen_test_layout__Mbstatet() { + assert_eq!( + ::std::mem::size_of::<_Mbstatet>(), + 8usize, + concat!("Size of: ", stringify!(_Mbstatet)) + ); + assert_eq!( + ::std::mem::align_of::<_Mbstatet>(), + 4usize, + concat!("Alignment of ", stringify!(_Mbstatet)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<_Mbstatet>()))._Wchar as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_Mbstatet), + "::", + stringify!(_Wchar) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<_Mbstatet>()))._Byte as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(_Mbstatet), + "::", + stringify!(_Byte) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<_Mbstatet>()))._State as *const _ as usize }, + 6usize, + concat!( + "Offset of field: ", + stringify!(_Mbstatet), + "::", + stringify!(_State) + ) + ); +} +pub type mbstate_t = _Mbstatet; +pub type time_t = __time64_t; +pub type rsize_t = usize; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct max_align_t { + pub __clang_max_align_nonce1: ::std::os::raw::c_longlong, + pub __clang_max_align_nonce2: f64, +} +#[test] +fn bindgen_test_layout_max_align_t() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(max_align_t)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(max_align_t)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).__clang_max_align_nonce1 as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(max_align_t), + "::", + stringify!(__clang_max_align_nonce1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).__clang_max_align_nonce2 as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(max_align_t), + "::", + stringify!(__clang_max_align_nonce2) + ) + ); +} +pub type _CoreCrtSecureSearchSortCompareFunction = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_void, + arg3: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, +>; +pub type _CoreCrtNonSecureSearchSortCompareFunction = ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, +>; +pub type _onexit_t = ::std::option::Option ::std::os::raw::c_int>; +pub type _purecall_handler = ::std::option::Option; +pub type _invalid_parameter_handler = ::std::option::Option< + unsafe extern "C" fn( + arg1: *const wchar_t, + arg2: *const wchar_t, + arg3: *const wchar_t, + arg4: ::std::os::raw::c_uint, + arg5: usize, + ), +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _div_t { + pub quot: ::std::os::raw::c_int, + pub rem: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout__div_t() { + assert_eq!( + ::std::mem::size_of::<_div_t>(), + 8usize, + concat!("Size of: ", stringify!(_div_t)) + ); + assert_eq!( + ::std::mem::align_of::<_div_t>(), + 4usize, + concat!("Alignment of ", stringify!(_div_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<_div_t>())).quot as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_div_t), + "::", + stringify!(quot) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<_div_t>())).rem as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(_div_t), + "::", + stringify!(rem) + ) + ); +} +pub type div_t = _div_t; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _ldiv_t { + pub quot: ::std::os::raw::c_long, + pub rem: ::std::os::raw::c_long, +} +#[test] +fn bindgen_test_layout__ldiv_t() { + assert_eq!( + ::std::mem::size_of::<_ldiv_t>(), + 8usize, + concat!("Size of: ", stringify!(_ldiv_t)) + ); + assert_eq!( + ::std::mem::align_of::<_ldiv_t>(), + 4usize, + concat!("Alignment of ", stringify!(_ldiv_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<_ldiv_t>())).quot as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_ldiv_t), + "::", + stringify!(quot) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<_ldiv_t>())).rem as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(_ldiv_t), + "::", + stringify!(rem) + ) + ); +} +pub type ldiv_t = _ldiv_t; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _lldiv_t { + pub quot: ::std::os::raw::c_longlong, + pub rem: ::std::os::raw::c_longlong, +} +#[test] +fn bindgen_test_layout__lldiv_t() { + assert_eq!( + ::std::mem::size_of::<_lldiv_t>(), + 16usize, + concat!("Size of: ", stringify!(_lldiv_t)) + ); + assert_eq!( + ::std::mem::align_of::<_lldiv_t>(), + 8usize, + concat!("Alignment of ", stringify!(_lldiv_t)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<_lldiv_t>())).quot as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_lldiv_t), + "::", + stringify!(quot) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<_lldiv_t>())).rem as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(_lldiv_t), + "::", + stringify!(rem) + ) + ); +} +pub type lldiv_t = _lldiv_t; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _LDOUBLE { + pub ld: [::std::os::raw::c_uchar; 10usize], +} +#[test] +fn bindgen_test_layout__LDOUBLE() { + assert_eq!( + ::std::mem::size_of::<_LDOUBLE>(), + 10usize, + concat!("Size of: ", stringify!(_LDOUBLE)) + ); + assert_eq!( + ::std::mem::align_of::<_LDOUBLE>(), + 1usize, + concat!("Alignment of ", stringify!(_LDOUBLE)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<_LDOUBLE>())).ld as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_LDOUBLE), + "::", + stringify!(ld) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _CRT_DOUBLE { + pub x: f64, +} +#[test] +fn bindgen_test_layout__CRT_DOUBLE() { + assert_eq!( + ::std::mem::size_of::<_CRT_DOUBLE>(), + 8usize, + concat!("Size of: ", stringify!(_CRT_DOUBLE)) + ); + assert_eq!( + ::std::mem::align_of::<_CRT_DOUBLE>(), + 8usize, + concat!("Alignment of ", stringify!(_CRT_DOUBLE)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<_CRT_DOUBLE>())).x as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_CRT_DOUBLE), + "::", + stringify!(x) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _CRT_FLOAT { + pub f: f32, +} +#[test] +fn bindgen_test_layout__CRT_FLOAT() { + assert_eq!( + ::std::mem::size_of::<_CRT_FLOAT>(), + 4usize, + concat!("Size of: ", stringify!(_CRT_FLOAT)) + ); + assert_eq!( + ::std::mem::align_of::<_CRT_FLOAT>(), + 4usize, + concat!("Alignment of ", stringify!(_CRT_FLOAT)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<_CRT_FLOAT>())).f as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_CRT_FLOAT), + "::", + stringify!(f) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _LONGDOUBLE { + pub x: f64, +} +#[test] +fn bindgen_test_layout__LONGDOUBLE() { + assert_eq!( + ::std::mem::size_of::<_LONGDOUBLE>(), + 8usize, + concat!("Size of: ", stringify!(_LONGDOUBLE)) + ); + assert_eq!( + ::std::mem::align_of::<_LONGDOUBLE>(), + 8usize, + concat!("Alignment of ", stringify!(_LONGDOUBLE)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<_LONGDOUBLE>())).x as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_LONGDOUBLE), + "::", + stringify!(x) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _LDBL12 { + pub ld12: [::std::os::raw::c_uchar; 12usize], +} +#[test] +fn bindgen_test_layout__LDBL12() { + assert_eq!( + ::std::mem::size_of::<_LDBL12>(), + 12usize, + concat!("Size of: ", stringify!(_LDBL12)) + ); + assert_eq!( + ::std::mem::align_of::<_LDBL12>(), + 1usize, + concat!("Alignment of ", stringify!(_LDBL12)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<_LDBL12>())).ld12 as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_LDBL12), + "::", + stringify!(ld12) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _iobuf { + pub _Placeholder: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout__iobuf() { + assert_eq!( + ::std::mem::size_of::<_iobuf>(), + 8usize, + concat!("Size of: ", stringify!(_iobuf)) + ); + assert_eq!( + ::std::mem::align_of::<_iobuf>(), + 8usize, + concat!("Alignment of ", stringify!(_iobuf)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<_iobuf>()))._Placeholder as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(_iobuf), + "::", + stringify!(_Placeholder) + ) + ); +} +pub type FILE = _iobuf; +pub type fpos_t = ::std::os::raw::c_longlong; +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; +#[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], +} +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 type Il2CppProfileFlags = i32; +pub const Il2CppProfileFileIOKind_IL2CPP_PROFILE_FILEIO_WRITE: Il2CppProfileFileIOKind = 0; +pub const Il2CppProfileFileIOKind_IL2CPP_PROFILE_FILEIO_READ: Il2CppProfileFileIOKind = 1; +pub type Il2CppProfileFileIOKind = i32; +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 type Il2CppGCEvent = i32; +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 type Il2CppStat = i32; +pub const Il2CppRuntimeUnhandledExceptionPolicy_IL2CPP_UNHANDLED_POLICY_LEGACY: + Il2CppRuntimeUnhandledExceptionPolicy = 0; +pub const Il2CppRuntimeUnhandledExceptionPolicy_IL2CPP_UNHANDLED_POLICY_CURRENT: + Il2CppRuntimeUnhandledExceptionPolicy = 1; +pub type Il2CppRuntimeUnhandledExceptionPolicy = i32; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppStackFrameInfo { + pub method: *const MethodInfo, +} +#[test] +fn bindgen_test_layout_Il2CppStackFrameInfo() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Il2CppStackFrameInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppStackFrameInfo)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).method as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStackFrameInfo), + "::", + stringify!(method) + ) + ); +} +#[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, + >, +} +#[test] +fn bindgen_test_layout_Il2CppMemoryCallbacks() { + assert_eq!( + ::std::mem::size_of::(), + 56usize, + concat!("Size of: ", stringify!(Il2CppMemoryCallbacks)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppMemoryCallbacks)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).malloc_func as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMemoryCallbacks), + "::", + stringify!(malloc_func) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aligned_malloc_func as *const _ + as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMemoryCallbacks), + "::", + stringify!(aligned_malloc_func) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free_func as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMemoryCallbacks), + "::", + stringify!(free_func) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aligned_free_func as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMemoryCallbacks), + "::", + stringify!(aligned_free_func) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).calloc_func as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMemoryCallbacks), + "::", + stringify!(calloc_func) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).realloc_func as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMemoryCallbacks), + "::", + stringify!(realloc_func) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aligned_realloc_func as *const _ + as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMemoryCallbacks), + "::", + stringify!(aligned_realloc_func) + ) + ); +} +pub type Il2CppChar = u16; +pub type Il2CppNativeChar = ::std::os::raw::c_char; +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_WorldChangedCallback = ::std::option::Option; +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 Il2CppMethodPointer = ::std::option::Option; +pub type il2cpp_array_size_t = usize; +pub type Il2CppMethodSlot = u32; +pub const kInvalidIl2CppMethodSlot: u32 = 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; +extern "C" { + pub static kIl2CppUInt64Max: u64; +} +extern "C" { + pub static kIl2CppUIntPtrMax: usize; +} +pub const ipv6AddressSize: ::std::os::raw::c_int = 16; +pub type il2cpp_hresult_t = i32; +extern "C" { + pub static mut kIl2CppNewLine: [Il2CppChar; 2usize]; +} +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 type Il2CppTypeEnum = i32; +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 InterfaceOffsetIndex = 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 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 type EncodedMethodIndex = u32; +pub const Il2CppMetadataUsage_kIl2CppMetadataUsageInvalid: Il2CppMetadataUsage = 0; +pub const Il2CppMetadataUsage_kIl2CppMetadataUsageTypeInfo: Il2CppMetadataUsage = 1; +pub const Il2CppMetadataUsage_kIl2CppMetadataUsageIl2CppType: Il2CppMetadataUsage = 2; +pub const Il2CppMetadataUsage_kIl2CppMetadataUsageMethodDef: Il2CppMetadataUsage = 3; +pub const Il2CppMetadataUsage_kIl2CppMetadataUsageFieldInfo: Il2CppMetadataUsage = 4; +pub const Il2CppMetadataUsage_kIl2CppMetadataUsageStringLiteral: Il2CppMetadataUsage = 5; +pub const Il2CppMetadataUsage_kIl2CppMetadataUsageMethodRef: Il2CppMetadataUsage = 6; +pub type Il2CppMetadataUsage = i32; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppTypeDefinitionMetadata { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union Il2CppRGCTXDefinitionData { + pub rgctxDataDummy: i32, + pub methodIndex: MethodIndex, + pub typeIndex: TypeIndex, + _bindgen_union_align: u32, +} +#[test] +fn bindgen_test_layout_Il2CppRGCTXDefinitionData() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(Il2CppRGCTXDefinitionData)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppRGCTXDefinitionData)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rgctxDataDummy as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRGCTXDefinitionData), + "::", + stringify!(rgctxDataDummy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).methodIndex as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRGCTXDefinitionData), + "::", + stringify!(methodIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).typeIndex as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRGCTXDefinitionData), + "::", + stringify!(typeIndex) + ) + ); +} +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 type Il2CppRGCTXDataType = i32; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppRGCTXDefinition { + pub type_: Il2CppRGCTXDataType, + pub data: Il2CppRGCTXDefinitionData, +} +#[test] +fn bindgen_test_layout_Il2CppRGCTXDefinition() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Il2CppRGCTXDefinition)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppRGCTXDefinition)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).type_ as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRGCTXDefinition), + "::", + stringify!(type_) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRGCTXDefinition), + "::", + stringify!(data) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppInterfaceOffsetPair { + pub interfaceTypeIndex: TypeIndex, + pub offset: i32, +} +#[test] +fn bindgen_test_layout_Il2CppInterfaceOffsetPair() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Il2CppInterfaceOffsetPair)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppInterfaceOffsetPair)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).interfaceTypeIndex as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInterfaceOffsetPair), + "::", + stringify!(interfaceTypeIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).offset as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInterfaceOffsetPair), + "::", + stringify!(offset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppTypeDefinition { + pub nameIndex: StringIndex, + pub namespaceIndex: StringIndex, + pub byvalTypeIndex: TypeIndex, + pub byrefTypeIndex: TypeIndex, + pub declaringTypeIndex: TypeIndex, + pub parentIndex: TypeIndex, + pub elementTypeIndex: TypeIndex, + pub rgctxStartIndex: RGCTXIndex, + pub rgctxCount: i32, + pub genericContainerIndex: GenericContainerIndex, + pub flags: u32, + pub fieldStart: FieldIndex, + pub methodStart: MethodIndex, + pub eventStart: EventIndex, + pub propertyStart: PropertyIndex, + pub nestedTypesStart: NestedTypeIndex, + pub interfacesStart: InterfacesIndex, + pub vtableStart: VTableIndex, + pub interfaceOffsetsStart: InterfacesIndex, + 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 bitfield: u32, + pub token: u32, +} +#[test] +fn bindgen_test_layout_Il2CppTypeDefinition() { + assert_eq!( + ::std::mem::size_of::(), + 100usize, + concat!("Size of: ", stringify!(Il2CppTypeDefinition)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppTypeDefinition)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nameIndex as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(nameIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).namespaceIndex as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(namespaceIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).byvalTypeIndex as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(byvalTypeIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).byrefTypeIndex as *const _ as usize + }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(byrefTypeIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).declaringTypeIndex as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(declaringTypeIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).parentIndex as *const _ as usize + }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(parentIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).elementTypeIndex as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(elementTypeIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rgctxStartIndex as *const _ as usize + }, + 28usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(rgctxStartIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).rgctxCount as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(rgctxCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).genericContainerIndex as *const _ + as usize + }, + 36usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(genericContainerIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).flags as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).fieldStart as *const _ as usize }, + 44usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(fieldStart) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).methodStart as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(methodStart) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).eventStart as *const _ as usize }, + 52usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(eventStart) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).propertyStart as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(propertyStart) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).nestedTypesStart as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(nestedTypesStart) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).interfacesStart as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(interfacesStart) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtableStart as *const _ as usize + }, + 68usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(vtableStart) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).interfaceOffsetsStart as *const _ + as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(interfaceOffsetsStart) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).method_count as *const _ as usize + }, + 76usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(method_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).property_count as *const _ as usize + }, + 78usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(property_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).field_count as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(field_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).event_count as *const _ as usize + }, + 82usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(event_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).nested_type_count as *const _ as usize + }, + 84usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(nested_type_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtable_count as *const _ as usize + }, + 86usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(vtable_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).interfaces_count as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(interfaces_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).interface_offsets_count as *const _ + as usize + }, + 90usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(interface_offsets_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bitfield as *const _ as usize }, + 92usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(bitfield) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinition), + "::", + stringify!(token) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppFieldDefinition { + pub nameIndex: StringIndex, + pub typeIndex: TypeIndex, + pub token: u32, +} +#[test] +fn bindgen_test_layout_Il2CppFieldDefinition() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!("Size of: ", stringify!(Il2CppFieldDefinition)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppFieldDefinition)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nameIndex as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppFieldDefinition), + "::", + stringify!(nameIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).typeIndex as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppFieldDefinition), + "::", + stringify!(typeIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppFieldDefinition), + "::", + stringify!(token) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppFieldDefaultValue { + pub fieldIndex: FieldIndex, + pub typeIndex: TypeIndex, + pub dataIndex: DefaultValueDataIndex, +} +#[test] +fn bindgen_test_layout_Il2CppFieldDefaultValue() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!("Size of: ", stringify!(Il2CppFieldDefaultValue)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppFieldDefaultValue)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).fieldIndex as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppFieldDefaultValue), + "::", + stringify!(fieldIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).typeIndex as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppFieldDefaultValue), + "::", + stringify!(typeIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).dataIndex as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppFieldDefaultValue), + "::", + stringify!(dataIndex) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppFieldMarshaledSize { + pub fieldIndex: FieldIndex, + pub typeIndex: TypeIndex, + pub size: i32, +} +#[test] +fn bindgen_test_layout_Il2CppFieldMarshaledSize() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!("Size of: ", stringify!(Il2CppFieldMarshaledSize)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppFieldMarshaledSize)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).fieldIndex as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppFieldMarshaledSize), + "::", + stringify!(fieldIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).typeIndex as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppFieldMarshaledSize), + "::", + stringify!(typeIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).size as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppFieldMarshaledSize), + "::", + stringify!(size) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppFieldRef { + pub typeIndex: TypeIndex, + pub fieldIndex: FieldIndex, +} +#[test] +fn bindgen_test_layout_Il2CppFieldRef() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Il2CppFieldRef)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppFieldRef)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).typeIndex as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppFieldRef), + "::", + stringify!(typeIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).fieldIndex as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppFieldRef), + "::", + stringify!(fieldIndex) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppParameterDefinition { + pub nameIndex: StringIndex, + pub token: u32, + pub typeIndex: TypeIndex, +} +#[test] +fn bindgen_test_layout_Il2CppParameterDefinition() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!("Size of: ", stringify!(Il2CppParameterDefinition)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppParameterDefinition)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).nameIndex as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppParameterDefinition), + "::", + stringify!(nameIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppParameterDefinition), + "::", + stringify!(token) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).typeIndex as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppParameterDefinition), + "::", + stringify!(typeIndex) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppParameterDefaultValue { + pub parameterIndex: ParameterIndex, + pub typeIndex: TypeIndex, + pub dataIndex: DefaultValueDataIndex, +} +#[test] +fn bindgen_test_layout_Il2CppParameterDefaultValue() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!("Size of: ", stringify!(Il2CppParameterDefaultValue)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppParameterDefaultValue)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).parameterIndex as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppParameterDefaultValue), + "::", + stringify!(parameterIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).typeIndex as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppParameterDefaultValue), + "::", + stringify!(typeIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).dataIndex as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppParameterDefaultValue), + "::", + stringify!(dataIndex) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppMethodDefinition { + pub nameIndex: StringIndex, + pub declaringType: TypeDefinitionIndex, + pub returnType: TypeIndex, + pub parameterStart: ParameterIndex, + pub genericContainerIndex: GenericContainerIndex, + pub methodIndex: MethodIndex, + pub invokerIndex: MethodIndex, + pub reversePInvokeWrapperIndex: MethodIndex, + pub rgctxStartIndex: RGCTXIndex, + pub rgctxCount: i32, + pub token: u32, + pub flags: u16, + pub iflags: u16, + pub slot: u16, + pub parameterCount: u16, +} +#[test] +fn bindgen_test_layout_Il2CppMethodDefinition() { + assert_eq!( + ::std::mem::size_of::(), + 52usize, + concat!("Size of: ", stringify!(Il2CppMethodDefinition)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppMethodDefinition)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).nameIndex as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodDefinition), + "::", + stringify!(nameIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).declaringType as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodDefinition), + "::", + stringify!(declaringType) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).returnType as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodDefinition), + "::", + stringify!(returnType) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).parameterStart as *const _ as usize + }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodDefinition), + "::", + stringify!(parameterStart) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).genericContainerIndex as *const _ + as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodDefinition), + "::", + stringify!(genericContainerIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).methodIndex as *const _ as usize + }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodDefinition), + "::", + stringify!(methodIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).invokerIndex as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodDefinition), + "::", + stringify!(invokerIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).reversePInvokeWrapperIndex + as *const _ as usize + }, + 28usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodDefinition), + "::", + stringify!(reversePInvokeWrapperIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rgctxStartIndex as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodDefinition), + "::", + stringify!(rgctxStartIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rgctxCount as *const _ as usize + }, + 36usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodDefinition), + "::", + stringify!(rgctxCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodDefinition), + "::", + stringify!(token) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).flags as *const _ as usize }, + 44usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodDefinition), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iflags as *const _ as usize }, + 46usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodDefinition), + "::", + stringify!(iflags) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).slot as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodDefinition), + "::", + stringify!(slot) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).parameterCount as *const _ as usize + }, + 50usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodDefinition), + "::", + stringify!(parameterCount) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppEventDefinition { + pub nameIndex: StringIndex, + pub typeIndex: TypeIndex, + pub add: MethodIndex, + pub remove: MethodIndex, + pub raise: MethodIndex, + pub token: u32, +} +#[test] +fn bindgen_test_layout_Il2CppEventDefinition() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(Il2CppEventDefinition)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppEventDefinition)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nameIndex as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppEventDefinition), + "::", + stringify!(nameIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).typeIndex as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppEventDefinition), + "::", + stringify!(typeIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).add as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppEventDefinition), + "::", + stringify!(add) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).remove as *const _ as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Il2CppEventDefinition), + "::", + stringify!(remove) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).raise as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppEventDefinition), + "::", + stringify!(raise) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Il2CppEventDefinition), + "::", + stringify!(token) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppPropertyDefinition { + pub nameIndex: StringIndex, + pub get: MethodIndex, + pub set: MethodIndex, + pub attrs: u32, + pub token: u32, +} +#[test] +fn bindgen_test_layout_Il2CppPropertyDefinition() { + assert_eq!( + ::std::mem::size_of::(), + 20usize, + concat!("Size of: ", stringify!(Il2CppPropertyDefinition)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppPropertyDefinition)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).nameIndex as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPropertyDefinition), + "::", + stringify!(nameIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).get as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPropertyDefinition), + "::", + stringify!(get) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).set as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPropertyDefinition), + "::", + stringify!(set) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).attrs as *const _ as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPropertyDefinition), + "::", + stringify!(attrs) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPropertyDefinition), + "::", + stringify!(token) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppMethodSpec { + pub methodDefinitionIndex: MethodIndex, + pub classIndexIndex: GenericInstIndex, + pub methodIndexIndex: GenericInstIndex, +} +#[test] +fn bindgen_test_layout_Il2CppMethodSpec() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!("Size of: ", stringify!(Il2CppMethodSpec)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppMethodSpec)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).methodDefinitionIndex as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodSpec), + "::", + stringify!(methodDefinitionIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).classIndexIndex as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodSpec), + "::", + stringify!(classIndexIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).methodIndexIndex as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodSpec), + "::", + stringify!(methodIndexIndex) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppStringLiteral { + pub length: u32, + pub dataIndex: StringLiteralIndex, +} +#[test] +fn bindgen_test_layout_Il2CppStringLiteral() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Il2CppStringLiteral)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppStringLiteral)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).length as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStringLiteral), + "::", + stringify!(length) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).dataIndex as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStringLiteral), + "::", + stringify!(dataIndex) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppGenericMethodIndices { + pub methodIndex: MethodIndex, + pub invokerIndex: MethodIndex, +} +#[test] +fn bindgen_test_layout_Il2CppGenericMethodIndices() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Il2CppGenericMethodIndices)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppGenericMethodIndices)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).methodIndex as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGenericMethodIndices), + "::", + stringify!(methodIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).invokerIndex as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGenericMethodIndices), + "::", + stringify!(invokerIndex) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppGenericMethodFunctionsDefinitions { + pub genericMethodIndex: GenericMethodIndex, + pub indices: Il2CppGenericMethodIndices, +} +#[test] +fn bindgen_test_layout_Il2CppGenericMethodFunctionsDefinitions() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(Il2CppGenericMethodFunctionsDefinitions) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(Il2CppGenericMethodFunctionsDefinitions) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).genericMethodIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGenericMethodFunctionsDefinitions), + "::", + stringify!(genericMethodIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).indices as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGenericMethodFunctionsDefinitions), + "::", + stringify!(indices) + ) + ); +} +pub const kPublicKeyByteLength: ::std::os::raw::c_int = 8; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppAssemblyNameDefinition { + pub nameIndex: StringIndex, + pub cultureIndex: StringIndex, + pub hashValueIndex: StringIndex, + pub publicKeyIndex: StringIndex, + 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], +} +#[test] +fn bindgen_test_layout_Il2CppAssemblyNameDefinition() { + assert_eq!( + ::std::mem::size_of::(), + 52usize, + concat!("Size of: ", stringify!(Il2CppAssemblyNameDefinition)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppAssemblyNameDefinition)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).nameIndex as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyNameDefinition), + "::", + stringify!(nameIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).cultureIndex as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyNameDefinition), + "::", + stringify!(cultureIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).hashValueIndex as *const _ + as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyNameDefinition), + "::", + stringify!(hashValueIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).publicKeyIndex as *const _ + as usize + }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyNameDefinition), + "::", + stringify!(publicKeyIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).hash_alg as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyNameDefinition), + "::", + stringify!(hash_alg) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).hash_len as *const _ as usize + }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyNameDefinition), + "::", + stringify!(hash_len) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).flags as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyNameDefinition), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).major as *const _ as usize + }, + 28usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyNameDefinition), + "::", + stringify!(major) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).minor as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyNameDefinition), + "::", + stringify!(minor) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).build as *const _ as usize + }, + 36usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyNameDefinition), + "::", + stringify!(build) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).revision as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyNameDefinition), + "::", + stringify!(revision) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).public_key_token as *const _ + as usize + }, + 44usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyNameDefinition), + "::", + stringify!(public_key_token) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppImageDefinition { + pub nameIndex: StringIndex, + pub assemblyIndex: AssemblyIndex, + pub typeStart: TypeDefinitionIndex, + pub typeCount: u32, + pub exportedTypeStart: TypeDefinitionIndex, + pub exportedTypeCount: u32, + pub entryPointIndex: MethodIndex, + pub token: u32, + pub customAttributeStart: CustomAttributeIndex, + pub customAttributeCount: u32, +} +#[test] +fn bindgen_test_layout_Il2CppImageDefinition() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(Il2CppImageDefinition)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppImageDefinition)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nameIndex as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppImageDefinition), + "::", + stringify!(nameIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).assemblyIndex as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppImageDefinition), + "::", + stringify!(assemblyIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).typeStart as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppImageDefinition), + "::", + stringify!(typeStart) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).typeCount as *const _ as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Il2CppImageDefinition), + "::", + stringify!(typeCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).exportedTypeStart as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppImageDefinition), + "::", + stringify!(exportedTypeStart) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).exportedTypeCount as *const _ as usize + }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Il2CppImageDefinition), + "::", + stringify!(exportedTypeCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).entryPointIndex as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppImageDefinition), + "::", + stringify!(entryPointIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(Il2CppImageDefinition), + "::", + stringify!(token) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).customAttributeStart as *const _ + as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppImageDefinition), + "::", + stringify!(customAttributeStart) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).customAttributeCount as *const _ + as usize + }, + 36usize, + concat!( + "Offset of field: ", + stringify!(Il2CppImageDefinition), + "::", + stringify!(customAttributeCount) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppAssemblyDefinition { + pub imageIndex: ImageIndex, + pub token: u32, + pub referencedAssemblyStart: i32, + pub referencedAssemblyCount: i32, + pub aname: Il2CppAssemblyNameDefinition, +} +#[test] +fn bindgen_test_layout_Il2CppAssemblyDefinition() { + assert_eq!( + ::std::mem::size_of::(), + 68usize, + concat!("Size of: ", stringify!(Il2CppAssemblyDefinition)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppAssemblyDefinition)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).imageIndex as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyDefinition), + "::", + stringify!(imageIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyDefinition), + "::", + stringify!(token) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).referencedAssemblyStart as *const _ + as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyDefinition), + "::", + stringify!(referencedAssemblyStart) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).referencedAssemblyCount as *const _ + as usize + }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyDefinition), + "::", + stringify!(referencedAssemblyCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aname as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyDefinition), + "::", + stringify!(aname) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppMetadataUsageList { + pub start: u32, + pub count: u32, +} +#[test] +fn bindgen_test_layout_Il2CppMetadataUsageList() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Il2CppMetadataUsageList)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppMetadataUsageList)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).start as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMetadataUsageList), + "::", + stringify!(start) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).count as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMetadataUsageList), + "::", + stringify!(count) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppMetadataUsagePair { + pub destinationIndex: u32, + pub encodedSourceIndex: u32, +} +#[test] +fn bindgen_test_layout_Il2CppMetadataUsagePair() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Il2CppMetadataUsagePair)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppMetadataUsagePair)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).destinationIndex as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMetadataUsagePair), + "::", + stringify!(destinationIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).encodedSourceIndex as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMetadataUsagePair), + "::", + stringify!(encodedSourceIndex) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppCustomAttributeTypeRange { + pub token: u32, + pub start: i32, + pub count: i32, +} +#[test] +fn bindgen_test_layout_Il2CppCustomAttributeTypeRange() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!("Size of: ", stringify!(Il2CppCustomAttributeTypeRange)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppCustomAttributeTypeRange)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).token as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCustomAttributeTypeRange), + "::", + stringify!(token) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).start as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCustomAttributeTypeRange), + "::", + stringify!(start) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).count as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCustomAttributeTypeRange), + "::", + stringify!(count) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppRange { + pub start: i32, + pub length: i32, +} +#[test] +fn bindgen_test_layout_Il2CppRange() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Il2CppRange)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppRange)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).start as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRange), + "::", + stringify!(start) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).length as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRange), + "::", + stringify!(length) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppWindowsRuntimeTypeNamePair { + pub nameIndex: StringIndex, + pub typeIndex: TypeIndex, +} +#[test] +fn bindgen_test_layout_Il2CppWindowsRuntimeTypeNamePair() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Il2CppWindowsRuntimeTypeNamePair)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(Il2CppWindowsRuntimeTypeNamePair) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).nameIndex as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppWindowsRuntimeTypeNamePair), + "::", + stringify!(nameIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).typeIndex as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppWindowsRuntimeTypeNamePair), + "::", + stringify!(typeIndex) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppGlobalMetadataHeader { + pub sanity: i32, + pub version: i32, + pub stringLiteralOffset: i32, + pub stringLiteralCount: i32, + pub stringLiteralDataOffset: i32, + pub stringLiteralDataCount: i32, + pub stringOffset: i32, + pub stringCount: i32, + pub eventsOffset: i32, + pub eventsCount: i32, + pub propertiesOffset: i32, + pub propertiesCount: i32, + pub methodsOffset: i32, + pub methodsCount: i32, + pub parameterDefaultValuesOffset: i32, + pub parameterDefaultValuesCount: i32, + pub fieldDefaultValuesOffset: i32, + pub fieldDefaultValuesCount: i32, + pub fieldAndParameterDefaultValueDataOffset: i32, + pub fieldAndParameterDefaultValueDataCount: i32, + pub fieldMarshaledSizesOffset: i32, + pub fieldMarshaledSizesCount: i32, + pub parametersOffset: i32, + pub parametersCount: i32, + pub fieldsOffset: i32, + pub fieldsCount: i32, + pub genericParametersOffset: i32, + pub genericParametersCount: i32, + pub genericParameterConstraintsOffset: i32, + pub genericParameterConstraintsCount: i32, + pub genericContainersOffset: i32, + pub genericContainersCount: i32, + pub nestedTypesOffset: i32, + pub nestedTypesCount: i32, + pub interfacesOffset: i32, + pub interfacesCount: i32, + pub vtableMethodsOffset: i32, + pub vtableMethodsCount: i32, + pub interfaceOffsetsOffset: i32, + pub interfaceOffsetsCount: i32, + pub typeDefinitionsOffset: i32, + pub typeDefinitionsCount: i32, + pub rgctxEntriesOffset: i32, + pub rgctxEntriesCount: i32, + pub imagesOffset: i32, + pub imagesCount: i32, + pub assembliesOffset: i32, + pub assembliesCount: i32, + pub metadataUsageListsOffset: i32, + pub metadataUsageListsCount: i32, + pub metadataUsagePairsOffset: i32, + pub metadataUsagePairsCount: i32, + pub fieldRefsOffset: i32, + pub fieldRefsCount: i32, + pub referencedAssembliesOffset: i32, + pub referencedAssembliesCount: i32, + pub attributesInfoOffset: i32, + pub attributesInfoCount: i32, + pub attributeTypesOffset: i32, + pub attributeTypesCount: i32, + pub unresolvedVirtualCallParameterTypesOffset: i32, + pub unresolvedVirtualCallParameterTypesCount: i32, + pub unresolvedVirtualCallParameterRangesOffset: i32, + pub unresolvedVirtualCallParameterRangesCount: i32, + pub windowsRuntimeTypeNamesOffset: i32, + pub windowsRuntimeTypeNamesSize: i32, + pub exportedTypeDefinitionsOffset: i32, + pub exportedTypeDefinitionsCount: i32, +} +#[test] +fn bindgen_test_layout_Il2CppGlobalMetadataHeader() { + assert_eq!( + ::std::mem::size_of::(), + 272usize, + concat!("Size of: ", stringify!(Il2CppGlobalMetadataHeader)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppGlobalMetadataHeader)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).sanity as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(sanity) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).version as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(version) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stringLiteralOffset as *const _ + as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(stringLiteralOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stringLiteralCount as *const _ + as usize + }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(stringLiteralCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stringLiteralDataOffset + as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(stringLiteralDataOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stringLiteralDataCount + as *const _ as usize + }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(stringLiteralDataCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stringOffset as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(stringOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stringCount as *const _ as usize + }, + 28usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(stringCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eventsOffset as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(eventsOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eventsCount as *const _ as usize + }, + 36usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(eventsCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).propertiesOffset as *const _ + as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(propertiesOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).propertiesCount as *const _ + as usize + }, + 44usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(propertiesCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).methodsOffset as *const _ + as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(methodsOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).methodsCount as *const _ as usize + }, + 52usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(methodsCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).parameterDefaultValuesOffset + as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(parameterDefaultValuesOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).parameterDefaultValuesCount + as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(parameterDefaultValuesCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).fieldDefaultValuesOffset + as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(fieldDefaultValuesOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).fieldDefaultValuesCount + as *const _ as usize + }, + 68usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(fieldDefaultValuesCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .fieldAndParameterDefaultValueDataOffset as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(fieldAndParameterDefaultValueDataOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .fieldAndParameterDefaultValueDataCount as *const _ as usize + }, + 76usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(fieldAndParameterDefaultValueDataCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).fieldMarshaledSizesOffset + as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(fieldMarshaledSizesOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).fieldMarshaledSizesCount + as *const _ as usize + }, + 84usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(fieldMarshaledSizesCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).parametersOffset as *const _ + as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(parametersOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).parametersCount as *const _ + as usize + }, + 92usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(parametersCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).fieldsOffset as *const _ as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(fieldsOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).fieldsCount as *const _ as usize + }, + 100usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(fieldsCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).genericParametersOffset + as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(genericParametersOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).genericParametersCount + as *const _ as usize + }, + 108usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(genericParametersCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).genericParameterConstraintsOffset + as *const _ as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(genericParameterConstraintsOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).genericParameterConstraintsCount + as *const _ as usize + }, + 116usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(genericParameterConstraintsCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).genericContainersOffset + as *const _ as usize + }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(genericContainersOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).genericContainersCount + as *const _ as usize + }, + 124usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(genericContainersCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).nestedTypesOffset as *const _ + as usize + }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(nestedTypesOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).nestedTypesCount as *const _ + as usize + }, + 132usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(nestedTypesCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).interfacesOffset as *const _ + as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(interfacesOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).interfacesCount as *const _ + as usize + }, + 140usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(interfacesCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtableMethodsOffset as *const _ + as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(vtableMethodsOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtableMethodsCount as *const _ + as usize + }, + 148usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(vtableMethodsCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).interfaceOffsetsOffset + as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(interfaceOffsetsOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).interfaceOffsetsCount as *const _ + as usize + }, + 156usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(interfaceOffsetsCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).typeDefinitionsOffset as *const _ + as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(typeDefinitionsOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).typeDefinitionsCount as *const _ + as usize + }, + 164usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(typeDefinitionsCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rgctxEntriesOffset as *const _ + as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(rgctxEntriesOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rgctxEntriesCount as *const _ + as usize + }, + 172usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(rgctxEntriesCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).imagesOffset as *const _ as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(imagesOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).imagesCount as *const _ as usize + }, + 180usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(imagesCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).assembliesOffset as *const _ + as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(assembliesOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).assembliesCount as *const _ + as usize + }, + 188usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(assembliesCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).metadataUsageListsOffset + as *const _ as usize + }, + 192usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(metadataUsageListsOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).metadataUsageListsCount + as *const _ as usize + }, + 196usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(metadataUsageListsCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).metadataUsagePairsOffset + as *const _ as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(metadataUsagePairsOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).metadataUsagePairsCount + as *const _ as usize + }, + 204usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(metadataUsagePairsCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).fieldRefsOffset as *const _ + as usize + }, + 208usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(fieldRefsOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).fieldRefsCount as *const _ + as usize + }, + 212usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(fieldRefsCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).referencedAssembliesOffset + as *const _ as usize + }, + 216usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(referencedAssembliesOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).referencedAssembliesCount + as *const _ as usize + }, + 220usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(referencedAssembliesCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).attributesInfoOffset as *const _ + as usize + }, + 224usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(attributesInfoOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).attributesInfoCount as *const _ + as usize + }, + 228usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(attributesInfoCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).attributeTypesOffset as *const _ + as usize + }, + 232usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(attributeTypesOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).attributeTypesCount as *const _ + as usize + }, + 236usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(attributeTypesCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .unresolvedVirtualCallParameterTypesOffset as *const _ as usize + }, + 240usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(unresolvedVirtualCallParameterTypesOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .unresolvedVirtualCallParameterTypesCount as *const _ as usize + }, + 244usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(unresolvedVirtualCallParameterTypesCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .unresolvedVirtualCallParameterRangesOffset as *const _ as usize + }, + 248usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(unresolvedVirtualCallParameterRangesOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .unresolvedVirtualCallParameterRangesCount as *const _ as usize + }, + 252usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(unresolvedVirtualCallParameterRangesCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).windowsRuntimeTypeNamesOffset + as *const _ as usize + }, + 256usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(windowsRuntimeTypeNamesOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).windowsRuntimeTypeNamesSize + as *const _ as usize + }, + 260usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(windowsRuntimeTypeNamesSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).exportedTypeDefinitionsOffset + as *const _ as usize + }, + 264usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(exportedTypeDefinitionsOffset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).exportedTypeDefinitionsCount + as *const _ as usize + }, + 268usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGlobalMetadataHeader), + "::", + stringify!(exportedTypeDefinitionsCount) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppArrayType() { + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(Il2CppArrayType)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppArrayType)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).etype as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppArrayType), + "::", + stringify!(etype) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).rank as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppArrayType), + "::", + stringify!(rank) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).numsizes as *const _ as usize }, + 9usize, + concat!( + "Offset of field: ", + stringify!(Il2CppArrayType), + "::", + stringify!(numsizes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).numlobounds as *const _ as usize }, + 10usize, + concat!( + "Offset of field: ", + stringify!(Il2CppArrayType), + "::", + stringify!(numlobounds) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sizes as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppArrayType), + "::", + stringify!(sizes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).lobounds as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppArrayType), + "::", + stringify!(lobounds) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppGenericInst { + pub type_argc: u32, + pub type_argv: *mut *const Il2CppType, +} +#[test] +fn bindgen_test_layout_Il2CppGenericInst() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Il2CppGenericInst)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppGenericInst)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).type_argc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGenericInst), + "::", + stringify!(type_argc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).type_argv as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGenericInst), + "::", + stringify!(type_argv) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppGenericContext { + pub class_inst: *const Il2CppGenericInst, + pub method_inst: *const Il2CppGenericInst, +} +#[test] +fn bindgen_test_layout_Il2CppGenericContext() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Il2CppGenericContext)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppGenericContext)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).class_inst as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGenericContext), + "::", + stringify!(class_inst) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).method_inst as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGenericContext), + "::", + stringify!(method_inst) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppGenericParameter { + pub ownerIndex: GenericContainerIndex, + pub nameIndex: StringIndex, + pub constraintsStart: GenericParameterConstraintIndex, + pub constraintsCount: i16, + pub num: u16, + pub flags: u16, +} +#[test] +fn bindgen_test_layout_Il2CppGenericParameter() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Il2CppGenericParameter)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppGenericParameter)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).ownerIndex as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGenericParameter), + "::", + stringify!(ownerIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).nameIndex as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGenericParameter), + "::", + stringify!(nameIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).constraintsStart as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGenericParameter), + "::", + stringify!(constraintsStart) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).constraintsCount as *const _ as usize + }, + 10usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGenericParameter), + "::", + stringify!(constraintsCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).num as *const _ as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGenericParameter), + "::", + stringify!(num) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).flags as *const _ as usize }, + 14usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGenericParameter), + "::", + stringify!(flags) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppGenericContainer { + pub ownerIndex: i32, + pub type_argc: i32, + pub is_method: i32, + pub genericParameterStart: GenericParameterIndex, +} +#[test] +fn bindgen_test_layout_Il2CppGenericContainer() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Il2CppGenericContainer)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppGenericContainer)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).ownerIndex as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGenericContainer), + "::", + stringify!(ownerIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).type_argc as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGenericContainer), + "::", + stringify!(type_argc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).is_method as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGenericContainer), + "::", + stringify!(is_method) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).genericParameterStart as *const _ + as usize + }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGenericContainer), + "::", + stringify!(genericParameterStart) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppGenericClass { + pub typeDefinitionIndex: TypeDefinitionIndex, + pub context: Il2CppGenericContext, + pub cached_class: *mut Il2CppClass, +} +#[test] +fn bindgen_test_layout_Il2CppGenericClass() { + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(Il2CppGenericClass)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppGenericClass)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).typeDefinitionIndex as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGenericClass), + "::", + stringify!(typeDefinitionIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).context as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGenericClass), + "::", + stringify!(context) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).cached_class as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGenericClass), + "::", + stringify!(cached_class) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppGenericMethod { + pub methodDefinition: *const MethodInfo, + pub context: Il2CppGenericContext, +} +#[test] +fn bindgen_test_layout_Il2CppGenericMethod() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(Il2CppGenericMethod)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppGenericMethod)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).methodDefinition as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGenericMethod), + "::", + stringify!(methodDefinition) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).context as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGenericMethod), + "::", + stringify!(context) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppType { + pub data: Il2CppType__bindgen_ty_1, + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u16>, + pub __bindgen_padding_0: u32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union Il2CppType__bindgen_ty_1 { + pub dummy: *mut ::std::os::raw::c_void, + pub klassIndex: TypeDefinitionIndex, + pub type_: *const Il2CppType, + pub array: *mut Il2CppArrayType, + pub genericParameterIndex: GenericParameterIndex, + pub generic_class: *mut Il2CppGenericClass, + _bindgen_union_align: u64, +} +#[test] +fn bindgen_test_layout_Il2CppType__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Il2CppType__bindgen_ty_1)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppType__bindgen_ty_1)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).dummy as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppType__bindgen_ty_1), + "::", + stringify!(dummy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).klassIndex as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppType__bindgen_ty_1), + "::", + stringify!(klassIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).type_ as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppType__bindgen_ty_1), + "::", + stringify!(type_) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).array as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppType__bindgen_ty_1), + "::", + stringify!(array) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).genericParameterIndex as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppType__bindgen_ty_1), + "::", + stringify!(genericParameterIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).generic_class as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppType__bindgen_ty_1), + "::", + stringify!(generic_class) + ) + ); +} +#[test] +fn bindgen_test_layout_Il2CppType() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Il2CppType)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppType)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppType), + "::", + stringify!(data) + ) + ); +} +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, 6u8) 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, 6u8, val as u64) + } + } + #[inline] + pub fn byref(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 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(30usize, 1u8, val as u64) + } + } + #[inline] + pub fn pinned(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 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(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, + ) -> __BindgenBitfieldUnit<[u8; 4usize], u16> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u16> = + 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, 6u8, { + let num_mods: u32 = unsafe { ::std::mem::transmute(num_mods) }; + num_mods as u64 + }); + __bindgen_bitfield_unit.set(30usize, 1u8, { + let byref: u32 = unsafe { ::std::mem::transmute(byref) }; + byref as u64 + }); + __bindgen_bitfield_unit.set(31usize, 1u8, { + let pinned: u32 = unsafe { ::std::mem::transmute(pinned) }; + pinned as u64 + }); + __bindgen_bitfield_unit + } +} +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 type Il2CppCallConvention = i32; +pub const Il2CppCharSet_CHARSET_ANSI: Il2CppCharSet = 0; +pub const Il2CppCharSet_CHARSET_UNICODE: Il2CppCharSet = 1; +pub const Il2CppCharSet_CHARSET_NOT_SPECIFIED: Il2CppCharSet = 2; +pub type Il2CppCharSet = i32; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppNameToTypeDefinitionIndexHashTable { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VirtualInvokeData { + pub methodPtr: Il2CppMethodPointer, + pub method: *const MethodInfo, +} +#[test] +fn bindgen_test_layout_VirtualInvokeData() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(VirtualInvokeData)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(VirtualInvokeData)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).methodPtr as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(VirtualInvokeData), + "::", + stringify!(methodPtr) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).method as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(VirtualInvokeData), + "::", + stringify!(method) + ) + ); +} +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; +pub type Il2CppTypeNameFormat = i32; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppDefaults { + pub corlib: *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 field_info_class: *mut Il2CppClass, + pub method_info_class: *mut Il2CppClass, + pub property_info_class: *mut Il2CppClass, + pub event_info_class: *mut Il2CppClass, + pub mono_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 version: *mut Il2CppClass, + pub culture_info: *mut Il2CppClass, + pub async_call_class: *mut Il2CppClass, + pub assembly_class: *mut Il2CppClass, + pub mono_assembly_class: *mut Il2CppClass, + pub assembly_name_class: *mut Il2CppClass, + pub mono_field_class: *mut Il2CppClass, + pub mono_method_class: *mut Il2CppClass, + pub mono_method_info_class: *mut Il2CppClass, + pub mono_property_info_class: *mut Il2CppClass, + pub parameter_info_class: *mut Il2CppClass, + pub mono_parameter_info_class: *mut Il2CppClass, + pub module_class: *mut Il2CppClass, + pub pointer_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, +} +#[test] +fn bindgen_test_layout_Il2CppDefaults() { + assert_eq!( + ::std::mem::size_of::(), + 784usize, + concat!("Size of: ", stringify!(Il2CppDefaults)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppDefaults)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).corlib as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(corlib) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).object_class as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(object_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).byte_class as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(byte_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).void_class as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(void_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).boolean_class as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(boolean_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sbyte_class as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(sbyte_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).int16_class as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(int16_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).uint16_class as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(uint16_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).int32_class as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(int32_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).uint32_class as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(uint32_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).int_class as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(int_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).uint_class as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(uint_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).int64_class as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(int64_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).uint64_class as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(uint64_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).single_class as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(single_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).double_class as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(double_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).char_class as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(char_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).string_class as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(string_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).enum_class as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(enum_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).array_class as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(array_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).delegate_class as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(delegate_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).multicastdelegate_class as *const _ as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(multicastdelegate_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).asyncresult_class as *const _ as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(asyncresult_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).manualresetevent_class as *const _ as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(manualresetevent_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).typehandle_class as *const _ as usize }, + 192usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(typehandle_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).fieldhandle_class as *const _ as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(fieldhandle_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).methodhandle_class as *const _ as usize + }, + 208usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(methodhandle_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).systemtype_class as *const _ as usize }, + 216usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(systemtype_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).monotype_class as *const _ as usize }, + 224usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(monotype_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).exception_class as *const _ as usize }, + 232usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(exception_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).threadabortexception_class as *const _ + as usize + }, + 240usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(threadabortexception_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).thread_class as *const _ as usize }, + 248usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(thread_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).internal_thread_class as *const _ as usize + }, + 256usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(internal_thread_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).appdomain_class as *const _ as usize }, + 264usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(appdomain_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).appdomain_setup_class as *const _ as usize + }, + 272usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(appdomain_setup_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).field_info_class as *const _ as usize }, + 280usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(field_info_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).method_info_class as *const _ as usize + }, + 288usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(method_info_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).property_info_class as *const _ as usize + }, + 296usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(property_info_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).event_info_class as *const _ as usize }, + 304usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(event_info_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mono_event_info_class as *const _ as usize + }, + 312usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(mono_event_info_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stringbuilder_class as *const _ as usize + }, + 320usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(stringbuilder_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stack_frame_class as *const _ as usize + }, + 328usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(stack_frame_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stack_trace_class as *const _ as usize + }, + 336usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(stack_trace_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).marshal_class as *const _ as usize }, + 344usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(marshal_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).typed_reference_class as *const _ as usize + }, + 352usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(typed_reference_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).marshalbyrefobject_class as *const _ as usize + }, + 360usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(marshalbyrefobject_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).generic_ilist_class as *const _ as usize + }, + 368usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(generic_ilist_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).generic_icollection_class as *const _ + as usize + }, + 376usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(generic_icollection_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).generic_ienumerable_class as *const _ + as usize + }, + 384usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(generic_ienumerable_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).generic_ireadonlylist_class as *const _ + as usize + }, + 392usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(generic_ireadonlylist_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).generic_ireadonlycollection_class as *const _ + as usize + }, + 400usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(generic_ireadonlycollection_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).runtimetype_class as *const _ as usize + }, + 408usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(runtimetype_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).generic_nullable_class as *const _ as usize + }, + 416usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(generic_nullable_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).il2cpp_com_object_class as *const _ as usize + }, + 424usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(il2cpp_com_object_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).attribute_class as *const _ as usize }, + 432usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(attribute_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).customattribute_data_class as *const _ + as usize + }, + 440usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(customattribute_data_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).version as *const _ as usize }, + 448usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(version) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).culture_info as *const _ as usize }, + 456usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(culture_info) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).async_call_class as *const _ as usize }, + 464usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(async_call_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).assembly_class as *const _ as usize }, + 472usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(assembly_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mono_assembly_class as *const _ as usize + }, + 480usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(mono_assembly_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).assembly_name_class as *const _ as usize + }, + 488usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(assembly_name_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mono_field_class as *const _ as usize }, + 496usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(mono_field_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mono_method_class as *const _ as usize + }, + 504usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(mono_method_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mono_method_info_class as *const _ as usize + }, + 512usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(mono_method_info_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mono_property_info_class as *const _ as usize + }, + 520usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(mono_property_info_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).parameter_info_class as *const _ as usize + }, + 528usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(parameter_info_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mono_parameter_info_class as *const _ + as usize + }, + 536usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(mono_parameter_info_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).module_class as *const _ as usize }, + 544usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(module_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pointer_class as *const _ as usize }, + 552usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(pointer_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).system_exception_class as *const _ as usize + }, + 560usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(system_exception_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argument_exception_class as *const _ as usize + }, + 568usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(argument_exception_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wait_handle_class as *const _ as usize + }, + 576usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(wait_handle_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).safe_handle_class as *const _ as usize + }, + 584usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(safe_handle_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sort_key_class as *const _ as usize }, + 592usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(sort_key_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).dbnull_class as *const _ as usize }, + 600usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(dbnull_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).error_wrapper_class as *const _ as usize + }, + 608usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(error_wrapper_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).missing_class as *const _ as usize }, + 616usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(missing_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_type_class as *const _ as usize }, + 624usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(value_type_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).threadpool_wait_callback_class as *const _ + as usize + }, + 632usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(threadpool_wait_callback_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).threadpool_perform_wait_callback_method + as *const _ as usize + }, + 640usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(threadpool_perform_wait_callback_method) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mono_method_message_class as *const _ + as usize + }, + 648usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(mono_method_message_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).ireference_class as *const _ as usize }, + 656usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(ireference_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).ireferencearray_class as *const _ as usize + }, + 664usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(ireferencearray_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).ikey_value_pair_class as *const _ as usize + }, + 672usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(ikey_value_pair_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).key_value_pair_class as *const _ as usize + }, + 680usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(key_value_pair_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).windows_foundation_uri_class as *const _ + as usize + }, + 688usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(windows_foundation_uri_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).windows_foundation_iuri_runtime_class_class + as *const _ as usize + }, + 696usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(windows_foundation_iuri_runtime_class_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).system_uri_class as *const _ as usize }, + 704usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(system_uri_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).system_guid_class as *const _ as usize + }, + 712usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(system_guid_class) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).sbyte_shared_enum as *const _ as usize + }, + 720usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(sbyte_shared_enum) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).int16_shared_enum as *const _ as usize + }, + 728usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(int16_shared_enum) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).int32_shared_enum as *const _ as usize + }, + 736usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(int32_shared_enum) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).int64_shared_enum as *const _ as usize + }, + 744usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(int64_shared_enum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).byte_shared_enum as *const _ as usize }, + 752usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(byte_shared_enum) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).uint16_shared_enum as *const _ as usize + }, + 760usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(uint16_shared_enum) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).uint32_shared_enum as *const _ as usize + }, + 768usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(uint32_shared_enum) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).uint64_shared_enum as *const _ as usize + }, + 776usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDefaults), + "::", + stringify!(uint64_shared_enum) + ) + ); +} +extern "C" { + pub static mut il2cpp_defaults: Il2CppDefaults; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct MemberInfo { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct CustomAttributesCache { + pub count: ::std::os::raw::c_int, + pub attributes: *mut *mut Il2CppObject, +} +#[test] +fn bindgen_test_layout_CustomAttributesCache() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(CustomAttributesCache)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(CustomAttributesCache)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).count as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(CustomAttributesCache), + "::", + stringify!(count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).attributes as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(CustomAttributesCache), + "::", + stringify!(attributes) + ) + ); +} +pub type CustomAttributesCacheGenerator = + ::std::option::Option; +pub const THREAD_STATIC_FIELD_OFFSET: ::std::os::raw::c_int = -1; +#[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, +} +#[test] +fn bindgen_test_layout_FieldInfo() { + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(FieldInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(FieldInfo)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(FieldInfo), + "::", + stringify!(name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).type_ as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(FieldInfo), + "::", + stringify!(type_) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).parent as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(FieldInfo), + "::", + stringify!(parent) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).offset as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(FieldInfo), + "::", + stringify!(offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(FieldInfo), + "::", + stringify!(token) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_PropertyInfo() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(PropertyInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(PropertyInfo)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).parent as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(PropertyInfo), + "::", + stringify!(parent) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(PropertyInfo), + "::", + stringify!(name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).get as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(PropertyInfo), + "::", + stringify!(get) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).set as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(PropertyInfo), + "::", + stringify!(set) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).attrs as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(PropertyInfo), + "::", + stringify!(attrs) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(PropertyInfo), + "::", + stringify!(token) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_EventInfo() { + assert_eq!( + ::std::mem::size_of::(), + 56usize, + concat!("Size of: ", stringify!(EventInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(EventInfo)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(EventInfo), + "::", + stringify!(name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).eventType as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(EventInfo), + "::", + stringify!(eventType) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).parent as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(EventInfo), + "::", + stringify!(parent) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).add as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(EventInfo), + "::", + stringify!(add) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).remove as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(EventInfo), + "::", + stringify!(remove) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).raise as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(EventInfo), + "::", + stringify!(raise) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(EventInfo), + "::", + stringify!(token) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct ParameterInfo { + pub name: *const ::std::os::raw::c_char, + pub position: i32, + pub token: u32, + pub parameter_type: *const Il2CppType, +} +#[test] +fn bindgen_test_layout_ParameterInfo() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(ParameterInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(ParameterInfo)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(ParameterInfo), + "::", + stringify!(name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).position as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(ParameterInfo), + "::", + stringify!(position) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(ParameterInfo), + "::", + stringify!(token) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).parameter_type as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(ParameterInfo), + "::", + stringify!(parameter_type) + ) + ); +} +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, + ) -> *mut ::std::os::raw::c_void, +>; +pub const MethodVariableKind_kMethodVariableKind_This: MethodVariableKind = 0; +pub const MethodVariableKind_kMethodVariableKind_Parameter: MethodVariableKind = 1; +pub const MethodVariableKind_kMethodVariableKind_LocalVariable: MethodVariableKind = 2; +pub type MethodVariableKind = i32; +pub const SequencePointKind_kSequencePointKind_Normal: SequencePointKind = 0; +pub const SequencePointKind_kSequencePointKind_StepOut: SequencePointKind = 1; +pub type SequencePointKind = i32; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppMethodExecutionContextInfo { + pub typeIndex: TypeIndex, + pub nameIndex: i32, + pub scopeIndex: i32, +} +#[test] +fn bindgen_test_layout_Il2CppMethodExecutionContextInfo() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!("Size of: ", stringify!(Il2CppMethodExecutionContextInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(Il2CppMethodExecutionContextInfo) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).typeIndex as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodExecutionContextInfo), + "::", + stringify!(typeIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).nameIndex as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodExecutionContextInfo), + "::", + stringify!(nameIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).scopeIndex as *const _ + as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodExecutionContextInfo), + "::", + stringify!(scopeIndex) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppMethodExecutionContextInfoIndex { + pub tableIndex: i8, + pub startIndex: i32, + pub count: i32, +} +#[test] +fn bindgen_test_layout_Il2CppMethodExecutionContextInfoIndex() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(Il2CppMethodExecutionContextInfoIndex) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(Il2CppMethodExecutionContextInfoIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).tableIndex as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodExecutionContextInfoIndex), + "::", + stringify!(tableIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).startIndex as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodExecutionContextInfoIndex), + "::", + stringify!(startIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).count as *const _ + as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodExecutionContextInfoIndex), + "::", + stringify!(count) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppMethodScope { + pub startOffset: i32, + pub endOffset: i32, +} +#[test] +fn bindgen_test_layout_Il2CppMethodScope() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Il2CppMethodScope)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppMethodScope)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).startOffset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodScope), + "::", + stringify!(startOffset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).endOffset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodScope), + "::", + stringify!(endOffset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppMethodHeaderInfo { + pub codeSize: i32, + pub startScope: i32, + pub numScopes: i32, +} +#[test] +fn bindgen_test_layout_Il2CppMethodHeaderInfo() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!("Size of: ", stringify!(Il2CppMethodHeaderInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppMethodHeaderInfo)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).codeSize as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodHeaderInfo), + "::", + stringify!(codeSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).startScope as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodHeaderInfo), + "::", + stringify!(startScope) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).numScopes as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodHeaderInfo), + "::", + stringify!(numScopes) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppSequencePointIndex { + pub tableIndex: u8, + pub index: i32, +} +#[test] +fn bindgen_test_layout_Il2CppSequencePointIndex() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Il2CppSequencePointIndex)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppSequencePointIndex)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).tableIndex as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSequencePointIndex), + "::", + stringify!(tableIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).index as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSequencePointIndex), + "::", + stringify!(index) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppSequencePointSourceFile { + pub file: *const ::std::os::raw::c_char, + pub hash: [u8; 16usize], +} +#[test] +fn bindgen_test_layout_Il2CppSequencePointSourceFile() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(Il2CppSequencePointSourceFile)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppSequencePointSourceFile)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).file as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSequencePointSourceFile), + "::", + stringify!(file) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).hash as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSequencePointSourceFile), + "::", + stringify!(hash) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppTypeSourceFilePair { + pub klassIndex: TypeIndex, + pub sourceFileIndex: i32, +} +#[test] +fn bindgen_test_layout_Il2CppTypeSourceFilePair() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Il2CppTypeSourceFilePair)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppTypeSourceFilePair)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).klassIndex as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeSourceFilePair), + "::", + stringify!(klassIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).sourceFileIndex as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeSourceFilePair), + "::", + stringify!(sourceFileIndex) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppSequencePoint { + pub methodDefinitionIndex: MethodIndex, + pub catchTypeIndex: TypeIndex, + pub sourceFileIndex: i32, + pub lineStart: i32, + pub lineEnd: i32, + pub columnStart: i32, + pub columnEnd: i32, + pub ilOffset: i32, + pub kind: SequencePointKind, + pub isActive: u8, + pub id: i32, + pub tryDepth: u8, +} +#[test] +fn bindgen_test_layout_Il2CppSequencePoint() { + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!("Size of: ", stringify!(Il2CppSequencePoint)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppSequencePoint)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).methodDefinitionIndex as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSequencePoint), + "::", + stringify!(methodDefinitionIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).catchTypeIndex as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSequencePoint), + "::", + stringify!(catchTypeIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).sourceFileIndex as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSequencePoint), + "::", + stringify!(sourceFileIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).lineStart as *const _ as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSequencePoint), + "::", + stringify!(lineStart) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).lineEnd as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSequencePoint), + "::", + stringify!(lineEnd) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).columnStart as *const _ as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSequencePoint), + "::", + stringify!(columnStart) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).columnEnd as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSequencePoint), + "::", + stringify!(columnEnd) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).ilOffset as *const _ as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSequencePoint), + "::", + stringify!(ilOffset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).kind as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSequencePoint), + "::", + stringify!(kind) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).isActive as *const _ as usize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSequencePoint), + "::", + stringify!(isActive) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).id as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSequencePoint), + "::", + stringify!(id) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).tryDepth as *const _ as usize }, + 44usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSequencePoint), + "::", + stringify!(tryDepth) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppDebuggerMetadataRegistration { + pub methodExecutionContextInfos: *mut *mut Il2CppMethodExecutionContextInfo, + pub methodExecutionContextInfoIndexes: *mut Il2CppMethodExecutionContextInfoIndex, + pub methodScopes: *mut Il2CppMethodScope, + pub methodHeaderInfos: *mut Il2CppMethodHeaderInfo, + pub sequencePointSourceFiles: *mut Il2CppSequencePointSourceFile, + pub numSequencePoints: i32, + pub sequencePointIndexes: *mut Il2CppSequencePointIndex, + pub sequencePoints: *mut *mut Il2CppSequencePoint, + pub numTypeSourceFileEntries: i32, + pub typeSourceFiles: *mut Il2CppTypeSourceFilePair, + pub methodExecutionContextInfoStrings: *mut *const ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_Il2CppDebuggerMetadataRegistration() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(Il2CppDebuggerMetadataRegistration)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!( + "Alignment of ", + stringify!(Il2CppDebuggerMetadataRegistration) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .methodExecutionContextInfos as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDebuggerMetadataRegistration), + "::", + stringify!(methodExecutionContextInfos) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .methodExecutionContextInfoIndexes as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDebuggerMetadataRegistration), + "::", + stringify!(methodExecutionContextInfoIndexes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).methodScopes as *const _ + as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDebuggerMetadataRegistration), + "::", + stringify!(methodScopes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).methodHeaderInfos + as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDebuggerMetadataRegistration), + "::", + stringify!(methodHeaderInfos) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).sequencePointSourceFiles + as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDebuggerMetadataRegistration), + "::", + stringify!(sequencePointSourceFiles) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).numSequencePoints + as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDebuggerMetadataRegistration), + "::", + stringify!(numSequencePoints) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).sequencePointIndexes + as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDebuggerMetadataRegistration), + "::", + stringify!(sequencePointIndexes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).sequencePoints + as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDebuggerMetadataRegistration), + "::", + stringify!(sequencePoints) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).numTypeSourceFileEntries + as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDebuggerMetadataRegistration), + "::", + stringify!(numTypeSourceFileEntries) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).typeSourceFiles + as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDebuggerMetadataRegistration), + "::", + stringify!(typeSourceFiles) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .methodExecutionContextInfoStrings as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDebuggerMetadataRegistration), + "::", + stringify!(methodExecutionContextInfoStrings) + ) + ); +} +#[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, + _bindgen_union_align: u64, +} +#[test] +fn bindgen_test_layout_Il2CppRGCTXData() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Il2CppRGCTXData)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppRGCTXData)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).rgctxDataDummy as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRGCTXData), + "::", + stringify!(rgctxDataDummy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).method as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRGCTXData), + "::", + stringify!(method) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).type_ as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRGCTXData), + "::", + stringify!(type_) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).klass as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRGCTXData), + "::", + stringify!(klass) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct MethodInfo { + pub methodPointer: Il2CppMethodPointer, + pub invoker_method: InvokerMethod, + pub name: *const ::std::os::raw::c_char, + pub klass: *mut Il2CppClass, + pub return_type: *const Il2CppType, + pub parameters: *const ParameterInfo, + 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_1: __BindgenBitfieldUnit<[u8; 1usize], u8>, + pub __bindgen_padding_0: u32, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union MethodInfo__bindgen_ty_1 { + pub rgctx_data: *const Il2CppRGCTXData, + pub methodDefinition: *const Il2CppMethodDefinition, + _bindgen_union_align: u64, +} +#[test] +fn bindgen_test_layout_MethodInfo__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(MethodInfo__bindgen_ty_1)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(MethodInfo__bindgen_ty_1)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rgctx_data as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(MethodInfo__bindgen_ty_1), + "::", + stringify!(rgctx_data) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).methodDefinition as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(MethodInfo__bindgen_ty_1), + "::", + stringify!(methodDefinition) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union MethodInfo__bindgen_ty_2 { + pub genericMethod: *const Il2CppGenericMethod, + pub genericContainer: *const Il2CppGenericContainer, + _bindgen_union_align: u64, +} +#[test] +fn bindgen_test_layout_MethodInfo__bindgen_ty_2() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(MethodInfo__bindgen_ty_2)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(MethodInfo__bindgen_ty_2)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).genericMethod as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(MethodInfo__bindgen_ty_2), + "::", + stringify!(genericMethod) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).genericContainer as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(MethodInfo__bindgen_ty_2), + "::", + stringify!(genericContainer) + ) + ); +} +#[test] +fn bindgen_test_layout_MethodInfo() { + assert_eq!( + ::std::mem::size_of::(), + 80usize, + concat!("Size of: ", stringify!(MethodInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(MethodInfo)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).methodPointer as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(MethodInfo), + "::", + stringify!(methodPointer) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).invoker_method as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(MethodInfo), + "::", + stringify!(invoker_method) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(MethodInfo), + "::", + stringify!(name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).klass as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(MethodInfo), + "::", + stringify!(klass) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).return_type as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(MethodInfo), + "::", + stringify!(return_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).parameters as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(MethodInfo), + "::", + stringify!(parameters) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(MethodInfo), + "::", + stringify!(token) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).flags as *const _ as usize }, + 68usize, + concat!( + "Offset of field: ", + stringify!(MethodInfo), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iflags as *const _ as usize }, + 70usize, + concat!( + "Offset of field: ", + stringify!(MethodInfo), + "::", + stringify!(iflags) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).slot as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(MethodInfo), + "::", + stringify!(slot) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).parameters_count as *const _ as usize }, + 74usize, + concat!( + "Offset of field: ", + stringify!(MethodInfo), + "::", + stringify!(parameters_count) + ) + ); +} +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 is_marshaled_from_native(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) } + } + #[inline] + pub fn set_is_marshaled_from_native(&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, + is_marshaled_from_native: u8, + ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> = + 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 is_marshaled_from_native: u8 = + unsafe { ::std::mem::transmute(is_marshaled_from_native) }; + is_marshaled_from_native as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppRuntimeInterfaceOffsetPair { + pub interfaceType: *mut Il2CppClass, + pub offset: i32, +} +#[test] +fn bindgen_test_layout_Il2CppRuntimeInterfaceOffsetPair() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Il2CppRuntimeInterfaceOffsetPair)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!( + "Alignment of ", + stringify!(Il2CppRuntimeInterfaceOffsetPair) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).interfaceType as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRuntimeInterfaceOffsetPair), + "::", + stringify!(interfaceType) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).offset as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRuntimeInterfaceOffsetPair), + "::", + stringify!(offset) + ) + ); +} +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; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppIUnknown { + _unused: [u8; 0], +} +pub type CreateCCWFunc = + ::std::option::Option *mut Il2CppIUnknown>; +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppInteropData() { + assert_eq!( + ::std::mem::size_of::(), + 56usize, + concat!("Size of: ", stringify!(Il2CppInteropData)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppInteropData)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).delegatePInvokeWrapperFunction as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInteropData), + "::", + stringify!(delegatePInvokeWrapperFunction) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).pinvokeMarshalToNativeFunction as *const _ + as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInteropData), + "::", + stringify!(pinvokeMarshalToNativeFunction) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).pinvokeMarshalFromNativeFunction + as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInteropData), + "::", + stringify!(pinvokeMarshalFromNativeFunction) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).pinvokeMarshalCleanupFunction as *const _ + as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInteropData), + "::", + stringify!(pinvokeMarshalCleanupFunction) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).createCCWFunction as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInteropData), + "::", + stringify!(createCCWFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).guid as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInteropData), + "::", + stringify!(guid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).type_ as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInteropData), + "::", + stringify!(type_) + ) + ); +} +#[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 typeDefinition: *const Il2CppTypeDefinition, + 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 initializationExceptionGCHandle: u32, + pub cctor_started: u32, + pub cctor_finished: u32, + pub cctor_thread: u64, + pub genericContainerIndex: GenericContainerIndex, + pub instance_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_1: __BindgenBitfieldUnit<[u8; 2usize], u8>, + pub vtable: __IncompleteArrayField, +} +#[test] +fn bindgen_test_layout_Il2CppClass() { + assert_eq!( + ::std::mem::size_of::(), + 296usize, + concat!("Size of: ", stringify!(Il2CppClass)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppClass)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).image as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(image) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).gc_desc as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(gc_desc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).namespaze as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(namespaze) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).byval_arg as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(byval_arg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).this_arg as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(this_arg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).element_class as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(element_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).castClass as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(castClass) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).declaringType as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(declaringType) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).parent as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(parent) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).generic_class as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(generic_class) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).typeDefinition as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(typeDefinition) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).interopData as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(interopData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).klass as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(klass) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).fields as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(fields) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).events as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(events) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).properties as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(properties) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).methods as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(methods) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nestedTypes as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(nestedTypes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).implementedInterfaces as *const _ as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(implementedInterfaces) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).interfaceOffsets as *const _ as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(interfaceOffsets) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).static_fields as *const _ as usize }, + 184usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(static_fields) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).rgctx_data as *const _ as usize }, + 192usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(rgctx_data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).typeHierarchy as *const _ as usize }, + 200usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(typeHierarchy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).initializationExceptionGCHandle as *const _ + as usize + }, + 208usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(initializationExceptionGCHandle) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).cctor_started as *const _ as usize }, + 212usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(cctor_started) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).cctor_finished as *const _ as usize }, + 216usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(cctor_finished) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).cctor_thread as *const _ as usize }, + 224usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(cctor_thread) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).genericContainerIndex as *const _ as usize + }, + 232usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(genericContainerIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).instance_size as *const _ as usize }, + 236usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(instance_size) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).actualSize as *const _ as usize }, + 240usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(actualSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).element_size as *const _ as usize }, + 244usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(element_size) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).native_size as *const _ as usize }, + 248usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(native_size) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).static_fields_size as *const _ as usize }, + 252usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(static_fields_size) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_static_fields_size as *const _ as usize + }, + 256usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(thread_static_fields_size) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_static_fields_offset as *const _ as usize + }, + 260usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(thread_static_fields_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).flags as *const _ as usize }, + 264usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, + 268usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(token) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).method_count as *const _ as usize }, + 272usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(method_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).property_count as *const _ as usize }, + 274usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(property_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).field_count as *const _ as usize }, + 276usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(field_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).event_count as *const _ as usize }, + 278usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(event_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nested_type_count as *const _ as usize }, + 280usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(nested_type_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vtable_count as *const _ as usize }, + 282usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(vtable_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).interfaces_count as *const _ as usize }, + 284usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(interfaces_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).interface_offsets_count as *const _ as usize + }, + 286usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(interface_offsets_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).typeHierarchyDepth as *const _ as usize }, + 288usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(typeHierarchyDepth) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).genericRecursionDepth as *const _ as usize + }, + 289usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(genericRecursionDepth) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).rank as *const _ as usize }, + 290usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(rank) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).minimumAlignment as *const _ as usize }, + 291usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(minimumAlignment) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).packingSize as *const _ as usize }, + 292usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(packingSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vtable as *const _ as usize }, + 296usize, + concat!( + "Offset of field: ", + stringify!(Il2CppClass), + "::", + stringify!(vtable) + ) + ); +} +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 valuetype(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } + } + #[inline] + pub fn set_valuetype(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn initialized(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) } + } + #[inline] + pub fn set_initialized(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn enumtype(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) } + } + #[inline] + pub fn set_enumtype(&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_inited(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 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(7usize, 1u8, val as u64) + } + } + #[inline] + pub fn has_finalize(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 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(8usize, 1u8, val as u64) + } + } + #[inline] + pub fn has_cctor(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 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(9usize, 1u8, val as u64) + } + } + #[inline] + pub fn is_blittable(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 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(10usize, 1u8, val as u64) + } + } + #[inline] + pub fn is_import_or_windows_runtime(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 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(11usize, 1u8, val as u64) + } + } + #[inline] + pub fn is_vtable_initialized(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 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(12usize, 1u8, val as u64) + } + } + #[inline] + pub fn has_initialization_error(&self) -> u8 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u8) } + } + #[inline] + pub fn set_has_initialization_error(&mut self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + initialized_and_no_error: u8, + valuetype: u8, + initialized: u8, + enumtype: u8, + is_generic: u8, + has_references: u8, + 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, + has_initialization_error: u8, + ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> = + 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 valuetype: u8 = unsafe { ::std::mem::transmute(valuetype) }; + valuetype as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let initialized: u8 = unsafe { ::std::mem::transmute(initialized) }; + initialized as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let enumtype: u8 = unsafe { ::std::mem::transmute(enumtype) }; + enumtype 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_inited: u8 = unsafe { ::std::mem::transmute(size_inited) }; + size_inited as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let has_finalize: u8 = unsafe { ::std::mem::transmute(has_finalize) }; + has_finalize as u64 + }); + __bindgen_bitfield_unit.set(9usize, 1u8, { + let has_cctor: u8 = unsafe { ::std::mem::transmute(has_cctor) }; + has_cctor as u64 + }); + __bindgen_bitfield_unit.set(10usize, 1u8, { + let is_blittable: u8 = unsafe { ::std::mem::transmute(is_blittable) }; + is_blittable as u64 + }); + __bindgen_bitfield_unit.set(11usize, 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(12usize, 1u8, { + let is_vtable_initialized: u8 = unsafe { ::std::mem::transmute(is_vtable_initialized) }; + is_vtable_initialized as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let has_initialization_error: u8 = + unsafe { ::std::mem::transmute(has_initialization_error) }; + has_initialization_error as u64 + }); + __bindgen_bitfield_unit + } +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppTypeDefinitionSizes() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Il2CppTypeDefinitionSizes)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppTypeDefinitionSizes)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).instance_size as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinitionSizes), + "::", + stringify!(instance_size) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).native_size as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinitionSizes), + "::", + stringify!(native_size) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).static_fields_size as *const _ + as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinitionSizes), + "::", + stringify!(static_fields_size) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_static_fields_size + as *const _ as usize + }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypeDefinitionSizes), + "::", + stringify!(thread_static_fields_size) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppDomain { + pub domain: *mut Il2CppAppDomain, + pub setup: *mut Il2CppAppDomainSetup, + pub default_context: *mut Il2CppAppContext, + 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, +} +#[test] +fn bindgen_test_layout_Il2CppDomain() { + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!("Size of: ", stringify!(Il2CppDomain)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppDomain)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).domain as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDomain), + "::", + stringify!(domain) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).setup as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDomain), + "::", + stringify!(setup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).default_context as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDomain), + "::", + stringify!(default_context) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).friendly_name as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDomain), + "::", + stringify!(friendly_name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).domain_id as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDomain), + "::", + stringify!(domain_id) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).threadpool_jobs as *const _ as usize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDomain), + "::", + stringify!(threadpool_jobs) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).agent_info as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDomain), + "::", + stringify!(agent_info) + ) + ); +} +#[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 hash_value: *const ::std::os::raw::c_char, + pub public_key: *const ::std::os::raw::c_char, + 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], +} +#[test] +fn bindgen_test_layout_Il2CppAssemblyName() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(Il2CppAssemblyName)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppAssemblyName)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyName), + "::", + stringify!(name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).culture as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyName), + "::", + stringify!(culture) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).hash_value as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyName), + "::", + stringify!(hash_value) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).public_key as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyName), + "::", + stringify!(public_key) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).hash_alg as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyName), + "::", + stringify!(hash_alg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).hash_len as *const _ as usize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyName), + "::", + stringify!(hash_len) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).flags as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyName), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).major as *const _ as usize }, + 44usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyName), + "::", + stringify!(major) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).minor as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyName), + "::", + stringify!(minor) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).build as *const _ as usize }, + 52usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyName), + "::", + stringify!(build) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).revision as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyName), + "::", + stringify!(revision) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).public_key_token as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssemblyName), + "::", + stringify!(public_key_token) + ) + ); +} +#[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 typeStart: TypeDefinitionIndex, + pub typeCount: u32, + pub exportedTypeStart: TypeDefinitionIndex, + pub exportedTypeCount: u32, + pub customAttributeStart: CustomAttributeIndex, + pub customAttributeCount: u32, + pub entryPointIndex: MethodIndex, + pub nameToClassHashTable: *mut Il2CppNameToTypeDefinitionIndexHashTable, + pub token: u32, + pub dynamic: u8, +} +#[test] +fn bindgen_test_layout_Il2CppImage() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(Il2CppImage)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppImage)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppImage), + "::", + stringify!(name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nameNoExt as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppImage), + "::", + stringify!(nameNoExt) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).assembly as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppImage), + "::", + stringify!(assembly) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).typeStart as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppImage), + "::", + stringify!(typeStart) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).typeCount as *const _ as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(Il2CppImage), + "::", + stringify!(typeCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).exportedTypeStart as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppImage), + "::", + stringify!(exportedTypeStart) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).exportedTypeCount as *const _ as usize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(Il2CppImage), + "::", + stringify!(exportedTypeCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).customAttributeStart as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppImage), + "::", + stringify!(customAttributeStart) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).customAttributeCount as *const _ as usize + }, + 44usize, + concat!( + "Offset of field: ", + stringify!(Il2CppImage), + "::", + stringify!(customAttributeCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).entryPointIndex as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppImage), + "::", + stringify!(entryPointIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).nameToClassHashTable as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppImage), + "::", + stringify!(nameToClassHashTable) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppImage), + "::", + stringify!(token) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).dynamic as *const _ as usize }, + 68usize, + concat!( + "Offset of field: ", + stringify!(Il2CppImage), + "::", + stringify!(dynamic) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppAssembly() { + assert_eq!( + ::std::mem::size_of::(), + 96usize, + concat!("Size of: ", stringify!(Il2CppAssembly)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppAssembly)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).image as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssembly), + "::", + stringify!(image) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssembly), + "::", + stringify!(token) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).referencedAssemblyStart as *const _ as usize + }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssembly), + "::", + stringify!(referencedAssemblyStart) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).referencedAssemblyCount as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssembly), + "::", + stringify!(referencedAssemblyCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aname as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAssembly), + "::", + stringify!(aname) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppCodeGenOptions { + pub enablePrimitiveValueTypeGenericSharing: u8, +} +#[test] +fn bindgen_test_layout_Il2CppCodeGenOptions() { + assert_eq!( + ::std::mem::size_of::(), + 1usize, + concat!("Size of: ", stringify!(Il2CppCodeGenOptions)) + ); + assert_eq!( + ::std::mem::align_of::(), + 1usize, + concat!("Alignment of ", stringify!(Il2CppCodeGenOptions)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).enablePrimitiveValueTypeGenericSharing + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCodeGenOptions), + "::", + stringify!(enablePrimitiveValueTypeGenericSharing) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppCodeRegistration { + pub methodPointersCount: u32, + pub methodPointers: *const Il2CppMethodPointer, + pub reversePInvokeWrapperCount: u32, + pub reversePInvokeWrappers: *const Il2CppMethodPointer, + pub genericMethodPointersCount: u32, + pub genericMethodPointers: *const Il2CppMethodPointer, + pub invokerPointersCount: u32, + pub invokerPointers: *const InvokerMethod, + pub customAttributeCount: CustomAttributeIndex, + pub customAttributeGenerators: *const CustomAttributesCacheGenerator, + pub unresolvedVirtualCallCount: u32, + pub unresolvedVirtualCallPointers: *const Il2CppMethodPointer, + pub interopDataCount: u32, + pub interopData: *mut Il2CppInteropData, +} +#[test] +fn bindgen_test_layout_Il2CppCodeRegistration() { + assert_eq!( + ::std::mem::size_of::(), + 112usize, + concat!("Size of: ", stringify!(Il2CppCodeRegistration)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppCodeRegistration)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).methodPointersCount as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCodeRegistration), + "::", + stringify!(methodPointersCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).methodPointers as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCodeRegistration), + "::", + stringify!(methodPointers) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).reversePInvokeWrapperCount + as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCodeRegistration), + "::", + stringify!(reversePInvokeWrapperCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).reversePInvokeWrappers as *const _ + as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCodeRegistration), + "::", + stringify!(reversePInvokeWrappers) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).genericMethodPointersCount + as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCodeRegistration), + "::", + stringify!(genericMethodPointersCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).genericMethodPointers as *const _ + as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCodeRegistration), + "::", + stringify!(genericMethodPointers) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).invokerPointersCount as *const _ + as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCodeRegistration), + "::", + stringify!(invokerPointersCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).invokerPointers as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCodeRegistration), + "::", + stringify!(invokerPointers) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).customAttributeCount as *const _ + as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCodeRegistration), + "::", + stringify!(customAttributeCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).customAttributeGenerators as *const _ + as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCodeRegistration), + "::", + stringify!(customAttributeGenerators) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).unresolvedVirtualCallCount + as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCodeRegistration), + "::", + stringify!(unresolvedVirtualCallCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).unresolvedVirtualCallPointers + as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCodeRegistration), + "::", + stringify!(unresolvedVirtualCallPointers) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).interopDataCount as *const _ as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCodeRegistration), + "::", + stringify!(interopDataCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).interopData as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCodeRegistration), + "::", + stringify!(interopData) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppMetadataRegistration() { + assert_eq!( + ::std::mem::size_of::(), + 128usize, + concat!("Size of: ", stringify!(Il2CppMetadataRegistration)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppMetadataRegistration)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).genericClassesCount as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMetadataRegistration), + "::", + stringify!(genericClassesCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).genericClasses as *const _ + as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMetadataRegistration), + "::", + stringify!(genericClasses) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).genericInstsCount as *const _ + as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMetadataRegistration), + "::", + stringify!(genericInstsCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).genericInsts as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMetadataRegistration), + "::", + stringify!(genericInsts) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).genericMethodTableCount + as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMetadataRegistration), + "::", + stringify!(genericMethodTableCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).genericMethodTable as *const _ + as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMetadataRegistration), + "::", + stringify!(genericMethodTable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).typesCount as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMetadataRegistration), + "::", + stringify!(typesCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).types as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMetadataRegistration), + "::", + stringify!(types) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).methodSpecsCount as *const _ + as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMetadataRegistration), + "::", + stringify!(methodSpecsCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).methodSpecs as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMetadataRegistration), + "::", + stringify!(methodSpecs) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).fieldOffsetsCount as *const _ + as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMetadataRegistration), + "::", + stringify!(fieldOffsetsCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).fieldOffsets as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMetadataRegistration), + "::", + stringify!(fieldOffsets) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).typeDefinitionsSizesCount + as *const _ as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMetadataRegistration), + "::", + stringify!(typeDefinitionsSizesCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).typeDefinitionsSizes as *const _ + as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMetadataRegistration), + "::", + stringify!(typeDefinitionsSizes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).metadataUsagesCount as *const _ + as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMetadataRegistration), + "::", + stringify!(metadataUsagesCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).metadataUsages as *const _ + as usize + }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMetadataRegistration), + "::", + stringify!(metadataUsages) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppRuntimeStats { + pub new_object_count: u64, + pub initialized_class_count: u64, + pub method_count: u64, + pub class_static_data_size: u64, + pub generic_instance_count: u64, + pub generic_class_count: u64, + pub inflated_method_count: u64, + pub inflated_type_count: u64, + pub enabled: u8, +} +#[test] +fn bindgen_test_layout_Il2CppRuntimeStats() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(Il2CppRuntimeStats)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppRuntimeStats)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).new_object_count as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRuntimeStats), + "::", + stringify!(new_object_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).initialized_class_count as *const _ + as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRuntimeStats), + "::", + stringify!(initialized_class_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).method_count as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRuntimeStats), + "::", + stringify!(method_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).class_static_data_size as *const _ + as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRuntimeStats), + "::", + stringify!(class_static_data_size) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).generic_instance_count as *const _ + as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRuntimeStats), + "::", + stringify!(generic_instance_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).generic_class_count as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRuntimeStats), + "::", + stringify!(generic_class_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).inflated_method_count as *const _ + as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRuntimeStats), + "::", + stringify!(inflated_method_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).inflated_type_count as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRuntimeStats), + "::", + stringify!(inflated_type_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).enabled as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRuntimeStats), + "::", + stringify!(enabled) + ) + ); +} +extern "C" { + pub static mut il2cpp_runtime_stats: Il2CppRuntimeStats; +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppPerfCounters() { + assert_eq!( + ::std::mem::size_of::(), + 264usize, + concat!("Size of: ", stringify!(Il2CppPerfCounters)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppPerfCounters)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).jit_methods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(jit_methods) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).jit_bytes as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(jit_bytes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).jit_time as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(jit_time) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).jit_failures as *const _ as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(jit_failures) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).exceptions_thrown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(exceptions_thrown) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).exceptions_filters as *const _ as usize + }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(exceptions_filters) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).exceptions_finallys as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(exceptions_finallys) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).exceptions_depth as *const _ as usize + }, + 28usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(exceptions_depth) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aspnet_requests_queued as *const _ + as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(aspnet_requests_queued) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aspnet_requests as *const _ as usize + }, + 36usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(aspnet_requests) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).gc_collections0 as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(gc_collections0) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).gc_collections1 as *const _ as usize + }, + 44usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(gc_collections1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).gc_collections2 as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(gc_collections2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).gc_promotions0 as *const _ as usize + }, + 52usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(gc_promotions0) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).gc_promotions1 as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(gc_promotions1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).gc_promotion_finalizers as *const _ + as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(gc_promotion_finalizers) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).gc_gen0size as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(gc_gen0size) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).gc_gen1size as *const _ as usize }, + 68usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(gc_gen1size) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).gc_gen2size as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(gc_gen2size) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).gc_lossize as *const _ as usize }, + 76usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(gc_lossize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).gc_fin_survivors as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(gc_fin_survivors) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).gc_num_handles as *const _ as usize + }, + 84usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(gc_num_handles) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).gc_allocated as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(gc_allocated) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).gc_induced as *const _ as usize }, + 92usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(gc_induced) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).gc_time as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(gc_time) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).gc_total_bytes as *const _ as usize + }, + 100usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(gc_total_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).gc_committed_bytes as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(gc_committed_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).gc_reserved_bytes as *const _ as usize + }, + 108usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(gc_reserved_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).gc_num_pinned as *const _ as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(gc_num_pinned) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).gc_sync_blocks as *const _ as usize + }, + 116usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(gc_sync_blocks) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).remoting_calls as *const _ as usize + }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(remoting_calls) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).remoting_channels as *const _ as usize + }, + 124usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(remoting_channels) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).remoting_proxies as *const _ as usize + }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(remoting_proxies) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).remoting_classes as *const _ as usize + }, + 132usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(remoting_classes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).remoting_objects as *const _ as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(remoting_objects) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).remoting_contexts as *const _ as usize + }, + 140usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(remoting_contexts) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).loader_classes as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(loader_classes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).loader_total_classes as *const _ as usize + }, + 148usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(loader_total_classes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).loader_appdomains as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(loader_appdomains) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).loader_total_appdomains as *const _ + as usize + }, + 156usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(loader_total_appdomains) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).loader_assemblies as *const _ as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(loader_assemblies) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).loader_total_assemblies as *const _ + as usize + }, + 164usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(loader_total_assemblies) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).loader_failures as *const _ as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(loader_failures) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).loader_bytes as *const _ as usize }, + 172usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(loader_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).loader_appdomains_uloaded as *const _ + as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(loader_appdomains_uloaded) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_contentions as *const _ as usize + }, + 180usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(thread_contentions) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_queue_len as *const _ as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(thread_queue_len) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_queue_max as *const _ as usize + }, + 188usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(thread_queue_max) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_num_logical as *const _ as usize + }, + 192usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(thread_num_logical) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_num_physical as *const _ as usize + }, + 196usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(thread_num_physical) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_cur_recognized as *const _ + as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(thread_cur_recognized) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_num_recognized as *const _ + as usize + }, + 204usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(thread_num_recognized) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).interop_num_ccw as *const _ as usize + }, + 208usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(interop_num_ccw) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).interop_num_stubs as *const _ as usize + }, + 212usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(interop_num_stubs) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).interop_num_marshals as *const _ as usize + }, + 216usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(interop_num_marshals) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).security_num_checks as *const _ as usize + }, + 220usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(security_num_checks) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).security_num_link_checks as *const _ + as usize + }, + 224usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(security_num_link_checks) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).security_time as *const _ as usize + }, + 228usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(security_time) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).security_depth as *const _ as usize + }, + 232usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(security_depth) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).unused as *const _ as usize }, + 236usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(unused) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).threadpool_workitems as *const _ as usize + }, + 240usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(threadpool_workitems) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).threadpool_ioworkitems as *const _ + as usize + }, + 248usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(threadpool_ioworkitems) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).threadpool_threads as *const _ as usize + }, + 256usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(threadpool_threads) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).threadpool_iothreads as *const _ as usize + }, + 260usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPerfCounters), + "::", + stringify!(threadpool_iothreads) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppWaitHandle { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct MonitorData { + _unused: [u8; 0], +} +pub type Il2CppVTable = Il2CppClass; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppObject { + pub __bindgen_anon_1: Il2CppObject__bindgen_ty_1, + pub monitor: *mut MonitorData, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union Il2CppObject__bindgen_ty_1 { + pub klass: *mut Il2CppClass, + pub vtable: *mut Il2CppVTable, + _bindgen_union_align: u64, +} +#[test] +fn bindgen_test_layout_Il2CppObject__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Il2CppObject__bindgen_ty_1)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppObject__bindgen_ty_1)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).klass as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppObject__bindgen_ty_1), + "::", + stringify!(klass) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtable as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppObject__bindgen_ty_1), + "::", + stringify!(vtable) + ) + ); +} +#[test] +fn bindgen_test_layout_Il2CppObject() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Il2CppObject)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppObject)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).monitor as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppObject), + "::", + stringify!(monitor) + ) + ); +} +pub type il2cpp_array_lower_bound_t = i32; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppArrayBounds { + pub length: il2cpp_array_size_t, + pub lower_bound: il2cpp_array_lower_bound_t, +} +#[test] +fn bindgen_test_layout_Il2CppArrayBounds() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Il2CppArrayBounds)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppArrayBounds)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).length as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppArrayBounds), + "::", + stringify!(length) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).lower_bound as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppArrayBounds), + "::", + stringify!(lower_bound) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppArray { + pub obj: Il2CppObject, + pub bounds: *mut Il2CppArrayBounds, + pub max_length: il2cpp_array_size_t, +} +#[test] +fn bindgen_test_layout_Il2CppArray() { + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(Il2CppArray)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppArray)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppArray), + "::", + stringify!(obj) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bounds as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppArray), + "::", + stringify!(bounds) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).max_length as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppArray), + "::", + stringify!(max_length) + ) + ); +} +#[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>, +} +#[test] +fn bindgen_test_layout_Il2CppArraySize() { + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(Il2CppArraySize)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppArraySize)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppArraySize), + "::", + stringify!(obj) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bounds as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppArraySize), + "::", + stringify!(bounds) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).max_length as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppArraySize), + "::", + stringify!(max_length) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vector as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppArraySize), + "::", + stringify!(vector) + ) + ); +} +pub const kIl2CppSizeOfArray: usize = 32; +pub const kIl2CppOffsetOfArrayBounds: usize = 16; +pub const kIl2CppOffsetOfArrayLength: usize = 24; +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppString() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(Il2CppString)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppString)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppString), + "::", + stringify!(object) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).length as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppString), + "::", + stringify!(length) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).chars as *const _ as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Il2CppString), + "::", + stringify!(chars) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionType { + pub object: Il2CppObject, + pub type_: *const Il2CppType, +} +#[test] +fn bindgen_test_layout_Il2CppReflectionType() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(Il2CppReflectionType)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppReflectionType)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionType), + "::", + stringify!(object) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).type_ as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionType), + "::", + stringify!(type_) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionRuntimeType { + pub type_: Il2CppReflectionType, + pub type_info: *mut Il2CppObject, + pub genericCache: *mut Il2CppObject, + pub serializationCtor: *mut Il2CppObject, +} +#[test] +fn bindgen_test_layout_Il2CppReflectionRuntimeType() { + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!("Size of: ", stringify!(Il2CppReflectionRuntimeType)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppReflectionRuntimeType)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).type_ as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionRuntimeType), + "::", + stringify!(type_) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).type_info as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionRuntimeType), + "::", + stringify!(type_info) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).genericCache as *const _ + as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionRuntimeType), + "::", + stringify!(genericCache) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).serializationCtor as *const _ + as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionRuntimeType), + "::", + stringify!(serializationCtor) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionMonoType { + pub type_: Il2CppReflectionRuntimeType, +} +#[test] +fn bindgen_test_layout_Il2CppReflectionMonoType() { + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!("Size of: ", stringify!(Il2CppReflectionMonoType)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppReflectionMonoType)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).type_ as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMonoType), + "::", + stringify!(type_) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionEvent { + pub object: Il2CppObject, + pub cached_add_event: *mut Il2CppObject, +} +#[test] +fn bindgen_test_layout_Il2CppReflectionEvent() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(Il2CppReflectionEvent)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppReflectionEvent)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionEvent), + "::", + stringify!(object) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).cached_add_event as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionEvent), + "::", + stringify!(cached_add_event) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionMonoEvent { + pub event: Il2CppReflectionEvent, + pub reflectedType: *mut Il2CppReflectionType, + pub eventInfo: *const EventInfo, +} +#[test] +fn bindgen_test_layout_Il2CppReflectionMonoEvent() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(Il2CppReflectionMonoEvent)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppReflectionMonoEvent)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).event as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMonoEvent), + "::", + stringify!(event) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).reflectedType as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMonoEvent), + "::", + stringify!(reflectedType) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eventInfo as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMonoEvent), + "::", + stringify!(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, +} +#[test] +fn bindgen_test_layout_Il2CppReflectionMonoEventInfo() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(Il2CppReflectionMonoEventInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppReflectionMonoEventInfo)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).declaringType as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMonoEventInfo), + "::", + stringify!(declaringType) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).reflectedType as *const _ + as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMonoEventInfo), + "::", + stringify!(reflectedType) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).name as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMonoEventInfo), + "::", + stringify!(name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).addMethod as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMonoEventInfo), + "::", + stringify!(addMethod) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).removeMethod as *const _ + as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMonoEventInfo), + "::", + stringify!(removeMethod) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).raiseMethod as *const _ + as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMonoEventInfo), + "::", + stringify!(raiseMethod) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eventAttributes as *const _ + as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMonoEventInfo), + "::", + stringify!(eventAttributes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).otherMethods as *const _ + as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMonoEventInfo), + "::", + stringify!(otherMethods) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppReflectionField() { + assert_eq!( + ::std::mem::size_of::(), + 56usize, + concat!("Size of: ", stringify!(Il2CppReflectionField)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppReflectionField)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionField), + "::", + stringify!(object) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).klass as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionField), + "::", + stringify!(klass) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).field as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionField), + "::", + stringify!(field) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionField), + "::", + stringify!(name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).type_ as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionField), + "::", + stringify!(type_) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).attrs as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionField), + "::", + stringify!(attrs) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionProperty { + pub object: Il2CppObject, + pub klass: *mut Il2CppClass, + pub property: *const PropertyInfo, +} +#[test] +fn bindgen_test_layout_Il2CppReflectionProperty() { + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(Il2CppReflectionProperty)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppReflectionProperty)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionProperty), + "::", + stringify!(object) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).klass as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionProperty), + "::", + stringify!(klass) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).property as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionProperty), + "::", + stringify!(property) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionMethod { + pub object: Il2CppObject, + pub method: *const MethodInfo, + pub name: *mut Il2CppString, + pub reftype: *mut Il2CppReflectionType, +} +#[test] +fn bindgen_test_layout_Il2CppReflectionMethod() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(Il2CppReflectionMethod)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppReflectionMethod)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMethod), + "::", + stringify!(object) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).method as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMethod), + "::", + stringify!(method) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMethod), + "::", + stringify!(name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).reftype as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMethod), + "::", + stringify!(reftype) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionGenericMethod { + pub base: Il2CppReflectionMethod, +} +#[test] +fn bindgen_test_layout_Il2CppReflectionGenericMethod() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(Il2CppReflectionGenericMethod)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppReflectionGenericMethod)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).base as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionGenericMethod), + "::", + stringify!(base) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppMethodInfo() { + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(Il2CppMethodInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppMethodInfo)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).parent as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodInfo), + "::", + stringify!(parent) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).ret as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodInfo), + "::", + stringify!(ret) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).attrs as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodInfo), + "::", + stringify!(attrs) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).implattrs as *const _ as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodInfo), + "::", + stringify!(implattrs) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).callconv as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodInfo), + "::", + stringify!(callconv) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppPropertyInfo() { + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!("Size of: ", stringify!(Il2CppPropertyInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppPropertyInfo)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).parent as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPropertyInfo), + "::", + stringify!(parent) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).declaringType as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPropertyInfo), + "::", + stringify!(declaringType) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPropertyInfo), + "::", + stringify!(name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).get as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPropertyInfo), + "::", + stringify!(get) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).set as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPropertyInfo), + "::", + stringify!(set) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).attrs as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppPropertyInfo), + "::", + stringify!(attrs) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionParameter { + pub object: Il2CppObject, + pub ClassImpl: *mut Il2CppReflectionType, + pub DefaultValueImpl: *mut Il2CppObject, + pub MemberImpl: *mut Il2CppObject, + pub NameImpl: *mut Il2CppString, + pub PositionImpl: i32, + pub AttrsImpl: u32, + pub MarshalAsImpl: *mut Il2CppObject, +} +#[test] +fn bindgen_test_layout_Il2CppReflectionParameter() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(Il2CppReflectionParameter)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppReflectionParameter)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).object as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionParameter), + "::", + stringify!(object) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).ClassImpl as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionParameter), + "::", + stringify!(ClassImpl) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).DefaultValueImpl as *const _ + as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionParameter), + "::", + stringify!(DefaultValueImpl) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).MemberImpl as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionParameter), + "::", + stringify!(MemberImpl) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).NameImpl as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionParameter), + "::", + stringify!(NameImpl) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).PositionImpl as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionParameter), + "::", + stringify!(PositionImpl) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).AttrsImpl as *const _ as usize + }, + 52usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionParameter), + "::", + stringify!(AttrsImpl) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).MarshalAsImpl as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionParameter), + "::", + stringify!(MarshalAsImpl) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppReflectionModule() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(Il2CppReflectionModule)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppReflectionModule)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionModule), + "::", + stringify!(obj) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).image as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionModule), + "::", + stringify!(image) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).assembly as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionModule), + "::", + stringify!(assembly) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).fqname as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionModule), + "::", + stringify!(fqname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionModule), + "::", + stringify!(name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).scopename as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionModule), + "::", + stringify!(scopename) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).is_resource as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionModule), + "::", + stringify!(is_resource) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).token as *const _ as usize }, + 60usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionModule), + "::", + stringify!(token) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppReflectionAssemblyName() { + assert_eq!( + ::std::mem::size_of::(), + 112usize, + concat!("Size of: ", stringify!(Il2CppReflectionAssemblyName)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppReflectionAssemblyName)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).obj as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssemblyName), + "::", + stringify!(obj) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).name as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssemblyName), + "::", + stringify!(name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).codebase as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssemblyName), + "::", + stringify!(codebase) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).major as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssemblyName), + "::", + stringify!(major) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).minor as *const _ as usize + }, + 36usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssemblyName), + "::", + stringify!(minor) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).build as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssemblyName), + "::", + stringify!(build) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).revision as *const _ as usize + }, + 44usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssemblyName), + "::", + stringify!(revision) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).cultureInfo as *const _ + as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssemblyName), + "::", + stringify!(cultureInfo) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).flags as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssemblyName), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).hashalg as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssemblyName), + "::", + stringify!(hashalg) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).keypair as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssemblyName), + "::", + stringify!(keypair) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).publicKey as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssemblyName), + "::", + stringify!(publicKey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).keyToken as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssemblyName), + "::", + stringify!(keyToken) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).versioncompat as *const _ + as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssemblyName), + "::", + stringify!(versioncompat) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).version as *const _ as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssemblyName), + "::", + stringify!(version) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).processor_architecture + as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssemblyName), + "::", + stringify!(processor_architecture) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).contentType as *const _ + as usize + }, + 108usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssemblyName), + "::", + stringify!(contentType) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionAssembly { + pub object: Il2CppObject, + pub assembly: *const Il2CppAssembly, + pub resolve_event_holder: *mut Il2CppObject, + pub evidence: *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, +} +#[test] +fn bindgen_test_layout_Il2CppReflectionAssembly() { + assert_eq!( + ::std::mem::size_of::(), + 96usize, + concat!("Size of: ", stringify!(Il2CppReflectionAssembly)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppReflectionAssembly)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssembly), + "::", + stringify!(object) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).assembly as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssembly), + "::", + stringify!(assembly) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).resolve_event_holder as *const _ + as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssembly), + "::", + stringify!(resolve_event_holder) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).evidence as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssembly), + "::", + stringify!(evidence) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).minimum as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssembly), + "::", + stringify!(minimum) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).optional as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssembly), + "::", + stringify!(optional) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).refuse as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssembly), + "::", + stringify!(refuse) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).granted as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssembly), + "::", + stringify!(granted) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).denied as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssembly), + "::", + stringify!(denied) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).from_byte_array as *const _ + as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssembly), + "::", + stringify!(from_byte_array) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionAssembly), + "::", + stringify!(name) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppReflectionMarshal() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(Il2CppReflectionMarshal)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppReflectionMarshal)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMarshal), + "::", + stringify!(object) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).count as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMarshal), + "::", + stringify!(count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).type_ as *const _ as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMarshal), + "::", + stringify!(type_) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).eltype as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMarshal), + "::", + stringify!(eltype) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).guid as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMarshal), + "::", + stringify!(guid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mcookie as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMarshal), + "::", + stringify!(mcookie) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).marshaltype as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMarshal), + "::", + stringify!(marshaltype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).marshaltyperef as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMarshal), + "::", + stringify!(marshaltyperef) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).param_num as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMarshal), + "::", + stringify!(param_num) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).has_size as *const _ as usize + }, + 68usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionMarshal), + "::", + stringify!(has_size) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppReflectionPointer { + pub object: Il2CppObject, + pub data: *mut ::std::os::raw::c_void, + pub type_: *mut Il2CppReflectionType, +} +#[test] +fn bindgen_test_layout_Il2CppReflectionPointer() { + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(Il2CppReflectionPointer)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppReflectionPointer)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionPointer), + "::", + stringify!(object) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionPointer), + "::", + stringify!(data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).type_ as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppReflectionPointer), + "::", + stringify!(type_) + ) + ); +} +#[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 cached_culture_info: *mut Il2CppArray, + pub name: *mut Il2CppChar, + pub name_len: ::std::os::raw::c_int, + 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 *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 synch_cs: *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 interrupt_on_stop: *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 unused2: usize, + pub last: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_Il2CppInternalThread() { + assert_eq!( + ::std::mem::size_of::(), + 288usize, + concat!("Size of: ", stringify!(Il2CppInternalThread)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppInternalThread)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(obj) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).lock_thread_id as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(lock_thread_id) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).handle as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).native_handle as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(native_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).cached_culture_info as *const _ + as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(cached_culture_info) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).name_len as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(name_len) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).state as *const _ as usize }, + 60usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(state) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).abort_exc as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(abort_exc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).abort_state_handle as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(abort_state_handle) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).tid as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(tid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).debugger_thread as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(debugger_thread) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).static_data as *const _ as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(static_data) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).runtime_thread_info as *const _ + as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(runtime_thread_info) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).current_appcontext as *const _ as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(current_appcontext) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).root_domain_thread as *const _ as usize + }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(root_domain_thread) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::()))._serialized_principal as *const _ + as usize + }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(_serialized_principal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::()))._serialized_principal_version + as *const _ as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(_serialized_principal_version) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).appdomain_refs as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(appdomain_refs) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).interruption_requested as *const _ + as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(interruption_requested) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).synch_cs as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(synch_cs) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).threadpool_thread as *const _ as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(threadpool_thread) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_interrupt_requested as *const _ + as usize + }, + 169usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(thread_interrupt_requested) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).stack_size as *const _ as usize }, + 172usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(stack_size) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).apartment_state as *const _ as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(apartment_state) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).critical_region_level as *const _ + as usize + }, + 180usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(critical_region_level) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).managed_id as *const _ as usize }, + 184usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(managed_id) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).small_id as *const _ as usize }, + 188usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(small_id) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).manage_callback as *const _ as usize + }, + 192usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(manage_callback) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).interrupt_on_stop as *const _ as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(interrupt_on_stop) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).flags as *const _ as usize }, + 208usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_pinning_ref as *const _ as usize + }, + 216usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(thread_pinning_ref) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).abort_protected_block_count as *const _ + as usize + }, + 224usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(abort_protected_block_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).priority as *const _ as usize }, + 232usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(priority) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).owned_mutexes as *const _ as usize + }, + 240usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(owned_mutexes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).suspended as *const _ as usize }, + 248usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(suspended) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).self_suspended as *const _ as usize + }, + 256usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(self_suspended) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_state as *const _ as usize + }, + 264usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(thread_state) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).unused2 as *const _ as usize }, + 272usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(unused2) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).last as *const _ as usize }, + 280usize, + concat!( + "Offset of field: ", + stringify!(Il2CppInternalThread), + "::", + stringify!(last) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppIOSelectorJob { + pub object: Il2CppObject, + pub operation: i32, + pub callback: *mut Il2CppObject, + pub state: *mut Il2CppObject, +} +#[test] +fn bindgen_test_layout_Il2CppIOSelectorJob() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(Il2CppIOSelectorJob)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppIOSelectorJob)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppIOSelectorJob), + "::", + stringify!(object) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).operation as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppIOSelectorJob), + "::", + stringify!(operation) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).callback as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppIOSelectorJob), + "::", + stringify!(callback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).state as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppIOSelectorJob), + "::", + stringify!(state) + ) + ); +} +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; +pub type Il2CppCallType = i32; +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppMethodMessage() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(Il2CppMethodMessage)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppMethodMessage)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodMessage), + "::", + stringify!(obj) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).method as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodMessage), + "::", + stringify!(method) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).args as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodMessage), + "::", + stringify!(args) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).names as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodMessage), + "::", + stringify!(names) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).arg_types as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodMessage), + "::", + stringify!(arg_types) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).ctx as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodMessage), + "::", + stringify!(ctx) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).rval as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodMessage), + "::", + stringify!(rval) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).exc as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodMessage), + "::", + stringify!(exc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).async_result as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodMessage), + "::", + stringify!(async_result) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).call_type as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMethodMessage), + "::", + stringify!(call_type) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppAppDomainSetup() { + assert_eq!( + ::std::mem::size_of::(), + 168usize, + concat!("Size of: ", stringify!(Il2CppAppDomainSetup)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppAppDomainSetup)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomainSetup), + "::", + stringify!(object) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).application_base as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomainSetup), + "::", + stringify!(application_base) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).application_name as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomainSetup), + "::", + stringify!(application_name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).cache_path as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomainSetup), + "::", + stringify!(cache_path) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).configuration_file as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomainSetup), + "::", + stringify!(configuration_file) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).dynamic_base as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomainSetup), + "::", + stringify!(dynamic_base) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).license_file as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomainSetup), + "::", + stringify!(license_file) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).private_bin_path as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomainSetup), + "::", + stringify!(private_bin_path) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).private_bin_path_probe as *const _ + as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomainSetup), + "::", + stringify!(private_bin_path_probe) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).shadow_copy_directories as *const _ + as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomainSetup), + "::", + stringify!(shadow_copy_directories) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).shadow_copy_files as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomainSetup), + "::", + stringify!(shadow_copy_files) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).publisher_policy as *const _ as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomainSetup), + "::", + stringify!(publisher_policy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).path_changed as *const _ as usize + }, + 97usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomainSetup), + "::", + stringify!(path_changed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).loader_optimization as *const _ + as usize + }, + 100usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomainSetup), + "::", + stringify!(loader_optimization) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).disallow_binding_redirects as *const _ + as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomainSetup), + "::", + stringify!(disallow_binding_redirects) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).disallow_code_downloads as *const _ + as usize + }, + 105usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomainSetup), + "::", + stringify!(disallow_code_downloads) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).activation_arguments as *const _ + as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomainSetup), + "::", + stringify!(activation_arguments) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).domain_initializer as *const _ as usize + }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomainSetup), + "::", + stringify!(domain_initializer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).application_trust as *const _ as usize + }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomainSetup), + "::", + stringify!(application_trust) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).domain_initializer_args as *const _ + as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomainSetup), + "::", + stringify!(domain_initializer_args) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).disallow_appbase_probe as *const _ + as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomainSetup), + "::", + stringify!(disallow_appbase_probe) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).configuration_bytes as *const _ + as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomainSetup), + "::", + stringify!(configuration_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).serialized_non_primitives as *const _ + as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomainSetup), + "::", + stringify!(serialized_non_primitives) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppThread() { + assert_eq!( + ::std::mem::size_of::(), + 80usize, + concat!("Size of: ", stringify!(Il2CppThread)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppThread)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppThread), + "::", + stringify!(obj) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).internal_thread as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppThread), + "::", + stringify!(internal_thread) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).start_obj as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppThread), + "::", + stringify!(start_obj) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pending_exception as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppThread), + "::", + stringify!(pending_exception) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).principal as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppThread), + "::", + stringify!(principal) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).principal_version as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppThread), + "::", + stringify!(principal_version) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).delegate as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppThread), + "::", + stringify!(delegate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).executionContext as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppThread), + "::", + stringify!(executionContext) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).executionContextBelongsToOuterScope as *const _ + as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Il2CppThread), + "::", + stringify!(executionContextBelongsToOuterScope) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppException() { + assert_eq!( + ::std::mem::size_of::(), + 136usize, + concat!("Size of: ", stringify!(Il2CppException)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppException)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppException), + "::", + stringify!(object) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).className as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppException), + "::", + stringify!(className) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).message as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppException), + "::", + stringify!(message) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::()))._data as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppException), + "::", + stringify!(_data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).inner_ex as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppException), + "::", + stringify!(inner_ex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::()))._helpURL as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppException), + "::", + stringify!(_helpURL) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace_ips as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppException), + "::", + stringify!(trace_ips) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).stack_trace as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppException), + "::", + stringify!(stack_trace) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).remote_stack_trace as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Il2CppException), + "::", + stringify!(remote_stack_trace) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).remote_stack_index as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Il2CppException), + "::", + stringify!(remote_stack_index) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::()))._dynamicMethods as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Il2CppException), + "::", + stringify!(_dynamicMethods) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).hresult as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Il2CppException), + "::", + stringify!(hresult) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).source as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Il2CppException), + "::", + stringify!(source) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).safeSerializationManager as *const _ + as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Il2CppException), + "::", + stringify!(safeSerializationManager) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).captured_traces as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Il2CppException), + "::", + stringify!(captured_traces) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).native_trace_ips as *const _ as usize + }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Il2CppException), + "::", + stringify!(native_trace_ips) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppSystemException { + pub base: Il2CppException, +} +#[test] +fn bindgen_test_layout_Il2CppSystemException() { + assert_eq!( + ::std::mem::size_of::(), + 136usize, + concat!("Size of: ", stringify!(Il2CppSystemException)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppSystemException)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).base as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSystemException), + "::", + stringify!(base) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppArgumentException { + pub base: Il2CppException, + pub argName: *mut Il2CppString, +} +#[test] +fn bindgen_test_layout_Il2CppArgumentException() { + assert_eq!( + ::std::mem::size_of::(), + 144usize, + concat!("Size of: ", stringify!(Il2CppArgumentException)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppArgumentException)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).base as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppArgumentException), + "::", + stringify!(base) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).argName as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(Il2CppArgumentException), + "::", + stringify!(argName) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppTypedRef() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(Il2CppTypedRef)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppTypedRef)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).type_ as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypedRef), + "::", + stringify!(type_) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypedRef), + "::", + stringify!(value) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).klass as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppTypedRef), + "::", + stringify!(klass) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppDelegate { + pub object: Il2CppObject, + pub method_ptr: Il2CppMethodPointer, + pub invoke_impl: InvokerMethod, + pub target: *mut Il2CppObject, + pub method: *const MethodInfo, + pub delegate_trampoline: *mut ::std::os::raw::c_void, + pub extraArg: isize, + pub method_code: *mut *mut u8, + pub method_info: *mut Il2CppReflectionMethod, + pub original_method_info: *mut Il2CppReflectionMethod, + pub data: *mut Il2CppObject, + pub method_is_virtual: u8, +} +#[test] +fn bindgen_test_layout_Il2CppDelegate() { + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(Il2CppDelegate)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppDelegate)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDelegate), + "::", + stringify!(object) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).method_ptr as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDelegate), + "::", + stringify!(method_ptr) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).invoke_impl as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDelegate), + "::", + stringify!(invoke_impl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).target as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDelegate), + "::", + stringify!(target) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).method as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDelegate), + "::", + stringify!(method) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).delegate_trampoline as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDelegate), + "::", + stringify!(delegate_trampoline) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).extraArg as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDelegate), + "::", + stringify!(extraArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).method_code as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDelegate), + "::", + stringify!(method_code) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).method_info as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDelegate), + "::", + stringify!(method_info) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).original_method_info as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDelegate), + "::", + stringify!(original_method_info) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDelegate), + "::", + stringify!(data) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).method_is_virtual as *const _ as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDelegate), + "::", + stringify!(method_is_virtual) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppMulticastDelegate { + pub delegate: Il2CppDelegate, + pub delegates: *mut Il2CppArray, +} +#[test] +fn bindgen_test_layout_Il2CppMulticastDelegate() { + assert_eq!( + ::std::mem::size_of::(), + 112usize, + concat!("Size of: ", stringify!(Il2CppMulticastDelegate)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppMulticastDelegate)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).delegate as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMulticastDelegate), + "::", + stringify!(delegate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).delegates as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMulticastDelegate), + "::", + stringify!(delegates) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppMarshalByRefObject { + pub obj: Il2CppObject, + pub identity: *mut Il2CppObject, +} +#[test] +fn bindgen_test_layout_Il2CppMarshalByRefObject() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(Il2CppMarshalByRefObject)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppMarshalByRefObject)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMarshalByRefObject), + "::", + stringify!(obj) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).identity as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppMarshalByRefObject), + "::", + stringify!(identity) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppAppDomain { + pub mbr: Il2CppMarshalByRefObject, + pub data: *mut Il2CppDomain, +} +#[test] +fn bindgen_test_layout_Il2CppAppDomain() { + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(Il2CppAppDomain)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppAppDomain)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mbr as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomain), + "::", + stringify!(mbr) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppDomain), + "::", + stringify!(data) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppStackFrame() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(Il2CppStackFrame)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppStackFrame)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStackFrame), + "::", + stringify!(obj) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).il_offset as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStackFrame), + "::", + stringify!(il_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).native_offset as *const _ as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStackFrame), + "::", + stringify!(native_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).methodAddress as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStackFrame), + "::", + stringify!(methodAddress) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).methodIndex as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStackFrame), + "::", + stringify!(methodIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).method as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStackFrame), + "::", + stringify!(method) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).filename as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStackFrame), + "::", + stringify!(filename) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).line as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStackFrame), + "::", + stringify!(line) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).column as *const _ as usize }, + 60usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStackFrame), + "::", + stringify!(column) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).internal_method_name as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStackFrame), + "::", + stringify!(internal_method_name) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppDateTimeFormatInfo() { + assert_eq!( + ::std::mem::size_of::(), + 376usize, + concat!("Size of: ", stringify!(Il2CppDateTimeFormatInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppDateTimeFormatInfo)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(obj) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).CultureData as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(CultureData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).Name as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(Name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).LangName as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(LangName) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).CompareInfo as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(CompareInfo) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).CultureInfo as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(CultureInfo) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).AMDesignator as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(AMDesignator) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).PMDesignator as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(PMDesignator) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).DateSeparator as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(DateSeparator) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).GeneralShortTimePattern as *const _ + as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(GeneralShortTimePattern) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).GeneralLongTimePattern as *const _ + as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(GeneralLongTimePattern) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).TimeSeparator as *const _ as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(TimeSeparator) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).MonthDayPattern as *const _ + as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(MonthDayPattern) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).DateTimeOffsetPattern as *const _ + as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(DateTimeOffsetPattern) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).Calendar as *const _ as usize + }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(Calendar) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).FirstDayOfWeek as *const _ as usize + }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(FirstDayOfWeek) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).CalendarWeekRule as *const _ + as usize + }, + 132usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(CalendarWeekRule) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).FullDateTimePattern as *const _ + as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(FullDateTimePattern) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).AbbreviatedDayNames as *const _ + as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(AbbreviatedDayNames) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).ShortDayNames as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(ShortDayNames) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).DayNames as *const _ as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(DayNames) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).AbbreviatedMonthNames as *const _ + as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(AbbreviatedMonthNames) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).MonthNames as *const _ as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(MonthNames) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).GenitiveMonthNames as *const _ + as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(GenitiveMonthNames) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).GenitiveAbbreviatedMonthNames + as *const _ as usize + }, + 192usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(GenitiveAbbreviatedMonthNames) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).LeapYearMonthNames as *const _ + as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(LeapYearMonthNames) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).LongDatePattern as *const _ + as usize + }, + 208usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(LongDatePattern) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).ShortDatePattern as *const _ + as usize + }, + 216usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(ShortDatePattern) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).YearMonthPattern as *const _ + as usize + }, + 224usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(YearMonthPattern) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).LongTimePattern as *const _ + as usize + }, + 232usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(LongTimePattern) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).ShortTimePattern as *const _ + as usize + }, + 240usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(ShortTimePattern) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).YearMonthPatterns as *const _ + as usize + }, + 248usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(YearMonthPatterns) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).ShortDatePatterns as *const _ + as usize + }, + 256usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(ShortDatePatterns) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).LongDatePatterns as *const _ + as usize + }, + 264usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(LongDatePatterns) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).ShortTimePatterns as *const _ + as usize + }, + 272usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(ShortTimePatterns) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).LongTimePatterns as *const _ + as usize + }, + 280usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(LongTimePatterns) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).EraNames as *const _ as usize + }, + 288usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(EraNames) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).AbbrevEraNames as *const _ as usize + }, + 296usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(AbbrevEraNames) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).AbbrevEnglishEraNames as *const _ + as usize + }, + 304usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(AbbrevEnglishEraNames) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).OptionalCalendars as *const _ + as usize + }, + 312usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(OptionalCalendars) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).readOnly as *const _ as usize + }, + 320usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(readOnly) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).FormatFlags as *const _ as usize + }, + 324usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(FormatFlags) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).CultureID as *const _ as usize + }, + 328usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(CultureID) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).UseUserOverride as *const _ + as usize + }, + 332usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(UseUserOverride) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).UseCalendarInfo as *const _ + as usize + }, + 333usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(UseCalendarInfo) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).DataItem as *const _ as usize + }, + 336usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(DataItem) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).IsDefaultCalendar as *const _ + as usize + }, + 340usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(IsDefaultCalendar) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).DateWords as *const _ as usize + }, + 344usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(DateWords) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).FullTimeSpanPositivePattern + as *const _ as usize + }, + 352usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(FullTimeSpanPositivePattern) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).FullTimeSpanNegativePattern + as *const _ as usize + }, + 360usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(FullTimeSpanNegativePattern) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).dtfiTokenHash as *const _ as usize + }, + 368usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDateTimeFormatInfo), + "::", + stringify!(dtfiTokenHash) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppNumberFormatInfo() { + assert_eq!( + ::std::mem::size_of::(), + 216usize, + concat!("Size of: ", stringify!(Il2CppNumberFormatInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppNumberFormatInfo)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(obj) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).numberGroupSizes as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(numberGroupSizes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).currencyGroupSizes as *const _ + as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(currencyGroupSizes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).percentGroupSizes as *const _ + as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(percentGroupSizes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).positiveSign as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(positiveSign) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).negativeSign as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(negativeSign) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).numberDecimalSeparator as *const _ + as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(numberDecimalSeparator) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).numberGroupSeparator as *const _ + as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(numberGroupSeparator) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).currencyGroupSeparator as *const _ + as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(currencyGroupSeparator) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).currencyDecimalSeparator as *const _ + as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(currencyDecimalSeparator) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).currencySymbol as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(currencySymbol) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).ansiCurrencySymbol as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(ansiCurrencySymbol) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).naNSymbol as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(naNSymbol) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).positiveInfinitySymbol as *const _ + as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(positiveInfinitySymbol) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).negativeInfinitySymbol as *const _ + as usize + }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(negativeInfinitySymbol) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).percentDecimalSeparator as *const _ + as usize + }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(percentDecimalSeparator) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).percentGroupSeparator as *const _ + as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(percentGroupSeparator) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).percentSymbol as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(percentSymbol) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).perMilleSymbol as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(perMilleSymbol) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).nativeDigits as *const _ as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(nativeDigits) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).dataItem as *const _ as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(dataItem) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).numberDecimalDigits as *const _ + as usize + }, + 172usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(numberDecimalDigits) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).currencyDecimalDigits as *const _ + as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(currencyDecimalDigits) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).currencyPositivePattern as *const _ + as usize + }, + 180usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(currencyPositivePattern) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).currencyNegativePattern as *const _ + as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(currencyNegativePattern) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).numberNegativePattern as *const _ + as usize + }, + 188usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(numberNegativePattern) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).percentPositivePattern as *const _ + as usize + }, + 192usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(percentPositivePattern) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).percentNegativePattern as *const _ + as usize + }, + 196usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(percentNegativePattern) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).percentDecimalDigits as *const _ + as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(percentDecimalDigits) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).digitSubstitution as *const _ + as usize + }, + 204usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(digitSubstitution) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).readOnly as *const _ as usize }, + 208usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(readOnly) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).useUserOverride as *const _ as usize + }, + 209usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(useUserOverride) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).isInvariant as *const _ as usize + }, + 210usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(isInvariant) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).validForParseAsNumber as *const _ + as usize + }, + 211usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(validForParseAsNumber) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).validForParseAsCurrency as *const _ + as usize + }, + 212usize, + concat!( + "Offset of field: ", + stringify!(Il2CppNumberFormatInfo), + "::", + stringify!(validForParseAsCurrency) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppCultureData() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(Il2CppCultureData)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppCultureData)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureData), + "::", + stringify!(obj) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).AMDesignator as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureData), + "::", + stringify!(AMDesignator) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).PMDesignator as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureData), + "::", + stringify!(PMDesignator) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).TimeSeparator as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureData), + "::", + stringify!(TimeSeparator) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).LongTimePatterns as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureData), + "::", + stringify!(LongTimePatterns) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).ShortTimePatterns as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureData), + "::", + stringify!(ShortTimePatterns) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).FirstDayOfWeek as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureData), + "::", + stringify!(FirstDayOfWeek) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).CalendarWeekRule as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureData), + "::", + stringify!(CalendarWeekRule) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppCalendarData() { + assert_eq!( + ::std::mem::size_of::(), + 136usize, + concat!("Size of: ", stringify!(Il2CppCalendarData)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppCalendarData)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCalendarData), + "::", + stringify!(obj) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).NativeName as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCalendarData), + "::", + stringify!(NativeName) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).ShortDatePatterns as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCalendarData), + "::", + stringify!(ShortDatePatterns) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).YearMonthPatterns as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCalendarData), + "::", + stringify!(YearMonthPatterns) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).LongDatePatterns as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCalendarData), + "::", + stringify!(LongDatePatterns) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).MonthDayPattern as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCalendarData), + "::", + stringify!(MonthDayPattern) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).EraNames as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCalendarData), + "::", + stringify!(EraNames) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).AbbreviatedEraNames as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCalendarData), + "::", + stringify!(AbbreviatedEraNames) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).AbbreviatedEnglishEraNames as *const _ + as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCalendarData), + "::", + stringify!(AbbreviatedEnglishEraNames) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).DayNames as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCalendarData), + "::", + stringify!(DayNames) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).AbbreviatedDayNames as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCalendarData), + "::", + stringify!(AbbreviatedDayNames) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).SuperShortDayNames as *const _ as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCalendarData), + "::", + stringify!(SuperShortDayNames) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).MonthNames as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCalendarData), + "::", + stringify!(MonthNames) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).AbbreviatedMonthNames as *const _ + as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCalendarData), + "::", + stringify!(AbbreviatedMonthNames) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).GenitiveMonthNames as *const _ as usize + }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCalendarData), + "::", + stringify!(GenitiveMonthNames) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).GenitiveAbbreviatedMonthNames as *const _ + as usize + }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCalendarData), + "::", + stringify!(GenitiveAbbreviatedMonthNames) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppCultureInfo() { + assert_eq!( + ::std::mem::size_of::(), + 208usize, + concat!("Size of: ", stringify!(Il2CppCultureInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppCultureInfo)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(obj) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).is_read_only as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(is_read_only) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).lcid as *const _ as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(lcid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).parent_lcid as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(parent_lcid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).datetime_index as *const _ as usize + }, + 28usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(datetime_index) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).number_index as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(number_index) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).default_calendar_type as *const _ as usize + }, + 36usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(default_calendar_type) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).use_user_override as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(use_user_override) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).number_format as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(number_format) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).datetime_format as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(datetime_format) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).textinfo as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(textinfo) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).englishname as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(englishname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nativename as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(nativename) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iso3lang as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(iso3lang) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iso2lang as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(iso2lang) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).win3lang as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(win3lang) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).territory as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(territory) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).native_calendar_names as *const _ as usize + }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(native_calendar_names) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).compareinfo as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(compareinfo) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).text_info_data as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(text_info_data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).dataItem as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(dataItem) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).calendar as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(calendar) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).parent_culture as *const _ as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(parent_culture) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).constructed as *const _ as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(constructed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).cached_serialized_form as *const _ + as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(cached_serialized_form) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).cultureData as *const _ as usize }, + 192usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(cultureData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).isInherited as *const _ as usize }, + 200usize, + concat!( + "Offset of field: ", + stringify!(Il2CppCultureInfo), + "::", + stringify!(isInherited) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppRegionInfo() { + assert_eq!( + ::std::mem::size_of::(), + 96usize, + concat!("Size of: ", stringify!(Il2CppRegionInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppRegionInfo)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRegionInfo), + "::", + stringify!(obj) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).geo_id as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRegionInfo), + "::", + stringify!(geo_id) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iso2name as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRegionInfo), + "::", + stringify!(iso2name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iso3name as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRegionInfo), + "::", + stringify!(iso3name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).win3name as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRegionInfo), + "::", + stringify!(win3name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).english_name as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRegionInfo), + "::", + stringify!(english_name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).native_name as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRegionInfo), + "::", + stringify!(native_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).currency_symbol as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRegionInfo), + "::", + stringify!(currency_symbol) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iso_currency_symbol as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRegionInfo), + "::", + stringify!(iso_currency_symbol) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).currency_english_name as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRegionInfo), + "::", + stringify!(currency_english_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).currency_native_name as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Il2CppRegionInfo), + "::", + stringify!(currency_native_name) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppSafeHandle() { + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(Il2CppSafeHandle)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppSafeHandle)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).base as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSafeHandle), + "::", + stringify!(base) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).handle as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSafeHandle), + "::", + stringify!(handle) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).state as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSafeHandle), + "::", + stringify!(state) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).owns_handle as *const _ as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSafeHandle), + "::", + stringify!(owns_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).fullyInitialized as *const _ as usize + }, + 29usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSafeHandle), + "::", + stringify!(fullyInitialized) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppStringBuilder() { + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!("Size of: ", stringify!(Il2CppStringBuilder)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppStringBuilder)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).object as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStringBuilder), + "::", + stringify!(object) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).chunkChars as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStringBuilder), + "::", + stringify!(chunkChars) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).chunkPrevious as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStringBuilder), + "::", + stringify!(chunkPrevious) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).chunkLength as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStringBuilder), + "::", + stringify!(chunkLength) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).chunkOffset as *const _ as usize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStringBuilder), + "::", + stringify!(chunkOffset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).maxCapacity as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStringBuilder), + "::", + stringify!(maxCapacity) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppSocketAddress() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(Il2CppSocketAddress)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppSocketAddress)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).base as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSocketAddress), + "::", + stringify!(base) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).m_Size as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSocketAddress), + "::", + stringify!(m_Size) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSocketAddress), + "::", + stringify!(data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).m_changed as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSocketAddress), + "::", + stringify!(m_changed) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).m_hash as *const _ as usize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSocketAddress), + "::", + stringify!(m_hash) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppSortKey() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(Il2CppSortKey)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppSortKey)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).base as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSortKey), + "::", + stringify!(base) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSortKey), + "::", + stringify!(str) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).key as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSortKey), + "::", + stringify!(key) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).options as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSortKey), + "::", + stringify!(options) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).lcid as *const _ as usize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSortKey), + "::", + stringify!(lcid) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppErrorWrapper { + pub base: Il2CppObject, + pub errorCode: i32, +} +#[test] +fn bindgen_test_layout_Il2CppErrorWrapper() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(Il2CppErrorWrapper)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppErrorWrapper)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).base as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppErrorWrapper), + "::", + stringify!(base) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errorCode as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppErrorWrapper), + "::", + stringify!(errorCode) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppAsyncResult() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(Il2CppAsyncResult)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppAsyncResult)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).base as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAsyncResult), + "::", + stringify!(base) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).async_state as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAsyncResult), + "::", + stringify!(async_state) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).handle as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAsyncResult), + "::", + stringify!(handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).async_delegate as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAsyncResult), + "::", + stringify!(async_delegate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAsyncResult), + "::", + stringify!(data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).object_data as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAsyncResult), + "::", + stringify!(object_data) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).sync_completed as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAsyncResult), + "::", + stringify!(sync_completed) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).completed as *const _ as usize }, + 57usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAsyncResult), + "::", + stringify!(completed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).endinvoke_called as *const _ as usize + }, + 58usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAsyncResult), + "::", + stringify!(endinvoke_called) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).async_callback as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAsyncResult), + "::", + stringify!(async_callback) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).execution_context as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAsyncResult), + "::", + stringify!(execution_context) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).original_context as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAsyncResult), + "::", + stringify!(original_context) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppAsyncCall() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(Il2CppAsyncCall)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppAsyncCall)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).base as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAsyncCall), + "::", + stringify!(base) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).msg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAsyncCall), + "::", + stringify!(msg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).cb_method as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAsyncCall), + "::", + stringify!(cb_method) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).cb_target as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAsyncCall), + "::", + stringify!(cb_target) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).state as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAsyncCall), + "::", + stringify!(state) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).res as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAsyncCall), + "::", + stringify!(res) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).out_args as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAsyncCall), + "::", + stringify!(out_args) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppExceptionWrapper { + pub ex: *mut Il2CppException, +} +#[test] +fn bindgen_test_layout_Il2CppExceptionWrapper() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Il2CppExceptionWrapper)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppExceptionWrapper)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).ex as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppExceptionWrapper), + "::", + stringify!(ex) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppIOAsyncResult() { + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!("Size of: ", stringify!(Il2CppIOAsyncResult)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppIOAsyncResult)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).base as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppIOAsyncResult), + "::", + stringify!(base) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).callback as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppIOAsyncResult), + "::", + stringify!(callback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).state as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppIOAsyncResult), + "::", + stringify!(state) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).wait_handle as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppIOAsyncResult), + "::", + stringify!(wait_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).completed_synchronously as *const _ + as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppIOAsyncResult), + "::", + stringify!(completed_synchronously) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).completed as *const _ as usize }, + 41usize, + concat!( + "Offset of field: ", + stringify!(Il2CppIOAsyncResult), + "::", + stringify!(completed) + ) + ); +} +#[doc = " Corresponds to Mono's internal System.Net.Sockets.Socket.SocketAsyncResult"] +#[doc = " 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, +} +#[test] +fn bindgen_test_layout_Il2CppSocketAsyncResult() { + assert_eq!( + ::std::mem::size_of::(), + 168usize, + concat!("Size of: ", stringify!(Il2CppSocketAsyncResult)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppSocketAsyncResult)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).base as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSocketAsyncResult), + "::", + stringify!(base) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).socket as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSocketAsyncResult), + "::", + stringify!(socket) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).operation as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSocketAsyncResult), + "::", + stringify!(operation) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).delayedException as *const _ + as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSocketAsyncResult), + "::", + stringify!(delayedException) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).endPoint as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSocketAsyncResult), + "::", + stringify!(endPoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).buffer as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSocketAsyncResult), + "::", + stringify!(buffer) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).offset as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSocketAsyncResult), + "::", + stringify!(offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).size as *const _ as usize }, + 92usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSocketAsyncResult), + "::", + stringify!(size) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).socket_flags as *const _ as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSocketAsyncResult), + "::", + stringify!(socket_flags) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).acceptSocket as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSocketAsyncResult), + "::", + stringify!(acceptSocket) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).addresses as *const _ as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSocketAsyncResult), + "::", + stringify!(addresses) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).port as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSocketAsyncResult), + "::", + stringify!(port) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).buffers as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSocketAsyncResult), + "::", + stringify!(buffers) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).reuseSocket as *const _ as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSocketAsyncResult), + "::", + stringify!(reuseSocket) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).currentAddress as *const _ as usize + }, + 140usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSocketAsyncResult), + "::", + stringify!(currentAddress) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).acceptedSocket as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSocketAsyncResult), + "::", + stringify!(acceptedSocket) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).total as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSocketAsyncResult), + "::", + stringify!(total) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).error as *const _ as usize }, + 156usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSocketAsyncResult), + "::", + stringify!(error) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).endCalled as *const _ as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSocketAsyncResult), + "::", + stringify!(endCalled) + ) + ); +} +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; +pub type Il2CppResourceLocation = i32; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppManifestResourceInfo { + pub object: Il2CppObject, + pub assembly: *mut Il2CppReflectionAssembly, + pub filename: *mut Il2CppString, + pub location: u32, +} +#[test] +fn bindgen_test_layout_Il2CppManifestResourceInfo() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(Il2CppManifestResourceInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppManifestResourceInfo)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).object as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppManifestResourceInfo), + "::", + stringify!(object) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).assembly as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppManifestResourceInfo), + "::", + stringify!(assembly) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).filename as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppManifestResourceInfo), + "::", + stringify!(filename) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).location as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppManifestResourceInfo), + "::", + stringify!(location) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppAppContext() { + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(Il2CppAppContext)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppAppContext)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).obj as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppContext), + "::", + stringify!(obj) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).domain_id as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppContext), + "::", + stringify!(domain_id) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).context_id as *const _ as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppContext), + "::", + stringify!(context_id) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).static_data as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppAppContext), + "::", + stringify!(static_data) + ) + ); +} +#[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(Copy, Clone)] +pub union Il2CppDecimal__bindgen_ty_1 { + pub u: Il2CppDecimal__bindgen_ty_1__bindgen_ty_1, + pub signscale: u16, + _bindgen_union_align: u16, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppDecimal__bindgen_ty_1__bindgen_ty_1 { + pub scale: u8, + pub sign: u8, +} +#[test] +fn bindgen_test_layout_Il2CppDecimal__bindgen_ty_1__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::(), + 2usize, + concat!( + "Size of: ", + stringify!(Il2CppDecimal__bindgen_ty_1__bindgen_ty_1) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 1usize, + concat!( + "Alignment of ", + stringify!(Il2CppDecimal__bindgen_ty_1__bindgen_ty_1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).scale as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDecimal__bindgen_ty_1__bindgen_ty_1), + "::", + stringify!(scale) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).sign as *const _ + as usize + }, + 1usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDecimal__bindgen_ty_1__bindgen_ty_1), + "::", + stringify!(sign) + ) + ); +} +#[test] +fn bindgen_test_layout_Il2CppDecimal__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::(), + 2usize, + concat!("Size of: ", stringify!(Il2CppDecimal__bindgen_ty_1)) + ); + assert_eq!( + ::std::mem::align_of::(), + 2usize, + concat!("Alignment of ", stringify!(Il2CppDecimal__bindgen_ty_1)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).u as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDecimal__bindgen_ty_1), + "::", + stringify!(u) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).signscale as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDecimal__bindgen_ty_1), + "::", + stringify!(signscale) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union Il2CppDecimal__bindgen_ty_2 { + pub v: Il2CppDecimal__bindgen_ty_2__bindgen_ty_1, + pub Lo64: u64, + _bindgen_union_align: u64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppDecimal__bindgen_ty_2__bindgen_ty_1 { + pub Lo32: u32, + pub Mid32: u32, +} +#[test] +fn bindgen_test_layout_Il2CppDecimal__bindgen_ty_2__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(Il2CppDecimal__bindgen_ty_2__bindgen_ty_1) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(Il2CppDecimal__bindgen_ty_2__bindgen_ty_1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).Lo32 as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDecimal__bindgen_ty_2__bindgen_ty_1), + "::", + stringify!(Lo32) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).Mid32 as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDecimal__bindgen_ty_2__bindgen_ty_1), + "::", + stringify!(Mid32) + ) + ); +} +#[test] +fn bindgen_test_layout_Il2CppDecimal__bindgen_ty_2() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Il2CppDecimal__bindgen_ty_2)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppDecimal__bindgen_ty_2)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).v as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDecimal__bindgen_ty_2), + "::", + stringify!(v) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).Lo64 as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDecimal__bindgen_ty_2), + "::", + stringify!(Lo64) + ) + ); +} +#[test] +fn bindgen_test_layout_Il2CppDecimal() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Il2CppDecimal)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppDecimal)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).reserved as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDecimal), + "::", + stringify!(reserved) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).u as *const _ as usize }, + 2usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDecimal), + "::", + stringify!(u) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).Hi32 as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDecimal), + "::", + stringify!(Hi32) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).v as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDecimal), + "::", + stringify!(v) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppDouble { + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize], u32>, +} +#[test] +fn bindgen_test_layout_Il2CppDouble() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Il2CppDouble)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppDouble)) + ); +} +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], u32> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize], u32> = + 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 + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union Il2CppDouble_double { + pub s: Il2CppDouble, + pub d: f64, + _bindgen_union_align: u64, +} +#[test] +fn bindgen_test_layout_Il2CppDouble_double() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Il2CppDouble_double)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppDouble_double)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).s as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDouble_double), + "::", + stringify!(s) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).d as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppDouble_double), + "::", + stringify!(d) + ) + ); +} +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; +pub type Il2CppDecimalCompareResult = i32; +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppSingle { + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u32>, +} +#[test] +fn bindgen_test_layout_Il2CppSingle() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(Il2CppSingle)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppSingle)) + ); +} +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], u32> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u32> = + 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 + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union Il2CppSingle_float { + pub s: Il2CppSingle, + pub f: f32, + _bindgen_union_align: u32, +} +#[test] +fn bindgen_test_layout_Il2CppSingle_float() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(Il2CppSingle_float)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppSingle_float)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).s as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSingle_float), + "::", + stringify!(s) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).f as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSingle_float), + "::", + stringify!(f) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppGuid { + pub data1: u32, + pub data2: u16, + pub data3: u16, + pub data4: [u8; 8usize], +} +#[test] +fn bindgen_test_layout_Il2CppGuid() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Il2CppGuid)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppGuid)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data1 as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGuid), + "::", + stringify!(data1) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data2 as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGuid), + "::", + stringify!(data2) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data3 as *const _ as usize }, + 6usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGuid), + "::", + stringify!(data3) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data4 as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppGuid), + "::", + stringify!(data4) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppSafeArrayBound { + pub element_count: u32, + pub lower_bound: i32, +} +#[test] +fn bindgen_test_layout_Il2CppSafeArrayBound() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Il2CppSafeArrayBound)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppSafeArrayBound)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).element_count as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSafeArrayBound), + "::", + stringify!(element_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).lower_bound as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSafeArrayBound), + "::", + stringify!(lower_bound) + ) + ); +} +#[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], +} +#[test] +fn bindgen_test_layout_Il2CppSafeArray() { + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(Il2CppSafeArray)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppSafeArray)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).dimension_count as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSafeArray), + "::", + stringify!(dimension_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).features as *const _ as usize }, + 2usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSafeArray), + "::", + stringify!(features) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).element_size as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSafeArray), + "::", + stringify!(element_size) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).lock_count as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSafeArray), + "::", + stringify!(lock_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSafeArray), + "::", + stringify!(data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bounds as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppSafeArray), + "::", + stringify!(bounds) + ) + ); +} +#[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(Copy, Clone)] +pub union Il2CppWin32Decimal__bindgen_ty_1 { + pub s: Il2CppWin32Decimal__bindgen_ty_1__bindgen_ty_1, + pub signscale: u16, + _bindgen_union_align: u16, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppWin32Decimal__bindgen_ty_1__bindgen_ty_1 { + pub scale: u8, + pub sign: u8, +} +#[test] +fn bindgen_test_layout_Il2CppWin32Decimal__bindgen_ty_1__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::(), + 2usize, + concat!( + "Size of: ", + stringify!(Il2CppWin32Decimal__bindgen_ty_1__bindgen_ty_1) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 1usize, + concat!( + "Alignment of ", + stringify!(Il2CppWin32Decimal__bindgen_ty_1__bindgen_ty_1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).scale + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppWin32Decimal__bindgen_ty_1__bindgen_ty_1), + "::", + stringify!(scale) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).sign + as *const _ as usize + }, + 1usize, + concat!( + "Offset of field: ", + stringify!(Il2CppWin32Decimal__bindgen_ty_1__bindgen_ty_1), + "::", + stringify!(sign) + ) + ); +} +#[test] +fn bindgen_test_layout_Il2CppWin32Decimal__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::(), + 2usize, + concat!("Size of: ", stringify!(Il2CppWin32Decimal__bindgen_ty_1)) + ); + assert_eq!( + ::std::mem::align_of::(), + 2usize, + concat!( + "Alignment of ", + stringify!(Il2CppWin32Decimal__bindgen_ty_1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).s as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppWin32Decimal__bindgen_ty_1), + "::", + stringify!(s) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).signscale as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppWin32Decimal__bindgen_ty_1), + "::", + stringify!(signscale) + ) + ); +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union Il2CppWin32Decimal__bindgen_ty_2 { + pub s2: Il2CppWin32Decimal__bindgen_ty_2__bindgen_ty_1, + pub lo64: u64, + _bindgen_union_align: u64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppWin32Decimal__bindgen_ty_2__bindgen_ty_1 { + pub lo32: u32, + pub mid32: u32, +} +#[test] +fn bindgen_test_layout_Il2CppWin32Decimal__bindgen_ty_2__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(Il2CppWin32Decimal__bindgen_ty_2__bindgen_ty_1) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(Il2CppWin32Decimal__bindgen_ty_2__bindgen_ty_1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).lo32 + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppWin32Decimal__bindgen_ty_2__bindgen_ty_1), + "::", + stringify!(lo32) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mid32 + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppWin32Decimal__bindgen_ty_2__bindgen_ty_1), + "::", + stringify!(mid32) + ) + ); +} +#[test] +fn bindgen_test_layout_Il2CppWin32Decimal__bindgen_ty_2() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Il2CppWin32Decimal__bindgen_ty_2)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!( + "Alignment of ", + stringify!(Il2CppWin32Decimal__bindgen_ty_2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).s2 as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppWin32Decimal__bindgen_ty_2), + "::", + stringify!(s2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).lo64 as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppWin32Decimal__bindgen_ty_2), + "::", + stringify!(lo64) + ) + ); +} +#[test] +fn bindgen_test_layout_Il2CppWin32Decimal() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Il2CppWin32Decimal)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppWin32Decimal)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).reserved as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppWin32Decimal), + "::", + stringify!(reserved) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).u as *const _ as usize }, + 2usize, + concat!( + "Offset of field: ", + stringify!(Il2CppWin32Decimal), + "::", + stringify!(u) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).hi32 as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppWin32Decimal), + "::", + stringify!(hi32) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).u2 as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppWin32Decimal), + "::", + stringify!(u2) + ) + ); +} +pub type IL2CPP_VARIANT_BOOL = i16; +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; +pub type Il2CppVarType = i32; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppVariant { + pub n1: Il2CppVariant__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union Il2CppVariant__bindgen_ty_1 { + pub n2: Il2CppVariant__bindgen_ty_1___tagVARIANT, + pub decVal: Il2CppWin32Decimal, + _bindgen_union_align: [u64; 3usize], +} +#[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(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, + _bindgen_union_align: [u64; 2usize], +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1___tagBRECORD() { + assert_eq!( + ::std::mem::size_of::( + ), + 16usize, + concat!( + "Size of: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1___tagBRECORD) + ) + ); + assert_eq!( + ::std::mem::align_of::( + ), + 8usize, + concat!( + "Alignment of ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1___tagBRECORD) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::< + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1___tagBRECORD, + >())) + .pvRecord as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1___tagBRECORD), + "::", + stringify!(pvRecord) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::< + Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1___tagBRECORD, + >())) + .pRecInfo as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1___tagBRECORD), + "::", + stringify!(pRecInfo) + ) + ); +} +#[test] +fn bindgen_test_layout_Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!( + "Size of: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!( + "Alignment of ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).llVal + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(llVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).lVal + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(lVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bVal + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(bVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iVal + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(iVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .fltVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(fltVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .dblVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(dblVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .boolVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(boolVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).scode + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(scode) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).cyVal + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(cyVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).date + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(date) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .bstrVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(bstrVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .punkVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(punkVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .pdispVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(pdispVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .parray as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(parray) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).pbVal + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(pbVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).piVal + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(piVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).plVal + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(plVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .pllVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(pllVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .pfltVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(pfltVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .pdblVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(pdblVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .pboolVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(pboolVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .pscode as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(pscode) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .pcyVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(pcyVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).pdate + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(pdate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .pbstrVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(pbstrVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .ppunkVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(ppunkVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .ppdispVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(ppdispVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .pparray as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(pparray) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .pvarVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(pvarVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).byref + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(byref) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).cVal + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(cVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).uiVal + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(uiVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).ulVal + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(ulVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .ullVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(ullVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .intVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(intVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .uintVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(uintVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .pdecVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(pdecVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).pcVal + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(pcVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .puiVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(puiVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .pulVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(pulVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .pullVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(pullVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .pintVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(pintVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .puintVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(puintVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).n4 + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT__bindgen_ty_1), + "::", + stringify!(n4) + ) + ); +} +#[test] +fn bindgen_test_layout_Il2CppVariant__bindgen_ty_1___tagVARIANT() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!( + "Size of: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!( + "Alignment of ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).type_ as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT), + "::", + stringify!(type_) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).reserved1 + as *const _ as usize + }, + 2usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).reserved2 + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT), + "::", + stringify!(reserved2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).reserved3 + as *const _ as usize + }, + 6usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT), + "::", + stringify!(reserved3) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).n3 as *const _ + as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1___tagVARIANT), + "::", + stringify!(n3) + ) + ); +} +#[test] +fn bindgen_test_layout_Il2CppVariant__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(Il2CppVariant__bindgen_ty_1)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppVariant__bindgen_ty_1)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).n2 as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1), + "::", + stringify!(n2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).decVal as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant__bindgen_ty_1), + "::", + stringify!(decVal) + ) + ); +} +#[test] +fn bindgen_test_layout_Il2CppVariant() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(Il2CppVariant)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppVariant)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).n1 as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppVariant), + "::", + stringify!(n1) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppFileTime { + pub low: u32, + pub high: u32, +} +#[test] +fn bindgen_test_layout_Il2CppFileTime() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(Il2CppFileTime)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppFileTime)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).low as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppFileTime), + "::", + stringify!(low) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).high as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(Il2CppFileTime), + "::", + stringify!(high) + ) + ); +} +#[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, +} +#[test] +fn bindgen_test_layout_Il2CppStatStg() { + assert_eq!( + ::std::mem::size_of::(), + 80usize, + concat!("Size of: ", stringify!(Il2CppStatStg)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppStatStg)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).name as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStatStg), + "::", + stringify!(name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).type_ as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStatStg), + "::", + stringify!(type_) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).size as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStatStg), + "::", + stringify!(size) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mtime as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStatStg), + "::", + stringify!(mtime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).ctime as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStatStg), + "::", + stringify!(ctime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).atime as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStatStg), + "::", + stringify!(atime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mode as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStatStg), + "::", + stringify!(mode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).locks as *const _ as usize }, + 52usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStatStg), + "::", + stringify!(locks) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).clsid as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStatStg), + "::", + stringify!(clsid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).state as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStatStg), + "::", + stringify!(state) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).reserved as *const _ as usize }, + 76usize, + concat!( + "Offset of field: ", + stringify!(Il2CppStatStg), + "::", + stringify!(reserved) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppHString__ { + pub unused: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_Il2CppHString__() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(Il2CppHString__)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(Il2CppHString__)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).unused as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppHString__), + "::", + stringify!(unused) + ) + ); +} +pub type Il2CppHString = *mut Il2CppHString__; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct Il2CppHStringHeader { + pub Reserved: Il2CppHStringHeader__bindgen_ty_1, +} +#[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], + _bindgen_union_align: [u64; 3usize], +} +#[test] +fn bindgen_test_layout_Il2CppHStringHeader__bindgen_ty_1() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(Il2CppHStringHeader__bindgen_ty_1)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!( + "Alignment of ", + stringify!(Il2CppHStringHeader__bindgen_ty_1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).Reserved1 as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppHStringHeader__bindgen_ty_1), + "::", + stringify!(Reserved1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).Reserved2 as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppHStringHeader__bindgen_ty_1), + "::", + stringify!(Reserved2) + ) + ); +} +#[test] +fn bindgen_test_layout_Il2CppHStringHeader() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(Il2CppHStringHeader)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppHStringHeader)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).Reserved as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppHStringHeader), + "::", + stringify!(Reserved) + ) + ); +} +pub const Il2CppWindowsRuntimeTypeKind_kTypeKindPrimitive: Il2CppWindowsRuntimeTypeKind = 0; +pub const Il2CppWindowsRuntimeTypeKind_kTypeKindMetadata: Il2CppWindowsRuntimeTypeKind = 1; +pub const Il2CppWindowsRuntimeTypeKind_kTypeKindCustom: Il2CppWindowsRuntimeTypeKind = 2; +pub type Il2CppWindowsRuntimeTypeKind = i32; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Il2CppWindowsRuntimeTypeName { + pub typeName: Il2CppHString, + pub typeKind: Il2CppWindowsRuntimeTypeKind, +} +#[test] +fn bindgen_test_layout_Il2CppWindowsRuntimeTypeName() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Il2CppWindowsRuntimeTypeName)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Il2CppWindowsRuntimeTypeName)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).typeName as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Il2CppWindowsRuntimeTypeName), + "::", + stringify!(typeName) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).typeKind as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Il2CppWindowsRuntimeTypeName), + "::", + stringify!(typeKind) + ) + ); +} +#[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 type __builtin_va_list = *mut ::std::os::raw::c_char; From 8e3761bd49b6eec064c335e5fab5f1020041e4df Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 11 Nov 2024 18:17:24 -0400 Subject: [PATCH 07/71] Fmt and clippy --- libil2cpp/src/lib.rs | 5 ++++- libil2cpp/src/parameter_info_stub.rs | 1 - libil2cpp/src/raw/functions.rs | 2 +- 3 files changed, 5 insertions(+), 3 deletions(-) diff --git a/libil2cpp/src/lib.rs b/libil2cpp/src/lib.rs index 13271ab0..e0e5edee 100644 --- a/libil2cpp/src/lib.rs +++ b/libil2cpp/src/lib.rs @@ -97,7 +97,10 @@ mod field_info; mod method_info; mod object; -#[cfg_attr(any(feature = "unity2018", feature = "il2cpp_v24"), path = "parameter_info.rs")] +#[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; diff --git a/libil2cpp/src/parameter_info_stub.rs b/libil2cpp/src/parameter_info_stub.rs index 8eac785e..f3db914e 100644 --- a/libil2cpp/src/parameter_info_stub.rs +++ b/libil2cpp/src/parameter_info_stub.rs @@ -1,4 +1,3 @@ -use std::borrow::Cow; use std::fmt; use crate::{raw, Il2CppType, WrapRaw}; 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, From 83b2e141c6902d1777154863dd2a3f84bb90968e Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Tue, 26 Nov 2024 17:16:33 -0400 Subject: [PATCH 08/71] Add feature --- Cargo.toml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Cargo.toml b/Cargo.toml index bedd7943..62656e65 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -34,6 +34,8 @@ tracing-subscriber = { version = "0.3", features = [ [features] default = ["util", "cache"] +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"] From 078c20903fb0c23209db46b9032837ee07c913a2 Mon Sep 17 00:00:00 2001 From: Fernthedev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 2 Dec 2024 12:45:38 -0400 Subject: [PATCH 09/71] Fix version check --- .vscode/settings.json | 2 +- libil2cpp/src/lib.rs | 4 +++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index 1475a492..c45b7300 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,6 +1,6 @@ { "rust-analyzer.cargo.features": [ - "il2cpp_v24", + "il2cpp_v31", "serde" ], "rust-analyzer.imports.granularity.group": "module" diff --git a/libil2cpp/src/lib.rs b/libil2cpp/src/lib.rs index e0e5edee..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 = "il2cpp_v31", feature = "il2cpp_v24", 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")] @@ -125,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 From d99d802c80c3557093631cdd1a66395741fbf9be Mon Sep 17 00:00:00 2001 From: Fernthedev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 2 Dec 2024 12:53:02 -0400 Subject: [PATCH 10/71] Add Void type --- libil2cpp/src/method_info.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/libil2cpp/src/method_info.rs b/libil2cpp/src/method_info.rs index f9d1f090..a7f99d4e 100644 --- a/libil2cpp/src/method_info.rs +++ b/libil2cpp/src/method_info.rs @@ -24,6 +24,8 @@ pub struct MethodInfo(raw::MethodInfo); unsafe impl Send for MethodInfo {} unsafe impl Sync for MethodInfo {} +pub type Void = (); + impl MethodInfo { /// Invoke this method, type checking against its signature with the /// provided instance, arguments and return type From 63b28ffb789a8f326c4f5b5ec7574c7f1ec6a926 Mon Sep 17 00:00:00 2001 From: Fernthedev <15272073+Fernthedev@users.noreply.github.com> Date: Tue, 3 Dec 2024 11:17:21 -0400 Subject: [PATCH 11/71] Add types for cordl --- libil2cpp/src/lib.rs | 4 +--- libil2cpp/src/method_info.rs | 7 ++++--- 2 files changed, 5 insertions(+), 6 deletions(-) diff --git a/libil2cpp/src/lib.rs b/libil2cpp/src/lib.rs index 3d16b348..83141290 100644 --- a/libil2cpp/src/lib.rs +++ b/libil2cpp/src/lib.rs @@ -115,7 +115,7 @@ pub use array::Il2CppArray; pub use class::{FindMethodError, Il2CppClass}; pub use exception::Il2CppException; pub use field_info::FieldInfo; -pub use method_info::{Il2CppReflectionMethod, MethodInfo}; +pub use method_info::{Il2CppReflectionMethod, MethodInfo, Result, Void}; pub use object::{Il2CppObject, ObjectExt}; pub use parameter_info::ParameterInfo; pub use raw::{unbox, WrapRaw}; @@ -125,5 +125,3 @@ 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 a7f99d4e..0a55dd6f 100644 --- a/libil2cpp/src/method_info.rs +++ b/libil2cpp/src/method_info.rs @@ -25,6 +25,7 @@ unsafe impl Send for MethodInfo {} unsafe impl Sync for MethodInfo {} pub type Void = (); +pub type Result<'a, T> = std::result::Result; impl MethodInfo { /// Invoke this method, type checking against its signature with the @@ -33,7 +34,7 @@ impl MethodInfo { &self, this: T, args: A, - ) -> Result + ) -> Result<'_, R> where T: ThisArgument, A: Arguments, @@ -55,7 +56,7 @@ impl MethodInfo { &self, mut this: T, mut args: A, - ) -> Result + ) -> Result<'_, R> where T: ThisArgument, A: Arguments, @@ -77,7 +78,7 @@ impl MethodInfo { &self, this: *mut c_void, args: &mut [*mut c_void], - ) -> Result, &'err mut raw::Il2CppException> { + ) -> std::result::Result, &'err mut raw::Il2CppException> { let mut exception = None; let r = raw::runtime_invoke(self.raw(), this, args.as_mut_ptr(), &mut exception); match exception { From e571825447be2a7bf263cbb2b95e4cb45539a9e5 Mon Sep 17 00:00:00 2001 From: Fernthedev <15272073+Fernthedev@users.noreply.github.com> Date: Tue, 3 Dec 2024 11:17:50 -0400 Subject: [PATCH 12/71] Generics information --- proc_macros/src/impl_type.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/proc_macros/src/impl_type.rs b/proc_macros/src/impl_type.rs index f152cd87..d986cdc0 100644 --- a/proc_macros/src/impl_type.rs +++ b/proc_macros/src/impl_type.rs @@ -67,7 +67,7 @@ impl Parse for Input { if rust_generics.len() != cs_generics.len() { return Err(Error::new( Span::call_site(), - "mismatched Rust and C# generics", + format!("mismatched Rust {:?} and C# generics {:?}", rust_generics, cs_generics), )); } From fad17631f58bde15de5957d7c51592989d40a18b Mon Sep 17 00:00:00 2001 From: Fernthedev <15272073+Fernthedev@users.noreply.github.com> Date: Wed, 4 Dec 2024 16:25:30 -0400 Subject: [PATCH 13/71] Add ByRef/ByRefMut --- libil2cpp/src/lib.rs | 2 +- libil2cpp/src/object.rs | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/libil2cpp/src/lib.rs b/libil2cpp/src/lib.rs index 83141290..5147ecb3 100644 --- a/libil2cpp/src/lib.rs +++ b/libil2cpp/src/lib.rs @@ -116,7 +116,7 @@ pub use class::{FindMethodError, Il2CppClass}; pub use exception::Il2CppException; pub use field_info::FieldInfo; pub use method_info::{Il2CppReflectionMethod, MethodInfo, Result, Void}; -pub use object::{Il2CppObject, ObjectExt}; +pub use object::{Il2CppObject, ObjectExt, ByRef, ByRefMut}; pub use parameter_info::ParameterInfo; pub use raw::{unbox, WrapRaw}; pub use string::Il2CppString; diff --git a/libil2cpp/src/object.rs b/libil2cpp/src/object.rs index 5f73682b..964f4585 100644 --- a/libil2cpp/src/object.rs +++ b/libil2cpp/src/object.rs @@ -7,6 +7,9 @@ use crate::{raw, Argument, Arguments, Il2CppClass, Il2CppException, Returned, Ty #[repr(transparent)] pub struct Il2CppObject(raw::Il2CppObject); +pub type ByRefMut = *mut T; +pub type ByRef = *const T; + impl Il2CppObject { /// [`Il2CppClass`] of the object pub fn class(&self) -> &'static Il2CppClass { From 0513125e0dbc45f5be6466ee6d2da5031719e350 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Fri, 6 Dec 2024 01:20:33 -0400 Subject: [PATCH 14/71] static il2cpp exception lifetime --- libil2cpp/src/method_info.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/libil2cpp/src/method_info.rs b/libil2cpp/src/method_info.rs index 0a55dd6f..00882fb3 100644 --- a/libil2cpp/src/method_info.rs +++ b/libil2cpp/src/method_info.rs @@ -25,7 +25,7 @@ unsafe impl Send for MethodInfo {} unsafe impl Sync for MethodInfo {} pub type Void = (); -pub type Result<'a, T> = std::result::Result; +pub type Result = std::result::Result; impl MethodInfo { /// Invoke this method, type checking against its signature with the @@ -34,7 +34,7 @@ impl MethodInfo { &self, this: T, args: A, - ) -> Result<'_, R> + ) -> Result where T: ThisArgument, A: Arguments, @@ -56,7 +56,7 @@ impl MethodInfo { &self, mut this: T, mut args: A, - ) -> Result<'_, R> + ) -> Result where T: ThisArgument, A: Arguments, From 09f2ee6113a7bff1649e8790076446f6e3ea89c9 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Fri, 6 Dec 2024 22:37:28 -0400 Subject: [PATCH 15/71] Add ObjectType trait --- libil2cpp/src/lib.rs | 2 +- libil2cpp/src/object.rs | 33 ++++++++++++++++++++++++++++++++- 2 files changed, 33 insertions(+), 2 deletions(-) diff --git a/libil2cpp/src/lib.rs b/libil2cpp/src/lib.rs index 5147ecb3..2ac7dfb6 100644 --- a/libil2cpp/src/lib.rs +++ b/libil2cpp/src/lib.rs @@ -116,7 +116,7 @@ pub use class::{FindMethodError, Il2CppClass}; pub use exception::Il2CppException; pub use field_info::FieldInfo; pub use method_info::{Il2CppReflectionMethod, MethodInfo, Result, Void}; -pub use object::{Il2CppObject, ObjectExt, ByRef, ByRefMut}; +pub use object::{Il2CppObject, ObjectExt, ByRef, ByRefMut, ObjectType}; pub use parameter_info::ParameterInfo; pub use raw::{unbox, WrapRaw}; pub use string::Il2CppString; diff --git a/libil2cpp/src/object.rs b/libil2cpp/src/object.rs index 964f4585..2b4fd229 100644 --- a/libil2cpp/src/object.rs +++ b/libil2cpp/src/object.rs @@ -1,7 +1,7 @@ use std::fmt; use std::ops::DerefMut; -use crate::{raw, Argument, Arguments, Il2CppClass, Il2CppException, Returned, Type, WrapRaw}; +use crate::{raw, Argument, Arguments, Il2CppClass, Il2CppException, Returned, ThisArgument, Type, WrapRaw}; /// An il2cpp object #[repr(transparent)] @@ -116,3 +116,34 @@ where T: DerefMut, { } + + +pub trait ObjectType { + fn as_object(&self) -> &Il2CppObject; + fn as_object_mut(&mut self) -> &mut Il2CppObject; +} + +impl ObjectType for Il2CppObject { + fn as_object(&self) -> &Il2CppObject { + self + } + + fn as_object_mut(&mut self) -> &mut Il2CppObject { + self + } +} + +// implement object type for anything that can be dereferenced to Il2CppObject +impl ObjectType for T +where + for<'a> T: Type = Option<&'a mut Self>>, + T: DerefMut, +{ + fn as_object(&self) -> &Il2CppObject { + self + } + + fn as_object_mut(&mut self) -> &mut Il2CppObject { + self + } +} \ No newline at end of file From 92a6d16314dc8845b878ff6fedd57688675da590 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Fri, 6 Dec 2024 23:35:30 -0400 Subject: [PATCH 16/71] Value type extension helper --- libil2cpp/src/lib.rs | 2 ++ libil2cpp/src/raw/mod.rs | 4 +++- libil2cpp/src/valuetype.rs | 46 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 51 insertions(+), 1 deletion(-) create mode 100644 libil2cpp/src/valuetype.rs diff --git a/libil2cpp/src/lib.rs b/libil2cpp/src/lib.rs index 2ac7dfb6..aed157d7 100644 --- a/libil2cpp/src/lib.rs +++ b/libil2cpp/src/lib.rs @@ -96,6 +96,7 @@ mod exception; mod field_info; mod method_info; mod object; +mod valuetype; #[cfg_attr( any(feature = "unity2018", feature = "il2cpp_v24"), @@ -125,3 +126,4 @@ 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 use valuetype::ValueTypeExt; diff --git a/libil2cpp/src/raw/mod.rs b/libil2cpp/src/raw/mod.rs index 854f6be8..b4099dd2 100644 --- a/libil2cpp/src/raw/mod.rs +++ b/libil2cpp/src/raw/mod.rs @@ -16,6 +16,8 @@ pub use types::*; use std::mem::{size_of, transmute}; +use crate::{ThisArgument, Type}; + /// Safe wrapper around a raw il2cpp type which can be used in its place /// /// # Safety @@ -92,4 +94,4 @@ pub unsafe fn unbox(object: &Il2CppObject) -> T { let address = object as *const Il2CppObject as usize; let ptr = (address + size_of::()) as *const T; ptr.read_unaligned() -} +} \ No newline at end of file diff --git a/libil2cpp/src/valuetype.rs b/libil2cpp/src/valuetype.rs new file mode 100644 index 00000000..70809670 --- /dev/null +++ b/libil2cpp/src/valuetype.rs @@ -0,0 +1,46 @@ +use crate::{Arguments, Il2CppException, Returned, ThisArgument, Type}; + +pub trait ValueTypeExt: for<'a> Type = Self> + Sized + ThisArgument { + /// Invokes the method with the given name on `self` using the given + /// arguments, with type checking + /// + /// # Panics + /// + /// This method will panic if a matching method can't be found. + fn invoke( + &mut self, + name: &str, + args: A, + ) -> Result + where + A: Arguments, + R: Returned, + { + let method = Self::class().find_method::(name).unwrap(); + unsafe { method.invoke_unchecked(self, args) } + } + + /// Invokes the `void` method with the given name on `self` using the + /// given arguments, with type checking + /// + /// # Panics + /// + /// This method will panic if a matching method can't be found. + fn invoke_void( + &mut self, + name: &str, + args: A, + ) -> Result<(), &mut Il2CppException> + where + A: Arguments, + { + let method = Self::class().find_method::(name).unwrap(); + unsafe { method.invoke_unchecked(self, args) } + } +} +impl ValueTypeExt for T +where + T: for<'a> Type = T>, + T: ThisArgument, +{ +} From ee46f0115b8e3e97c18566f32a34e65a8ab6b7cf Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Fri, 6 Dec 2024 23:53:16 -0400 Subject: [PATCH 17/71] Move value box --- libil2cpp/src/lib.rs | 2 +- libil2cpp/src/raw/mod.rs | 7 ++++++- libil2cpp/src/valuetype.rs | 6 ++++-- 3 files changed, 11 insertions(+), 4 deletions(-) diff --git a/libil2cpp/src/lib.rs b/libil2cpp/src/lib.rs index aed157d7..9a79185c 100644 --- a/libil2cpp/src/lib.rs +++ b/libil2cpp/src/lib.rs @@ -119,7 +119,7 @@ pub use field_info::FieldInfo; pub use method_info::{Il2CppReflectionMethod, MethodInfo, Result, Void}; pub use object::{Il2CppObject, ObjectExt, ByRef, ByRefMut, ObjectType}; pub use parameter_info::ParameterInfo; -pub use raw::{unbox, WrapRaw}; +pub use raw::{unbox, value_box, WrapRaw}; pub use string::Il2CppString; pub use ty::{Builtin, Il2CppReflectionType, Il2CppType}; pub use typecheck::callee::{Parameter, Parameters, Return, ThisParameter}; diff --git a/libil2cpp/src/raw/mod.rs b/libil2cpp/src/raw/mod.rs index b4099dd2..8a1df200 100644 --- a/libil2cpp/src/raw/mod.rs +++ b/libil2cpp/src/raw/mod.rs @@ -94,4 +94,9 @@ pub unsafe fn unbox(object: &Il2CppObject) -> T { let address = object as *const Il2CppObject as usize; let ptr = (address + size_of::()) as *const T; ptr.read_unaligned() -} \ No newline at end of file +} + +#[inline] +pub unsafe fn value_box(this: &mut T) -> *mut T { + this as *mut T +} diff --git a/libil2cpp/src/valuetype.rs b/libil2cpp/src/valuetype.rs index 70809670..4db5d3cc 100644 --- a/libil2cpp/src/valuetype.rs +++ b/libil2cpp/src/valuetype.rs @@ -1,6 +1,6 @@ use crate::{Arguments, Il2CppException, Returned, ThisArgument, Type}; -pub trait ValueTypeExt: for<'a> Type = Self> + Sized + ThisArgument { +pub trait ValueTypeExt: for<'a> Type = Self> + Sized { /// Invokes the method with the given name on `self` using the given /// arguments, with type checking /// @@ -38,9 +38,11 @@ pub trait ValueTypeExt: for<'a> Type = Self> + Sized + ThisArgument { unsafe { method.invoke_unchecked(self, args) } } } + + + impl ValueTypeExt for T where T: for<'a> Type = T>, - T: ThisArgument, { } From 19175693a9e80287341cc88063bd6792f55a0e55 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Sat, 7 Dec 2024 12:29:16 -0400 Subject: [PATCH 18/71] Implement type for pointer variants --- libil2cpp/src/typecheck/ty.rs | 48 +++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) diff --git a/libil2cpp/src/typecheck/ty.rs b/libil2cpp/src/typecheck/ty.rs index f17fc4df..9f99b00f 100644 --- a/libil2cpp/src/typecheck/ty.rs +++ b/libil2cpp/src/typecheck/ty.rs @@ -63,6 +63,54 @@ pub unsafe trait Type: 'static { } } +// implement type for pointers +unsafe impl Type for *mut T { + type Held<'a> = Option<&'a mut T>; + type HeldRaw = *mut T; + + const NAMESPACE: &'static str = T::NAMESPACE; + const CLASS_NAME: &'static str = T::CLASS_NAME; + + fn matches_reference_argument(ty: &Il2CppType) -> bool { + T::matches_reference_argument(ty) + } + + fn matches_value_argument(ty: &Il2CppType) -> bool { + T::matches_value_argument(ty) + } + + fn matches_reference_parameter(ty: &Il2CppType) -> bool { + T::matches_reference_parameter(ty) + } + + fn matches_value_parameter(ty: &Il2CppType) -> bool { + T::matches_value_argument(ty) + } +} +unsafe impl Type for *const T { + type Held<'a> = Option<&'a mut T>; + type HeldRaw = *mut T; + + const NAMESPACE: &'static str = T::NAMESPACE; + const CLASS_NAME: &'static str = T::CLASS_NAME; + + fn matches_reference_argument(ty: &Il2CppType) -> bool { + T::matches_reference_argument(ty) + } + + fn matches_value_argument(ty: &Il2CppType) -> bool { + T::matches_value_argument(ty) + } + + fn matches_reference_parameter(ty: &Il2CppType) -> bool { + T::matches_reference_parameter(ty) + } + + fn matches_value_parameter(ty: &Il2CppType) -> bool { + T::matches_value_argument(ty) + } +} + crate::unsafe_impl_value_type!(in crate for u8 => System.Byte); crate::unsafe_impl_value_type!(in crate for i8 => System.SByte); crate::unsafe_impl_value_type!(in crate for u16 => System.UInt16); From 361d9cddc9768e116249fd4d3928abbd214320ed Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Sat, 7 Dec 2024 13:19:07 -0400 Subject: [PATCH 19/71] Implement traits for pointer types --- libil2cpp/src/typecheck/callee.rs | 53 +++++++++++++++++++++++++++ libil2cpp/src/typecheck/caller.rs | 60 +++++++++++++++++++++++++++++++ 2 files changed, 113 insertions(+) diff --git a/libil2cpp/src/typecheck/callee.rs b/libil2cpp/src/typecheck/callee.rs index bfa6dd48..c6ccf65e 100644 --- a/libil2cpp/src/typecheck/callee.rs +++ b/libil2cpp/src/typecheck/callee.rs @@ -103,6 +103,23 @@ where self } } +unsafe impl ThisParameter for *mut T +where + T: Type, +{ + type Actual = Self; + + fn matches(method: &MethodInfo) -> bool { + T::matches_this_parameter(method) + } + + fn from_actual(actual: Self::Actual) -> Self { + actual + } + fn into_actual(self) -> Self::Actual { + self + } +} unsafe impl ThisParameter for &mut T where @@ -156,6 +173,24 @@ where self } } +#[rustfmt::skip] +unsafe impl Parameter for *mut T +where + T: for<'a> Type = Option<&'a mut T>>, +{ + type Actual = Self; + + fn matches(ty: &Il2CppType) -> bool { + T::matches_reference_parameter(ty) + } + + fn from_actual(actual: Self::Actual) -> Self { + actual + } + fn into_actual(self) -> Self::Actual { + self + } +} // TODO: Remove this once rustfmt stops dropping generics on GATs #[rustfmt::skip] @@ -196,6 +231,24 @@ where actual } } +#[rustfmt::skip] +unsafe impl Return for *mut T +where + T: for<'a> Type = Option<&'a mut T>>, +{ + type Actual = Self; + + fn matches(ty: &Il2CppType) -> bool { + T::matches_return(ty) + } + + fn into_actual(self) -> Self::Actual { + self + } + fn from_actual(actual: Self::Actual) -> Self { + actual + } +} // TODO: Remove this once rustfmt stops dropping generics on GATs #[rustfmt::skip] diff --git a/libil2cpp/src/typecheck/caller.rs b/libil2cpp/src/typecheck/caller.rs index 8769c478..5013611c 100644 --- a/libil2cpp/src/typecheck/caller.rs +++ b/libil2cpp/src/typecheck/caller.rs @@ -102,6 +102,20 @@ where unsafe { transmute((self as *mut Self).read()) } } } +unsafe impl ThisArgument for *mut T +where + T: Type, +{ + type Type = T; + + fn matches(method: &MethodInfo) -> bool { + T::matches_this_argument(method) + } + + fn invokable(&mut self) -> *mut c_void { + unsafe { transmute((self as *mut Self).read()) } + } +} unsafe impl ThisArgument for &mut T where @@ -146,6 +160,22 @@ where unsafe { transmute((self as *mut Self).read()) } } } +// TODO: Remove this once rustfmt stops dropping generics on GATs +#[rustfmt::skip] +unsafe impl Argument for *mut T +where + T: for<'a> Type = Option<&'a mut T>>, +{ + type Type = T; + + fn matches(ty: &Il2CppType) -> bool { + T::matches_reference_argument(ty) + } + + fn invokable(&mut self) -> *mut c_void { + unsafe { transmute((self as *mut Self).read()) } + } +} // TODO: Remove this once rustfmt stops dropping generics on GATs #[rustfmt::skip] @@ -180,6 +210,21 @@ where unsafe { transmute(object) } } } +#[rustfmt::skip] +unsafe impl Returned for *mut T +where + T: for<'a> Type = Option<&'a mut T>>, +{ + type Type = T; + + fn matches(ty: &Il2CppType) -> bool { + T::matches_returned(ty) + } + + fn from_object(object: Option<&mut Il2CppObject>) -> Self { + unsafe { transmute(object) } + } +} // TODO: Remove this once rustfmt stops dropping generics on GATs #[rustfmt::skip] @@ -197,6 +242,21 @@ where unsafe { transmute(object) } } } +#[rustfmt::skip] +unsafe impl Returned for *const T +where + T: for<'a> Type = Option<&'a mut T>>, +{ + type Type = T; + + fn matches(ty: &Il2CppType) -> bool { + T::matches_returned(ty) + } + + fn from_object(object: Option<&mut Il2CppObject>) -> Self { + unsafe { transmute(object) } + } +} // TODO: Remove this once rustfmt stops dropping generics on GATs #[rustfmt::skip] From e6e35886c6d34732e18b93fa942886be7cd7fc32 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Sat, 7 Dec 2024 13:39:09 -0400 Subject: [PATCH 20/71] Add static lifetime --- libil2cpp/src/object.rs | 4 ++-- libil2cpp/src/valuetype.rs | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/libil2cpp/src/object.rs b/libil2cpp/src/object.rs index 2b4fd229..68ba2d77 100644 --- a/libil2cpp/src/object.rs +++ b/libil2cpp/src/object.rs @@ -26,7 +26,7 @@ impl Il2CppObject { &mut self, name: &str, args: A, - ) -> Result + ) -> Result where A: Arguments, R: Returned, @@ -45,7 +45,7 @@ impl Il2CppObject { &mut self, name: &str, args: A, - ) -> Result<(), &mut Il2CppException> + ) -> Result<(), &'static mut Il2CppException> where A: Arguments, { diff --git a/libil2cpp/src/valuetype.rs b/libil2cpp/src/valuetype.rs index 4db5d3cc..606c1d24 100644 --- a/libil2cpp/src/valuetype.rs +++ b/libil2cpp/src/valuetype.rs @@ -11,7 +11,7 @@ pub trait ValueTypeExt: for<'a> Type = Self> + Sized { &mut self, name: &str, args: A, - ) -> Result + ) -> Result where A: Arguments, R: Returned, @@ -30,7 +30,7 @@ pub trait ValueTypeExt: for<'a> Type = Self> + Sized { &mut self, name: &str, args: A, - ) -> Result<(), &mut Il2CppException> + ) -> Result<(), &'static mut Il2CppException> where A: Arguments, { From 7e2afd6fe32405e1da8b7d50101c018c902af36a Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Sat, 7 Dec 2024 17:13:05 -0400 Subject: [PATCH 21/71] ObjectType implementation for pointer type --- libil2cpp/src/object.rs | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/libil2cpp/src/object.rs b/libil2cpp/src/object.rs index 68ba2d77..df2bde67 100644 --- a/libil2cpp/src/object.rs +++ b/libil2cpp/src/object.rs @@ -1,7 +1,9 @@ use std::fmt; use std::ops::DerefMut; -use crate::{raw, Argument, Arguments, Il2CppClass, Il2CppException, Returned, ThisArgument, Type, WrapRaw}; +use crate::{ + raw, Argument, Arguments, Il2CppClass, Il2CppException, Returned, ThisArgument, Type, WrapRaw, +}; /// An il2cpp object #[repr(transparent)] @@ -117,7 +119,6 @@ where { } - pub trait ObjectType { fn as_object(&self) -> &Il2CppObject; fn as_object_mut(&mut self) -> &mut Il2CppObject; @@ -146,4 +147,16 @@ where fn as_object_mut(&mut self) -> &mut Il2CppObject { self } -} \ No newline at end of file +} +impl ObjectType for *mut T +where + T: ObjectType, +{ + fn as_object(&self) -> &Il2CppObject { + unsafe { self.as_ref().unwrap().as_object() } + } + + fn as_object_mut(&mut self) -> &mut Il2CppObject { + unsafe { self.as_mut().unwrap().as_object_mut() } + } +} From 2773c1f260c864141906b7cb2387fcf92b0936a7 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Sat, 7 Dec 2024 19:43:11 -0400 Subject: [PATCH 22/71] Remove conflicting trait impl --- libil2cpp/src/object.rs | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/libil2cpp/src/object.rs b/libil2cpp/src/object.rs index df2bde67..0be4e860 100644 --- a/libil2cpp/src/object.rs +++ b/libil2cpp/src/object.rs @@ -135,19 +135,6 @@ impl ObjectType for Il2CppObject { } // implement object type for anything that can be dereferenced to Il2CppObject -impl ObjectType for T -where - for<'a> T: Type = Option<&'a mut Self>>, - T: DerefMut, -{ - fn as_object(&self) -> &Il2CppObject { - self - } - - fn as_object_mut(&mut self) -> &mut Il2CppObject { - self - } -} impl ObjectType for *mut T where T: ObjectType, From a3ea98a1fd75ae4a5bc8da20ecf26e3d1c3a6f17 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Sat, 7 Dec 2024 20:08:31 -0400 Subject: [PATCH 23/71] add type impl for char --- libil2cpp/src/typecheck/ty.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/libil2cpp/src/typecheck/ty.rs b/libil2cpp/src/typecheck/ty.rs index 9f99b00f..a0e7226b 100644 --- a/libil2cpp/src/typecheck/ty.rs +++ b/libil2cpp/src/typecheck/ty.rs @@ -124,6 +124,7 @@ crate::unsafe_impl_value_type!(in crate for isize => System.IntPtr); crate::unsafe_impl_value_type!(in crate for f32 => System.Single); crate::unsafe_impl_value_type!(in crate for f64 => System.Double); crate::unsafe_impl_value_type!(in crate for bool => System.Boolean); +crate::unsafe_impl_value_type!(in crate for char => System.Char); crate::unsafe_impl_reference_type!(in crate for Il2CppObject => System.Object); crate::unsafe_impl_reference_type!(in crate for Il2CppString => System.String); From f4cec343087dd7afb7761b327606597aebd6d879 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Sat, 7 Dec 2024 20:13:55 -0400 Subject: [PATCH 24/71] ByRef ignorance --- libil2cpp/src/object.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libil2cpp/src/object.rs b/libil2cpp/src/object.rs index 0be4e860..4c8399e0 100644 --- a/libil2cpp/src/object.rs +++ b/libil2cpp/src/object.rs @@ -9,8 +9,8 @@ use crate::{ #[repr(transparent)] pub struct Il2CppObject(raw::Il2CppObject); -pub type ByRefMut = *mut T; -pub type ByRef = *const T; +pub type ByRefMut = T; // TODO: *mut T; +pub type ByRef = T;// TODO: *const T; impl Il2CppObject { /// [`Il2CppClass`] of the object From d7620c5b5bf6825f3ccb1208239ca24b781f8fc1 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Sun, 8 Dec 2024 19:49:09 -0400 Subject: [PATCH 25/71] Increase maximum parameter count --- libil2cpp/src/typecheck/mod.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libil2cpp/src/typecheck/mod.rs b/libil2cpp/src/typecheck/mod.rs index 1badd089..8db8efd8 100644 --- a/libil2cpp/src/typecheck/mod.rs +++ b/libil2cpp/src/typecheck/mod.rs @@ -10,5 +10,5 @@ use crate::{ Type, WrapRaw, }; -quest_hook_proc_macros::impl_arguments_parameters!(1..=16); -quest_hook_proc_macros::impl_generics!(1..=16); +quest_hook_proc_macros::impl_arguments_parameters!(1..=32); +quest_hook_proc_macros::impl_generics!(1..=32); From 6750adc3e268fc007ac0cfb1b7999a1eb032bda9 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Sun, 8 Dec 2024 22:42:58 -0400 Subject: [PATCH 26/71] Add Gc/GcType for reference types --- libil2cpp/src/gc.rs | 108 +++++++++++++++++++++++++++++++++++++++++++ libil2cpp/src/lib.rs | 3 ++ 2 files changed, 111 insertions(+) create mode 100644 libil2cpp/src/gc.rs diff --git a/libil2cpp/src/gc.rs b/libil2cpp/src/gc.rs new file mode 100644 index 00000000..c63c3525 --- /dev/null +++ b/libil2cpp/src/gc.rs @@ -0,0 +1,108 @@ +use std::ops::{Deref, DerefMut}; + +use crate::{Argument, Returned, ThisArgument, Type}; + +#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct Gc(*mut T) +where + T: GcType; + +pub trait GcType = Type + Returned + ThisArgument + Argument; + +impl Gc { + /// Creates a new `Gc` instance with the given pointer. + pub fn new(ptr: *mut T) -> Self { + Self(ptr) + } + + /// Creates a new `Gc` instance with a null pointer. + pub fn null() -> Self { + Self::default() + } + + /// Checks if the pointer is null. + pub fn is_null(&self) -> bool { + self.0.is_null() + } +} + +impl Default for Gc { + fn default() -> Self { + Self(std::ptr::null_mut()) + } +} + +impl Deref for Gc { + type Target = T; + + fn deref(&self) -> &Self::Target { + if self.is_null() { + panic!( + "Attempted to dereference a null type {}::{}", + T::NAMESPACE, + T::CLASS_NAME + ); + } + unsafe { &*self.0 } + } +} +impl DerefMut for Gc { + fn deref_mut(&mut self) -> &mut Self::Target { + if self.is_null() { + panic!( + "Attempted to dereference a null type {}::{}", + T::NAMESPACE, + T::CLASS_NAME + ); + } + unsafe { &mut *self.0 } + } +} + +impl From<*mut T> for Gc { + fn from(ptr: *mut T) -> Self { + Self(ptr) + } +} +impl From<&mut T> for Gc { + fn from(ptr: &mut T) -> Self { + Self(ptr) + } +} +impl From> for Gc { + fn from(ptr: Option<&mut T>) -> Self { + match ptr { + Some(ptr) => Self(ptr), + None => Self::null(), + } + } +} + +unsafe impl Type for Gc +where + T: Type, +{ + type Held<'a> = Option<&'a mut Self>; + + type HeldRaw = *mut T; + + const NAMESPACE: &'static str = T::NAMESPACE; + + const CLASS_NAME: &'static str = T::CLASS_NAME; + + fn matches_reference_argument(ty: &crate::Il2CppType) -> bool { + T::matches_reference_argument(ty) + } + + fn matches_value_argument(ty: &crate::Il2CppType) -> bool { + T::matches_value_argument(ty) + } + + fn matches_reference_parameter(ty: &crate::Il2CppType) -> bool { + T::matches_reference_parameter(ty) + } + + fn matches_value_parameter(ty: &crate::Il2CppType) -> bool { + T::matches_value_parameter(ty) + } +} diff --git a/libil2cpp/src/lib.rs b/libil2cpp/src/lib.rs index 9a79185c..eeed7790 100644 --- a/libil2cpp/src/lib.rs +++ b/libil2cpp/src/lib.rs @@ -1,4 +1,5 @@ #![feature(once_cell, generic_associated_types, never_type)] +#![feature(trait_alias)] #![doc(html_root_url = "https://stackdoubleflow.github.io/quest-hook-rs/libil2cpp")] #![warn( clippy::all, @@ -97,6 +98,7 @@ mod field_info; mod method_info; mod object; mod valuetype; +mod gc; #[cfg_attr( any(feature = "unity2018", feature = "il2cpp_v24"), @@ -127,3 +129,4 @@ pub use typecheck::caller::{Argument, Arguments, Returned, ThisArgument}; pub use typecheck::generic::Generics; pub use typecheck::ty::Type; pub use valuetype::ValueTypeExt; +pub use gc::{Gc, GcType}; From 12acbcecc474df94569170a79ca88afbb9ebae7b Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Sun, 8 Dec 2024 22:57:17 -0400 Subject: [PATCH 27/71] Manually implement traits --- libil2cpp/src/gc.rs | 74 +++++++++++++++++++++++++++------------------ 1 file changed, 44 insertions(+), 30 deletions(-) diff --git a/libil2cpp/src/gc.rs b/libil2cpp/src/gc.rs index c63c3525..5c3411ba 100644 --- a/libil2cpp/src/gc.rs +++ b/libil2cpp/src/gc.rs @@ -1,8 +1,8 @@ +use std::hash::Hash; use std::ops::{Deref, DerefMut}; use crate::{Argument, Returned, ThisArgument, Type}; -#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct Gc(*mut T) where T: GcType; @@ -26,6 +26,49 @@ impl Gc { } } +unsafe impl Type for Gc +where + T: Type, +{ + type Held<'a> = Option<&'a mut Self>; + + type HeldRaw = *mut T; + + const NAMESPACE: &'static str = T::NAMESPACE; + + const CLASS_NAME: &'static str = T::CLASS_NAME; + + fn matches_reference_argument(ty: &crate::Il2CppType) -> bool { + T::matches_reference_argument(ty) + } + + fn matches_value_argument(ty: &crate::Il2CppType) -> bool { + T::matches_value_argument(ty) + } + + fn matches_reference_parameter(ty: &crate::Il2CppType) -> bool { + T::matches_reference_parameter(ty) + } + + fn matches_value_parameter(ty: &crate::Il2CppType) -> bool { + T::matches_value_parameter(ty) + } +} + +impl PartialEq for Gc { + fn eq(&self, other: &Self) -> bool { + self.0 == other.0 + } +} +impl Eq for Gc {} + +impl Clone for Gc { + fn clone(&self) -> Self { + *self + } +} +impl Copy for Gc {} + impl Default for Gc { fn default() -> Self { Self(std::ptr::null_mut()) @@ -77,32 +120,3 @@ impl From> for Gc { } } } - -unsafe impl Type for Gc -where - T: Type, -{ - type Held<'a> = Option<&'a mut Self>; - - type HeldRaw = *mut T; - - const NAMESPACE: &'static str = T::NAMESPACE; - - const CLASS_NAME: &'static str = T::CLASS_NAME; - - fn matches_reference_argument(ty: &crate::Il2CppType) -> bool { - T::matches_reference_argument(ty) - } - - fn matches_value_argument(ty: &crate::Il2CppType) -> bool { - T::matches_value_argument(ty) - } - - fn matches_reference_parameter(ty: &crate::Il2CppType) -> bool { - T::matches_reference_parameter(ty) - } - - fn matches_value_parameter(ty: &crate::Il2CppType) -> bool { - T::matches_value_parameter(ty) - } -} From da58e65d0b53bbcc958c5c70c16cd8cbf9444573 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 9 Dec 2024 00:03:50 -0400 Subject: [PATCH 28/71] More GC type shenanigans --- libil2cpp/src/gc.rs | 21 +++++++++++-- libil2cpp/src/typecheck/caller.rs | 49 ++++++++++++++++++++++++++++++- 2 files changed, 67 insertions(+), 3 deletions(-) diff --git a/libil2cpp/src/gc.rs b/libil2cpp/src/gc.rs index 5c3411ba..c7420a77 100644 --- a/libil2cpp/src/gc.rs +++ b/libil2cpp/src/gc.rs @@ -1,5 +1,4 @@ -use std::hash::Hash; -use std::ops::{Deref, DerefMut}; +use std::ops::{Deref, DerefMut, Not}; use crate::{Argument, Returned, ThisArgument, Type}; @@ -24,6 +23,13 @@ impl Gc { pub fn is_null(&self) -> bool { self.0.is_null() } + + pub fn as_opt(&self) -> Option<&T> { + self.is_null().not().then(|| unsafe { &*self.0 }) + } + pub fn as_opt_mut(&mut self) -> Option<&mut T> { + self.is_null().not().then(|| unsafe { &mut *self.0 }) + } } unsafe impl Type for Gc @@ -55,6 +61,17 @@ where } } +impl From> for Option<&T> { + fn from(value: Gc) -> Self { + value.is_null().not().then(|| unsafe { &*value.0 }) + } +} +impl From> for Option<&mut T> { + fn from(value: Gc) -> Self { + value.is_null().not().then(|| unsafe { &mut *value.0 }) + } +} + impl PartialEq for Gc { fn eq(&self, other: &Self) -> bool { self.0 == other.0 diff --git a/libil2cpp/src/typecheck/caller.rs b/libil2cpp/src/typecheck/caller.rs index 5013611c..79e9eb28 100644 --- a/libil2cpp/src/typecheck/caller.rs +++ b/libil2cpp/src/typecheck/caller.rs @@ -3,7 +3,7 @@ use std::ffi::c_void; use std::mem::transmute; use std::ptr::null_mut; -use crate::{Builtin, Il2CppObject, Il2CppType, MethodInfo, Type}; +use crate::{Builtin, Gc, GcType, Il2CppObject, Il2CppType, MethodInfo, Type}; /// Trait implemented by types that can be used as a C# `this` arguments /// @@ -116,6 +116,20 @@ where unsafe { transmute((self as *mut Self).read()) } } } +unsafe impl ThisArgument for Gc +where + T: GcType, +{ + type Type = T; + + fn matches(method: &MethodInfo) -> bool { + T::matches_this_argument(method) + } + + fn invokable(&mut self) -> *mut c_void { + unsafe { transmute((self as *mut Self).read()) } + } +} unsafe impl ThisArgument for &mut T where @@ -194,6 +208,24 @@ where } } +#[rustfmt::skip] +unsafe impl Argument for Gc +where T: GcType, + T: for<'a> Type = Option<&'a mut T>>, +{ + type Type = ::Type; + + fn matches(ty: &Il2CppType) -> bool { + T::matches_returned(ty) + } + + fn invokable(&mut self) -> *mut c_void { + unsafe { transmute((self as *mut Self).read()) } + + } + +} + // TODO: Remove this once rustfmt stops dropping generics on GATs #[rustfmt::skip] unsafe impl Returned for Option<&mut T> @@ -211,6 +243,21 @@ where } } #[rustfmt::skip] +unsafe impl Returned for Gc +where T: GcType, + T: for<'a> Type = Option<&'a mut T>>, +{ + type Type = T; + + fn matches(ty: &Il2CppType) -> bool { + T::matches_returned(ty) + } + + fn from_object(object: Option<&mut Il2CppObject>) -> Self { + unsafe { transmute(object) } + } +} +#[rustfmt::skip] unsafe impl Returned for *mut T where T: for<'a> Type = Option<&'a mut T>>, From d62dd8c2b129d8b67ade7205315b79b681f92dcb Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 9 Dec 2024 00:35:57 -0400 Subject: [PATCH 29/71] aDD bounds --- libil2cpp/src/typecheck/caller.rs | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/libil2cpp/src/typecheck/caller.rs b/libil2cpp/src/typecheck/caller.rs index 79e9eb28..24f704fd 100644 --- a/libil2cpp/src/typecheck/caller.rs +++ b/libil2cpp/src/typecheck/caller.rs @@ -116,9 +116,10 @@ where unsafe { transmute((self as *mut Self).read()) } } } -unsafe impl ThisArgument for Gc +unsafe impl ThisArgument for Gc where T: GcType, + T: for<'a> Type = Option<&'a mut T>>, { type Type = T; @@ -212,8 +213,9 @@ where unsafe impl Argument for Gc where T: GcType, T: for<'a> Type = Option<&'a mut T>>, + { - type Type = ::Type; + type Type = T; fn matches(ty: &Il2CppType) -> bool { T::matches_returned(ty) @@ -246,6 +248,7 @@ where unsafe impl Returned for Gc where T: GcType, T: for<'a> Type = Option<&'a mut T>>, + { type Type = T; @@ -261,6 +264,8 @@ where T: GcType, unsafe impl Returned for *mut T where T: for<'a> Type = Option<&'a mut T>>, + T: for<'a> Type = Option<&'a mut T>>, + { type Type = T; From 9faeae162708e5c95426a47103b00354c04c9ddf Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 9 Dec 2024 00:58:52 -0400 Subject: [PATCH 30/71] Fix Held type --- libil2cpp/src/gc.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libil2cpp/src/gc.rs b/libil2cpp/src/gc.rs index c7420a77..2466066f 100644 --- a/libil2cpp/src/gc.rs +++ b/libil2cpp/src/gc.rs @@ -36,7 +36,7 @@ unsafe impl Type for Gc where T: Type, { - type Held<'a> = Option<&'a mut Self>; + type Held<'a> = Option<&'a mut T>; type HeldRaw = *mut T; From 95aa66c8e5405b59df0510f007ec5e5a65f3874c Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 9 Dec 2024 01:10:06 -0400 Subject: [PATCH 31/71] Fix generic bounds check for Gc --- libil2cpp/src/gc.rs | 88 +++++++++++++++++++++++++------ libil2cpp/src/typecheck/caller.rs | 52 +----------------- 2 files changed, 73 insertions(+), 67 deletions(-) diff --git a/libil2cpp/src/gc.rs b/libil2cpp/src/gc.rs index 2466066f..3791beb2 100644 --- a/libil2cpp/src/gc.rs +++ b/libil2cpp/src/gc.rs @@ -4,11 +4,16 @@ use crate::{Argument, Returned, ThisArgument, Type}; pub struct Gc(*mut T) where - T: GcType; + *mut T: GcType, // assert that *mut T is a GcType + T: for<'a> Type = Option<&'a mut T>>; pub trait GcType = Type + Returned + ThisArgument + Argument; -impl Gc { +impl Gc +where + *mut T: GcType, + T: for<'a> Type = Option<&'a mut T>>, +{ /// Creates a new `Gc` instance with the given pointer. pub fn new(ptr: *mut T) -> Self { Self(ptr) @@ -32,9 +37,10 @@ impl Gc { } } -unsafe impl Type for Gc +unsafe impl Type for Gc where - T: Type, + *mut T: GcType, + T: for<'a> Type = Option<&'a mut T>>, { type Held<'a> = Option<&'a mut T>; @@ -61,38 +67,72 @@ where } } -impl From> for Option<&T> { +impl From> for Option<&T> +where + *mut T: GcType, + T: for<'a> Type = Option<&'a mut T>>, +{ fn from(value: Gc) -> Self { value.is_null().not().then(|| unsafe { &*value.0 }) } } -impl From> for Option<&mut T> { +impl From> for Option<&mut T> +where + *mut T: GcType, + T: for<'a> Type = Option<&'a mut T>>, +{ fn from(value: Gc) -> Self { value.is_null().not().then(|| unsafe { &mut *value.0 }) } } -impl PartialEq for Gc { +impl PartialEq for Gc +where + *mut T: GcType, + T: for<'a> Type = Option<&'a mut T>>, +{ fn eq(&self, other: &Self) -> bool { self.0 == other.0 } } -impl Eq for Gc {} +impl Eq for Gc +where + *mut T: GcType, + T: for<'a> Type = Option<&'a mut T>>, +{ +} -impl Clone for Gc { +impl Clone for Gc +where + *mut T: GcType, + T: for<'a> Type = Option<&'a mut T>>, +{ fn clone(&self) -> Self { *self } } -impl Copy for Gc {} +impl Copy for Gc +where + *mut T: GcType, + T: for<'a> Type = Option<&'a mut T>>, +{ +} -impl Default for Gc { +impl Default for Gc +where + *mut T: GcType, + T: for<'a> Type = Option<&'a mut T>>, +{ fn default() -> Self { Self(std::ptr::null_mut()) } } -impl Deref for Gc { +impl Deref for Gc +where + *mut T: GcType, + T: for<'a> Type = Option<&'a mut T>>, +{ type Target = T; fn deref(&self) -> &Self::Target { @@ -106,7 +146,11 @@ impl Deref for Gc { unsafe { &*self.0 } } } -impl DerefMut for Gc { +impl DerefMut for Gc +where + *mut T: GcType, + T: for<'a> Type = Option<&'a mut T>>, +{ fn deref_mut(&mut self) -> &mut Self::Target { if self.is_null() { panic!( @@ -119,17 +163,29 @@ impl DerefMut for Gc { } } -impl From<*mut T> for Gc { +impl From<*mut T> for Gc +where + *mut T: GcType, + T: for<'a> Type = Option<&'a mut T>>, +{ fn from(ptr: *mut T) -> Self { Self(ptr) } } -impl From<&mut T> for Gc { +impl From<&mut T> for Gc +where + *mut T: GcType, + T: for<'a> Type = Option<&'a mut T>>, +{ fn from(ptr: &mut T) -> Self { Self(ptr) } } -impl From> for Gc { +impl From> for Gc +where + *mut T: GcType, + T: for<'a> Type = Option<&'a mut T>>, +{ fn from(ptr: Option<&mut T>) -> Self { match ptr { Some(ptr) => Self(ptr), diff --git a/libil2cpp/src/typecheck/caller.rs b/libil2cpp/src/typecheck/caller.rs index 24f704fd..f4e04688 100644 --- a/libil2cpp/src/typecheck/caller.rs +++ b/libil2cpp/src/typecheck/caller.rs @@ -3,7 +3,7 @@ use std::ffi::c_void; use std::mem::transmute; use std::ptr::null_mut; -use crate::{Builtin, Gc, GcType, Il2CppObject, Il2CppType, MethodInfo, Type}; +use crate::{Builtin, Il2CppObject, Il2CppType, MethodInfo, Type}; /// Trait implemented by types that can be used as a C# `this` arguments /// @@ -116,21 +116,6 @@ where unsafe { transmute((self as *mut Self).read()) } } } -unsafe impl ThisArgument for Gc -where - T: GcType, - T: for<'a> Type = Option<&'a mut T>>, -{ - type Type = T; - - fn matches(method: &MethodInfo) -> bool { - T::matches_this_argument(method) - } - - fn invokable(&mut self) -> *mut c_void { - unsafe { transmute((self as *mut Self).read()) } - } -} unsafe impl ThisArgument for &mut T where @@ -209,25 +194,6 @@ where } } -#[rustfmt::skip] -unsafe impl Argument for Gc -where T: GcType, - T: for<'a> Type = Option<&'a mut T>>, - -{ - type Type = T; - - fn matches(ty: &Il2CppType) -> bool { - T::matches_returned(ty) - } - - fn invokable(&mut self) -> *mut c_void { - unsafe { transmute((self as *mut Self).read()) } - - } - -} - // TODO: Remove this once rustfmt stops dropping generics on GATs #[rustfmt::skip] unsafe impl Returned for Option<&mut T> @@ -244,27 +210,11 @@ where unsafe { transmute(object) } } } -#[rustfmt::skip] -unsafe impl Returned for Gc -where T: GcType, - T: for<'a> Type = Option<&'a mut T>>, -{ - type Type = T; - - fn matches(ty: &Il2CppType) -> bool { - T::matches_returned(ty) - } - - fn from_object(object: Option<&mut Il2CppObject>) -> Self { - unsafe { transmute(object) } - } -} #[rustfmt::skip] unsafe impl Returned for *mut T where T: for<'a> Type = Option<&'a mut T>>, - T: for<'a> Type = Option<&'a mut T>>, { type Type = T; From e1705dca2c6b3a2c9c998d0c12271434f3c743bd Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 9 Dec 2024 01:11:04 -0400 Subject: [PATCH 32/71] Fix generic bounds check in `caller` --- libil2cpp/src/typecheck/caller.rs | 51 ++++++++++++++++++++++++++++++- 1 file changed, 50 insertions(+), 1 deletion(-) diff --git a/libil2cpp/src/typecheck/caller.rs b/libil2cpp/src/typecheck/caller.rs index f4e04688..c3a1dc27 100644 --- a/libil2cpp/src/typecheck/caller.rs +++ b/libil2cpp/src/typecheck/caller.rs @@ -3,7 +3,7 @@ use std::ffi::c_void; use std::mem::transmute; use std::ptr::null_mut; -use crate::{Builtin, Il2CppObject, Il2CppType, MethodInfo, Type}; +use crate::{Builtin, Gc, GcType, Il2CppObject, Il2CppType, MethodInfo, Type}; /// Trait implemented by types that can be used as a C# `this` arguments /// @@ -116,6 +116,21 @@ where unsafe { transmute((self as *mut Self).read()) } } } +unsafe impl ThisArgument for Gc +where + *mut T: GcType, + T: for<'a> Type = Option<&'a mut T>>, +{ + type Type = T; + + fn matches(method: &MethodInfo) -> bool { + T::matches_this_argument(method) + } + + fn invokable(&mut self) -> *mut c_void { + unsafe { transmute((self as *mut Self).read()) } + } +} unsafe impl ThisArgument for &mut T where @@ -194,6 +209,26 @@ where } } +#[rustfmt::skip] +unsafe impl Argument for Gc +where + *mut T: GcType, + T: for<'a> Type = Option<&'a mut T>>, + +{ + type Type = T; + + fn matches(ty: &Il2CppType) -> bool { + T::matches_returned(ty) + } + + fn invokable(&mut self) -> *mut c_void { + unsafe { transmute((self as *mut Self).read()) } + + } + +} + // TODO: Remove this once rustfmt stops dropping generics on GATs #[rustfmt::skip] unsafe impl Returned for Option<&mut T> @@ -210,7 +245,21 @@ where unsafe { transmute(object) } } } +#[rustfmt::skip] +unsafe impl Returned for Gc +where *mut T: GcType, + T: for<'a> Type = Option<&'a mut T>>, +{ + type Type = T; + + fn matches(ty: &Il2CppType) -> bool { + T::matches_returned(ty) + } + fn from_object(object: Option<&mut Il2CppObject>) -> Self { + unsafe { transmute(object) } + } +} #[rustfmt::skip] unsafe impl Returned for *mut T where From 6b96da1fc2621e5edcd66fd63464e063fbc05a79 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 9 Dec 2024 19:22:23 -0400 Subject: [PATCH 33/71] Implement debug for `Gc` --- libil2cpp/src/gc.rs | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/libil2cpp/src/gc.rs b/libil2cpp/src/gc.rs index 3791beb2..9252b937 100644 --- a/libil2cpp/src/gc.rs +++ b/libil2cpp/src/gc.rs @@ -1,3 +1,4 @@ +use std::fmt::{self, Debug, Formatter}; use std::ops::{Deref, DerefMut, Not}; use crate::{Argument, Returned, ThisArgument, Type}; @@ -193,3 +194,17 @@ where } } } + +impl Debug for Gc +where + *mut T: GcType, + T: for<'a> Type = Option<&'a mut T>>, +{ + fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { + if self.is_null() { + write!(f, "Gc<{}>::null()", T::CLASS_NAME) + } else { + write!(f, "Gc<{}>({:p})", T::CLASS_NAME, self.0) + } + } +} From f72a2d10a07a373f05baac4a6ef6f034111ea385 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 9 Dec 2024 22:07:57 -0400 Subject: [PATCH 34/71] Use GC for return types --- libil2cpp/src/array.rs | 18 ++++++----- libil2cpp/src/gc.rs | 70 +++++++++++++++++++++++++++++++++++++++++ libil2cpp/src/object.rs | 9 +++--- libil2cpp/src/string.rs | 31 +++++++++--------- 4 files changed, 102 insertions(+), 26 deletions(-) diff --git a/libil2cpp/src/array.rs b/libil2cpp/src/array.rs index f9c2f5d3..8954fc6d 100644 --- a/libil2cpp/src/array.rs +++ b/libil2cpp/src/array.rs @@ -3,7 +3,7 @@ use std::mem::transmute; use std::ops::{Deref, DerefMut}; use std::{fmt, ptr, slice}; -use crate::{raw, Il2CppClass, Il2CppObject, Type, WrapRaw}; +use crate::{raw, Gc, Il2CppClass, Il2CppObject, Type, WrapRaw}; /// An il2cpp array #[repr(transparent)] @@ -11,7 +11,7 @@ pub struct Il2CppArray(raw::Il2CppArray, PhantomData<[T]>); impl Il2CppArray { /// Creates an array from an iterator - pub fn new<'a, I>(items: I) -> &'a mut Self + pub fn new<'a, I>(items: I) -> Gc where I: IntoIterator>, I::IntoIter: ExactSizeIterator>, @@ -27,7 +27,7 @@ impl Il2CppArray { ptr::write_unaligned(ptr, elem); } } - unsafe { Self::wrap_mut(arr) } + unsafe { Self::wrap_mut(arr).into() } } /// Slice of values in the array @@ -122,18 +122,20 @@ impl DerefMut for Il2CppArray { #[cfg(feature = "serde")] mod serde { + use crate::Gc; + use super::{fmt, ptr, raw, Il2CppArray, PhantomData, Type, WrapRaw}; use serde::de::{Deserialize, Deserializer, SeqAccess, Visitor}; use serde::ser::{Serialize, Serializer}; - struct ArrayVisitor(PhantomData>); + struct ArrayVisitor(PhantomData>>); impl<'de, T: Type> ArrayVisitor where T::Held<'de>: Deserialize<'de>, { - fn visit_self(mut seq: A, len: usize) -> Result<&'de mut Il2CppArray, A::Error> + fn visit_self(mut seq: A, len: usize) -> Result>, A::Error> where A: SeqAccess<'de>, { @@ -146,7 +148,7 @@ mod serde { ptr::write_unaligned(ptr, seq.next_element()?.unwrap()); } } - Ok(unsafe { Il2CppArray::wrap_mut(arr) }) + Ok(unsafe { Il2CppArray::wrap_mut(arr).into() }) } fn visit_vec(mut seq: A) -> Result>, A::Error> @@ -165,7 +167,7 @@ mod serde { where T::Held<'de>: Deserialize<'de>, { - type Value = &'de mut Il2CppArray; + type Value = Gc>; fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { formatter.write_str("an array of C# compatible values") @@ -182,7 +184,7 @@ mod serde { } } - impl<'de, T: Type> Deserialize<'de> for &'de mut Il2CppArray + impl<'de, T: Type> Deserialize<'de> for Gc> where T::Held<'de>: Deserialize<'de>, { diff --git a/libil2cpp/src/gc.rs b/libil2cpp/src/gc.rs index 9252b937..c76de6a7 100644 --- a/libil2cpp/src/gc.rs +++ b/libil2cpp/src/gc.rs @@ -3,6 +3,8 @@ use std::ops::{Deref, DerefMut, Not}; use crate::{Argument, Returned, ThisArgument, Type}; +// Wrapper type which implies the type is GC managed lifetime +#[repr(transparent)] pub struct Gc(*mut T) where *mut T: GcType, // assert that *mut T is a GcType @@ -36,6 +38,15 @@ where pub fn as_opt_mut(&mut self) -> Option<&mut T> { self.is_null().not().then(|| unsafe { &mut *self.0 }) } + + pub fn get_pointer(&self) -> *const T { + self.0 + } + pub fn get_pointer_mut(&mut self) -> *mut T { + self.0 + } + + } unsafe impl Type for Gc @@ -164,6 +175,25 @@ where } } +impl AsRef for Gc +where + *mut T: GcType, + T: for<'a> Type = Option<&'a mut T>>, +{ + fn as_ref(&self) -> &T { + self + } +} +impl AsMut for Gc +where + *mut T: GcType, + T: for<'a> Type = Option<&'a mut T>>, +{ + fn as_mut(&mut self) -> &mut T { + self + } +} + impl From<*mut T> for Gc where *mut T: GcType, @@ -208,3 +238,43 @@ where } } } + +#[cfg(feature = "serde")] +mod serde { + + use serde::de::{Deserialize, Deserializer}; + use serde::ser::{Serialize, Serializer}; + + use crate::Type; + + use super::{Gc, GcType}; + + impl<'de, T> Deserialize<'de> for Gc + where + *mut T: GcType, + T: for<'a> Type = Option<&'a mut T>>, + for<'a> &'a mut T: Deserialize<'de>, + { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let result = as Deserialize>::deserialize(deserializer)?; + Ok(result.into()) + } + } + + impl Serialize for Gc + where + T: for<'a> Type = Option<&'a mut T>>, + for<'a> Option<&'a T>: Serialize, + *mut T: GcType, + { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + as Serialize>::serialize(&self.as_opt(), serializer) + } + } +} diff --git a/libil2cpp/src/object.rs b/libil2cpp/src/object.rs index 4c8399e0..48bbcea4 100644 --- a/libil2cpp/src/object.rs +++ b/libil2cpp/src/object.rs @@ -2,7 +2,8 @@ use std::fmt; use std::ops::DerefMut; use crate::{ - raw, Argument, Arguments, Il2CppClass, Il2CppException, Returned, ThisArgument, Type, WrapRaw, + raw, Argument, Arguments, Gc, Il2CppClass, Il2CppException, Returned, ThisArgument, Type, + WrapRaw, }; /// An il2cpp object @@ -10,7 +11,7 @@ use crate::{ pub struct Il2CppObject(raw::Il2CppObject); pub type ByRefMut = T; // TODO: *mut T; -pub type ByRef = T;// TODO: *const T; +pub type ByRef = T; // TODO: *const T; impl Il2CppObject { /// [`Il2CppClass`] of the object @@ -102,13 +103,13 @@ pub trait ObjectExt: for<'a> Type = Option<&'a mut Self>> + DerefMut + Sized { /// Creates a new object using the constructor taking the given arguments - fn new(args: A) -> &'static mut Self + fn new(args: A) -> Gc where A: Arguments, { let object: &mut Self = Self::class().instantiate(); object.invoke_void(".ctor", args).unwrap(); - object + object.into() } } #[rustfmt::skip] diff --git a/libil2cpp/src/string.rs b/libil2cpp/src/string.rs index ae43d958..3733c2d5 100644 --- a/libil2cpp/src/string.rs +++ b/libil2cpp/src/string.rs @@ -4,7 +4,7 @@ use std::ops::{Deref, DerefMut}; use std::str::FromStr; use std::string::FromUtf16Error; -use crate::{raw, Il2CppObject, WrapRaw}; +use crate::{raw, Gc, Il2CppObject, WrapRaw}; /// An il2cpp string #[repr(transparent)] @@ -12,10 +12,10 @@ pub struct Il2CppString(raw::Il2CppString); impl Il2CppString { /// Creates a new string from a Rust string - pub fn new(s: impl AsRef) -> &'static mut Self { + pub fn new(s: impl AsRef) -> Gc { let b = s.as_ref().as_bytes(); let s = unsafe { raw::string_new_len(b.as_ptr().cast(), b.len() as _) }; - unsafe { Self::wrap_mut(s) } + unsafe { Self::wrap_mut(s).into() } } /// Converts the string to a Rust string, returning an error if its utf-16 @@ -74,16 +74,17 @@ impl AsMut<[u16]> for Il2CppString { } } -impl From for &'static mut Il2CppString -where - T: AsRef, -{ - fn from(s: T) -> Self { - Il2CppString::new(s) - } -} - -impl FromStr for &'static mut Il2CppString { +// TODO: Fix? +// impl From for Gc +// where +// T: AsRef, +// { +// fn from(s: T) -> Self { +// Il2CppString::new(s) +// } +// } + +impl FromStr for Gc { type Err = Infallible; fn from_str(s: &str) -> Result { @@ -122,12 +123,14 @@ impl fmt::Display for Il2CppString { #[cfg(feature = "serde")] mod serde { + use crate::Gc; + use super::Il2CppString; use serde::de::{Deserialize, Deserializer}; use serde::ser::{Serialize, Serializer}; - impl<'de> Deserialize<'de> for &mut Il2CppString { + impl<'de> Deserialize<'de> for Gc { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, From 798d0b0abfd27b967cc54cef95a818ab298b71f5 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 9 Dec 2024 23:52:19 -0400 Subject: [PATCH 35/71] Fix type bindings for different platforms --- libil2cpp/Cargo.toml | 3 + libil2cpp/bindings_out.rs | 8621 +++++++++++++++++ libil2cpp/build.rs | 24 + libil2cpp/generate_bindings.ps1 | 2 +- libil2cpp/generate_bindings_android.ps1 | 5 + libil2cpp/src/raw/mod.rs | 2 +- libil2cpp/src/raw/types_v31/android.rs | 8621 +++++++++++++++++ libil2cpp/src/raw/types_v31/linux.rs | 8516 ++++++++++++++++ libil2cpp/src/raw/types_v31/mod.rs | 7 + .../{types_v31.rs => types_v31/windows.rs} | 1621 +++- libil2cpp/src/ty.rs | 6 +- 11 files changed, 26993 insertions(+), 435 deletions(-) create mode 100644 libil2cpp/bindings_out.rs create mode 100644 libil2cpp/build.rs create mode 100644 libil2cpp/generate_bindings_android.ps1 create mode 100644 libil2cpp/src/raw/types_v31/android.rs create mode 100644 libil2cpp/src/raw/types_v31/linux.rs create mode 100644 libil2cpp/src/raw/types_v31/mod.rs rename libil2cpp/src/raw/{types_v31.rs => types_v31/windows.rs} (91%) diff --git a/libil2cpp/Cargo.toml b/libil2cpp/Cargo.toml index c26a34af..c2910416 100644 --- a/libil2cpp/Cargo.toml +++ b/libil2cpp/Cargo.toml @@ -30,3 +30,6 @@ il2cpp_v24 = [] unity2018 = [] cache = [] trace = ["tracing"] + +[build-dependencies] +bindgen = "0.71.1" diff --git a/libil2cpp/bindings_out.rs b/libil2cpp/bindings_out.rs new file mode 100644 index 00000000..4cd3b7fe --- /dev/null +++ b/libil2cpp/bindings_out.rs @@ -0,0 +1,8621 @@ +/* automatically generated by rust-bindgen 0.71.1 */ + +pub type wchar_t = ::std::os::raw::c_uint; +pub type __int8_t = ::std::os::raw::c_schar; +pub type __uint8_t = ::std::os::raw::c_uchar; +pub type __int16_t = ::std::os::raw::c_short; +pub type __uint16_t = ::std::os::raw::c_ushort; +pub type __int32_t = ::std::os::raw::c_int; +pub type __uint32_t = ::std::os::raw::c_uint; +pub type __int64_t = ::std::os::raw::c_long; +pub type __uint64_t = ::std::os::raw::c_ulong; +pub type __intptr_t = ::std::os::raw::c_long; +pub type __uintptr_t = ::std::os::raw::c_ulong; +pub type int_least8_t = i8; +pub type uint_least8_t = u8; +pub type int_least16_t = i16; +pub type uint_least16_t = u16; +pub type int_least32_t = i32; +pub type uint_least32_t = u32; +pub type int_least64_t = i64; +pub type uint_least64_t = u64; +pub type int_fast8_t = i8; +pub type uint_fast8_t = u8; +pub type int_fast64_t = i64; +pub type uint_fast64_t = u64; +pub type int_fast16_t = i64; +pub type uint_fast16_t = u64; +pub type int_fast32_t = i64; +pub type uint_fast32_t = u64; +pub type uintmax_t = u64; +pub type intmax_t = i64; +pub type Il2CppProfileFlags = ::std::os::raw::c_uint; +pub type Il2CppProfileFileIOKind = ::std::os::raw::c_uint; +pub type Il2CppGCEvent = ::std::os::raw::c_uint; +pub type Il2CppGCMode = ::std::os::raw::c_uint; +pub type Il2CppStat = ::std::os::raw::c_uint; +pub type Il2CppRuntimeUnhandledExceptionPolicy = ::std::os::raw::c_uint; +pub type Il2CppMethodPointer = ::std::option::Option; +pub type Il2CppChar = u16; +pub type Il2CppNativeChar = ::std::os::raw::c_char; +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 locale_t = *mut __locale_t; +pub type __s8 = ::std::os::raw::c_schar; +pub type __u8 = ::std::os::raw::c_uchar; +pub type __s16 = ::std::os::raw::c_short; +pub type __u16 = ::std::os::raw::c_ushort; +pub type __s32 = ::std::os::raw::c_int; +pub type __u32 = ::std::os::raw::c_uint; +pub type __s64 = ::std::os::raw::c_longlong; +pub type __u64 = ::std::os::raw::c_ulonglong; +pub type __kernel_sighandler_t = + ::std::option::Option; +pub type __kernel_key_t = ::std::os::raw::c_int; +pub type __kernel_mqd_t = ::std::os::raw::c_int; +pub type __kernel_old_uid_t = ::std::os::raw::c_ushort; +pub type __kernel_old_gid_t = ::std::os::raw::c_ushort; +pub type __kernel_long_t = ::std::os::raw::c_long; +pub type __kernel_ulong_t = ::std::os::raw::c_ulong; +pub type __kernel_ino_t = __kernel_ulong_t; +pub type __kernel_mode_t = ::std::os::raw::c_uint; +pub type __kernel_pid_t = ::std::os::raw::c_int; +pub type __kernel_ipc_pid_t = ::std::os::raw::c_int; +pub type __kernel_uid_t = ::std::os::raw::c_uint; +pub type __kernel_gid_t = ::std::os::raw::c_uint; +pub type __kernel_suseconds_t = __kernel_long_t; +pub type __kernel_daddr_t = ::std::os::raw::c_int; +pub type __kernel_uid32_t = ::std::os::raw::c_uint; +pub type __kernel_gid32_t = ::std::os::raw::c_uint; +pub type __kernel_old_dev_t = ::std::os::raw::c_uint; +pub type __kernel_size_t = __kernel_ulong_t; +pub type __kernel_ssize_t = __kernel_long_t; +pub type __kernel_ptrdiff_t = __kernel_long_t; +pub type __kernel_off_t = __kernel_long_t; +pub type __kernel_loff_t = ::std::os::raw::c_longlong; +pub type __kernel_old_time_t = __kernel_long_t; +pub type __kernel_time_t = __kernel_long_t; +pub type __kernel_time64_t = ::std::os::raw::c_longlong; +pub type __kernel_clock_t = __kernel_long_t; +pub type __kernel_timer_t = ::std::os::raw::c_int; +pub type __kernel_clockid_t = ::std::os::raw::c_int; +pub type __kernel_caddr_t = *mut ::std::os::raw::c_char; +pub type __kernel_uid16_t = ::std::os::raw::c_ushort; +pub type __kernel_gid16_t = ::std::os::raw::c_ushort; +pub type __le16 = __u16; +pub type __be16 = __u16; +pub type __le32 = __u32; +pub type __be32 = __u32; +pub type __le64 = __u64; +pub type __be64 = __u64; +pub type __sum16 = __u16; +pub type __wsum = __u32; +pub type __poll_t = ::std::os::raw::c_uint; +pub type pthread_barrierattr_t = ::std::os::raw::c_int; +pub type pthread_condattr_t = ::std::os::raw::c_long; +pub type pthread_key_t = ::std::os::raw::c_int; +pub type pthread_mutexattr_t = ::std::os::raw::c_long; +pub type pthread_once_t = ::std::os::raw::c_int; +pub type pthread_rwlockattr_t = ::std::os::raw::c_long; +pub type pthread_t = ::std::os::raw::c_long; +pub type __gid_t = __kernel_gid32_t; +pub type gid_t = __gid_t; +pub type __uid_t = __kernel_uid32_t; +pub type uid_t = __uid_t; +pub type __pid_t = __kernel_pid_t; +pub type pid_t = __pid_t; +pub type __id_t = u32; +pub type id_t = __id_t; +pub type blkcnt_t = ::std::os::raw::c_ulong; +pub type blksize_t = ::std::os::raw::c_ulong; +pub type caddr_t = __kernel_caddr_t; +pub type clock_t = __kernel_clock_t; +pub type __clockid_t = __kernel_clockid_t; +pub type clockid_t = __clockid_t; +pub type daddr_t = __kernel_daddr_t; +pub type fsblkcnt_t = ::std::os::raw::c_ulong; +pub type fsfilcnt_t = ::std::os::raw::c_ulong; +pub type __mode_t = __kernel_mode_t; +pub type mode_t = __mode_t; +pub type __key_t = __kernel_key_t; +pub type key_t = __key_t; +pub type __ino_t = __kernel_ino_t; +pub type ino_t = __ino_t; +pub type ino64_t = u64; +pub type __nlink_t = u32; +pub type nlink_t = __nlink_t; +pub type __timer_t = *mut ::std::os::raw::c_void; +pub type timer_t = __timer_t; +pub type __suseconds_t = __kernel_suseconds_t; +pub type suseconds_t = __suseconds_t; +pub type __useconds_t = u32; +pub type useconds_t = __useconds_t; +pub type dev_t = u64; +pub type __time_t = __kernel_time_t; +pub type time_t = __time_t; +pub type off_t = i64; +pub type loff_t = off_t; +pub type off64_t = loff_t; +pub type __socklen_t = u32; +pub type socklen_t = __socklen_t; +pub type __va_list = __BindgenOpaqueArray; +pub type uint_t = ::std::os::raw::c_uint; +pub type uint = ::std::os::raw::c_uint; +pub type u_char = ::std::os::raw::c_uchar; +pub type u_short = ::std::os::raw::c_ushort; +pub type u_int = ::std::os::raw::c_uint; +pub type u_long = ::std::os::raw::c_ulong; +pub type u_int32_t = u32; +pub type u_int16_t = u16; +pub type u_int8_t = u8; +pub type u_int64_t = u64; +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_uint; +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_uint; +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_uint; +pub type Il2CppCallConvention = ::std::os::raw::c_uint; +pub type Il2CppCharSet = ::std::os::raw::c_uint; +pub type Il2CppHString = *mut Il2CppHString__; +pub type IL2CPP_VARIANT_BOOL = i16; +pub type Il2CppVarType = ::std::os::raw::c_uint; +pub type Il2CppWindowsRuntimeTypeKind = ::std::os::raw::c_uint; +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_uint; +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_uint; +pub type SequencePointKind = ::std::os::raw::c_uint; +pub type Il2CppVTable = Il2CppClass; +pub type il2cpp_array_lower_bound_t = i32; +pub type Il2CppCallType = ::std::os::raw::c_uint; +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_uint; +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, +} +#[doc = r" If Bindgen could only determine the size and alignment of a"] +#[doc = r" type, it is represented like this."] +#[derive(PartialEq, Copy, Clone, Debug, Hash)] +#[repr(C)] +pub struct __BindgenOpaqueArray(pub [T; N]); +#[repr(C)] +#[derive(Default)] +pub struct __IncompleteArrayField(::std::marker::PhantomData, [T; 0]); +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct max_align_t { + pub __clang_max_align_nonce1: ::std::os::raw::c_longlong, + pub __bindgen_padding_0: u64, + pub __clang_max_align_nonce2: u128, +} +#[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 __locale_t { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __kernel_fd_set { + pub fds_bits: [::std::os::raw::c_ulong; 16usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __kernel_fsid_t { + pub val: [::std::os::raw::c_int; 2usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct pthread_attr_t { + pub flags: u32, + pub stack_base: *mut ::std::os::raw::c_void, + pub stack_size: usize, + pub guard_size: usize, + pub sched_policy: i32, + pub sched_priority: i32, + pub __reserved: [::std::os::raw::c_char; 16usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct pthread_barrier_t { + pub __private: [i64; 4usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct pthread_cond_t { + pub __private: [i32; 12usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct pthread_mutex_t { + pub __private: [i32; 10usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct pthread_rwlock_t { + pub __private: [i32; 14usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct pthread_spinlock_t { + pub __private: i64, +} +#[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, +} +pub const __BIONIC__: u32 = 1; +pub const __WORDSIZE: u32 = 64; +pub const __bos_level: u32 = 0; +pub const __ANDROID_API_FUTURE__: u32 = 10000; +pub const __ANDROID_API__: u32 = 10000; +pub const __ANDROID_API_G__: u32 = 9; +pub const __ANDROID_API_I__: u32 = 14; +pub const __ANDROID_API_J__: u32 = 16; +pub const __ANDROID_API_J_MR1__: u32 = 17; +pub const __ANDROID_API_J_MR2__: u32 = 18; +pub const __ANDROID_API_K__: u32 = 19; +pub const __ANDROID_API_L__: u32 = 21; +pub const __ANDROID_API_L_MR1__: u32 = 22; +pub const __ANDROID_API_M__: u32 = 23; +pub const __ANDROID_API_N__: u32 = 24; +pub const __ANDROID_API_N_MR1__: u32 = 25; +pub const __ANDROID_API_O__: u32 = 26; +pub const __ANDROID_API_O_MR1__: u32 = 27; +pub const __ANDROID_API_P__: u32 = 28; +pub const __ANDROID_API_Q__: u32 = 29; +pub const __ANDROID_API_R__: u32 = 30; +pub const __ANDROID_API_S__: u32 = 31; +pub const __ANDROID_API_T__: u32 = 33; +pub const __ANDROID_API_U__: u32 = 34; +pub const __ANDROID_API_V__: u32 = 35; +pub const __ANDROID_NDK__: u32 = 1; +pub const __NDK_MAJOR__: u32 = 27; +pub const __NDK_MINOR__: u32 = 0; +pub const __NDK_BETA__: u32 = 0; +pub const __NDK_BUILD__: u32 = 10883340; +pub const __NDK_CANARY__: u32 = 1; +pub const WCHAR_MIN: u8 = 0u8; +pub const INT8_MIN: i32 = -128; +pub const INT8_MAX: u32 = 127; +pub const INT_LEAST8_MIN: i32 = -128; +pub const INT_LEAST8_MAX: u32 = 127; +pub const INT_FAST8_MIN: i32 = -128; +pub const INT_FAST8_MAX: u32 = 127; +pub const UINT8_MAX: u32 = 255; +pub const UINT_LEAST8_MAX: u32 = 255; +pub const UINT_FAST8_MAX: u32 = 255; +pub const INT16_MIN: i32 = -32768; +pub const INT16_MAX: u32 = 32767; +pub const INT_LEAST16_MIN: i32 = -32768; +pub const INT_LEAST16_MAX: u32 = 32767; +pub const UINT16_MAX: u32 = 65535; +pub const UINT_LEAST16_MAX: u32 = 65535; +pub const INT32_MIN: i32 = -2147483648; +pub const INT32_MAX: u32 = 2147483647; +pub const INT_LEAST32_MIN: i32 = -2147483648; +pub const INT_LEAST32_MAX: u32 = 2147483647; +pub const INT_FAST32_MIN: i32 = -2147483648; +pub const INT_FAST32_MAX: u32 = 2147483647; +pub const UINT32_MAX: u32 = 4294967295; +pub const UINT_LEAST32_MAX: u32 = 4294967295; +pub const UINT_FAST32_MAX: u32 = 4294967295; +pub const SIG_ATOMIC_MAX: u32 = 2147483647; +pub const SIG_ATOMIC_MIN: i32 = -2147483648; +pub const WINT_MAX: u32 = 4294967295; +pub const WINT_MIN: u32 = 0; +pub const IL2CPP_TARGET_ARM64: u32 = 1; +pub const IL2CPP_TARGET_ARMV7: u32 = 0; +pub const IL2CPP_TARGET_ARM64E: u32 = 0; +pub const IL2CPP_TARGET_X64: u32 = 0; +pub const IL2CPP_TARGET_X86: u32 = 0; +pub const IL2CPP_LARGE_EXECUTABLE_ARM_WORKAROUND: u32 = 0; +pub const IL2CPP_BINARY_SECTION_NAME: &[u8; 7] = b"il2cpp\0"; +pub const IL2CPP_TARGET_ANDROID: u32 = 1; +pub const IL2CPP_PLATFORM_SUPPORTS_TIMEZONEINFO: u32 = 1; +pub const IL2CPP_ENABLE_PLATFORM_THREAD_RENAME: u32 = 1; +pub const IL2CPP_PLATFORM_DISABLE_LIBC_PINVOKE: u32 = 1; +pub const IL2CPP_TARGET_WINDOWS: u32 = 0; +pub const IL2CPP_TARGET_WINDOWS_DESKTOP: u32 = 0; +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_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_SYSTEM_CERTIFICATES: u32 = 0; +pub const IL2CPP_DEBUG: u32 = 0; +pub const IL2CPP_PLATFORM_SUPPORTS_CPU_INFO: u32 = 0; +pub const IL2CPP_PLATFORM_SUPPORTS_DEBUGGER_PRESENT: 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 = 1; +pub const IL2CPP_API_DYNAMIC_NO_DLSYM: u32 = 0; +pub const IL2CPP_POINTER_SPARE_BITS: u32 = 0; +pub const __BITS_PER_LONG: u32 = 64; +pub const __FD_SETSIZE: u32 = 1024; +pub const IL2CPP_CXX_ABI_MSVC: u32 = 0; +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 = 0; +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 = 47u8; +pub const IL2CPP_DISABLE_FULL_MESSAGES: u32 = 1; +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 = 0; +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 = 1; +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 max_align_t"][::std::mem::size_of::() - 32usize]; + ["Alignment of max_align_t"][::std::mem::align_of::() - 16usize]; + ["Offset of field: max_align_t::__clang_max_align_nonce1"] + [::std::mem::offset_of!(max_align_t, __clang_max_align_nonce1) - 0usize]; + ["Offset of field: max_align_t::__clang_max_align_nonce2"] + [::std::mem::offset_of!(max_align_t, __clang_max_align_nonce2) - 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]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of __kernel_fd_set"][::std::mem::size_of::<__kernel_fd_set>() - 128usize]; + ["Alignment of __kernel_fd_set"][::std::mem::align_of::<__kernel_fd_set>() - 8usize]; + ["Offset of field: __kernel_fd_set::fds_bits"] + [::std::mem::offset_of!(__kernel_fd_set, fds_bits) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of __kernel_fsid_t"][::std::mem::size_of::<__kernel_fsid_t>() - 8usize]; + ["Alignment of __kernel_fsid_t"][::std::mem::align_of::<__kernel_fsid_t>() - 4usize]; + ["Offset of field: __kernel_fsid_t::val"] + [::std::mem::offset_of!(__kernel_fsid_t, val) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of pthread_attr_t"][::std::mem::size_of::() - 56usize]; + ["Alignment of pthread_attr_t"][::std::mem::align_of::() - 8usize]; + ["Offset of field: pthread_attr_t::flags"] + [::std::mem::offset_of!(pthread_attr_t, flags) - 0usize]; + ["Offset of field: pthread_attr_t::stack_base"] + [::std::mem::offset_of!(pthread_attr_t, stack_base) - 8usize]; + ["Offset of field: pthread_attr_t::stack_size"] + [::std::mem::offset_of!(pthread_attr_t, stack_size) - 16usize]; + ["Offset of field: pthread_attr_t::guard_size"] + [::std::mem::offset_of!(pthread_attr_t, guard_size) - 24usize]; + ["Offset of field: pthread_attr_t::sched_policy"] + [::std::mem::offset_of!(pthread_attr_t, sched_policy) - 32usize]; + ["Offset of field: pthread_attr_t::sched_priority"] + [::std::mem::offset_of!(pthread_attr_t, sched_priority) - 36usize]; + ["Offset of field: pthread_attr_t::__reserved"] + [::std::mem::offset_of!(pthread_attr_t, __reserved) - 40usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of pthread_barrier_t"][::std::mem::size_of::() - 32usize]; + ["Alignment of pthread_barrier_t"][::std::mem::align_of::() - 8usize]; + ["Offset of field: pthread_barrier_t::__private"] + [::std::mem::offset_of!(pthread_barrier_t, __private) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of pthread_cond_t"][::std::mem::size_of::() - 48usize]; + ["Alignment of pthread_cond_t"][::std::mem::align_of::() - 4usize]; + ["Offset of field: pthread_cond_t::__private"] + [::std::mem::offset_of!(pthread_cond_t, __private) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of pthread_mutex_t"][::std::mem::size_of::() - 40usize]; + ["Alignment of pthread_mutex_t"][::std::mem::align_of::() - 4usize]; + ["Offset of field: pthread_mutex_t::__private"] + [::std::mem::offset_of!(pthread_mutex_t, __private) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of pthread_rwlock_t"][::std::mem::size_of::() - 56usize]; + ["Alignment of pthread_rwlock_t"][::std::mem::align_of::() - 4usize]; + ["Offset of field: pthread_rwlock_t::__private"] + [::std::mem::offset_of!(pthread_rwlock_t, __private) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of pthread_spinlock_t"][::std::mem::size_of::() - 8usize]; + ["Alignment of pthread_spinlock_t"][::std::mem::align_of::() - 8usize]; + ["Offset of field: pthread_spinlock_t::__private"] + [::std::mem::offset_of!(pthread_spinlock_t, __private) - 0usize]; +}; +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] + fn extract_bit(byte: u8, index: usize) -> bool { + 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 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]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize); + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + 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 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]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = + (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize); + *byte = Self::change_bit(*byte, index, val); + } + #[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 unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); + let mut val = 0; + for i in 0..(bit_width as usize) { + if Self::raw_get_bit(this, 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); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); + 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::raw_set_bit(this, index + bit_offset, val_bit_is_set); + } + } +} +impl Default for __BindgenOpaqueArray { + fn default() -> Self { + Self([::default(); N]) + } +} +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 unsafe fn attrs_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 16u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_attrs_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn type__raw(this: *const Self) -> Il2CppTypeEnum { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_type_raw(this: *mut Self, val: Il2CppTypeEnum) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn num_mods_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 24usize, + 5u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_num_mods_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn byref_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 29usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_byref_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn pinned_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 30usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_pinned_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn valuetype_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 31usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_valuetype_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn is_generic_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_generic_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn is_inflated_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_inflated_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn wrapper_type_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_wrapper_type_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn has_full_generic_sharing_signature_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_has_full_generic_sharing_signature_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn initialized_and_no_error_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_initialized_and_no_error_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn initialized_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_initialized_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn enumtype_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_enumtype_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn nullabletype_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_nullabletype_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn is_generic_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_generic_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn has_references_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_has_references_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn init_pending_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_init_pending_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn size_init_pending_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 7usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_size_init_pending_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn size_inited_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_size_inited_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn has_finalize_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 9usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_has_finalize_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn has_cctor_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 10usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_has_cctor_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn is_blittable_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 11usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_blittable_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn is_import_or_windows_runtime_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 12usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_import_or_windows_runtime_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn is_vtable_initialized_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 13usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_vtable_initialized_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn is_byref_like_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 14usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_byref_like_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn mantLo_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 32u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_mantLo_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn mantHi_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 32usize, + 20u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_mantHi_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn exp_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 52usize, + 11u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_exp_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn sign_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 63usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_sign_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn mant_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 23u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_mant_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn exp_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 23usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_exp_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn sign_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 31usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_sign_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 + } +} +unsafe extern "C" { + pub fn android_get_application_target_sdk_version() -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn android_get_device_api_level() -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_init(domain_name: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_init_utf16(domain_name: *const Il2CppChar) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_shutdown(); +} +unsafe extern "C" { + pub fn il2cpp_set_config_dir(config_path: *const ::std::os::raw::c_char); +} +unsafe extern "C" { + pub fn il2cpp_set_data_dir(data_path: *const ::std::os::raw::c_char); +} +unsafe extern "C" { + pub fn il2cpp_set_temp_dir(temp_path: *const ::std::os::raw::c_char); +} +unsafe 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, + ); +} +unsafe 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, + ); +} +unsafe extern "C" { + pub fn il2cpp_set_config_utf16(executablePath: *const Il2CppChar); +} +unsafe extern "C" { + pub fn il2cpp_set_config(executablePath: *const ::std::os::raw::c_char); +} +unsafe extern "C" { + pub fn il2cpp_set_memory_callbacks(callbacks: *mut Il2CppMemoryCallbacks); +} +unsafe extern "C" { + pub fn il2cpp_get_corlib() -> *const Il2CppImage; +} +unsafe extern "C" { + pub fn il2cpp_add_internal_call( + name: *const ::std::os::raw::c_char, + method: Il2CppMethodPointer, + ); +} +unsafe extern "C" { + pub fn il2cpp_resolve_icall(name: *const ::std::os::raw::c_char) -> Il2CppMethodPointer; +} +unsafe extern "C" { + pub fn il2cpp_alloc(size: usize) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn il2cpp_free(ptr: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn il2cpp_array_class_get(element_class: *mut Il2CppClass, rank: u32) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_array_length(array: *mut Il2CppArray) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_array_get_byte_length(array: *mut Il2CppArray) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_array_new( + elementTypeInfo: *mut Il2CppClass, + length: il2cpp_array_size_t, + ) -> *mut Il2CppArray; +} +unsafe extern "C" { + pub fn il2cpp_array_new_specific( + arrayTypeInfo: *mut Il2CppClass, + length: il2cpp_array_size_t, + ) -> *mut Il2CppArray; +} +unsafe 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; +} +unsafe extern "C" { + pub fn il2cpp_bounded_array_class_get( + element_class: *mut Il2CppClass, + rank: u32, + bounded: u8, + ) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_array_element_size(array_class: *const Il2CppClass) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_assembly_get_image(assembly: *const Il2CppAssembly) -> *const Il2CppImage; +} +unsafe 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, + ); +} +unsafe extern "C" { + pub fn il2cpp_class_enum_basetype(klass: *mut Il2CppClass) -> *const Il2CppType; +} +unsafe extern "C" { + pub fn il2cpp_class_is_inited(klass: *const Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_is_generic(klass: *const Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_is_inflated(klass: *const Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_is_assignable_from(klass: *mut Il2CppClass, oklass: *mut Il2CppClass) + -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_is_subclass_of( + klass: *mut Il2CppClass, + klassc: *mut Il2CppClass, + check_interfaces: u8, + ) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_has_parent(klass: *mut Il2CppClass, klassc: *mut Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_from_il2cpp_type(type_: *const Il2CppType) -> *mut Il2CppClass; +} +unsafe 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; +} +unsafe extern "C" { + pub fn il2cpp_class_from_system_type(type_: *mut Il2CppReflectionType) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_class_get_element_class(klass: *mut Il2CppClass) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_class_get_events( + klass: *mut Il2CppClass, + iter: *mut *mut ::std::os::raw::c_void, + ) -> *const EventInfo; +} +unsafe extern "C" { + pub fn il2cpp_class_get_fields( + klass: *mut Il2CppClass, + iter: *mut *mut ::std::os::raw::c_void, + ) -> *mut FieldInfo; +} +unsafe extern "C" { + pub fn il2cpp_class_get_nested_types( + klass: *mut Il2CppClass, + iter: *mut *mut ::std::os::raw::c_void, + ) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_class_get_interfaces( + klass: *mut Il2CppClass, + iter: *mut *mut ::std::os::raw::c_void, + ) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_class_get_properties( + klass: *mut Il2CppClass, + iter: *mut *mut ::std::os::raw::c_void, + ) -> *const PropertyInfo; +} +unsafe extern "C" { + pub fn il2cpp_class_get_property_from_name( + klass: *mut Il2CppClass, + name: *const ::std::os::raw::c_char, + ) -> *const PropertyInfo; +} +unsafe extern "C" { + pub fn il2cpp_class_get_field_from_name( + klass: *mut Il2CppClass, + name: *const ::std::os::raw::c_char, + ) -> *mut FieldInfo; +} +unsafe extern "C" { + pub fn il2cpp_class_get_methods( + klass: *mut Il2CppClass, + iter: *mut *mut ::std::os::raw::c_void, + ) -> *const MethodInfo; +} +unsafe 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; +} +unsafe extern "C" { + pub fn il2cpp_class_get_name(klass: *mut Il2CppClass) -> *const ::std::os::raw::c_char; +} +unsafe 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, + ); +} +unsafe extern "C" { + pub fn il2cpp_class_get_namespace(klass: *mut Il2CppClass) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_class_get_parent(klass: *mut Il2CppClass) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_class_get_declaring_type(klass: *mut Il2CppClass) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_class_instance_size(klass: *mut Il2CppClass) -> i32; +} +unsafe extern "C" { + pub fn il2cpp_class_num_fields(enumKlass: *const Il2CppClass) -> usize; +} +unsafe extern "C" { + pub fn il2cpp_class_is_valuetype(klass: *const Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_value_size(klass: *mut Il2CppClass, align: *mut u32) -> i32; +} +unsafe extern "C" { + pub fn il2cpp_class_is_blittable(klass: *const Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_get_flags(klass: *const Il2CppClass) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_class_is_abstract(klass: *const Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_is_interface(klass: *const Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_array_element_size(klass: *const Il2CppClass) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_class_from_type(type_: *const Il2CppType) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_class_get_type(klass: *mut Il2CppClass) -> *const Il2CppType; +} +unsafe extern "C" { + pub fn il2cpp_class_get_type_token(klass: *mut Il2CppClass) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_class_has_attribute(klass: *mut Il2CppClass, attr_class: *mut Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_has_references(klass: *mut Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_is_enum(klass: *const Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_get_image(klass: *mut Il2CppClass) -> *const Il2CppImage; +} +unsafe extern "C" { + pub fn il2cpp_class_get_assemblyname( + klass: *const Il2CppClass, + ) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_class_get_rank(klass: *const Il2CppClass) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_class_get_data_size(klass: *const Il2CppClass) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_class_get_static_field_data( + klass: *const Il2CppClass, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn il2cpp_class_get_bitmap_size(klass: *const Il2CppClass) -> usize; +} +unsafe extern "C" { + pub fn il2cpp_class_get_bitmap(klass: *mut Il2CppClass, bitmap: *mut usize); +} +unsafe extern "C" { + pub fn il2cpp_stats_dump_to_file(path: *const ::std::os::raw::c_char) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_stats_get_value(stat: Il2CppStat) -> u64; +} +unsafe extern "C" { + pub fn il2cpp_domain_get() -> *mut Il2CppDomain; +} +unsafe extern "C" { + pub fn il2cpp_domain_assembly_open( + domain: *mut Il2CppDomain, + name: *const ::std::os::raw::c_char, + ) -> *const Il2CppAssembly; +} +unsafe extern "C" { + pub fn il2cpp_domain_get_assemblies( + domain: *const Il2CppDomain, + size: *mut usize, + ) -> *mut *const Il2CppAssembly; +} +unsafe extern "C" { + pub fn il2cpp_raise_exception(arg1: *mut Il2CppException) -> !; +} +unsafe 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; +} +unsafe extern "C" { + pub fn il2cpp_get_exception_argument_null( + arg: *const ::std::os::raw::c_char, + ) -> *mut Il2CppException; +} +unsafe extern "C" { + pub fn il2cpp_format_exception( + ex: *const Il2CppException, + message: *mut ::std::os::raw::c_char, + message_size: ::std::os::raw::c_int, + ); +} +unsafe 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, + ); +} +unsafe extern "C" { + pub fn il2cpp_unhandled_exception(arg1: *mut Il2CppException); +} +unsafe 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, + ); +} +unsafe extern "C" { + pub fn il2cpp_field_get_flags(field: *mut FieldInfo) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_field_get_name(field: *mut FieldInfo) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_field_get_parent(field: *mut FieldInfo) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_field_get_offset(field: *mut FieldInfo) -> usize; +} +unsafe extern "C" { + pub fn il2cpp_field_get_type(field: *mut FieldInfo) -> *const Il2CppType; +} +unsafe extern "C" { + pub fn il2cpp_field_get_value( + obj: *mut Il2CppObject, + field: *mut FieldInfo, + value: *mut ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub fn il2cpp_field_get_value_object( + field: *mut FieldInfo, + obj: *mut Il2CppObject, + ) -> *mut Il2CppObject; +} +unsafe extern "C" { + pub fn il2cpp_field_has_attribute(field: *mut FieldInfo, attr_class: *mut Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_field_set_value( + obj: *mut Il2CppObject, + field: *mut FieldInfo, + value: *mut ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub fn il2cpp_field_static_get_value(field: *mut FieldInfo, value: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn il2cpp_field_static_set_value(field: *mut FieldInfo, value: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn il2cpp_field_set_value_object( + instance: *mut Il2CppObject, + field: *mut FieldInfo, + value: *mut Il2CppObject, + ); +} +unsafe extern "C" { + pub fn il2cpp_field_is_literal(field: *mut FieldInfo) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_gc_collect(maxGenerations: ::std::os::raw::c_int); +} +unsafe extern "C" { + pub fn il2cpp_gc_collect_a_little() -> i32; +} +unsafe extern "C" { + pub fn il2cpp_gc_start_incremental_collection(); +} +unsafe extern "C" { + pub fn il2cpp_gc_disable(); +} +unsafe extern "C" { + pub fn il2cpp_gc_enable(); +} +unsafe extern "C" { + pub fn il2cpp_gc_is_disabled() -> u8; +} +unsafe extern "C" { + pub fn il2cpp_gc_set_mode(mode: Il2CppGCMode); +} +unsafe extern "C" { + pub fn il2cpp_gc_get_max_time_slice_ns() -> i64; +} +unsafe extern "C" { + pub fn il2cpp_gc_set_max_time_slice_ns(maxTimeSlice: i64); +} +unsafe extern "C" { + pub fn il2cpp_gc_is_incremental() -> u8; +} +unsafe extern "C" { + pub fn il2cpp_gc_get_used_size() -> i64; +} +unsafe extern "C" { + pub fn il2cpp_gc_get_heap_size() -> i64; +} +unsafe 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, + ); +} +unsafe extern "C" { + pub fn il2cpp_gc_has_strict_wbarriers() -> u8; +} +unsafe 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, + ), + >, + ); +} +unsafe extern "C" { + pub fn il2cpp_gc_set_external_wbarrier_tracker( + func: ::std::option::Option, + ); +} +unsafe 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, + ); +} +unsafe extern "C" { + pub fn il2cpp_stop_gc_world(); +} +unsafe extern "C" { + pub fn il2cpp_start_gc_world(); +} +unsafe extern "C" { + pub fn il2cpp_gc_alloc_fixed(size: usize) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn il2cpp_gc_free_fixed(address: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn il2cpp_gchandle_new(obj: *mut Il2CppObject, pinned: u8) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_gchandle_new_weakref(obj: *mut Il2CppObject, track_resurrection: u8) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_gchandle_get_target(gchandle: u32) -> *mut Il2CppObject; +} +unsafe extern "C" { + pub fn il2cpp_gchandle_free(gchandle: u32); +} +unsafe 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, + ); +} +unsafe extern "C" { + pub fn il2cpp_object_header_size() -> u32; +} +unsafe extern "C" { + pub fn il2cpp_array_object_header_size() -> u32; +} +unsafe extern "C" { + pub fn il2cpp_offset_of_array_length_in_array_object_header() -> u32; +} +unsafe extern "C" { + pub fn il2cpp_offset_of_array_bounds_in_array_object_header() -> u32; +} +unsafe extern "C" { + pub fn il2cpp_allocation_granularity() -> u32; +} +unsafe 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; +} +unsafe extern "C" { + pub fn il2cpp_unity_liveness_calculation_from_root( + root: *mut Il2CppObject, + state: *mut ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub fn il2cpp_unity_liveness_calculation_from_statics(state: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn il2cpp_unity_liveness_finalize(state: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn il2cpp_unity_liveness_free_struct(state: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn il2cpp_method_get_return_type(method: *const MethodInfo) -> *const Il2CppType; +} +unsafe extern "C" { + pub fn il2cpp_method_get_declaring_type(method: *const MethodInfo) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_method_get_name(method: *const MethodInfo) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_method_get_from_reflection( + method: *const Il2CppReflectionMethod, + ) -> *const MethodInfo; +} +unsafe extern "C" { + pub fn il2cpp_method_get_object( + method: *const MethodInfo, + refclass: *mut Il2CppClass, + ) -> *mut Il2CppReflectionMethod; +} +unsafe extern "C" { + pub fn il2cpp_method_is_generic(method: *const MethodInfo) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_method_is_inflated(method: *const MethodInfo) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_method_is_instance(method: *const MethodInfo) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_method_get_param_count(method: *const MethodInfo) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_method_get_param(method: *const MethodInfo, index: u32) -> *const Il2CppType; +} +unsafe extern "C" { + pub fn il2cpp_method_get_class(method: *const MethodInfo) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_method_has_attribute( + method: *const MethodInfo, + attr_class: *mut Il2CppClass, + ) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_method_get_flags(method: *const MethodInfo, iflags: *mut u32) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_method_get_token(method: *const MethodInfo) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_method_get_param_name( + method: *const MethodInfo, + index: u32, + ) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_profiler_install(prof: *mut Il2CppProfiler, shutdown_callback: Il2CppProfileFunc); +} +unsafe extern "C" { + pub fn il2cpp_profiler_set_events(events: Il2CppProfileFlags); +} +unsafe extern "C" { + pub fn il2cpp_profiler_install_enter_leave( + enter: Il2CppProfileMethodFunc, + fleave: Il2CppProfileMethodFunc, + ); +} +unsafe extern "C" { + pub fn il2cpp_profiler_install_allocation(callback: Il2CppProfileAllocFunc); +} +unsafe extern "C" { + pub fn il2cpp_profiler_install_gc( + callback: Il2CppProfileGCFunc, + heap_resize_callback: Il2CppProfileGCResizeFunc, + ); +} +unsafe extern "C" { + pub fn il2cpp_profiler_install_fileio(callback: Il2CppProfileFileIOFunc); +} +unsafe extern "C" { + pub fn il2cpp_profiler_install_thread( + start: Il2CppProfileThreadFunc, + end: Il2CppProfileThreadFunc, + ); +} +unsafe extern "C" { + pub fn il2cpp_property_get_flags(prop: *mut PropertyInfo) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_property_get_get_method(prop: *mut PropertyInfo) -> *const MethodInfo; +} +unsafe extern "C" { + pub fn il2cpp_property_get_set_method(prop: *mut PropertyInfo) -> *const MethodInfo; +} +unsafe extern "C" { + pub fn il2cpp_property_get_name(prop: *mut PropertyInfo) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_property_get_parent(prop: *mut PropertyInfo) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_object_get_class(obj: *mut Il2CppObject) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_object_get_size(obj: *mut Il2CppObject) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_object_get_virtual_method( + obj: *mut Il2CppObject, + method: *const MethodInfo, + ) -> *const MethodInfo; +} +unsafe extern "C" { + pub fn il2cpp_object_new(klass: *const Il2CppClass) -> *mut Il2CppObject; +} +unsafe extern "C" { + pub fn il2cpp_object_unbox(obj: *mut Il2CppObject) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn il2cpp_value_box( + klass: *mut Il2CppClass, + data: *mut ::std::os::raw::c_void, + ) -> *mut Il2CppObject; +} +unsafe extern "C" { + pub fn il2cpp_monitor_enter(obj: *mut Il2CppObject); +} +unsafe extern "C" { + pub fn il2cpp_monitor_try_enter(obj: *mut Il2CppObject, timeout: u32) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_monitor_exit(obj: *mut Il2CppObject); +} +unsafe extern "C" { + pub fn il2cpp_monitor_pulse(obj: *mut Il2CppObject); +} +unsafe extern "C" { + pub fn il2cpp_monitor_pulse_all(obj: *mut Il2CppObject); +} +unsafe extern "C" { + pub fn il2cpp_monitor_wait(obj: *mut Il2CppObject); +} +unsafe extern "C" { + pub fn il2cpp_monitor_try_wait(obj: *mut Il2CppObject, timeout: u32) -> u8; +} +unsafe 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; +} +unsafe 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; +} +unsafe extern "C" { + pub fn il2cpp_runtime_class_init(klass: *mut Il2CppClass); +} +unsafe extern "C" { + pub fn il2cpp_runtime_object_init(obj: *mut Il2CppObject); +} +unsafe extern "C" { + pub fn il2cpp_runtime_object_init_exception( + obj: *mut Il2CppObject, + exc: *mut *mut Il2CppException, + ); +} +unsafe extern "C" { + pub fn il2cpp_runtime_unhandled_exception_policy_set( + value: Il2CppRuntimeUnhandledExceptionPolicy, + ); +} +unsafe extern "C" { + pub fn il2cpp_string_length(str_: *mut Il2CppString) -> i32; +} +unsafe extern "C" { + pub fn il2cpp_string_chars(str_: *mut Il2CppString) -> *mut Il2CppChar; +} +unsafe extern "C" { + pub fn il2cpp_string_new(str_: *const ::std::os::raw::c_char) -> *mut Il2CppString; +} +unsafe extern "C" { + pub fn il2cpp_string_new_len( + str_: *const ::std::os::raw::c_char, + length: u32, + ) -> *mut Il2CppString; +} +unsafe extern "C" { + pub fn il2cpp_string_new_utf16(text: *const Il2CppChar, len: i32) -> *mut Il2CppString; +} +unsafe extern "C" { + pub fn il2cpp_string_new_wrapper(str_: *const ::std::os::raw::c_char) -> *mut Il2CppString; +} +unsafe extern "C" { + pub fn il2cpp_string_intern(str_: *mut Il2CppString) -> *mut Il2CppString; +} +unsafe extern "C" { + pub fn il2cpp_string_is_interned(str_: *mut Il2CppString) -> *mut Il2CppString; +} +unsafe extern "C" { + pub fn il2cpp_thread_current() -> *mut Il2CppThread; +} +unsafe extern "C" { + pub fn il2cpp_thread_attach(domain: *mut Il2CppDomain) -> *mut Il2CppThread; +} +unsafe extern "C" { + pub fn il2cpp_thread_detach(thread: *mut Il2CppThread); +} +unsafe extern "C" { + pub fn il2cpp_thread_get_all_attached_threads(size: *mut usize) -> *mut *mut Il2CppThread; +} +unsafe extern "C" { + pub fn il2cpp_is_vm_thread(thread: *mut Il2CppThread) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_current_thread_walk_frame_stack( + func: Il2CppFrameWalkFunc, + user_data: *mut ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub fn il2cpp_thread_walk_frame_stack( + thread: *mut Il2CppThread, + func: Il2CppFrameWalkFunc, + user_data: *mut ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub fn il2cpp_current_thread_get_top_frame(frame: *mut Il2CppStackFrameInfo) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_thread_get_top_frame( + thread: *mut Il2CppThread, + frame: *mut Il2CppStackFrameInfo, + ) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_current_thread_get_frame_at(offset: i32, frame: *mut Il2CppStackFrameInfo) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_thread_get_frame_at( + thread: *mut Il2CppThread, + offset: i32, + frame: *mut Il2CppStackFrameInfo, + ) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_current_thread_get_stack_depth() -> i32; +} +unsafe extern "C" { + pub fn il2cpp_thread_get_stack_depth(thread: *mut Il2CppThread) -> i32; +} +unsafe extern "C" { + pub fn il2cpp_override_stack_backtrace(stackBacktraceFunc: Il2CppBacktraceFunc); +} +unsafe extern "C" { + pub fn il2cpp_type_get_object(type_: *const Il2CppType) -> *mut Il2CppObject; +} +unsafe extern "C" { + pub fn il2cpp_type_get_type(type_: *const Il2CppType) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_type_get_class_or_element_class(type_: *const Il2CppType) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_type_get_name(type_: *const Il2CppType) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_type_is_byref(type_: *const Il2CppType) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_type_get_attrs(type_: *const Il2CppType) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_type_equals(type_: *const Il2CppType, otherType: *const Il2CppType) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_type_get_assembly_qualified_name( + type_: *const Il2CppType, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_type_get_reflection_name(type_: *const Il2CppType) + -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_type_is_static(type_: *const Il2CppType) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_type_is_pointer_type(type_: *const Il2CppType) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_image_get_assembly(image: *const Il2CppImage) -> *const Il2CppAssembly; +} +unsafe extern "C" { + pub fn il2cpp_image_get_name(image: *const Il2CppImage) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_image_get_filename(image: *const Il2CppImage) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_image_get_entry_point(image: *const Il2CppImage) -> *const MethodInfo; +} +unsafe extern "C" { + pub fn il2cpp_image_get_class_count(image: *const Il2CppImage) -> usize; +} +unsafe extern "C" { + pub fn il2cpp_image_get_class(image: *const Il2CppImage, index: usize) -> *const Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_capture_memory_snapshot() -> *mut Il2CppManagedMemorySnapshot; +} +unsafe extern "C" { + pub fn il2cpp_free_captured_memory_snapshot(snapshot: *mut Il2CppManagedMemorySnapshot); +} +unsafe extern "C" { + pub fn il2cpp_set_find_plugin_callback(method: Il2CppSetFindPlugInCallback); +} +unsafe extern "C" { + pub fn il2cpp_register_log_callback(method: Il2CppLogCallback); +} +unsafe extern "C" { + pub fn il2cpp_debugger_set_agent_options(options: *const ::std::os::raw::c_char); +} +unsafe extern "C" { + pub fn il2cpp_is_debugger_attached() -> u8; +} +unsafe extern "C" { + pub fn il2cpp_register_debugger_agent_transport( + debuggerTransport: *mut Il2CppDebuggerTransport, + ); +} +unsafe extern "C" { + pub fn il2cpp_debug_get_method_info( + arg1: *const MethodInfo, + methodDebugInfo: *mut Il2CppMethodDebugInfo, + ) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_unity_install_unitytls_interface( + unitytlsInterfaceStruct: *const ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub fn il2cpp_custom_attrs_from_class(klass: *mut Il2CppClass) -> *mut Il2CppCustomAttrInfo; +} +unsafe extern "C" { + pub fn il2cpp_custom_attrs_from_method(method: *const MethodInfo) -> *mut Il2CppCustomAttrInfo; +} +unsafe extern "C" { + pub fn il2cpp_custom_attrs_from_field(field: *const FieldInfo) -> *mut Il2CppCustomAttrInfo; +} +unsafe extern "C" { + pub fn il2cpp_custom_attrs_get_attr( + ainfo: *mut Il2CppCustomAttrInfo, + attr_klass: *mut Il2CppClass, + ) -> *mut Il2CppObject; +} +unsafe extern "C" { + pub fn il2cpp_custom_attrs_has_attr( + ainfo: *mut Il2CppCustomAttrInfo, + attr_klass: *mut Il2CppClass, + ) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_custom_attrs_construct(cinfo: *mut Il2CppCustomAttrInfo) -> *mut Il2CppArray; +} +unsafe extern "C" { + pub fn il2cpp_custom_attrs_free(ainfo: *mut Il2CppCustomAttrInfo); +} +unsafe extern "C" { + pub fn il2cpp_class_set_userdata( + klass: *mut Il2CppClass, + userdata: *mut ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub fn il2cpp_class_get_userdata_offset() -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_set_default_thread_affinity(affinity_mask: i64); +} +unsafe extern "C" { + pub fn il2cpp_unity_set_android_network_up_state_func(func: Il2CppAndroidUpStateFunc); +} +unsafe extern "C" { + pub fn strcasecmp( + __s1: *const ::std::os::raw::c_char, + __s2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strcasecmp_l( + __s1: *const ::std::os::raw::c_char, + __s2: *const ::std::os::raw::c_char, + __l: locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strncasecmp( + __s1: *const ::std::os::raw::c_char, + __s2: *const ::std::os::raw::c_char, + __n: ::std::os::raw::c_ulong, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strncasecmp_l( + __s1: *const ::std::os::raw::c_char, + __s2: *const ::std::os::raw::c_char, + __n: usize, + __l: locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn memccpy( + __dst: *mut ::std::os::raw::c_void, + __src: *const ::std::os::raw::c_void, + __stop_char: ::std::os::raw::c_int, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn memchr( + __s: *const ::std::os::raw::c_void, + __ch: ::std::os::raw::c_int, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn memrchr( + __s: *const ::std::os::raw::c_void, + __ch: ::std::os::raw::c_int, + __n: usize, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn memcmp( + __lhs: *const ::std::os::raw::c_void, + __rhs: *const ::std::os::raw::c_void, + __n: ::std::os::raw::c_ulong, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn memcpy( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn memmove( + __dst: *mut ::std::os::raw::c_void, + __src: *const ::std::os::raw::c_void, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn memset( + __dst: *mut ::std::os::raw::c_void, + __ch: ::std::os::raw::c_int, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn memset_explicit( + __dst: *mut ::std::os::raw::c_void, + __ch: ::std::os::raw::c_int, + __n: usize, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn memmem( + __haystack: *const ::std::os::raw::c_void, + __haystack_size: usize, + __needle: *const ::std::os::raw::c_void, + __needle_size: usize, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn strchr( + __s: *const ::std::os::raw::c_char, + __ch: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn __strchr_chk( + __s: *const ::std::os::raw::c_char, + __ch: ::std::os::raw::c_int, + __n: usize, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strrchr( + __s: *const ::std::os::raw::c_char, + __ch: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn __strrchr_chk( + __s: *const ::std::os::raw::c_char, + __ch: ::std::os::raw::c_int, + __n: usize, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strlen(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_ulong; +} +unsafe extern "C" { + pub fn __strlen_chk(__s: *const ::std::os::raw::c_char, __n: usize) -> usize; +} +unsafe extern "C" { + pub fn strcmp( + __lhs: *const ::std::os::raw::c_char, + __rhs: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn stpcpy( + __dst: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strcpy( + __dst: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strcat( + __dst: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strdup(__s: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strstr( + __haystack: *const ::std::os::raw::c_char, + __needle: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strcasestr( + __haystack: *const ::std::os::raw::c_char, + __needle: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strtok( + __s: *mut ::std::os::raw::c_char, + __delimiter: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strtok_r( + __s: *mut ::std::os::raw::c_char, + __delimiter: *const ::std::os::raw::c_char, + __pos_ptr: *mut *mut ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strerror(__errno_value: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strerror_l( + __errno_value: ::std::os::raw::c_int, + __l: locale_t, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strerror_r( + __errno_value: ::std::os::raw::c_int, + __buf: *mut ::std::os::raw::c_char, + __n: usize, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strnlen(__s: *const ::std::os::raw::c_char, __n: usize) -> usize; +} +unsafe extern "C" { + pub fn strncat( + __dst: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strndup( + __s: *const ::std::os::raw::c_char, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strncmp( + __lhs: *const ::std::os::raw::c_char, + __rhs: *const ::std::os::raw::c_char, + __n: ::std::os::raw::c_ulong, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn stpncpy( + __dst: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strncpy( + __dst: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strlcat( + __dst: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + __n: usize, + ) -> usize; +} +unsafe extern "C" { + pub fn strlcpy( + __dst: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + __n: usize, + ) -> usize; +} +unsafe extern "C" { + pub fn strcspn( + __s: *const ::std::os::raw::c_char, + __reject: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_ulong; +} +unsafe extern "C" { + pub fn strpbrk( + __s: *const ::std::os::raw::c_char, + __accept: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strsep( + __s_ptr: *mut *mut ::std::os::raw::c_char, + __delimiter: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strspn( + __s: *const ::std::os::raw::c_char, + __accept: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_ulong; +} +unsafe extern "C" { + pub fn strsignal(__signal: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strcoll( + __lhs: *const ::std::os::raw::c_char, + __rhs: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strxfrm( + __dst: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + __n: ::std::os::raw::c_ulong, + ) -> ::std::os::raw::c_ulong; +} +unsafe extern "C" { + pub fn strcoll_l( + __lhs: *const ::std::os::raw::c_char, + __rhs: *const ::std::os::raw::c_char, + __l: locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strxfrm_l( + __dst: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + __n: usize, + __l: locale_t, + ) -> usize; +} +unsafe extern "C" { + pub static kIl2CppUInt64Max: u64; +} +unsafe extern "C" { + pub static kIl2CppUIntPtrMax: usize; +} +unsafe extern "C" { + pub static kIl2CppNewLine: [Il2CppChar; 2usize]; +} +unsafe extern "C" { + pub static mut il2cpp_defaults: Il2CppDefaults; +} diff --git a/libil2cpp/build.rs b/libil2cpp/build.rs new file mode 100644 index 00000000..e57e59da --- /dev/null +++ b/libil2cpp/build.rs @@ -0,0 +1,24 @@ +use std::env; +use std::path::PathBuf; + +fn main() { + if env::var("RUN_BINDGEN").is_err() { + println!("Skipping bindgen; set RUN_BINDGEN=1 to enable."); + return; + } + let bindings = bindgen::Builder::default() + .header("wrapper.h") + .clang_arg("-I./extern/includes/libil2cpp/il2cpp/libil2cpp") + .clang_arg("-v") + .wrap_unsafe_ops(true) + .sort_semantically(true) // Incluye las cabeceras si es necesario + .generate() + .expect("Unable to generate bindings"); + let current_dir = env::current_dir().expect("Failed to get current directory"); + let output_path = current_dir.join("bindings_out.rs"); + + bindings + .write_to_file(&output_path) + .expect("Couldn't write bindings!"); + panic!("Written bindings to {}", output_path.display()); +} diff --git a/libil2cpp/generate_bindings.ps1 b/libil2cpp/generate_bindings.ps1 index 3943933c..72909ae0 100644 --- a/libil2cpp/generate_bindings.ps1 +++ b/libil2cpp/generate_bindings.ps1 @@ -1,4 +1,4 @@ #!/bin/pwsh -bindgen wrapper.h -o bindings.rs --wrap-unsafe-ops --sort-semantically \ No newline at end of file +bindgen wrapper.h -o bindings.rs --wrap-unsafe-ops --sort-semantically -- -I./extern/includes/libil2cpp/il2cpp/libil2cpp \ No newline at end of file diff --git a/libil2cpp/generate_bindings_android.ps1 b/libil2cpp/generate_bindings_android.ps1 new file mode 100644 index 00000000..8ca27af0 --- /dev/null +++ b/libil2cpp/generate_bindings_android.ps1 @@ -0,0 +1,5 @@ +#!/bin/pwsh + +# $ENV:BINDGEN_EXTRA_CLANG_ARGS="--target=aarch64-linux-android21 -I./extern/includes/libil2cpp/il2cpp/libil2cpp -I$ENV:ANDROID_NDK_HOME/sysroot/usr/include -I$ENV:ANDROID_NDK_HOME/sysroot/usr/include/aarch64-linux-android" +# bindgen wrapper.h -o bindings.rs --wrap-unsafe-ops --sort-semantically +RUST_BINDGEN=1 cargo ndk --bindgen -t arm64-v8a build \ No newline at end of file diff --git a/libil2cpp/src/raw/mod.rs b/libil2cpp/src/raw/mod.rs index 8a1df200..5d4beaf6 100644 --- a/libil2cpp/src/raw/mod.rs +++ b/libil2cpp/src/raw/mod.rs @@ -5,7 +5,7 @@ mod functions; -#[cfg_attr(feature = "il2cpp_v31", path = "types_v31.rs")] +#[cfg_attr(feature = "il2cpp_v31", path = "types_v31/mod.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")] diff --git a/libil2cpp/src/raw/types_v31/android.rs b/libil2cpp/src/raw/types_v31/android.rs new file mode 100644 index 00000000..4cd3b7fe --- /dev/null +++ b/libil2cpp/src/raw/types_v31/android.rs @@ -0,0 +1,8621 @@ +/* automatically generated by rust-bindgen 0.71.1 */ + +pub type wchar_t = ::std::os::raw::c_uint; +pub type __int8_t = ::std::os::raw::c_schar; +pub type __uint8_t = ::std::os::raw::c_uchar; +pub type __int16_t = ::std::os::raw::c_short; +pub type __uint16_t = ::std::os::raw::c_ushort; +pub type __int32_t = ::std::os::raw::c_int; +pub type __uint32_t = ::std::os::raw::c_uint; +pub type __int64_t = ::std::os::raw::c_long; +pub type __uint64_t = ::std::os::raw::c_ulong; +pub type __intptr_t = ::std::os::raw::c_long; +pub type __uintptr_t = ::std::os::raw::c_ulong; +pub type int_least8_t = i8; +pub type uint_least8_t = u8; +pub type int_least16_t = i16; +pub type uint_least16_t = u16; +pub type int_least32_t = i32; +pub type uint_least32_t = u32; +pub type int_least64_t = i64; +pub type uint_least64_t = u64; +pub type int_fast8_t = i8; +pub type uint_fast8_t = u8; +pub type int_fast64_t = i64; +pub type uint_fast64_t = u64; +pub type int_fast16_t = i64; +pub type uint_fast16_t = u64; +pub type int_fast32_t = i64; +pub type uint_fast32_t = u64; +pub type uintmax_t = u64; +pub type intmax_t = i64; +pub type Il2CppProfileFlags = ::std::os::raw::c_uint; +pub type Il2CppProfileFileIOKind = ::std::os::raw::c_uint; +pub type Il2CppGCEvent = ::std::os::raw::c_uint; +pub type Il2CppGCMode = ::std::os::raw::c_uint; +pub type Il2CppStat = ::std::os::raw::c_uint; +pub type Il2CppRuntimeUnhandledExceptionPolicy = ::std::os::raw::c_uint; +pub type Il2CppMethodPointer = ::std::option::Option; +pub type Il2CppChar = u16; +pub type Il2CppNativeChar = ::std::os::raw::c_char; +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 locale_t = *mut __locale_t; +pub type __s8 = ::std::os::raw::c_schar; +pub type __u8 = ::std::os::raw::c_uchar; +pub type __s16 = ::std::os::raw::c_short; +pub type __u16 = ::std::os::raw::c_ushort; +pub type __s32 = ::std::os::raw::c_int; +pub type __u32 = ::std::os::raw::c_uint; +pub type __s64 = ::std::os::raw::c_longlong; +pub type __u64 = ::std::os::raw::c_ulonglong; +pub type __kernel_sighandler_t = + ::std::option::Option; +pub type __kernel_key_t = ::std::os::raw::c_int; +pub type __kernel_mqd_t = ::std::os::raw::c_int; +pub type __kernel_old_uid_t = ::std::os::raw::c_ushort; +pub type __kernel_old_gid_t = ::std::os::raw::c_ushort; +pub type __kernel_long_t = ::std::os::raw::c_long; +pub type __kernel_ulong_t = ::std::os::raw::c_ulong; +pub type __kernel_ino_t = __kernel_ulong_t; +pub type __kernel_mode_t = ::std::os::raw::c_uint; +pub type __kernel_pid_t = ::std::os::raw::c_int; +pub type __kernel_ipc_pid_t = ::std::os::raw::c_int; +pub type __kernel_uid_t = ::std::os::raw::c_uint; +pub type __kernel_gid_t = ::std::os::raw::c_uint; +pub type __kernel_suseconds_t = __kernel_long_t; +pub type __kernel_daddr_t = ::std::os::raw::c_int; +pub type __kernel_uid32_t = ::std::os::raw::c_uint; +pub type __kernel_gid32_t = ::std::os::raw::c_uint; +pub type __kernel_old_dev_t = ::std::os::raw::c_uint; +pub type __kernel_size_t = __kernel_ulong_t; +pub type __kernel_ssize_t = __kernel_long_t; +pub type __kernel_ptrdiff_t = __kernel_long_t; +pub type __kernel_off_t = __kernel_long_t; +pub type __kernel_loff_t = ::std::os::raw::c_longlong; +pub type __kernel_old_time_t = __kernel_long_t; +pub type __kernel_time_t = __kernel_long_t; +pub type __kernel_time64_t = ::std::os::raw::c_longlong; +pub type __kernel_clock_t = __kernel_long_t; +pub type __kernel_timer_t = ::std::os::raw::c_int; +pub type __kernel_clockid_t = ::std::os::raw::c_int; +pub type __kernel_caddr_t = *mut ::std::os::raw::c_char; +pub type __kernel_uid16_t = ::std::os::raw::c_ushort; +pub type __kernel_gid16_t = ::std::os::raw::c_ushort; +pub type __le16 = __u16; +pub type __be16 = __u16; +pub type __le32 = __u32; +pub type __be32 = __u32; +pub type __le64 = __u64; +pub type __be64 = __u64; +pub type __sum16 = __u16; +pub type __wsum = __u32; +pub type __poll_t = ::std::os::raw::c_uint; +pub type pthread_barrierattr_t = ::std::os::raw::c_int; +pub type pthread_condattr_t = ::std::os::raw::c_long; +pub type pthread_key_t = ::std::os::raw::c_int; +pub type pthread_mutexattr_t = ::std::os::raw::c_long; +pub type pthread_once_t = ::std::os::raw::c_int; +pub type pthread_rwlockattr_t = ::std::os::raw::c_long; +pub type pthread_t = ::std::os::raw::c_long; +pub type __gid_t = __kernel_gid32_t; +pub type gid_t = __gid_t; +pub type __uid_t = __kernel_uid32_t; +pub type uid_t = __uid_t; +pub type __pid_t = __kernel_pid_t; +pub type pid_t = __pid_t; +pub type __id_t = u32; +pub type id_t = __id_t; +pub type blkcnt_t = ::std::os::raw::c_ulong; +pub type blksize_t = ::std::os::raw::c_ulong; +pub type caddr_t = __kernel_caddr_t; +pub type clock_t = __kernel_clock_t; +pub type __clockid_t = __kernel_clockid_t; +pub type clockid_t = __clockid_t; +pub type daddr_t = __kernel_daddr_t; +pub type fsblkcnt_t = ::std::os::raw::c_ulong; +pub type fsfilcnt_t = ::std::os::raw::c_ulong; +pub type __mode_t = __kernel_mode_t; +pub type mode_t = __mode_t; +pub type __key_t = __kernel_key_t; +pub type key_t = __key_t; +pub type __ino_t = __kernel_ino_t; +pub type ino_t = __ino_t; +pub type ino64_t = u64; +pub type __nlink_t = u32; +pub type nlink_t = __nlink_t; +pub type __timer_t = *mut ::std::os::raw::c_void; +pub type timer_t = __timer_t; +pub type __suseconds_t = __kernel_suseconds_t; +pub type suseconds_t = __suseconds_t; +pub type __useconds_t = u32; +pub type useconds_t = __useconds_t; +pub type dev_t = u64; +pub type __time_t = __kernel_time_t; +pub type time_t = __time_t; +pub type off_t = i64; +pub type loff_t = off_t; +pub type off64_t = loff_t; +pub type __socklen_t = u32; +pub type socklen_t = __socklen_t; +pub type __va_list = __BindgenOpaqueArray; +pub type uint_t = ::std::os::raw::c_uint; +pub type uint = ::std::os::raw::c_uint; +pub type u_char = ::std::os::raw::c_uchar; +pub type u_short = ::std::os::raw::c_ushort; +pub type u_int = ::std::os::raw::c_uint; +pub type u_long = ::std::os::raw::c_ulong; +pub type u_int32_t = u32; +pub type u_int16_t = u16; +pub type u_int8_t = u8; +pub type u_int64_t = u64; +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_uint; +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_uint; +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_uint; +pub type Il2CppCallConvention = ::std::os::raw::c_uint; +pub type Il2CppCharSet = ::std::os::raw::c_uint; +pub type Il2CppHString = *mut Il2CppHString__; +pub type IL2CPP_VARIANT_BOOL = i16; +pub type Il2CppVarType = ::std::os::raw::c_uint; +pub type Il2CppWindowsRuntimeTypeKind = ::std::os::raw::c_uint; +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_uint; +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_uint; +pub type SequencePointKind = ::std::os::raw::c_uint; +pub type Il2CppVTable = Il2CppClass; +pub type il2cpp_array_lower_bound_t = i32; +pub type Il2CppCallType = ::std::os::raw::c_uint; +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_uint; +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, +} +#[doc = r" If Bindgen could only determine the size and alignment of a"] +#[doc = r" type, it is represented like this."] +#[derive(PartialEq, Copy, Clone, Debug, Hash)] +#[repr(C)] +pub struct __BindgenOpaqueArray(pub [T; N]); +#[repr(C)] +#[derive(Default)] +pub struct __IncompleteArrayField(::std::marker::PhantomData, [T; 0]); +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct max_align_t { + pub __clang_max_align_nonce1: ::std::os::raw::c_longlong, + pub __bindgen_padding_0: u64, + pub __clang_max_align_nonce2: u128, +} +#[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 __locale_t { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __kernel_fd_set { + pub fds_bits: [::std::os::raw::c_ulong; 16usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __kernel_fsid_t { + pub val: [::std::os::raw::c_int; 2usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct pthread_attr_t { + pub flags: u32, + pub stack_base: *mut ::std::os::raw::c_void, + pub stack_size: usize, + pub guard_size: usize, + pub sched_policy: i32, + pub sched_priority: i32, + pub __reserved: [::std::os::raw::c_char; 16usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct pthread_barrier_t { + pub __private: [i64; 4usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct pthread_cond_t { + pub __private: [i32; 12usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct pthread_mutex_t { + pub __private: [i32; 10usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct pthread_rwlock_t { + pub __private: [i32; 14usize], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct pthread_spinlock_t { + pub __private: i64, +} +#[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, +} +pub const __BIONIC__: u32 = 1; +pub const __WORDSIZE: u32 = 64; +pub const __bos_level: u32 = 0; +pub const __ANDROID_API_FUTURE__: u32 = 10000; +pub const __ANDROID_API__: u32 = 10000; +pub const __ANDROID_API_G__: u32 = 9; +pub const __ANDROID_API_I__: u32 = 14; +pub const __ANDROID_API_J__: u32 = 16; +pub const __ANDROID_API_J_MR1__: u32 = 17; +pub const __ANDROID_API_J_MR2__: u32 = 18; +pub const __ANDROID_API_K__: u32 = 19; +pub const __ANDROID_API_L__: u32 = 21; +pub const __ANDROID_API_L_MR1__: u32 = 22; +pub const __ANDROID_API_M__: u32 = 23; +pub const __ANDROID_API_N__: u32 = 24; +pub const __ANDROID_API_N_MR1__: u32 = 25; +pub const __ANDROID_API_O__: u32 = 26; +pub const __ANDROID_API_O_MR1__: u32 = 27; +pub const __ANDROID_API_P__: u32 = 28; +pub const __ANDROID_API_Q__: u32 = 29; +pub const __ANDROID_API_R__: u32 = 30; +pub const __ANDROID_API_S__: u32 = 31; +pub const __ANDROID_API_T__: u32 = 33; +pub const __ANDROID_API_U__: u32 = 34; +pub const __ANDROID_API_V__: u32 = 35; +pub const __ANDROID_NDK__: u32 = 1; +pub const __NDK_MAJOR__: u32 = 27; +pub const __NDK_MINOR__: u32 = 0; +pub const __NDK_BETA__: u32 = 0; +pub const __NDK_BUILD__: u32 = 10883340; +pub const __NDK_CANARY__: u32 = 1; +pub const WCHAR_MIN: u8 = 0u8; +pub const INT8_MIN: i32 = -128; +pub const INT8_MAX: u32 = 127; +pub const INT_LEAST8_MIN: i32 = -128; +pub const INT_LEAST8_MAX: u32 = 127; +pub const INT_FAST8_MIN: i32 = -128; +pub const INT_FAST8_MAX: u32 = 127; +pub const UINT8_MAX: u32 = 255; +pub const UINT_LEAST8_MAX: u32 = 255; +pub const UINT_FAST8_MAX: u32 = 255; +pub const INT16_MIN: i32 = -32768; +pub const INT16_MAX: u32 = 32767; +pub const INT_LEAST16_MIN: i32 = -32768; +pub const INT_LEAST16_MAX: u32 = 32767; +pub const UINT16_MAX: u32 = 65535; +pub const UINT_LEAST16_MAX: u32 = 65535; +pub const INT32_MIN: i32 = -2147483648; +pub const INT32_MAX: u32 = 2147483647; +pub const INT_LEAST32_MIN: i32 = -2147483648; +pub const INT_LEAST32_MAX: u32 = 2147483647; +pub const INT_FAST32_MIN: i32 = -2147483648; +pub const INT_FAST32_MAX: u32 = 2147483647; +pub const UINT32_MAX: u32 = 4294967295; +pub const UINT_LEAST32_MAX: u32 = 4294967295; +pub const UINT_FAST32_MAX: u32 = 4294967295; +pub const SIG_ATOMIC_MAX: u32 = 2147483647; +pub const SIG_ATOMIC_MIN: i32 = -2147483648; +pub const WINT_MAX: u32 = 4294967295; +pub const WINT_MIN: u32 = 0; +pub const IL2CPP_TARGET_ARM64: u32 = 1; +pub const IL2CPP_TARGET_ARMV7: u32 = 0; +pub const IL2CPP_TARGET_ARM64E: u32 = 0; +pub const IL2CPP_TARGET_X64: u32 = 0; +pub const IL2CPP_TARGET_X86: u32 = 0; +pub const IL2CPP_LARGE_EXECUTABLE_ARM_WORKAROUND: u32 = 0; +pub const IL2CPP_BINARY_SECTION_NAME: &[u8; 7] = b"il2cpp\0"; +pub const IL2CPP_TARGET_ANDROID: u32 = 1; +pub const IL2CPP_PLATFORM_SUPPORTS_TIMEZONEINFO: u32 = 1; +pub const IL2CPP_ENABLE_PLATFORM_THREAD_RENAME: u32 = 1; +pub const IL2CPP_PLATFORM_DISABLE_LIBC_PINVOKE: u32 = 1; +pub const IL2CPP_TARGET_WINDOWS: u32 = 0; +pub const IL2CPP_TARGET_WINDOWS_DESKTOP: u32 = 0; +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_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_SYSTEM_CERTIFICATES: u32 = 0; +pub const IL2CPP_DEBUG: u32 = 0; +pub const IL2CPP_PLATFORM_SUPPORTS_CPU_INFO: u32 = 0; +pub const IL2CPP_PLATFORM_SUPPORTS_DEBUGGER_PRESENT: 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 = 1; +pub const IL2CPP_API_DYNAMIC_NO_DLSYM: u32 = 0; +pub const IL2CPP_POINTER_SPARE_BITS: u32 = 0; +pub const __BITS_PER_LONG: u32 = 64; +pub const __FD_SETSIZE: u32 = 1024; +pub const IL2CPP_CXX_ABI_MSVC: u32 = 0; +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 = 0; +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 = 47u8; +pub const IL2CPP_DISABLE_FULL_MESSAGES: u32 = 1; +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 = 0; +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 = 1; +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 max_align_t"][::std::mem::size_of::() - 32usize]; + ["Alignment of max_align_t"][::std::mem::align_of::() - 16usize]; + ["Offset of field: max_align_t::__clang_max_align_nonce1"] + [::std::mem::offset_of!(max_align_t, __clang_max_align_nonce1) - 0usize]; + ["Offset of field: max_align_t::__clang_max_align_nonce2"] + [::std::mem::offset_of!(max_align_t, __clang_max_align_nonce2) - 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]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of __kernel_fd_set"][::std::mem::size_of::<__kernel_fd_set>() - 128usize]; + ["Alignment of __kernel_fd_set"][::std::mem::align_of::<__kernel_fd_set>() - 8usize]; + ["Offset of field: __kernel_fd_set::fds_bits"] + [::std::mem::offset_of!(__kernel_fd_set, fds_bits) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of __kernel_fsid_t"][::std::mem::size_of::<__kernel_fsid_t>() - 8usize]; + ["Alignment of __kernel_fsid_t"][::std::mem::align_of::<__kernel_fsid_t>() - 4usize]; + ["Offset of field: __kernel_fsid_t::val"] + [::std::mem::offset_of!(__kernel_fsid_t, val) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of pthread_attr_t"][::std::mem::size_of::() - 56usize]; + ["Alignment of pthread_attr_t"][::std::mem::align_of::() - 8usize]; + ["Offset of field: pthread_attr_t::flags"] + [::std::mem::offset_of!(pthread_attr_t, flags) - 0usize]; + ["Offset of field: pthread_attr_t::stack_base"] + [::std::mem::offset_of!(pthread_attr_t, stack_base) - 8usize]; + ["Offset of field: pthread_attr_t::stack_size"] + [::std::mem::offset_of!(pthread_attr_t, stack_size) - 16usize]; + ["Offset of field: pthread_attr_t::guard_size"] + [::std::mem::offset_of!(pthread_attr_t, guard_size) - 24usize]; + ["Offset of field: pthread_attr_t::sched_policy"] + [::std::mem::offset_of!(pthread_attr_t, sched_policy) - 32usize]; + ["Offset of field: pthread_attr_t::sched_priority"] + [::std::mem::offset_of!(pthread_attr_t, sched_priority) - 36usize]; + ["Offset of field: pthread_attr_t::__reserved"] + [::std::mem::offset_of!(pthread_attr_t, __reserved) - 40usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of pthread_barrier_t"][::std::mem::size_of::() - 32usize]; + ["Alignment of pthread_barrier_t"][::std::mem::align_of::() - 8usize]; + ["Offset of field: pthread_barrier_t::__private"] + [::std::mem::offset_of!(pthread_barrier_t, __private) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of pthread_cond_t"][::std::mem::size_of::() - 48usize]; + ["Alignment of pthread_cond_t"][::std::mem::align_of::() - 4usize]; + ["Offset of field: pthread_cond_t::__private"] + [::std::mem::offset_of!(pthread_cond_t, __private) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of pthread_mutex_t"][::std::mem::size_of::() - 40usize]; + ["Alignment of pthread_mutex_t"][::std::mem::align_of::() - 4usize]; + ["Offset of field: pthread_mutex_t::__private"] + [::std::mem::offset_of!(pthread_mutex_t, __private) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of pthread_rwlock_t"][::std::mem::size_of::() - 56usize]; + ["Alignment of pthread_rwlock_t"][::std::mem::align_of::() - 4usize]; + ["Offset of field: pthread_rwlock_t::__private"] + [::std::mem::offset_of!(pthread_rwlock_t, __private) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of pthread_spinlock_t"][::std::mem::size_of::() - 8usize]; + ["Alignment of pthread_spinlock_t"][::std::mem::align_of::() - 8usize]; + ["Offset of field: pthread_spinlock_t::__private"] + [::std::mem::offset_of!(pthread_spinlock_t, __private) - 0usize]; +}; +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] + fn extract_bit(byte: u8, index: usize) -> bool { + 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 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]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize); + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + 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 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]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = + (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize); + *byte = Self::change_bit(*byte, index, val); + } + #[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 unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); + let mut val = 0; + for i in 0..(bit_width as usize) { + if Self::raw_get_bit(this, 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); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); + 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::raw_set_bit(this, index + bit_offset, val_bit_is_set); + } + } +} +impl Default for __BindgenOpaqueArray { + fn default() -> Self { + Self([::default(); N]) + } +} +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 unsafe fn attrs_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 16u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_attrs_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn type__raw(this: *const Self) -> Il2CppTypeEnum { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_type_raw(this: *mut Self, val: Il2CppTypeEnum) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn num_mods_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 24usize, + 5u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_num_mods_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn byref_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 29usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_byref_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn pinned_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 30usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_pinned_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn valuetype_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 31usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_valuetype_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn is_generic_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_generic_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn is_inflated_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_inflated_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn wrapper_type_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_wrapper_type_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn has_full_generic_sharing_signature_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_has_full_generic_sharing_signature_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn initialized_and_no_error_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_initialized_and_no_error_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn initialized_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_initialized_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn enumtype_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_enumtype_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn nullabletype_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_nullabletype_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn is_generic_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_generic_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn has_references_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_has_references_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn init_pending_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_init_pending_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn size_init_pending_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 7usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_size_init_pending_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn size_inited_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_size_inited_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn has_finalize_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 9usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_has_finalize_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn has_cctor_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 10usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_has_cctor_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn is_blittable_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 11usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_blittable_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn is_import_or_windows_runtime_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 12usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_import_or_windows_runtime_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn is_vtable_initialized_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 13usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_vtable_initialized_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn is_byref_like_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 14usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_byref_like_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn mantLo_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 32u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_mantLo_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn mantHi_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 32usize, + 20u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_mantHi_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn exp_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 52usize, + 11u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_exp_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn sign_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 63usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_sign_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn mant_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 23u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_mant_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn exp_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 23usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_exp_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn sign_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 31usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_sign_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 + } +} +unsafe extern "C" { + pub fn android_get_application_target_sdk_version() -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn android_get_device_api_level() -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_init(domain_name: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_init_utf16(domain_name: *const Il2CppChar) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_shutdown(); +} +unsafe extern "C" { + pub fn il2cpp_set_config_dir(config_path: *const ::std::os::raw::c_char); +} +unsafe extern "C" { + pub fn il2cpp_set_data_dir(data_path: *const ::std::os::raw::c_char); +} +unsafe extern "C" { + pub fn il2cpp_set_temp_dir(temp_path: *const ::std::os::raw::c_char); +} +unsafe 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, + ); +} +unsafe 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, + ); +} +unsafe extern "C" { + pub fn il2cpp_set_config_utf16(executablePath: *const Il2CppChar); +} +unsafe extern "C" { + pub fn il2cpp_set_config(executablePath: *const ::std::os::raw::c_char); +} +unsafe extern "C" { + pub fn il2cpp_set_memory_callbacks(callbacks: *mut Il2CppMemoryCallbacks); +} +unsafe extern "C" { + pub fn il2cpp_get_corlib() -> *const Il2CppImage; +} +unsafe extern "C" { + pub fn il2cpp_add_internal_call( + name: *const ::std::os::raw::c_char, + method: Il2CppMethodPointer, + ); +} +unsafe extern "C" { + pub fn il2cpp_resolve_icall(name: *const ::std::os::raw::c_char) -> Il2CppMethodPointer; +} +unsafe extern "C" { + pub fn il2cpp_alloc(size: usize) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn il2cpp_free(ptr: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn il2cpp_array_class_get(element_class: *mut Il2CppClass, rank: u32) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_array_length(array: *mut Il2CppArray) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_array_get_byte_length(array: *mut Il2CppArray) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_array_new( + elementTypeInfo: *mut Il2CppClass, + length: il2cpp_array_size_t, + ) -> *mut Il2CppArray; +} +unsafe extern "C" { + pub fn il2cpp_array_new_specific( + arrayTypeInfo: *mut Il2CppClass, + length: il2cpp_array_size_t, + ) -> *mut Il2CppArray; +} +unsafe 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; +} +unsafe extern "C" { + pub fn il2cpp_bounded_array_class_get( + element_class: *mut Il2CppClass, + rank: u32, + bounded: u8, + ) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_array_element_size(array_class: *const Il2CppClass) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_assembly_get_image(assembly: *const Il2CppAssembly) -> *const Il2CppImage; +} +unsafe 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, + ); +} +unsafe extern "C" { + pub fn il2cpp_class_enum_basetype(klass: *mut Il2CppClass) -> *const Il2CppType; +} +unsafe extern "C" { + pub fn il2cpp_class_is_inited(klass: *const Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_is_generic(klass: *const Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_is_inflated(klass: *const Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_is_assignable_from(klass: *mut Il2CppClass, oklass: *mut Il2CppClass) + -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_is_subclass_of( + klass: *mut Il2CppClass, + klassc: *mut Il2CppClass, + check_interfaces: u8, + ) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_has_parent(klass: *mut Il2CppClass, klassc: *mut Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_from_il2cpp_type(type_: *const Il2CppType) -> *mut Il2CppClass; +} +unsafe 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; +} +unsafe extern "C" { + pub fn il2cpp_class_from_system_type(type_: *mut Il2CppReflectionType) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_class_get_element_class(klass: *mut Il2CppClass) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_class_get_events( + klass: *mut Il2CppClass, + iter: *mut *mut ::std::os::raw::c_void, + ) -> *const EventInfo; +} +unsafe extern "C" { + pub fn il2cpp_class_get_fields( + klass: *mut Il2CppClass, + iter: *mut *mut ::std::os::raw::c_void, + ) -> *mut FieldInfo; +} +unsafe extern "C" { + pub fn il2cpp_class_get_nested_types( + klass: *mut Il2CppClass, + iter: *mut *mut ::std::os::raw::c_void, + ) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_class_get_interfaces( + klass: *mut Il2CppClass, + iter: *mut *mut ::std::os::raw::c_void, + ) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_class_get_properties( + klass: *mut Il2CppClass, + iter: *mut *mut ::std::os::raw::c_void, + ) -> *const PropertyInfo; +} +unsafe extern "C" { + pub fn il2cpp_class_get_property_from_name( + klass: *mut Il2CppClass, + name: *const ::std::os::raw::c_char, + ) -> *const PropertyInfo; +} +unsafe extern "C" { + pub fn il2cpp_class_get_field_from_name( + klass: *mut Il2CppClass, + name: *const ::std::os::raw::c_char, + ) -> *mut FieldInfo; +} +unsafe extern "C" { + pub fn il2cpp_class_get_methods( + klass: *mut Il2CppClass, + iter: *mut *mut ::std::os::raw::c_void, + ) -> *const MethodInfo; +} +unsafe 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; +} +unsafe extern "C" { + pub fn il2cpp_class_get_name(klass: *mut Il2CppClass) -> *const ::std::os::raw::c_char; +} +unsafe 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, + ); +} +unsafe extern "C" { + pub fn il2cpp_class_get_namespace(klass: *mut Il2CppClass) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_class_get_parent(klass: *mut Il2CppClass) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_class_get_declaring_type(klass: *mut Il2CppClass) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_class_instance_size(klass: *mut Il2CppClass) -> i32; +} +unsafe extern "C" { + pub fn il2cpp_class_num_fields(enumKlass: *const Il2CppClass) -> usize; +} +unsafe extern "C" { + pub fn il2cpp_class_is_valuetype(klass: *const Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_value_size(klass: *mut Il2CppClass, align: *mut u32) -> i32; +} +unsafe extern "C" { + pub fn il2cpp_class_is_blittable(klass: *const Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_get_flags(klass: *const Il2CppClass) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_class_is_abstract(klass: *const Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_is_interface(klass: *const Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_array_element_size(klass: *const Il2CppClass) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_class_from_type(type_: *const Il2CppType) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_class_get_type(klass: *mut Il2CppClass) -> *const Il2CppType; +} +unsafe extern "C" { + pub fn il2cpp_class_get_type_token(klass: *mut Il2CppClass) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_class_has_attribute(klass: *mut Il2CppClass, attr_class: *mut Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_has_references(klass: *mut Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_is_enum(klass: *const Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_get_image(klass: *mut Il2CppClass) -> *const Il2CppImage; +} +unsafe extern "C" { + pub fn il2cpp_class_get_assemblyname( + klass: *const Il2CppClass, + ) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_class_get_rank(klass: *const Il2CppClass) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_class_get_data_size(klass: *const Il2CppClass) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_class_get_static_field_data( + klass: *const Il2CppClass, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn il2cpp_class_get_bitmap_size(klass: *const Il2CppClass) -> usize; +} +unsafe extern "C" { + pub fn il2cpp_class_get_bitmap(klass: *mut Il2CppClass, bitmap: *mut usize); +} +unsafe extern "C" { + pub fn il2cpp_stats_dump_to_file(path: *const ::std::os::raw::c_char) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_stats_get_value(stat: Il2CppStat) -> u64; +} +unsafe extern "C" { + pub fn il2cpp_domain_get() -> *mut Il2CppDomain; +} +unsafe extern "C" { + pub fn il2cpp_domain_assembly_open( + domain: *mut Il2CppDomain, + name: *const ::std::os::raw::c_char, + ) -> *const Il2CppAssembly; +} +unsafe extern "C" { + pub fn il2cpp_domain_get_assemblies( + domain: *const Il2CppDomain, + size: *mut usize, + ) -> *mut *const Il2CppAssembly; +} +unsafe extern "C" { + pub fn il2cpp_raise_exception(arg1: *mut Il2CppException) -> !; +} +unsafe 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; +} +unsafe extern "C" { + pub fn il2cpp_get_exception_argument_null( + arg: *const ::std::os::raw::c_char, + ) -> *mut Il2CppException; +} +unsafe extern "C" { + pub fn il2cpp_format_exception( + ex: *const Il2CppException, + message: *mut ::std::os::raw::c_char, + message_size: ::std::os::raw::c_int, + ); +} +unsafe 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, + ); +} +unsafe extern "C" { + pub fn il2cpp_unhandled_exception(arg1: *mut Il2CppException); +} +unsafe 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, + ); +} +unsafe extern "C" { + pub fn il2cpp_field_get_flags(field: *mut FieldInfo) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_field_get_name(field: *mut FieldInfo) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_field_get_parent(field: *mut FieldInfo) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_field_get_offset(field: *mut FieldInfo) -> usize; +} +unsafe extern "C" { + pub fn il2cpp_field_get_type(field: *mut FieldInfo) -> *const Il2CppType; +} +unsafe extern "C" { + pub fn il2cpp_field_get_value( + obj: *mut Il2CppObject, + field: *mut FieldInfo, + value: *mut ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub fn il2cpp_field_get_value_object( + field: *mut FieldInfo, + obj: *mut Il2CppObject, + ) -> *mut Il2CppObject; +} +unsafe extern "C" { + pub fn il2cpp_field_has_attribute(field: *mut FieldInfo, attr_class: *mut Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_field_set_value( + obj: *mut Il2CppObject, + field: *mut FieldInfo, + value: *mut ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub fn il2cpp_field_static_get_value(field: *mut FieldInfo, value: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn il2cpp_field_static_set_value(field: *mut FieldInfo, value: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn il2cpp_field_set_value_object( + instance: *mut Il2CppObject, + field: *mut FieldInfo, + value: *mut Il2CppObject, + ); +} +unsafe extern "C" { + pub fn il2cpp_field_is_literal(field: *mut FieldInfo) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_gc_collect(maxGenerations: ::std::os::raw::c_int); +} +unsafe extern "C" { + pub fn il2cpp_gc_collect_a_little() -> i32; +} +unsafe extern "C" { + pub fn il2cpp_gc_start_incremental_collection(); +} +unsafe extern "C" { + pub fn il2cpp_gc_disable(); +} +unsafe extern "C" { + pub fn il2cpp_gc_enable(); +} +unsafe extern "C" { + pub fn il2cpp_gc_is_disabled() -> u8; +} +unsafe extern "C" { + pub fn il2cpp_gc_set_mode(mode: Il2CppGCMode); +} +unsafe extern "C" { + pub fn il2cpp_gc_get_max_time_slice_ns() -> i64; +} +unsafe extern "C" { + pub fn il2cpp_gc_set_max_time_slice_ns(maxTimeSlice: i64); +} +unsafe extern "C" { + pub fn il2cpp_gc_is_incremental() -> u8; +} +unsafe extern "C" { + pub fn il2cpp_gc_get_used_size() -> i64; +} +unsafe extern "C" { + pub fn il2cpp_gc_get_heap_size() -> i64; +} +unsafe 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, + ); +} +unsafe extern "C" { + pub fn il2cpp_gc_has_strict_wbarriers() -> u8; +} +unsafe 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, + ), + >, + ); +} +unsafe extern "C" { + pub fn il2cpp_gc_set_external_wbarrier_tracker( + func: ::std::option::Option, + ); +} +unsafe 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, + ); +} +unsafe extern "C" { + pub fn il2cpp_stop_gc_world(); +} +unsafe extern "C" { + pub fn il2cpp_start_gc_world(); +} +unsafe extern "C" { + pub fn il2cpp_gc_alloc_fixed(size: usize) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn il2cpp_gc_free_fixed(address: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn il2cpp_gchandle_new(obj: *mut Il2CppObject, pinned: u8) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_gchandle_new_weakref(obj: *mut Il2CppObject, track_resurrection: u8) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_gchandle_get_target(gchandle: u32) -> *mut Il2CppObject; +} +unsafe extern "C" { + pub fn il2cpp_gchandle_free(gchandle: u32); +} +unsafe 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, + ); +} +unsafe extern "C" { + pub fn il2cpp_object_header_size() -> u32; +} +unsafe extern "C" { + pub fn il2cpp_array_object_header_size() -> u32; +} +unsafe extern "C" { + pub fn il2cpp_offset_of_array_length_in_array_object_header() -> u32; +} +unsafe extern "C" { + pub fn il2cpp_offset_of_array_bounds_in_array_object_header() -> u32; +} +unsafe extern "C" { + pub fn il2cpp_allocation_granularity() -> u32; +} +unsafe 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; +} +unsafe extern "C" { + pub fn il2cpp_unity_liveness_calculation_from_root( + root: *mut Il2CppObject, + state: *mut ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub fn il2cpp_unity_liveness_calculation_from_statics(state: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn il2cpp_unity_liveness_finalize(state: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn il2cpp_unity_liveness_free_struct(state: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn il2cpp_method_get_return_type(method: *const MethodInfo) -> *const Il2CppType; +} +unsafe extern "C" { + pub fn il2cpp_method_get_declaring_type(method: *const MethodInfo) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_method_get_name(method: *const MethodInfo) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_method_get_from_reflection( + method: *const Il2CppReflectionMethod, + ) -> *const MethodInfo; +} +unsafe extern "C" { + pub fn il2cpp_method_get_object( + method: *const MethodInfo, + refclass: *mut Il2CppClass, + ) -> *mut Il2CppReflectionMethod; +} +unsafe extern "C" { + pub fn il2cpp_method_is_generic(method: *const MethodInfo) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_method_is_inflated(method: *const MethodInfo) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_method_is_instance(method: *const MethodInfo) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_method_get_param_count(method: *const MethodInfo) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_method_get_param(method: *const MethodInfo, index: u32) -> *const Il2CppType; +} +unsafe extern "C" { + pub fn il2cpp_method_get_class(method: *const MethodInfo) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_method_has_attribute( + method: *const MethodInfo, + attr_class: *mut Il2CppClass, + ) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_method_get_flags(method: *const MethodInfo, iflags: *mut u32) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_method_get_token(method: *const MethodInfo) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_method_get_param_name( + method: *const MethodInfo, + index: u32, + ) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_profiler_install(prof: *mut Il2CppProfiler, shutdown_callback: Il2CppProfileFunc); +} +unsafe extern "C" { + pub fn il2cpp_profiler_set_events(events: Il2CppProfileFlags); +} +unsafe extern "C" { + pub fn il2cpp_profiler_install_enter_leave( + enter: Il2CppProfileMethodFunc, + fleave: Il2CppProfileMethodFunc, + ); +} +unsafe extern "C" { + pub fn il2cpp_profiler_install_allocation(callback: Il2CppProfileAllocFunc); +} +unsafe extern "C" { + pub fn il2cpp_profiler_install_gc( + callback: Il2CppProfileGCFunc, + heap_resize_callback: Il2CppProfileGCResizeFunc, + ); +} +unsafe extern "C" { + pub fn il2cpp_profiler_install_fileio(callback: Il2CppProfileFileIOFunc); +} +unsafe extern "C" { + pub fn il2cpp_profiler_install_thread( + start: Il2CppProfileThreadFunc, + end: Il2CppProfileThreadFunc, + ); +} +unsafe extern "C" { + pub fn il2cpp_property_get_flags(prop: *mut PropertyInfo) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_property_get_get_method(prop: *mut PropertyInfo) -> *const MethodInfo; +} +unsafe extern "C" { + pub fn il2cpp_property_get_set_method(prop: *mut PropertyInfo) -> *const MethodInfo; +} +unsafe extern "C" { + pub fn il2cpp_property_get_name(prop: *mut PropertyInfo) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_property_get_parent(prop: *mut PropertyInfo) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_object_get_class(obj: *mut Il2CppObject) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_object_get_size(obj: *mut Il2CppObject) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_object_get_virtual_method( + obj: *mut Il2CppObject, + method: *const MethodInfo, + ) -> *const MethodInfo; +} +unsafe extern "C" { + pub fn il2cpp_object_new(klass: *const Il2CppClass) -> *mut Il2CppObject; +} +unsafe extern "C" { + pub fn il2cpp_object_unbox(obj: *mut Il2CppObject) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn il2cpp_value_box( + klass: *mut Il2CppClass, + data: *mut ::std::os::raw::c_void, + ) -> *mut Il2CppObject; +} +unsafe extern "C" { + pub fn il2cpp_monitor_enter(obj: *mut Il2CppObject); +} +unsafe extern "C" { + pub fn il2cpp_monitor_try_enter(obj: *mut Il2CppObject, timeout: u32) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_monitor_exit(obj: *mut Il2CppObject); +} +unsafe extern "C" { + pub fn il2cpp_monitor_pulse(obj: *mut Il2CppObject); +} +unsafe extern "C" { + pub fn il2cpp_monitor_pulse_all(obj: *mut Il2CppObject); +} +unsafe extern "C" { + pub fn il2cpp_monitor_wait(obj: *mut Il2CppObject); +} +unsafe extern "C" { + pub fn il2cpp_monitor_try_wait(obj: *mut Il2CppObject, timeout: u32) -> u8; +} +unsafe 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; +} +unsafe 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; +} +unsafe extern "C" { + pub fn il2cpp_runtime_class_init(klass: *mut Il2CppClass); +} +unsafe extern "C" { + pub fn il2cpp_runtime_object_init(obj: *mut Il2CppObject); +} +unsafe extern "C" { + pub fn il2cpp_runtime_object_init_exception( + obj: *mut Il2CppObject, + exc: *mut *mut Il2CppException, + ); +} +unsafe extern "C" { + pub fn il2cpp_runtime_unhandled_exception_policy_set( + value: Il2CppRuntimeUnhandledExceptionPolicy, + ); +} +unsafe extern "C" { + pub fn il2cpp_string_length(str_: *mut Il2CppString) -> i32; +} +unsafe extern "C" { + pub fn il2cpp_string_chars(str_: *mut Il2CppString) -> *mut Il2CppChar; +} +unsafe extern "C" { + pub fn il2cpp_string_new(str_: *const ::std::os::raw::c_char) -> *mut Il2CppString; +} +unsafe extern "C" { + pub fn il2cpp_string_new_len( + str_: *const ::std::os::raw::c_char, + length: u32, + ) -> *mut Il2CppString; +} +unsafe extern "C" { + pub fn il2cpp_string_new_utf16(text: *const Il2CppChar, len: i32) -> *mut Il2CppString; +} +unsafe extern "C" { + pub fn il2cpp_string_new_wrapper(str_: *const ::std::os::raw::c_char) -> *mut Il2CppString; +} +unsafe extern "C" { + pub fn il2cpp_string_intern(str_: *mut Il2CppString) -> *mut Il2CppString; +} +unsafe extern "C" { + pub fn il2cpp_string_is_interned(str_: *mut Il2CppString) -> *mut Il2CppString; +} +unsafe extern "C" { + pub fn il2cpp_thread_current() -> *mut Il2CppThread; +} +unsafe extern "C" { + pub fn il2cpp_thread_attach(domain: *mut Il2CppDomain) -> *mut Il2CppThread; +} +unsafe extern "C" { + pub fn il2cpp_thread_detach(thread: *mut Il2CppThread); +} +unsafe extern "C" { + pub fn il2cpp_thread_get_all_attached_threads(size: *mut usize) -> *mut *mut Il2CppThread; +} +unsafe extern "C" { + pub fn il2cpp_is_vm_thread(thread: *mut Il2CppThread) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_current_thread_walk_frame_stack( + func: Il2CppFrameWalkFunc, + user_data: *mut ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub fn il2cpp_thread_walk_frame_stack( + thread: *mut Il2CppThread, + func: Il2CppFrameWalkFunc, + user_data: *mut ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub fn il2cpp_current_thread_get_top_frame(frame: *mut Il2CppStackFrameInfo) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_thread_get_top_frame( + thread: *mut Il2CppThread, + frame: *mut Il2CppStackFrameInfo, + ) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_current_thread_get_frame_at(offset: i32, frame: *mut Il2CppStackFrameInfo) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_thread_get_frame_at( + thread: *mut Il2CppThread, + offset: i32, + frame: *mut Il2CppStackFrameInfo, + ) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_current_thread_get_stack_depth() -> i32; +} +unsafe extern "C" { + pub fn il2cpp_thread_get_stack_depth(thread: *mut Il2CppThread) -> i32; +} +unsafe extern "C" { + pub fn il2cpp_override_stack_backtrace(stackBacktraceFunc: Il2CppBacktraceFunc); +} +unsafe extern "C" { + pub fn il2cpp_type_get_object(type_: *const Il2CppType) -> *mut Il2CppObject; +} +unsafe extern "C" { + pub fn il2cpp_type_get_type(type_: *const Il2CppType) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_type_get_class_or_element_class(type_: *const Il2CppType) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_type_get_name(type_: *const Il2CppType) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_type_is_byref(type_: *const Il2CppType) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_type_get_attrs(type_: *const Il2CppType) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_type_equals(type_: *const Il2CppType, otherType: *const Il2CppType) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_type_get_assembly_qualified_name( + type_: *const Il2CppType, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_type_get_reflection_name(type_: *const Il2CppType) + -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_type_is_static(type_: *const Il2CppType) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_type_is_pointer_type(type_: *const Il2CppType) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_image_get_assembly(image: *const Il2CppImage) -> *const Il2CppAssembly; +} +unsafe extern "C" { + pub fn il2cpp_image_get_name(image: *const Il2CppImage) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_image_get_filename(image: *const Il2CppImage) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_image_get_entry_point(image: *const Il2CppImage) -> *const MethodInfo; +} +unsafe extern "C" { + pub fn il2cpp_image_get_class_count(image: *const Il2CppImage) -> usize; +} +unsafe extern "C" { + pub fn il2cpp_image_get_class(image: *const Il2CppImage, index: usize) -> *const Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_capture_memory_snapshot() -> *mut Il2CppManagedMemorySnapshot; +} +unsafe extern "C" { + pub fn il2cpp_free_captured_memory_snapshot(snapshot: *mut Il2CppManagedMemorySnapshot); +} +unsafe extern "C" { + pub fn il2cpp_set_find_plugin_callback(method: Il2CppSetFindPlugInCallback); +} +unsafe extern "C" { + pub fn il2cpp_register_log_callback(method: Il2CppLogCallback); +} +unsafe extern "C" { + pub fn il2cpp_debugger_set_agent_options(options: *const ::std::os::raw::c_char); +} +unsafe extern "C" { + pub fn il2cpp_is_debugger_attached() -> u8; +} +unsafe extern "C" { + pub fn il2cpp_register_debugger_agent_transport( + debuggerTransport: *mut Il2CppDebuggerTransport, + ); +} +unsafe extern "C" { + pub fn il2cpp_debug_get_method_info( + arg1: *const MethodInfo, + methodDebugInfo: *mut Il2CppMethodDebugInfo, + ) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_unity_install_unitytls_interface( + unitytlsInterfaceStruct: *const ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub fn il2cpp_custom_attrs_from_class(klass: *mut Il2CppClass) -> *mut Il2CppCustomAttrInfo; +} +unsafe extern "C" { + pub fn il2cpp_custom_attrs_from_method(method: *const MethodInfo) -> *mut Il2CppCustomAttrInfo; +} +unsafe extern "C" { + pub fn il2cpp_custom_attrs_from_field(field: *const FieldInfo) -> *mut Il2CppCustomAttrInfo; +} +unsafe extern "C" { + pub fn il2cpp_custom_attrs_get_attr( + ainfo: *mut Il2CppCustomAttrInfo, + attr_klass: *mut Il2CppClass, + ) -> *mut Il2CppObject; +} +unsafe extern "C" { + pub fn il2cpp_custom_attrs_has_attr( + ainfo: *mut Il2CppCustomAttrInfo, + attr_klass: *mut Il2CppClass, + ) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_custom_attrs_construct(cinfo: *mut Il2CppCustomAttrInfo) -> *mut Il2CppArray; +} +unsafe extern "C" { + pub fn il2cpp_custom_attrs_free(ainfo: *mut Il2CppCustomAttrInfo); +} +unsafe extern "C" { + pub fn il2cpp_class_set_userdata( + klass: *mut Il2CppClass, + userdata: *mut ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub fn il2cpp_class_get_userdata_offset() -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_set_default_thread_affinity(affinity_mask: i64); +} +unsafe extern "C" { + pub fn il2cpp_unity_set_android_network_up_state_func(func: Il2CppAndroidUpStateFunc); +} +unsafe extern "C" { + pub fn strcasecmp( + __s1: *const ::std::os::raw::c_char, + __s2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strcasecmp_l( + __s1: *const ::std::os::raw::c_char, + __s2: *const ::std::os::raw::c_char, + __l: locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strncasecmp( + __s1: *const ::std::os::raw::c_char, + __s2: *const ::std::os::raw::c_char, + __n: ::std::os::raw::c_ulong, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strncasecmp_l( + __s1: *const ::std::os::raw::c_char, + __s2: *const ::std::os::raw::c_char, + __n: usize, + __l: locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn memccpy( + __dst: *mut ::std::os::raw::c_void, + __src: *const ::std::os::raw::c_void, + __stop_char: ::std::os::raw::c_int, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn memchr( + __s: *const ::std::os::raw::c_void, + __ch: ::std::os::raw::c_int, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn memrchr( + __s: *const ::std::os::raw::c_void, + __ch: ::std::os::raw::c_int, + __n: usize, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn memcmp( + __lhs: *const ::std::os::raw::c_void, + __rhs: *const ::std::os::raw::c_void, + __n: ::std::os::raw::c_ulong, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn memcpy( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn memmove( + __dst: *mut ::std::os::raw::c_void, + __src: *const ::std::os::raw::c_void, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn memset( + __dst: *mut ::std::os::raw::c_void, + __ch: ::std::os::raw::c_int, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn memset_explicit( + __dst: *mut ::std::os::raw::c_void, + __ch: ::std::os::raw::c_int, + __n: usize, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn memmem( + __haystack: *const ::std::os::raw::c_void, + __haystack_size: usize, + __needle: *const ::std::os::raw::c_void, + __needle_size: usize, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn strchr( + __s: *const ::std::os::raw::c_char, + __ch: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn __strchr_chk( + __s: *const ::std::os::raw::c_char, + __ch: ::std::os::raw::c_int, + __n: usize, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strrchr( + __s: *const ::std::os::raw::c_char, + __ch: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn __strrchr_chk( + __s: *const ::std::os::raw::c_char, + __ch: ::std::os::raw::c_int, + __n: usize, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strlen(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_ulong; +} +unsafe extern "C" { + pub fn __strlen_chk(__s: *const ::std::os::raw::c_char, __n: usize) -> usize; +} +unsafe extern "C" { + pub fn strcmp( + __lhs: *const ::std::os::raw::c_char, + __rhs: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn stpcpy( + __dst: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strcpy( + __dst: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strcat( + __dst: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strdup(__s: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strstr( + __haystack: *const ::std::os::raw::c_char, + __needle: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strcasestr( + __haystack: *const ::std::os::raw::c_char, + __needle: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strtok( + __s: *mut ::std::os::raw::c_char, + __delimiter: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strtok_r( + __s: *mut ::std::os::raw::c_char, + __delimiter: *const ::std::os::raw::c_char, + __pos_ptr: *mut *mut ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strerror(__errno_value: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strerror_l( + __errno_value: ::std::os::raw::c_int, + __l: locale_t, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strerror_r( + __errno_value: ::std::os::raw::c_int, + __buf: *mut ::std::os::raw::c_char, + __n: usize, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strnlen(__s: *const ::std::os::raw::c_char, __n: usize) -> usize; +} +unsafe extern "C" { + pub fn strncat( + __dst: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strndup( + __s: *const ::std::os::raw::c_char, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strncmp( + __lhs: *const ::std::os::raw::c_char, + __rhs: *const ::std::os::raw::c_char, + __n: ::std::os::raw::c_ulong, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn stpncpy( + __dst: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strncpy( + __dst: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strlcat( + __dst: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + __n: usize, + ) -> usize; +} +unsafe extern "C" { + pub fn strlcpy( + __dst: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + __n: usize, + ) -> usize; +} +unsafe extern "C" { + pub fn strcspn( + __s: *const ::std::os::raw::c_char, + __reject: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_ulong; +} +unsafe extern "C" { + pub fn strpbrk( + __s: *const ::std::os::raw::c_char, + __accept: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strsep( + __s_ptr: *mut *mut ::std::os::raw::c_char, + __delimiter: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strspn( + __s: *const ::std::os::raw::c_char, + __accept: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_ulong; +} +unsafe extern "C" { + pub fn strsignal(__signal: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strcoll( + __lhs: *const ::std::os::raw::c_char, + __rhs: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strxfrm( + __dst: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + __n: ::std::os::raw::c_ulong, + ) -> ::std::os::raw::c_ulong; +} +unsafe extern "C" { + pub fn strcoll_l( + __lhs: *const ::std::os::raw::c_char, + __rhs: *const ::std::os::raw::c_char, + __l: locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strxfrm_l( + __dst: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + __n: usize, + __l: locale_t, + ) -> usize; +} +unsafe extern "C" { + pub static kIl2CppUInt64Max: u64; +} +unsafe extern "C" { + pub static kIl2CppUIntPtrMax: usize; +} +unsafe extern "C" { + pub static kIl2CppNewLine: [Il2CppChar; 2usize]; +} +unsafe extern "C" { + pub static mut il2cpp_defaults: Il2CppDefaults; +} diff --git a/libil2cpp/src/raw/types_v31/linux.rs b/libil2cpp/src/raw/types_v31/linux.rs new file mode 100644 index 00000000..9476e849 --- /dev/null +++ b/libil2cpp/src/raw/types_v31/linux.rs @@ -0,0 +1,8516 @@ +/* automatically generated by rust-bindgen 0.71.1 */ + +pub type __u_char = ::std::os::raw::c_uchar; +pub type __u_short = ::std::os::raw::c_ushort; +pub type __u_int = ::std::os::raw::c_uint; +pub type __u_long = ::std::os::raw::c_ulong; +pub type __int8_t = ::std::os::raw::c_schar; +pub type __uint8_t = ::std::os::raw::c_uchar; +pub type __int16_t = ::std::os::raw::c_short; +pub type __uint16_t = ::std::os::raw::c_ushort; +pub type __int32_t = ::std::os::raw::c_int; +pub type __uint32_t = ::std::os::raw::c_uint; +pub type __int64_t = ::std::os::raw::c_long; +pub type __uint64_t = ::std::os::raw::c_ulong; +pub type __int_least8_t = __int8_t; +pub type __uint_least8_t = __uint8_t; +pub type __int_least16_t = __int16_t; +pub type __uint_least16_t = __uint16_t; +pub type __int_least32_t = __int32_t; +pub type __uint_least32_t = __uint32_t; +pub type __int_least64_t = __int64_t; +pub type __uint_least64_t = __uint64_t; +pub type __quad_t = ::std::os::raw::c_long; +pub type __u_quad_t = ::std::os::raw::c_ulong; +pub type __intmax_t = ::std::os::raw::c_long; +pub type __uintmax_t = ::std::os::raw::c_ulong; +pub type __dev_t = ::std::os::raw::c_ulong; +pub type __uid_t = ::std::os::raw::c_uint; +pub type __gid_t = ::std::os::raw::c_uint; +pub type __ino_t = ::std::os::raw::c_ulong; +pub type __ino64_t = ::std::os::raw::c_ulong; +pub type __mode_t = ::std::os::raw::c_uint; +pub type __nlink_t = ::std::os::raw::c_ulong; +pub type __off_t = ::std::os::raw::c_long; +pub type __off64_t = ::std::os::raw::c_long; +pub type __pid_t = ::std::os::raw::c_int; +pub type __clock_t = ::std::os::raw::c_long; +pub type __rlim_t = ::std::os::raw::c_ulong; +pub type __rlim64_t = ::std::os::raw::c_ulong; +pub type __id_t = ::std::os::raw::c_uint; +pub type __time_t = ::std::os::raw::c_long; +pub type __useconds_t = ::std::os::raw::c_uint; +pub type __suseconds_t = ::std::os::raw::c_long; +pub type __suseconds64_t = ::std::os::raw::c_long; +pub type __daddr_t = ::std::os::raw::c_int; +pub type __key_t = ::std::os::raw::c_int; +pub type __clockid_t = ::std::os::raw::c_int; +pub type __timer_t = *mut ::std::os::raw::c_void; +pub type __blksize_t = ::std::os::raw::c_long; +pub type __blkcnt_t = ::std::os::raw::c_long; +pub type __blkcnt64_t = ::std::os::raw::c_long; +pub type __fsblkcnt_t = ::std::os::raw::c_ulong; +pub type __fsblkcnt64_t = ::std::os::raw::c_ulong; +pub type __fsfilcnt_t = ::std::os::raw::c_ulong; +pub type __fsfilcnt64_t = ::std::os::raw::c_ulong; +pub type __fsword_t = ::std::os::raw::c_long; +pub type __ssize_t = ::std::os::raw::c_long; +pub type __syscall_slong_t = ::std::os::raw::c_long; +pub type __syscall_ulong_t = ::std::os::raw::c_ulong; +pub type __loff_t = __off64_t; +pub type __caddr_t = *mut ::std::os::raw::c_char; +pub type __intptr_t = ::std::os::raw::c_long; +pub type __socklen_t = ::std::os::raw::c_uint; +pub type __sig_atomic_t = ::std::os::raw::c_int; +pub type int_least8_t = __int_least8_t; +pub type int_least16_t = __int_least16_t; +pub type int_least32_t = __int_least32_t; +pub type int_least64_t = __int_least64_t; +pub type uint_least8_t = __uint_least8_t; +pub type uint_least16_t = __uint_least16_t; +pub type uint_least32_t = __uint_least32_t; +pub type uint_least64_t = __uint_least64_t; +pub type int_fast8_t = ::std::os::raw::c_schar; +pub type int_fast16_t = ::std::os::raw::c_long; +pub type int_fast32_t = ::std::os::raw::c_long; +pub type int_fast64_t = ::std::os::raw::c_long; +pub type uint_fast8_t = ::std::os::raw::c_uchar; +pub type uint_fast16_t = ::std::os::raw::c_ulong; +pub type uint_fast32_t = ::std::os::raw::c_ulong; +pub type uint_fast64_t = ::std::os::raw::c_ulong; +pub type intmax_t = __intmax_t; +pub type uintmax_t = __uintmax_t; +pub type wchar_t = ::std::os::raw::c_int; +pub type Il2CppProfileFlags = ::std::os::raw::c_uint; +pub type Il2CppProfileFileIOKind = ::std::os::raw::c_uint; +pub type Il2CppGCEvent = ::std::os::raw::c_uint; +pub type Il2CppGCMode = ::std::os::raw::c_uint; +pub type Il2CppStat = ::std::os::raw::c_uint; +pub type Il2CppRuntimeUnhandledExceptionPolicy = ::std::os::raw::c_uint; +pub type Il2CppMethodPointer = ::std::option::Option; +pub type Il2CppChar = u16; +pub type Il2CppNativeChar = ::std::os::raw::c_char; +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 __locale_t = *mut __locale_struct; +pub type locale_t = __locale_t; +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_uint; +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_uint; +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_uint; +pub type Il2CppCallConvention = ::std::os::raw::c_uint; +pub type Il2CppCharSet = ::std::os::raw::c_uint; +pub type Il2CppHString = *mut Il2CppHString__; +pub type IL2CPP_VARIANT_BOOL = i16; +pub type Il2CppVarType = ::std::os::raw::c_uint; +pub type Il2CppWindowsRuntimeTypeKind = ::std::os::raw::c_uint; +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_uint; +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_uint; +pub type SequencePointKind = ::std::os::raw::c_uint; +pub type Il2CppVTable = Il2CppClass; +pub type il2cpp_array_lower_bound_t = i32; +pub type Il2CppCallType = ::std::os::raw::c_uint; +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_uint; +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 __fsid_t { + pub __val: [::std::os::raw::c_int; 2usize], +} +#[repr(C)] +#[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct max_align_t { + pub __clang_max_align_nonce1: ::std::os::raw::c_longlong, + pub __bindgen_padding_0: u64, + pub __clang_max_align_nonce2: u128, +} +#[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 __locale_struct { + pub __locales: [*mut __locale_data; 13usize], + pub __ctype_b: *const ::std::os::raw::c_ushort, + pub __ctype_tolower: *const ::std::os::raw::c_int, + pub __ctype_toupper: *const ::std::os::raw::c_int, + pub __names: [*const ::std::os::raw::c_char; 13usize], +} +#[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 __locale_data { + pub _address: u8, +} +pub const _STDINT_H: u32 = 1; +pub const _FEATURES_H: u32 = 1; +pub const _DEFAULT_SOURCE: u32 = 1; +pub const __GLIBC_USE_ISOC2X: u32 = 0; +pub const __USE_ISOC11: u32 = 1; +pub const __USE_ISOC99: u32 = 1; +pub const __USE_ISOC95: u32 = 1; +pub const __USE_POSIX_IMPLICITLY: u32 = 1; +pub const _POSIX_SOURCE: u32 = 1; +pub const _POSIX_C_SOURCE: u32 = 200809; +pub const __USE_POSIX: u32 = 1; +pub const __USE_POSIX2: u32 = 1; +pub const __USE_POSIX199309: u32 = 1; +pub const __USE_POSIX199506: u32 = 1; +pub const __USE_XOPEN2K: u32 = 1; +pub const __USE_XOPEN2K8: u32 = 1; +pub const _ATFILE_SOURCE: u32 = 1; +pub const __WORDSIZE: u32 = 64; +pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1; +pub const __SYSCALL_WORDSIZE: u32 = 64; +pub const __TIMESIZE: u32 = 64; +pub const __USE_MISC: u32 = 1; +pub const __USE_ATFILE: u32 = 1; +pub const __USE_FORTIFY_LEVEL: u32 = 0; +pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0; +pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0; +pub const _STDC_PREDEF_H: u32 = 1; +pub const __STDC_IEC_559__: u32 = 1; +pub const __STDC_IEC_60559_BFP__: u32 = 201404; +pub const __STDC_IEC_559_COMPLEX__: u32 = 1; +pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404; +pub const __STDC_ISO_10646__: u32 = 201706; +pub const __GNU_LIBRARY__: u32 = 6; +pub const __GLIBC__: u32 = 2; +pub const __GLIBC_MINOR__: u32 = 35; +pub const _SYS_CDEFS_H: u32 = 1; +pub const __glibc_c99_flexarr_available: u32 = 1; +pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0; +pub const __HAVE_GENERIC_SELECTION: u32 = 1; +pub const __GLIBC_USE_LIB_EXT2: u32 = 0; +pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0; +pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0; +pub const __GLIBC_USE_IEC_60559_EXT: u32 = 0; +pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0; +pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0; +pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0; +pub const _BITS_TYPES_H: u32 = 1; +pub const _BITS_TYPESIZES_H: u32 = 1; +pub const __OFF_T_MATCHES_OFF64_T: u32 = 1; +pub const __INO_T_MATCHES_INO64_T: u32 = 1; +pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1; +pub const __STATFS_MATCHES_STATFS64: u32 = 1; +pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 1; +pub const __FD_SETSIZE: u32 = 1024; +pub const _BITS_TIME64_H: u32 = 1; +pub const _BITS_WCHAR_H: u32 = 1; +pub const _BITS_STDINT_INTN_H: u32 = 1; +pub const _BITS_STDINT_UINTN_H: u32 = 1; +pub const INT8_MIN: i32 = -128; +pub const INT16_MIN: i32 = -32768; +pub const INT32_MIN: i32 = -2147483648; +pub const INT8_MAX: u32 = 127; +pub const INT16_MAX: u32 = 32767; +pub const INT32_MAX: u32 = 2147483647; +pub const UINT8_MAX: u32 = 255; +pub const UINT16_MAX: u32 = 65535; +pub const UINT32_MAX: u32 = 4294967295; +pub const INT_LEAST8_MIN: i32 = -128; +pub const INT_LEAST16_MIN: i32 = -32768; +pub const INT_LEAST32_MIN: i32 = -2147483648; +pub const INT_LEAST8_MAX: u32 = 127; +pub const INT_LEAST16_MAX: u32 = 32767; +pub const INT_LEAST32_MAX: u32 = 2147483647; +pub const UINT_LEAST8_MAX: u32 = 255; +pub const UINT_LEAST16_MAX: u32 = 65535; +pub const UINT_LEAST32_MAX: u32 = 4294967295; +pub const INT_FAST8_MIN: i32 = -128; +pub const INT_FAST16_MIN: i64 = -9223372036854775808; +pub const INT_FAST32_MIN: i64 = -9223372036854775808; +pub const INT_FAST8_MAX: u32 = 127; +pub const INT_FAST16_MAX: u64 = 9223372036854775807; +pub const INT_FAST32_MAX: u64 = 9223372036854775807; +pub const UINT_FAST8_MAX: u32 = 255; +pub const UINT_FAST16_MAX: i32 = -1; +pub const UINT_FAST32_MAX: i32 = -1; +pub const INTPTR_MIN: i64 = -9223372036854775808; +pub const INTPTR_MAX: u64 = 9223372036854775807; +pub const UINTPTR_MAX: i32 = -1; +pub const PTRDIFF_MIN: i64 = -9223372036854775808; +pub const PTRDIFF_MAX: u64 = 9223372036854775807; +pub const SIG_ATOMIC_MIN: i32 = -2147483648; +pub const SIG_ATOMIC_MAX: u32 = 2147483647; +pub const SIZE_MAX: i32 = -1; +pub const WINT_MIN: u32 = 0; +pub const WINT_MAX: u32 = 4294967295; +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_LINUX: u32 = 1; +pub const IL2CPP_PLATFORM_SUPPORTS_CPU_INFO: u32 = 1; +pub const IL2CPP_PLATFORM_SUPPORTS_SYSTEM_CERTIFICATES: u32 = 1; +pub const IL2CPP_TARGET_WINDOWS: u32 = 0; +pub const IL2CPP_TARGET_WINDOWS_DESKTOP: u32 = 0; +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_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_SUPPORTS_DEBUGGER_PRESENT: 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 IL2CPP_API_DYNAMIC_NO_DLSYM: u32 = 0; +pub const IL2CPP_POINTER_SPARE_BITS: u32 = 0; +pub const _STRING_H: u32 = 1; +pub const _BITS_TYPES_LOCALE_T_H: u32 = 1; +pub const _BITS_TYPES___LOCALE_T_H: u32 = 1; +pub const _STRINGS_H: u32 = 1; +pub const IL2CPP_CXX_ABI_MSVC: u32 = 0; +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 = 0; +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 = 47u8; +pub const IL2CPP_DISABLE_FULL_MESSAGES: u32 = 1; +pub const IL2CPP_USE_SEND_NOSIGNAL: u32 = 1; +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 = 0; +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 __fsid_t"][::std::mem::size_of::<__fsid_t>() - 8usize]; + ["Alignment of __fsid_t"][::std::mem::align_of::<__fsid_t>() - 4usize]; + ["Offset of field: __fsid_t::__val"][::std::mem::offset_of!(__fsid_t, __val) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of max_align_t"][::std::mem::size_of::() - 32usize]; + ["Alignment of max_align_t"][::std::mem::align_of::() - 16usize]; + ["Offset of field: max_align_t::__clang_max_align_nonce1"] + [::std::mem::offset_of!(max_align_t, __clang_max_align_nonce1) - 0usize]; + ["Offset of field: max_align_t::__clang_max_align_nonce2"] + [::std::mem::offset_of!(max_align_t, __clang_max_align_nonce2) - 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]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of __locale_struct"][::std::mem::size_of::<__locale_struct>() - 232usize]; + ["Alignment of __locale_struct"][::std::mem::align_of::<__locale_struct>() - 8usize]; + ["Offset of field: __locale_struct::__locales"] + [::std::mem::offset_of!(__locale_struct, __locales) - 0usize]; + ["Offset of field: __locale_struct::__ctype_b"] + [::std::mem::offset_of!(__locale_struct, __ctype_b) - 104usize]; + ["Offset of field: __locale_struct::__ctype_tolower"] + [::std::mem::offset_of!(__locale_struct, __ctype_tolower) - 112usize]; + ["Offset of field: __locale_struct::__ctype_toupper"] + [::std::mem::offset_of!(__locale_struct, __ctype_toupper) - 120usize]; + ["Offset of field: __locale_struct::__names"] + [::std::mem::offset_of!(__locale_struct, __names) - 128usize]; +}; +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] + fn extract_bit(byte: u8, index: usize) -> bool { + 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 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]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize); + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { + 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 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]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = + (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize); + *byte = Self::change_bit(*byte, index, val); + } + #[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 unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); + let mut val = 0; + for i in 0..(bit_width as usize) { + if Self::raw_get_bit(this, 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); + } + } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); + 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::raw_set_bit(this, 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 unsafe fn attrs_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 16u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_attrs_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn type__raw(this: *const Self) -> Il2CppTypeEnum { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_type_raw(this: *mut Self, val: Il2CppTypeEnum) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn num_mods_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 24usize, + 5u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_num_mods_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn byref_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 29usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_byref_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn pinned_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 30usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_pinned_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn valuetype_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 31usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_valuetype_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn is_generic_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_generic_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn is_inflated_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_inflated_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn wrapper_type_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_wrapper_type_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn has_full_generic_sharing_signature_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_has_full_generic_sharing_signature_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn initialized_and_no_error_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_initialized_and_no_error_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn initialized_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_initialized_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn enumtype_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_enumtype_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn nullabletype_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_nullabletype_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn is_generic_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_generic_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn has_references_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_has_references_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn init_pending_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_init_pending_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn size_init_pending_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 7usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_size_init_pending_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn size_inited_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_size_inited_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn has_finalize_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 9usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_has_finalize_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn has_cctor_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 10usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_has_cctor_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn is_blittable_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 11usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_blittable_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn is_import_or_windows_runtime_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 12usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_import_or_windows_runtime_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn is_vtable_initialized_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 13usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_vtable_initialized_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn is_byref_like_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 14usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_byref_like_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn mantLo_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 32u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_mantLo_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn mantHi_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 32usize, + 20u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_mantHi_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn exp_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 52usize, + 11u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_exp_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn sign_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 63usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_sign_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn mant_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 23u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_mant_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn exp_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 23usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_exp_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 unsafe fn sign_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 31usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_sign_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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 + } +} +unsafe extern "C" { + pub fn il2cpp_init(domain_name: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_init_utf16(domain_name: *const Il2CppChar) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_shutdown(); +} +unsafe extern "C" { + pub fn il2cpp_set_config_dir(config_path: *const ::std::os::raw::c_char); +} +unsafe extern "C" { + pub fn il2cpp_set_data_dir(data_path: *const ::std::os::raw::c_char); +} +unsafe extern "C" { + pub fn il2cpp_set_temp_dir(temp_path: *const ::std::os::raw::c_char); +} +unsafe 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, + ); +} +unsafe 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, + ); +} +unsafe extern "C" { + pub fn il2cpp_set_config_utf16(executablePath: *const Il2CppChar); +} +unsafe extern "C" { + pub fn il2cpp_set_config(executablePath: *const ::std::os::raw::c_char); +} +unsafe extern "C" { + pub fn il2cpp_set_memory_callbacks(callbacks: *mut Il2CppMemoryCallbacks); +} +unsafe extern "C" { + pub fn il2cpp_get_corlib() -> *const Il2CppImage; +} +unsafe extern "C" { + pub fn il2cpp_add_internal_call( + name: *const ::std::os::raw::c_char, + method: Il2CppMethodPointer, + ); +} +unsafe extern "C" { + pub fn il2cpp_resolve_icall(name: *const ::std::os::raw::c_char) -> Il2CppMethodPointer; +} +unsafe extern "C" { + pub fn il2cpp_alloc(size: usize) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn il2cpp_free(ptr: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn il2cpp_array_class_get(element_class: *mut Il2CppClass, rank: u32) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_array_length(array: *mut Il2CppArray) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_array_get_byte_length(array: *mut Il2CppArray) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_array_new( + elementTypeInfo: *mut Il2CppClass, + length: il2cpp_array_size_t, + ) -> *mut Il2CppArray; +} +unsafe extern "C" { + pub fn il2cpp_array_new_specific( + arrayTypeInfo: *mut Il2CppClass, + length: il2cpp_array_size_t, + ) -> *mut Il2CppArray; +} +unsafe 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; +} +unsafe extern "C" { + pub fn il2cpp_bounded_array_class_get( + element_class: *mut Il2CppClass, + rank: u32, + bounded: u8, + ) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_array_element_size(array_class: *const Il2CppClass) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_assembly_get_image(assembly: *const Il2CppAssembly) -> *const Il2CppImage; +} +unsafe 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, + ); +} +unsafe extern "C" { + pub fn il2cpp_class_enum_basetype(klass: *mut Il2CppClass) -> *const Il2CppType; +} +unsafe extern "C" { + pub fn il2cpp_class_is_inited(klass: *const Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_is_generic(klass: *const Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_is_inflated(klass: *const Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_is_assignable_from(klass: *mut Il2CppClass, oklass: *mut Il2CppClass) + -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_is_subclass_of( + klass: *mut Il2CppClass, + klassc: *mut Il2CppClass, + check_interfaces: u8, + ) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_has_parent(klass: *mut Il2CppClass, klassc: *mut Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_from_il2cpp_type(type_: *const Il2CppType) -> *mut Il2CppClass; +} +unsafe 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; +} +unsafe extern "C" { + pub fn il2cpp_class_from_system_type(type_: *mut Il2CppReflectionType) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_class_get_element_class(klass: *mut Il2CppClass) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_class_get_events( + klass: *mut Il2CppClass, + iter: *mut *mut ::std::os::raw::c_void, + ) -> *const EventInfo; +} +unsafe extern "C" { + pub fn il2cpp_class_get_fields( + klass: *mut Il2CppClass, + iter: *mut *mut ::std::os::raw::c_void, + ) -> *mut FieldInfo; +} +unsafe extern "C" { + pub fn il2cpp_class_get_nested_types( + klass: *mut Il2CppClass, + iter: *mut *mut ::std::os::raw::c_void, + ) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_class_get_interfaces( + klass: *mut Il2CppClass, + iter: *mut *mut ::std::os::raw::c_void, + ) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_class_get_properties( + klass: *mut Il2CppClass, + iter: *mut *mut ::std::os::raw::c_void, + ) -> *const PropertyInfo; +} +unsafe extern "C" { + pub fn il2cpp_class_get_property_from_name( + klass: *mut Il2CppClass, + name: *const ::std::os::raw::c_char, + ) -> *const PropertyInfo; +} +unsafe extern "C" { + pub fn il2cpp_class_get_field_from_name( + klass: *mut Il2CppClass, + name: *const ::std::os::raw::c_char, + ) -> *mut FieldInfo; +} +unsafe extern "C" { + pub fn il2cpp_class_get_methods( + klass: *mut Il2CppClass, + iter: *mut *mut ::std::os::raw::c_void, + ) -> *const MethodInfo; +} +unsafe 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; +} +unsafe extern "C" { + pub fn il2cpp_class_get_name(klass: *mut Il2CppClass) -> *const ::std::os::raw::c_char; +} +unsafe 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, + ); +} +unsafe extern "C" { + pub fn il2cpp_class_get_namespace(klass: *mut Il2CppClass) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_class_get_parent(klass: *mut Il2CppClass) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_class_get_declaring_type(klass: *mut Il2CppClass) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_class_instance_size(klass: *mut Il2CppClass) -> i32; +} +unsafe extern "C" { + pub fn il2cpp_class_num_fields(enumKlass: *const Il2CppClass) -> usize; +} +unsafe extern "C" { + pub fn il2cpp_class_is_valuetype(klass: *const Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_value_size(klass: *mut Il2CppClass, align: *mut u32) -> i32; +} +unsafe extern "C" { + pub fn il2cpp_class_is_blittable(klass: *const Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_get_flags(klass: *const Il2CppClass) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_class_is_abstract(klass: *const Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_is_interface(klass: *const Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_array_element_size(klass: *const Il2CppClass) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_class_from_type(type_: *const Il2CppType) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_class_get_type(klass: *mut Il2CppClass) -> *const Il2CppType; +} +unsafe extern "C" { + pub fn il2cpp_class_get_type_token(klass: *mut Il2CppClass) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_class_has_attribute(klass: *mut Il2CppClass, attr_class: *mut Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_has_references(klass: *mut Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_is_enum(klass: *const Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_class_get_image(klass: *mut Il2CppClass) -> *const Il2CppImage; +} +unsafe extern "C" { + pub fn il2cpp_class_get_assemblyname( + klass: *const Il2CppClass, + ) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_class_get_rank(klass: *const Il2CppClass) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_class_get_data_size(klass: *const Il2CppClass) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_class_get_static_field_data( + klass: *const Il2CppClass, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn il2cpp_class_get_bitmap_size(klass: *const Il2CppClass) -> usize; +} +unsafe extern "C" { + pub fn il2cpp_class_get_bitmap(klass: *mut Il2CppClass, bitmap: *mut usize); +} +unsafe extern "C" { + pub fn il2cpp_stats_dump_to_file(path: *const ::std::os::raw::c_char) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_stats_get_value(stat: Il2CppStat) -> u64; +} +unsafe extern "C" { + pub fn il2cpp_domain_get() -> *mut Il2CppDomain; +} +unsafe extern "C" { + pub fn il2cpp_domain_assembly_open( + domain: *mut Il2CppDomain, + name: *const ::std::os::raw::c_char, + ) -> *const Il2CppAssembly; +} +unsafe extern "C" { + pub fn il2cpp_domain_get_assemblies( + domain: *const Il2CppDomain, + size: *mut usize, + ) -> *mut *const Il2CppAssembly; +} +unsafe extern "C" { + pub fn il2cpp_raise_exception(arg1: *mut Il2CppException) -> !; +} +unsafe 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; +} +unsafe extern "C" { + pub fn il2cpp_get_exception_argument_null( + arg: *const ::std::os::raw::c_char, + ) -> *mut Il2CppException; +} +unsafe extern "C" { + pub fn il2cpp_format_exception( + ex: *const Il2CppException, + message: *mut ::std::os::raw::c_char, + message_size: ::std::os::raw::c_int, + ); +} +unsafe 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, + ); +} +unsafe extern "C" { + pub fn il2cpp_unhandled_exception(arg1: *mut Il2CppException); +} +unsafe 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, + ); +} +unsafe extern "C" { + pub fn il2cpp_field_get_flags(field: *mut FieldInfo) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_field_get_name(field: *mut FieldInfo) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_field_get_parent(field: *mut FieldInfo) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_field_get_offset(field: *mut FieldInfo) -> usize; +} +unsafe extern "C" { + pub fn il2cpp_field_get_type(field: *mut FieldInfo) -> *const Il2CppType; +} +unsafe extern "C" { + pub fn il2cpp_field_get_value( + obj: *mut Il2CppObject, + field: *mut FieldInfo, + value: *mut ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub fn il2cpp_field_get_value_object( + field: *mut FieldInfo, + obj: *mut Il2CppObject, + ) -> *mut Il2CppObject; +} +unsafe extern "C" { + pub fn il2cpp_field_has_attribute(field: *mut FieldInfo, attr_class: *mut Il2CppClass) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_field_set_value( + obj: *mut Il2CppObject, + field: *mut FieldInfo, + value: *mut ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub fn il2cpp_field_static_get_value(field: *mut FieldInfo, value: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn il2cpp_field_static_set_value(field: *mut FieldInfo, value: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn il2cpp_field_set_value_object( + instance: *mut Il2CppObject, + field: *mut FieldInfo, + value: *mut Il2CppObject, + ); +} +unsafe extern "C" { + pub fn il2cpp_field_is_literal(field: *mut FieldInfo) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_gc_collect(maxGenerations: ::std::os::raw::c_int); +} +unsafe extern "C" { + pub fn il2cpp_gc_collect_a_little() -> i32; +} +unsafe extern "C" { + pub fn il2cpp_gc_start_incremental_collection(); +} +unsafe extern "C" { + pub fn il2cpp_gc_disable(); +} +unsafe extern "C" { + pub fn il2cpp_gc_enable(); +} +unsafe extern "C" { + pub fn il2cpp_gc_is_disabled() -> u8; +} +unsafe extern "C" { + pub fn il2cpp_gc_set_mode(mode: Il2CppGCMode); +} +unsafe extern "C" { + pub fn il2cpp_gc_get_max_time_slice_ns() -> i64; +} +unsafe extern "C" { + pub fn il2cpp_gc_set_max_time_slice_ns(maxTimeSlice: i64); +} +unsafe extern "C" { + pub fn il2cpp_gc_is_incremental() -> u8; +} +unsafe extern "C" { + pub fn il2cpp_gc_get_used_size() -> i64; +} +unsafe extern "C" { + pub fn il2cpp_gc_get_heap_size() -> i64; +} +unsafe 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, + ); +} +unsafe extern "C" { + pub fn il2cpp_gc_has_strict_wbarriers() -> u8; +} +unsafe 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, + ), + >, + ); +} +unsafe extern "C" { + pub fn il2cpp_gc_set_external_wbarrier_tracker( + func: ::std::option::Option, + ); +} +unsafe 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, + ); +} +unsafe extern "C" { + pub fn il2cpp_stop_gc_world(); +} +unsafe extern "C" { + pub fn il2cpp_start_gc_world(); +} +unsafe extern "C" { + pub fn il2cpp_gc_alloc_fixed(size: usize) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn il2cpp_gc_free_fixed(address: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn il2cpp_gchandle_new(obj: *mut Il2CppObject, pinned: u8) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_gchandle_new_weakref(obj: *mut Il2CppObject, track_resurrection: u8) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_gchandle_get_target(gchandle: u32) -> *mut Il2CppObject; +} +unsafe extern "C" { + pub fn il2cpp_gchandle_free(gchandle: u32); +} +unsafe 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, + ); +} +unsafe extern "C" { + pub fn il2cpp_object_header_size() -> u32; +} +unsafe extern "C" { + pub fn il2cpp_array_object_header_size() -> u32; +} +unsafe extern "C" { + pub fn il2cpp_offset_of_array_length_in_array_object_header() -> u32; +} +unsafe extern "C" { + pub fn il2cpp_offset_of_array_bounds_in_array_object_header() -> u32; +} +unsafe extern "C" { + pub fn il2cpp_allocation_granularity() -> u32; +} +unsafe 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; +} +unsafe extern "C" { + pub fn il2cpp_unity_liveness_calculation_from_root( + root: *mut Il2CppObject, + state: *mut ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub fn il2cpp_unity_liveness_calculation_from_statics(state: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn il2cpp_unity_liveness_finalize(state: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn il2cpp_unity_liveness_free_struct(state: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub fn il2cpp_method_get_return_type(method: *const MethodInfo) -> *const Il2CppType; +} +unsafe extern "C" { + pub fn il2cpp_method_get_declaring_type(method: *const MethodInfo) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_method_get_name(method: *const MethodInfo) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_method_get_from_reflection( + method: *const Il2CppReflectionMethod, + ) -> *const MethodInfo; +} +unsafe extern "C" { + pub fn il2cpp_method_get_object( + method: *const MethodInfo, + refclass: *mut Il2CppClass, + ) -> *mut Il2CppReflectionMethod; +} +unsafe extern "C" { + pub fn il2cpp_method_is_generic(method: *const MethodInfo) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_method_is_inflated(method: *const MethodInfo) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_method_is_instance(method: *const MethodInfo) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_method_get_param_count(method: *const MethodInfo) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_method_get_param(method: *const MethodInfo, index: u32) -> *const Il2CppType; +} +unsafe extern "C" { + pub fn il2cpp_method_get_class(method: *const MethodInfo) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_method_has_attribute( + method: *const MethodInfo, + attr_class: *mut Il2CppClass, + ) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_method_get_flags(method: *const MethodInfo, iflags: *mut u32) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_method_get_token(method: *const MethodInfo) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_method_get_param_name( + method: *const MethodInfo, + index: u32, + ) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_profiler_install(prof: *mut Il2CppProfiler, shutdown_callback: Il2CppProfileFunc); +} +unsafe extern "C" { + pub fn il2cpp_profiler_set_events(events: Il2CppProfileFlags); +} +unsafe extern "C" { + pub fn il2cpp_profiler_install_enter_leave( + enter: Il2CppProfileMethodFunc, + fleave: Il2CppProfileMethodFunc, + ); +} +unsafe extern "C" { + pub fn il2cpp_profiler_install_allocation(callback: Il2CppProfileAllocFunc); +} +unsafe extern "C" { + pub fn il2cpp_profiler_install_gc( + callback: Il2CppProfileGCFunc, + heap_resize_callback: Il2CppProfileGCResizeFunc, + ); +} +unsafe extern "C" { + pub fn il2cpp_profiler_install_fileio(callback: Il2CppProfileFileIOFunc); +} +unsafe extern "C" { + pub fn il2cpp_profiler_install_thread( + start: Il2CppProfileThreadFunc, + end: Il2CppProfileThreadFunc, + ); +} +unsafe extern "C" { + pub fn il2cpp_property_get_flags(prop: *mut PropertyInfo) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_property_get_get_method(prop: *mut PropertyInfo) -> *const MethodInfo; +} +unsafe extern "C" { + pub fn il2cpp_property_get_set_method(prop: *mut PropertyInfo) -> *const MethodInfo; +} +unsafe extern "C" { + pub fn il2cpp_property_get_name(prop: *mut PropertyInfo) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_property_get_parent(prop: *mut PropertyInfo) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_object_get_class(obj: *mut Il2CppObject) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_object_get_size(obj: *mut Il2CppObject) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_object_get_virtual_method( + obj: *mut Il2CppObject, + method: *const MethodInfo, + ) -> *const MethodInfo; +} +unsafe extern "C" { + pub fn il2cpp_object_new(klass: *const Il2CppClass) -> *mut Il2CppObject; +} +unsafe extern "C" { + pub fn il2cpp_object_unbox(obj: *mut Il2CppObject) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn il2cpp_value_box( + klass: *mut Il2CppClass, + data: *mut ::std::os::raw::c_void, + ) -> *mut Il2CppObject; +} +unsafe extern "C" { + pub fn il2cpp_monitor_enter(obj: *mut Il2CppObject); +} +unsafe extern "C" { + pub fn il2cpp_monitor_try_enter(obj: *mut Il2CppObject, timeout: u32) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_monitor_exit(obj: *mut Il2CppObject); +} +unsafe extern "C" { + pub fn il2cpp_monitor_pulse(obj: *mut Il2CppObject); +} +unsafe extern "C" { + pub fn il2cpp_monitor_pulse_all(obj: *mut Il2CppObject); +} +unsafe extern "C" { + pub fn il2cpp_monitor_wait(obj: *mut Il2CppObject); +} +unsafe extern "C" { + pub fn il2cpp_monitor_try_wait(obj: *mut Il2CppObject, timeout: u32) -> u8; +} +unsafe 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; +} +unsafe 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; +} +unsafe extern "C" { + pub fn il2cpp_runtime_class_init(klass: *mut Il2CppClass); +} +unsafe extern "C" { + pub fn il2cpp_runtime_object_init(obj: *mut Il2CppObject); +} +unsafe extern "C" { + pub fn il2cpp_runtime_object_init_exception( + obj: *mut Il2CppObject, + exc: *mut *mut Il2CppException, + ); +} +unsafe extern "C" { + pub fn il2cpp_runtime_unhandled_exception_policy_set( + value: Il2CppRuntimeUnhandledExceptionPolicy, + ); +} +unsafe extern "C" { + pub fn il2cpp_string_length(str_: *mut Il2CppString) -> i32; +} +unsafe extern "C" { + pub fn il2cpp_string_chars(str_: *mut Il2CppString) -> *mut Il2CppChar; +} +unsafe extern "C" { + pub fn il2cpp_string_new(str_: *const ::std::os::raw::c_char) -> *mut Il2CppString; +} +unsafe extern "C" { + pub fn il2cpp_string_new_len( + str_: *const ::std::os::raw::c_char, + length: u32, + ) -> *mut Il2CppString; +} +unsafe extern "C" { + pub fn il2cpp_string_new_utf16(text: *const Il2CppChar, len: i32) -> *mut Il2CppString; +} +unsafe extern "C" { + pub fn il2cpp_string_new_wrapper(str_: *const ::std::os::raw::c_char) -> *mut Il2CppString; +} +unsafe extern "C" { + pub fn il2cpp_string_intern(str_: *mut Il2CppString) -> *mut Il2CppString; +} +unsafe extern "C" { + pub fn il2cpp_string_is_interned(str_: *mut Il2CppString) -> *mut Il2CppString; +} +unsafe extern "C" { + pub fn il2cpp_thread_current() -> *mut Il2CppThread; +} +unsafe extern "C" { + pub fn il2cpp_thread_attach(domain: *mut Il2CppDomain) -> *mut Il2CppThread; +} +unsafe extern "C" { + pub fn il2cpp_thread_detach(thread: *mut Il2CppThread); +} +unsafe extern "C" { + pub fn il2cpp_thread_get_all_attached_threads(size: *mut usize) -> *mut *mut Il2CppThread; +} +unsafe extern "C" { + pub fn il2cpp_is_vm_thread(thread: *mut Il2CppThread) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_current_thread_walk_frame_stack( + func: Il2CppFrameWalkFunc, + user_data: *mut ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub fn il2cpp_thread_walk_frame_stack( + thread: *mut Il2CppThread, + func: Il2CppFrameWalkFunc, + user_data: *mut ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub fn il2cpp_current_thread_get_top_frame(frame: *mut Il2CppStackFrameInfo) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_thread_get_top_frame( + thread: *mut Il2CppThread, + frame: *mut Il2CppStackFrameInfo, + ) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_current_thread_get_frame_at(offset: i32, frame: *mut Il2CppStackFrameInfo) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_thread_get_frame_at( + thread: *mut Il2CppThread, + offset: i32, + frame: *mut Il2CppStackFrameInfo, + ) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_current_thread_get_stack_depth() -> i32; +} +unsafe extern "C" { + pub fn il2cpp_thread_get_stack_depth(thread: *mut Il2CppThread) -> i32; +} +unsafe extern "C" { + pub fn il2cpp_override_stack_backtrace(stackBacktraceFunc: Il2CppBacktraceFunc); +} +unsafe extern "C" { + pub fn il2cpp_type_get_object(type_: *const Il2CppType) -> *mut Il2CppObject; +} +unsafe extern "C" { + pub fn il2cpp_type_get_type(type_: *const Il2CppType) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_type_get_class_or_element_class(type_: *const Il2CppType) -> *mut Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_type_get_name(type_: *const Il2CppType) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_type_is_byref(type_: *const Il2CppType) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_type_get_attrs(type_: *const Il2CppType) -> u32; +} +unsafe extern "C" { + pub fn il2cpp_type_equals(type_: *const Il2CppType, otherType: *const Il2CppType) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_type_get_assembly_qualified_name( + type_: *const Il2CppType, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_type_get_reflection_name(type_: *const Il2CppType) + -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_type_is_static(type_: *const Il2CppType) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_type_is_pointer_type(type_: *const Il2CppType) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_image_get_assembly(image: *const Il2CppImage) -> *const Il2CppAssembly; +} +unsafe extern "C" { + pub fn il2cpp_image_get_name(image: *const Il2CppImage) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_image_get_filename(image: *const Il2CppImage) -> *const ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn il2cpp_image_get_entry_point(image: *const Il2CppImage) -> *const MethodInfo; +} +unsafe extern "C" { + pub fn il2cpp_image_get_class_count(image: *const Il2CppImage) -> usize; +} +unsafe extern "C" { + pub fn il2cpp_image_get_class(image: *const Il2CppImage, index: usize) -> *const Il2CppClass; +} +unsafe extern "C" { + pub fn il2cpp_capture_memory_snapshot() -> *mut Il2CppManagedMemorySnapshot; +} +unsafe extern "C" { + pub fn il2cpp_free_captured_memory_snapshot(snapshot: *mut Il2CppManagedMemorySnapshot); +} +unsafe extern "C" { + pub fn il2cpp_set_find_plugin_callback(method: Il2CppSetFindPlugInCallback); +} +unsafe extern "C" { + pub fn il2cpp_register_log_callback(method: Il2CppLogCallback); +} +unsafe extern "C" { + pub fn il2cpp_debugger_set_agent_options(options: *const ::std::os::raw::c_char); +} +unsafe extern "C" { + pub fn il2cpp_is_debugger_attached() -> u8; +} +unsafe extern "C" { + pub fn il2cpp_register_debugger_agent_transport( + debuggerTransport: *mut Il2CppDebuggerTransport, + ); +} +unsafe extern "C" { + pub fn il2cpp_debug_get_method_info( + arg1: *const MethodInfo, + methodDebugInfo: *mut Il2CppMethodDebugInfo, + ) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_unity_install_unitytls_interface( + unitytlsInterfaceStruct: *const ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub fn il2cpp_custom_attrs_from_class(klass: *mut Il2CppClass) -> *mut Il2CppCustomAttrInfo; +} +unsafe extern "C" { + pub fn il2cpp_custom_attrs_from_method(method: *const MethodInfo) -> *mut Il2CppCustomAttrInfo; +} +unsafe extern "C" { + pub fn il2cpp_custom_attrs_from_field(field: *const FieldInfo) -> *mut Il2CppCustomAttrInfo; +} +unsafe extern "C" { + pub fn il2cpp_custom_attrs_get_attr( + ainfo: *mut Il2CppCustomAttrInfo, + attr_klass: *mut Il2CppClass, + ) -> *mut Il2CppObject; +} +unsafe extern "C" { + pub fn il2cpp_custom_attrs_has_attr( + ainfo: *mut Il2CppCustomAttrInfo, + attr_klass: *mut Il2CppClass, + ) -> u8; +} +unsafe extern "C" { + pub fn il2cpp_custom_attrs_construct(cinfo: *mut Il2CppCustomAttrInfo) -> *mut Il2CppArray; +} +unsafe extern "C" { + pub fn il2cpp_custom_attrs_free(ainfo: *mut Il2CppCustomAttrInfo); +} +unsafe extern "C" { + pub fn il2cpp_class_set_userdata( + klass: *mut Il2CppClass, + userdata: *mut ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub fn il2cpp_class_get_userdata_offset() -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn il2cpp_set_default_thread_affinity(affinity_mask: i64); +} +unsafe extern "C" { + pub fn il2cpp_unity_set_android_network_up_state_func(func: Il2CppAndroidUpStateFunc); +} +unsafe extern "C" { + pub fn memcpy( + __dest: *mut ::std::os::raw::c_void, + __src: *const ::std::os::raw::c_void, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn memmove( + __dest: *mut ::std::os::raw::c_void, + __src: *const ::std::os::raw::c_void, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn memccpy( + __dest: *mut ::std::os::raw::c_void, + __src: *const ::std::os::raw::c_void, + __c: ::std::os::raw::c_int, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn memset( + __s: *mut ::std::os::raw::c_void, + __c: ::std::os::raw::c_int, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn memcmp( + __s1: *const ::std::os::raw::c_void, + __s2: *const ::std::os::raw::c_void, + __n: ::std::os::raw::c_ulong, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn __memcmpeq( + __s1: *const ::std::os::raw::c_void, + __s2: *const ::std::os::raw::c_void, + __n: usize, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn memchr( + __s: *const ::std::os::raw::c_void, + __c: ::std::os::raw::c_int, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_void; +} +unsafe extern "C" { + pub fn strcpy( + __dest: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strncpy( + __dest: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strcat( + __dest: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strncat( + __dest: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strcmp( + __s1: *const ::std::os::raw::c_char, + __s2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strncmp( + __s1: *const ::std::os::raw::c_char, + __s2: *const ::std::os::raw::c_char, + __n: ::std::os::raw::c_ulong, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strcoll( + __s1: *const ::std::os::raw::c_char, + __s2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strxfrm( + __dest: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + __n: ::std::os::raw::c_ulong, + ) -> ::std::os::raw::c_ulong; +} +unsafe extern "C" { + pub fn strcoll_l( + __s1: *const ::std::os::raw::c_char, + __s2: *const ::std::os::raw::c_char, + __l: locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strxfrm_l( + __dest: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + __n: usize, + __l: locale_t, + ) -> usize; +} +unsafe extern "C" { + pub fn strdup(__s: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strndup( + __string: *const ::std::os::raw::c_char, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strchr( + __s: *const ::std::os::raw::c_char, + __c: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strrchr( + __s: *const ::std::os::raw::c_char, + __c: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strcspn( + __s: *const ::std::os::raw::c_char, + __reject: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_ulong; +} +unsafe extern "C" { + pub fn strspn( + __s: *const ::std::os::raw::c_char, + __accept: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_ulong; +} +unsafe extern "C" { + pub fn strpbrk( + __s: *const ::std::os::raw::c_char, + __accept: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strstr( + __haystack: *const ::std::os::raw::c_char, + __needle: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strtok( + __s: *mut ::std::os::raw::c_char, + __delim: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn __strtok_r( + __s: *mut ::std::os::raw::c_char, + __delim: *const ::std::os::raw::c_char, + __save_ptr: *mut *mut ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strtok_r( + __s: *mut ::std::os::raw::c_char, + __delim: *const ::std::os::raw::c_char, + __save_ptr: *mut *mut ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strlen(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_ulong; +} +unsafe extern "C" { + pub fn strnlen(__string: *const ::std::os::raw::c_char, __maxlen: usize) -> usize; +} +unsafe extern "C" { + pub fn strerror(__errnum: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + #[link_name = "\u{1}__xpg_strerror_r"] + pub fn strerror_r( + __errnum: ::std::os::raw::c_int, + __buf: *mut ::std::os::raw::c_char, + __buflen: usize, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strerror_l( + __errnum: ::std::os::raw::c_int, + __l: locale_t, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn bcmp( + __s1: *const ::std::os::raw::c_void, + __s2: *const ::std::os::raw::c_void, + __n: ::std::os::raw::c_ulong, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn bcopy( + __src: *const ::std::os::raw::c_void, + __dest: *mut ::std::os::raw::c_void, + __n: ::std::os::raw::c_ulong, + ); +} +unsafe extern "C" { + pub fn bzero(__s: *mut ::std::os::raw::c_void, __n: ::std::os::raw::c_ulong); +} +unsafe extern "C" { + pub fn index( + __s: *const ::std::os::raw::c_char, + __c: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn rindex( + __s: *const ::std::os::raw::c_char, + __c: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn ffs(__i: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn ffsl(__l: ::std::os::raw::c_long) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn ffsll(__ll: ::std::os::raw::c_longlong) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strcasecmp( + __s1: *const ::std::os::raw::c_char, + __s2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strncasecmp( + __s1: *const ::std::os::raw::c_char, + __s2: *const ::std::os::raw::c_char, + __n: ::std::os::raw::c_ulong, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strcasecmp_l( + __s1: *const ::std::os::raw::c_char, + __s2: *const ::std::os::raw::c_char, + __loc: locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn strncasecmp_l( + __s1: *const ::std::os::raw::c_char, + __s2: *const ::std::os::raw::c_char, + __n: usize, + __loc: locale_t, + ) -> ::std::os::raw::c_int; +} +unsafe extern "C" { + pub fn explicit_bzero(__s: *mut ::std::os::raw::c_void, __n: usize); +} +unsafe extern "C" { + pub fn strsep( + __stringp: *mut *mut ::std::os::raw::c_char, + __delim: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn strsignal(__sig: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn __stpcpy( + __dest: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn stpcpy( + __dest: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn __stpncpy( + __dest: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + __n: usize, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub fn stpncpy( + __dest: *mut ::std::os::raw::c_char, + __src: *const ::std::os::raw::c_char, + __n: ::std::os::raw::c_ulong, + ) -> *mut ::std::os::raw::c_char; +} +unsafe extern "C" { + pub static kIl2CppUInt64Max: u64; +} +unsafe extern "C" { + pub static kIl2CppUIntPtrMax: usize; +} +unsafe extern "C" { + pub static kIl2CppNewLine: [Il2CppChar; 2usize]; +} +unsafe extern "C" { + pub static mut il2cpp_defaults: Il2CppDefaults; +} diff --git a/libil2cpp/src/raw/types_v31/mod.rs b/libil2cpp/src/raw/types_v31/mod.rs new file mode 100644 index 00000000..c274244e --- /dev/null +++ b/libil2cpp/src/raw/types_v31/mod.rs @@ -0,0 +1,7 @@ +#[cfg_attr(target_os = "windows", path = "windows.rs")] +#[cfg_attr(target_os = "macos", path = "linux.rs")] +#[cfg_attr(target_os = "linux", path = "linux.rs")] +#[cfg_attr(target_os = "android", path = "android.rs")] +mod types; + +pub use types::*; \ No newline at end of file diff --git a/libil2cpp/src/raw/types_v31.rs b/libil2cpp/src/raw/types_v31/windows.rs similarity index 91% rename from libil2cpp/src/raw/types_v31.rs rename to libil2cpp/src/raw/types_v31/windows.rs index 16865503..831913fc 100644 --- a/libil2cpp/src/raw/types_v31.rs +++ b/libil2cpp/src/raw/types_v31/windows.rs @@ -1,4 +1,4 @@ -/* automatically generated by rust-bindgen 0.70.1 */ +/* automatically generated by rust-bindgen 0.71.1 */ pub type va_list = *mut ::std::os::raw::c_char; pub type __vcrt_bool = bool; @@ -5838,10 +5838,7 @@ 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]; + fn extract_bit(byte: u8, index: usize) -> bool { let bit_index = if cfg!(target_endian = "big") { 7 - (index % 8) } else { @@ -5851,10 +5848,21 @@ where byte & mask == mask } #[inline] - pub fn set_bit(&mut self, index: usize, val: bool) { + pub fn get_bit(&self, index: usize) -> 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 byte = self.storage.as_ref()[byte_index]; + Self::extract_bit(byte, index) + } + #[inline] + pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize); + Self::extract_bit(byte, index) + } + #[inline] + fn change_bit(byte: u8, index: usize, val: bool) -> u8 { let bit_index = if cfg!(target_endian = "big") { 7 - (index % 8) } else { @@ -5862,12 +5870,27 @@ where }; let mask = 1 << bit_index; if val { - *byte |= mask; + byte | mask } else { - *byte &= !mask; + byte & !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]; + *byte = Self::change_bit(*byte, index, val); + } + #[inline] + pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) { + debug_assert!(index / 8 < core::mem::size_of::()); + let byte_index = index / 8; + let byte = + (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize); + *byte = Self::change_bit(*byte, index, val); + } + #[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()); @@ -5886,6 +5909,24 @@ where val } #[inline] + pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); + let mut val = 0; + for i in 0..(bit_width as usize) { + if Self::raw_get_bit(this, 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()); @@ -5901,6 +5942,22 @@ where self.set_bit(index + bit_offset, val_bit_is_set); } } + #[inline] + pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < core::mem::size_of::()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::()); + 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::raw_set_bit(this, index + bit_offset, val_bit_is_set); + } + } } impl __IncompleteArrayField { #[inline] @@ -5942,6 +5999,28 @@ impl Il2CppType { } } #[inline] + pub unsafe fn attrs_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 16u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_attrs_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 16u8, + val as u64, + ) + } + } + #[inline] pub fn type_(&self) -> Il2CppTypeEnum { unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u32) } } @@ -5953,6 +6032,28 @@ impl Il2CppType { } } #[inline] + pub unsafe fn type__raw(this: *const Self) -> Il2CppTypeEnum { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 16usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_type_raw(this: *mut Self, val: Il2CppTypeEnum) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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) } } @@ -5964,6 +6065,28 @@ impl Il2CppType { } } #[inline] + pub unsafe fn num_mods_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 24usize, + 5u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_num_mods_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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) } } @@ -5975,6 +6098,28 @@ impl Il2CppType { } } #[inline] + pub unsafe fn byref_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 29usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_byref_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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) } } @@ -5986,6 +6131,28 @@ impl Il2CppType { } } #[inline] + pub unsafe fn pinned_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 30usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_pinned_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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) } } @@ -5997,6 +6164,28 @@ impl Il2CppType { } } #[inline] + pub unsafe fn valuetype_raw(this: *const Self) -> ::std::os::raw::c_uint { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 31usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_valuetype_raw(this: *mut Self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 31usize, + 1u8, + val as u64, + ) + } + } + #[inline] pub fn new_bitfield_1( attrs: ::std::os::raw::c_uint, type_: Il2CppTypeEnum, @@ -6046,6 +6235,28 @@ impl MethodInfo { } } #[inline] + pub unsafe fn is_generic_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_generic_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] pub fn is_inflated(&self) -> u8 { unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } } @@ -6057,6 +6268,28 @@ impl MethodInfo { } } #[inline] + pub unsafe fn is_inflated_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_inflated_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] pub fn wrapper_type(&self) -> u8 { unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) } } @@ -6068,6 +6301,28 @@ impl MethodInfo { } } #[inline] + pub unsafe fn wrapper_type_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_wrapper_type_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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) } } @@ -6079,6 +6334,28 @@ impl MethodInfo { } } #[inline] + pub unsafe fn has_full_generic_sharing_signature_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_has_full_generic_sharing_signature_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] pub fn new_bitfield_1( is_generic: u8, is_inflated: u8, @@ -6119,6 +6396,28 @@ impl Il2CppClass { } } #[inline] + pub unsafe fn initialized_and_no_error_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_initialized_and_no_error_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 1u8, + val as u64, + ) + } + } + #[inline] pub fn initialized(&self) -> u8 { unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) } } @@ -6130,6 +6429,28 @@ impl Il2CppClass { } } #[inline] + pub unsafe fn initialized_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 1usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_initialized_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 1usize, + 1u8, + val as u64, + ) + } + } + #[inline] pub fn enumtype(&self) -> u8 { unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) } } @@ -6141,6 +6462,28 @@ impl Il2CppClass { } } #[inline] + pub unsafe fn enumtype_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 2usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_enumtype_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 2usize, + 1u8, + val as u64, + ) + } + } + #[inline] pub fn nullabletype(&self) -> u8 { unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) } } @@ -6152,6 +6495,28 @@ impl Il2CppClass { } } #[inline] + pub unsafe fn nullabletype_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 3usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_nullabletype_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 3usize, + 1u8, + val as u64, + ) + } + } + #[inline] pub fn is_generic(&self) -> u8 { unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) } } @@ -6163,6 +6528,28 @@ impl Il2CppClass { } } #[inline] + pub unsafe fn is_generic_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 4usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_generic_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 4usize, + 1u8, + val as u64, + ) + } + } + #[inline] pub fn has_references(&self) -> u8 { unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) } } @@ -6174,6 +6561,28 @@ impl Il2CppClass { } } #[inline] + pub unsafe fn has_references_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 5usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_has_references_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 5usize, + 1u8, + val as u64, + ) + } + } + #[inline] pub fn init_pending(&self) -> u8 { unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8) } } @@ -6185,6 +6594,28 @@ impl Il2CppClass { } } #[inline] + pub unsafe fn init_pending_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 6usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_init_pending_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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) } } @@ -6196,6 +6627,28 @@ impl Il2CppClass { } } #[inline] + pub unsafe fn size_init_pending_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 7usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_size_init_pending_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 7usize, + 1u8, + val as u64, + ) + } + } + #[inline] pub fn size_inited(&self) -> u8 { unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u8) } } @@ -6207,6 +6660,28 @@ impl Il2CppClass { } } #[inline] + pub unsafe fn size_inited_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 8usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_size_inited_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 8usize, + 1u8, + val as u64, + ) + } + } + #[inline] pub fn has_finalize(&self) -> u8 { unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u8) } } @@ -6218,6 +6693,28 @@ impl Il2CppClass { } } #[inline] + pub unsafe fn has_finalize_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 9usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_has_finalize_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 9usize, + 1u8, + val as u64, + ) + } + } + #[inline] pub fn has_cctor(&self) -> u8 { unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u8) } } @@ -6229,6 +6726,28 @@ impl Il2CppClass { } } #[inline] + pub unsafe fn has_cctor_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 10usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_has_cctor_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 10usize, + 1u8, + val as u64, + ) + } + } + #[inline] pub fn is_blittable(&self) -> u8 { unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u8) } } @@ -6240,6 +6759,28 @@ impl Il2CppClass { } } #[inline] + pub unsafe fn is_blittable_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 11usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_blittable_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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) } } @@ -6251,6 +6792,28 @@ impl Il2CppClass { } } #[inline] + pub unsafe fn is_import_or_windows_runtime_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 12usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_import_or_windows_runtime_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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) } } @@ -6262,6 +6825,28 @@ impl Il2CppClass { } } #[inline] + pub unsafe fn is_vtable_initialized_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 13usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_vtable_initialized_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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) } } @@ -6273,6 +6858,28 @@ impl Il2CppClass { } } #[inline] + pub unsafe fn is_byref_like_raw(this: *const Self) -> u8 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 14usize, + 1u8, + ) as u8) + } + } + #[inline] + pub unsafe fn set_is_byref_like_raw(this: *mut Self, val: u8) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 14usize, + 1u8, + val as u64, + ) + } + } + #[inline] pub fn new_bitfield_1( initialized_and_no_error: u8, initialized: u8, @@ -6369,6 +6976,28 @@ impl Il2CppDouble { } } #[inline] + pub unsafe fn mantLo_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 32u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_mantLo_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 32u8, + val as u64, + ) + } + } + #[inline] pub fn mantHi(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 20u8) as u32) } } @@ -6380,6 +7009,28 @@ impl Il2CppDouble { } } #[inline] + pub unsafe fn mantHi_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 32usize, + 20u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_mantHi_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 32usize, + 20u8, + val as u64, + ) + } + } + #[inline] pub fn exp(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(52usize, 11u8) as u32) } } @@ -6391,6 +7042,28 @@ impl Il2CppDouble { } } #[inline] + pub unsafe fn exp_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 52usize, + 11u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_exp_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 52usize, + 11u8, + val as u64, + ) + } + } + #[inline] pub fn sign(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(63usize, 1u8) as u32) } } @@ -6402,6 +7075,28 @@ impl Il2CppDouble { } } #[inline] + pub unsafe fn sign_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 63usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_sign_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 63usize, + 1u8, + val as u64, + ) + } + } + #[inline] pub fn new_bitfield_1( mantLo: u32, mantHi: u32, @@ -6441,6 +7136,28 @@ impl Il2CppSingle { } } #[inline] + pub unsafe fn mant_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 0usize, + 23u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_mant_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 0usize, + 23u8, + val as u64, + ) + } + } + #[inline] pub fn exp(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 8u8) as u32) } } @@ -6452,6 +7169,28 @@ impl Il2CppSingle { } } #[inline] + pub unsafe fn exp_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 23usize, + 8u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_exp_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 23usize, + 8u8, + val as u64, + ) + } + } + #[inline] pub fn sign(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) } } @@ -6463,6 +7202,28 @@ impl Il2CppSingle { } } #[inline] + pub unsafe fn sign_raw(this: *const Self) -> u32 { + unsafe { + ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get( + ::std::ptr::addr_of!((*this)._bitfield_1), + 31usize, + 1u8, + ) as u32) + } + } + #[inline] + pub unsafe fn set_sign_raw(this: *mut Self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set( + ::std::ptr::addr_of_mut!((*this)._bitfield_1), + 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, { @@ -6480,28 +7241,28 @@ impl Il2CppSingle { __bindgen_bitfield_unit } } -extern "C" { +unsafe extern "C" { pub fn __va_start(arg1: *mut *mut ::std::os::raw::c_char, ...); } -extern "C" { +unsafe extern "C" { pub fn __security_init_cookie(); } -extern "C" { +unsafe extern "C" { pub fn __security_check_cookie(_StackCookie: usize); } -extern "C" { +unsafe extern "C" { pub fn __report_gsfailure(_StackCookie: usize) -> !; } -extern "C" { +unsafe extern "C" { pub static mut __security_cookie: usize; } -extern "C" { +unsafe extern "C" { pub fn _invalid_parameter_noinfo(); } -extern "C" { +unsafe extern "C" { pub fn _invalid_parameter_noinfo_noreturn() -> !; } -extern "C" { +unsafe extern "C" { pub fn _invoke_watson( _Expression: *const wchar_t, _FunctionName: *const wchar_t, @@ -6510,104 +7271,104 @@ extern "C" { _Reserved: usize, ) -> !; } -extern "C" { +unsafe extern "C" { pub fn _errno() -> *mut ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn _set_errno(_Value: ::std::os::raw::c_int) -> errno_t; } -extern "C" { +unsafe extern "C" { pub fn _get_errno(_Value: *mut ::std::os::raw::c_int) -> errno_t; } -extern "C" { +unsafe extern "C" { pub fn __threadid() -> ::std::os::raw::c_ulong; } -extern "C" { +unsafe extern "C" { pub fn __threadhandle() -> usize; } -extern "C" { +unsafe extern "C" { pub fn _calloc_base(_Count: usize, _Size: usize) -> *mut ::std::os::raw::c_void; } -extern "C" { +unsafe 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" { +unsafe extern "C" { pub fn _callnewh(_Size: usize) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn _expand( _Block: *mut ::std::os::raw::c_void, _Size: usize, ) -> *mut ::std::os::raw::c_void; } -extern "C" { +unsafe extern "C" { pub fn _free_base(_Block: *mut ::std::os::raw::c_void); } -extern "C" { +unsafe extern "C" { pub fn free(_Block: *mut ::std::os::raw::c_void); } -extern "C" { +unsafe extern "C" { pub fn _malloc_base(_Size: usize) -> *mut ::std::os::raw::c_void; } -extern "C" { +unsafe extern "C" { pub fn malloc(_Size: ::std::os::raw::c_ulonglong) -> *mut ::std::os::raw::c_void; } -extern "C" { +unsafe extern "C" { pub fn _msize_base(_Block: *mut ::std::os::raw::c_void) -> usize; } -extern "C" { +unsafe extern "C" { pub fn _msize(_Block: *mut ::std::os::raw::c_void) -> usize; } -extern "C" { +unsafe extern "C" { pub fn _realloc_base( _Block: *mut ::std::os::raw::c_void, _Size: usize, ) -> *mut ::std::os::raw::c_void; } -extern "C" { +unsafe 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" { +unsafe 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" { +unsafe extern "C" { pub fn _recalloc( _Block: *mut ::std::os::raw::c_void, _Count: usize, _Size: usize, ) -> *mut ::std::os::raw::c_void; } -extern "C" { +unsafe extern "C" { pub fn _aligned_free(_Block: *mut ::std::os::raw::c_void); } -extern "C" { +unsafe extern "C" { pub fn _aligned_malloc(_Size: usize, _Alignment: usize) -> *mut ::std::os::raw::c_void; } -extern "C" { +unsafe extern "C" { pub fn _aligned_offset_malloc( _Size: usize, _Alignment: usize, _Offset: usize, ) -> *mut ::std::os::raw::c_void; } -extern "C" { +unsafe extern "C" { pub fn _aligned_msize( _Block: *mut ::std::os::raw::c_void, _Alignment: usize, _Offset: usize, ) -> usize; } -extern "C" { +unsafe extern "C" { pub fn _aligned_offset_realloc( _Block: *mut ::std::os::raw::c_void, _Size: usize, @@ -6615,7 +7376,7 @@ extern "C" { _Offset: usize, ) -> *mut ::std::os::raw::c_void; } -extern "C" { +unsafe extern "C" { pub fn _aligned_offset_recalloc( _Block: *mut ::std::os::raw::c_void, _Count: usize, @@ -6624,14 +7385,14 @@ extern "C" { _Offset: usize, ) -> *mut ::std::os::raw::c_void; } -extern "C" { +unsafe 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" { +unsafe extern "C" { pub fn _aligned_recalloc( _Block: *mut ::std::os::raw::c_void, _Count: usize, @@ -6639,125 +7400,125 @@ extern "C" { _Alignment: usize, ) -> *mut ::std::os::raw::c_void; } -extern "C" { +unsafe extern "C" { pub fn _alloca(_Size: ::std::os::raw::c_ulonglong) -> *mut ::std::os::raw::c_void; } -extern "C" { +unsafe extern "C" { pub fn _get_heap_handle() -> isize; } -extern "C" { +unsafe extern "C" { pub fn _heapmin() -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn _heapwalk(_EntryInfo: *mut _HEAPINFO) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn _heapchk() -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn _resetstkoflw() -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_init(domain_name: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_init_utf16(domain_name: *const Il2CppChar) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_shutdown(); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_set_config_dir(config_path: *const ::std::os::raw::c_char); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_set_data_dir(data_path: *const ::std::os::raw::c_char); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_set_temp_dir(temp_path: *const ::std::os::raw::c_char); } -extern "C" { +unsafe 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" { +unsafe 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" { +unsafe extern "C" { pub fn il2cpp_set_config_utf16(executablePath: *const Il2CppChar); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_set_config(executablePath: *const ::std::os::raw::c_char); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_set_memory_callbacks(callbacks: *mut Il2CppMemoryCallbacks); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_get_corlib() -> *const Il2CppImage; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_add_internal_call( name: *const ::std::os::raw::c_char, method: Il2CppMethodPointer, ); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_resolve_icall(name: *const ::std::os::raw::c_char) -> Il2CppMethodPointer; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_alloc(size: usize) -> *mut ::std::os::raw::c_void; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_free(ptr: *mut ::std::os::raw::c_void); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_array_class_get(element_class: *mut Il2CppClass, rank: u32) -> *mut Il2CppClass; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_array_length(array: *mut Il2CppArray) -> u32; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_array_get_byte_length(array: *mut Il2CppArray) -> u32; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_array_new( elementTypeInfo: *mut Il2CppClass, length: il2cpp_array_size_t, ) -> *mut Il2CppArray; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_array_new_specific( arrayTypeInfo: *mut Il2CppClass, length: il2cpp_array_size_t, ) -> *mut Il2CppArray; } -extern "C" { +unsafe 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" { +unsafe extern "C" { pub fn il2cpp_bounded_array_class_get( element_class: *mut Il2CppClass, rank: u32, bounded: u8, ) -> *mut Il2CppClass; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_array_element_size(array_class: *const Il2CppClass) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_assembly_get_image(assembly: *const Il2CppAssembly) -> *const Il2CppImage; } -extern "C" { +unsafe 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), @@ -6765,107 +7526,107 @@ extern "C" { userData: *mut ::std::os::raw::c_void, ); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_enum_basetype(klass: *mut Il2CppClass) -> *const Il2CppType; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_is_inited(klass: *const Il2CppClass) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_is_generic(klass: *const Il2CppClass) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_is_inflated(klass: *const Il2CppClass) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_is_assignable_from(klass: *mut Il2CppClass, oklass: *mut Il2CppClass) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_is_subclass_of( klass: *mut Il2CppClass, klassc: *mut Il2CppClass, check_interfaces: u8, ) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_has_parent(klass: *mut Il2CppClass, klassc: *mut Il2CppClass) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_from_il2cpp_type(type_: *const Il2CppType) -> *mut Il2CppClass; } -extern "C" { +unsafe 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" { +unsafe extern "C" { pub fn il2cpp_class_from_system_type(type_: *mut Il2CppReflectionType) -> *mut Il2CppClass; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_get_element_class(klass: *mut Il2CppClass) -> *mut Il2CppClass; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_get_events( klass: *mut Il2CppClass, iter: *mut *mut ::std::os::raw::c_void, ) -> *const EventInfo; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_get_fields( klass: *mut Il2CppClass, iter: *mut *mut ::std::os::raw::c_void, ) -> *mut FieldInfo; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_get_nested_types( klass: *mut Il2CppClass, iter: *mut *mut ::std::os::raw::c_void, ) -> *mut Il2CppClass; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_get_interfaces( klass: *mut Il2CppClass, iter: *mut *mut ::std::os::raw::c_void, ) -> *mut Il2CppClass; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_get_properties( klass: *mut Il2CppClass, iter: *mut *mut ::std::os::raw::c_void, ) -> *const PropertyInfo; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_get_property_from_name( klass: *mut Il2CppClass, name: *const ::std::os::raw::c_char, ) -> *const PropertyInfo; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_get_field_from_name( klass: *mut Il2CppClass, name: *const ::std::os::raw::c_char, ) -> *mut FieldInfo; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_get_methods( klass: *mut Il2CppClass, iter: *mut *mut ::std::os::raw::c_void, ) -> *const MethodInfo; } -extern "C" { +unsafe 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" { +unsafe extern "C" { pub fn il2cpp_class_get_name(klass: *mut Il2CppClass) -> *const ::std::os::raw::c_char; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_type_get_name_chunked( type_: *const Il2CppType, chunkReportFunc: ::std::option::Option< @@ -6877,110 +7638,110 @@ extern "C" { userData: *mut ::std::os::raw::c_void, ); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_get_namespace(klass: *mut Il2CppClass) -> *const ::std::os::raw::c_char; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_get_parent(klass: *mut Il2CppClass) -> *mut Il2CppClass; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_get_declaring_type(klass: *mut Il2CppClass) -> *mut Il2CppClass; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_instance_size(klass: *mut Il2CppClass) -> i32; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_num_fields(enumKlass: *const Il2CppClass) -> usize; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_is_valuetype(klass: *const Il2CppClass) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_value_size(klass: *mut Il2CppClass, align: *mut u32) -> i32; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_is_blittable(klass: *const Il2CppClass) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_get_flags(klass: *const Il2CppClass) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_is_abstract(klass: *const Il2CppClass) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_is_interface(klass: *const Il2CppClass) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_array_element_size(klass: *const Il2CppClass) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_from_type(type_: *const Il2CppType) -> *mut Il2CppClass; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_get_type(klass: *mut Il2CppClass) -> *const Il2CppType; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_get_type_token(klass: *mut Il2CppClass) -> u32; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_has_attribute(klass: *mut Il2CppClass, attr_class: *mut Il2CppClass) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_has_references(klass: *mut Il2CppClass) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_is_enum(klass: *const Il2CppClass) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_get_image(klass: *mut Il2CppClass) -> *const Il2CppImage; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_get_assemblyname( klass: *const Il2CppClass, ) -> *const ::std::os::raw::c_char; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_get_rank(klass: *const Il2CppClass) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_get_data_size(klass: *const Il2CppClass) -> u32; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_get_static_field_data( klass: *const Il2CppClass, ) -> *mut ::std::os::raw::c_void; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_get_bitmap_size(klass: *const Il2CppClass) -> usize; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_get_bitmap(klass: *mut Il2CppClass, bitmap: *mut usize); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_stats_dump_to_file(path: *const ::std::os::raw::c_char) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_stats_get_value(stat: Il2CppStat) -> u64; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_domain_get() -> *mut Il2CppDomain; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_domain_assembly_open( domain: *mut Il2CppDomain, name: *const ::std::os::raw::c_char, ) -> *const Il2CppAssembly; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_domain_get_assemblies( domain: *const Il2CppDomain, size: *mut usize, ) -> *mut *const Il2CppAssembly; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_raise_exception(arg1: *mut Il2CppException) -> !; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_exception_from_name_msg( image: *const Il2CppImage, name_space: *const ::std::os::raw::c_char, @@ -6988,29 +7749,29 @@ extern "C" { msg: *const ::std::os::raw::c_char, ) -> *mut Il2CppException; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_get_exception_argument_null( arg: *const ::std::os::raw::c_char, ) -> *mut Il2CppException; } -extern "C" { +unsafe 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" { +unsafe 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" { +unsafe extern "C" { pub fn il2cpp_unhandled_exception(arg1: *mut Il2CppException); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_native_stack_trace( ex: *const Il2CppException, addresses: *mut *mut usize, @@ -7019,107 +7780,107 @@ extern "C" { imageName: *mut *mut ::std::os::raw::c_char, ); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_field_get_flags(field: *mut FieldInfo) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_field_get_name(field: *mut FieldInfo) -> *const ::std::os::raw::c_char; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_field_get_parent(field: *mut FieldInfo) -> *mut Il2CppClass; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_field_get_offset(field: *mut FieldInfo) -> usize; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_field_get_type(field: *mut FieldInfo) -> *const Il2CppType; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_field_get_value( obj: *mut Il2CppObject, field: *mut FieldInfo, value: *mut ::std::os::raw::c_void, ); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_field_get_value_object( field: *mut FieldInfo, obj: *mut Il2CppObject, ) -> *mut Il2CppObject; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_field_has_attribute(field: *mut FieldInfo, attr_class: *mut Il2CppClass) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_field_set_value( obj: *mut Il2CppObject, field: *mut FieldInfo, value: *mut ::std::os::raw::c_void, ); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_field_static_get_value(field: *mut FieldInfo, value: *mut ::std::os::raw::c_void); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_field_static_set_value(field: *mut FieldInfo, value: *mut ::std::os::raw::c_void); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_field_set_value_object( instance: *mut Il2CppObject, field: *mut FieldInfo, value: *mut Il2CppObject, ); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_field_is_literal(field: *mut FieldInfo) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_gc_collect(maxGenerations: ::std::os::raw::c_int); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_gc_collect_a_little() -> i32; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_gc_start_incremental_collection(); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_gc_disable(); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_gc_enable(); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_gc_is_disabled() -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_gc_set_mode(mode: Il2CppGCMode); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_gc_get_max_time_slice_ns() -> i64; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_gc_set_max_time_slice_ns(maxTimeSlice: i64); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_gc_is_incremental() -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_gc_get_used_size() -> i64; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_gc_get_heap_size() -> i64; } -extern "C" { +unsafe 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" { +unsafe extern "C" { pub fn il2cpp_gc_has_strict_wbarriers() -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_gc_set_external_allocation_tracker( func: ::std::option::Option< unsafe extern "C" fn( @@ -7130,12 +7891,12 @@ extern "C" { >, ); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_gc_set_external_wbarrier_tracker( func: ::std::option::Option, ); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_gc_foreach_heap( func: ::std::option::Option< unsafe extern "C" fn( @@ -7146,31 +7907,31 @@ extern "C" { userData: *mut ::std::os::raw::c_void, ); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_stop_gc_world(); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_start_gc_world(); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_gc_alloc_fixed(size: usize) -> *mut ::std::os::raw::c_void; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_gc_free_fixed(address: *mut ::std::os::raw::c_void); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_gchandle_new(obj: *mut Il2CppObject, pinned: u8) -> u32; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_gchandle_new_weakref(obj: *mut Il2CppObject, track_resurrection: u8) -> u32; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_gchandle_get_target(gchandle: u32) -> *mut Il2CppObject; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_gchandle_free(gchandle: u32); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_gchandle_foreach_get_target( func: ::std::option::Option< unsafe extern "C" fn( @@ -7181,22 +7942,22 @@ extern "C" { userData: *mut ::std::os::raw::c_void, ); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_object_header_size() -> u32; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_array_object_header_size() -> u32; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_offset_of_array_length_in_array_object_header() -> u32; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_offset_of_array_bounds_in_array_object_header() -> u32; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_allocation_granularity() -> u32; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_unity_liveness_allocate_struct( filter: *mut Il2CppClass, max_object_count: ::std::os::raw::c_int, @@ -7205,168 +7966,168 @@ extern "C" { reallocate: il2cpp_liveness_reallocate_callback, ) -> *mut ::std::os::raw::c_void; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_unity_liveness_calculation_from_root( root: *mut Il2CppObject, state: *mut ::std::os::raw::c_void, ); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_unity_liveness_calculation_from_statics(state: *mut ::std::os::raw::c_void); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_unity_liveness_finalize(state: *mut ::std::os::raw::c_void); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_unity_liveness_free_struct(state: *mut ::std::os::raw::c_void); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_method_get_return_type(method: *const MethodInfo) -> *const Il2CppType; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_method_get_declaring_type(method: *const MethodInfo) -> *mut Il2CppClass; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_method_get_name(method: *const MethodInfo) -> *const ::std::os::raw::c_char; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_method_get_from_reflection( method: *const Il2CppReflectionMethod, ) -> *const MethodInfo; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_method_get_object( method: *const MethodInfo, refclass: *mut Il2CppClass, ) -> *mut Il2CppReflectionMethod; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_method_is_generic(method: *const MethodInfo) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_method_is_inflated(method: *const MethodInfo) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_method_is_instance(method: *const MethodInfo) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_method_get_param_count(method: *const MethodInfo) -> u32; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_method_get_param(method: *const MethodInfo, index: u32) -> *const Il2CppType; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_method_get_class(method: *const MethodInfo) -> *mut Il2CppClass; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_method_has_attribute( method: *const MethodInfo, attr_class: *mut Il2CppClass, ) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_method_get_flags(method: *const MethodInfo, iflags: *mut u32) -> u32; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_method_get_token(method: *const MethodInfo) -> u32; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_method_get_param_name( method: *const MethodInfo, index: u32, ) -> *const ::std::os::raw::c_char; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_profiler_install(prof: *mut Il2CppProfiler, shutdown_callback: Il2CppProfileFunc); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_profiler_set_events(events: Il2CppProfileFlags); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_profiler_install_enter_leave( enter: Il2CppProfileMethodFunc, fleave: Il2CppProfileMethodFunc, ); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_profiler_install_allocation(callback: Il2CppProfileAllocFunc); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_profiler_install_gc( callback: Il2CppProfileGCFunc, heap_resize_callback: Il2CppProfileGCResizeFunc, ); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_profiler_install_fileio(callback: Il2CppProfileFileIOFunc); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_profiler_install_thread( start: Il2CppProfileThreadFunc, end: Il2CppProfileThreadFunc, ); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_property_get_flags(prop: *mut PropertyInfo) -> u32; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_property_get_get_method(prop: *mut PropertyInfo) -> *const MethodInfo; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_property_get_set_method(prop: *mut PropertyInfo) -> *const MethodInfo; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_property_get_name(prop: *mut PropertyInfo) -> *const ::std::os::raw::c_char; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_property_get_parent(prop: *mut PropertyInfo) -> *mut Il2CppClass; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_object_get_class(obj: *mut Il2CppObject) -> *mut Il2CppClass; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_object_get_size(obj: *mut Il2CppObject) -> u32; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_object_get_virtual_method( obj: *mut Il2CppObject, method: *const MethodInfo, ) -> *const MethodInfo; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_object_new(klass: *const Il2CppClass) -> *mut Il2CppObject; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_object_unbox(obj: *mut Il2CppObject) -> *mut ::std::os::raw::c_void; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_value_box( klass: *mut Il2CppClass, data: *mut ::std::os::raw::c_void, ) -> *mut Il2CppObject; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_monitor_enter(obj: *mut Il2CppObject); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_monitor_try_enter(obj: *mut Il2CppObject, timeout: u32) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_monitor_exit(obj: *mut Il2CppObject); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_monitor_pulse(obj: *mut Il2CppObject); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_monitor_pulse_all(obj: *mut Il2CppObject); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_monitor_wait(obj: *mut Il2CppObject); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_monitor_try_wait(obj: *mut Il2CppObject, timeout: u32) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_runtime_invoke( method: *const MethodInfo, obj: *mut ::std::os::raw::c_void, @@ -7374,7 +8135,7 @@ extern "C" { exc: *mut *mut Il2CppException, ) -> *mut Il2CppObject; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_runtime_invoke_convert_args( method: *const MethodInfo, obj: *mut ::std::os::raw::c_void, @@ -7383,318 +8144,318 @@ extern "C" { exc: *mut *mut Il2CppException, ) -> *mut Il2CppObject; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_runtime_class_init(klass: *mut Il2CppClass); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_runtime_object_init(obj: *mut Il2CppObject); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_runtime_object_init_exception( obj: *mut Il2CppObject, exc: *mut *mut Il2CppException, ); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_runtime_unhandled_exception_policy_set( value: Il2CppRuntimeUnhandledExceptionPolicy, ); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_string_length(str_: *mut Il2CppString) -> i32; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_string_chars(str_: *mut Il2CppString) -> *mut Il2CppChar; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_string_new(str_: *const ::std::os::raw::c_char) -> *mut Il2CppString; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_string_new_len( str_: *const ::std::os::raw::c_char, length: u32, ) -> *mut Il2CppString; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_string_new_utf16(text: *const Il2CppChar, len: i32) -> *mut Il2CppString; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_string_new_wrapper(str_: *const ::std::os::raw::c_char) -> *mut Il2CppString; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_string_intern(str_: *mut Il2CppString) -> *mut Il2CppString; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_string_is_interned(str_: *mut Il2CppString) -> *mut Il2CppString; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_thread_current() -> *mut Il2CppThread; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_thread_attach(domain: *mut Il2CppDomain) -> *mut Il2CppThread; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_thread_detach(thread: *mut Il2CppThread); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_thread_get_all_attached_threads(size: *mut usize) -> *mut *mut Il2CppThread; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_is_vm_thread(thread: *mut Il2CppThread) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_current_thread_walk_frame_stack( func: Il2CppFrameWalkFunc, user_data: *mut ::std::os::raw::c_void, ); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_thread_walk_frame_stack( thread: *mut Il2CppThread, func: Il2CppFrameWalkFunc, user_data: *mut ::std::os::raw::c_void, ); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_current_thread_get_top_frame(frame: *mut Il2CppStackFrameInfo) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_thread_get_top_frame( thread: *mut Il2CppThread, frame: *mut Il2CppStackFrameInfo, ) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_current_thread_get_frame_at(offset: i32, frame: *mut Il2CppStackFrameInfo) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_thread_get_frame_at( thread: *mut Il2CppThread, offset: i32, frame: *mut Il2CppStackFrameInfo, ) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_current_thread_get_stack_depth() -> i32; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_thread_get_stack_depth(thread: *mut Il2CppThread) -> i32; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_override_stack_backtrace(stackBacktraceFunc: Il2CppBacktraceFunc); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_type_get_object(type_: *const Il2CppType) -> *mut Il2CppObject; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_type_get_type(type_: *const Il2CppType) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_type_get_class_or_element_class(type_: *const Il2CppType) -> *mut Il2CppClass; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_type_get_name(type_: *const Il2CppType) -> *mut ::std::os::raw::c_char; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_type_is_byref(type_: *const Il2CppType) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_type_get_attrs(type_: *const Il2CppType) -> u32; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_type_equals(type_: *const Il2CppType, otherType: *const Il2CppType) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_type_get_assembly_qualified_name( type_: *const Il2CppType, ) -> *mut ::std::os::raw::c_char; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_type_get_reflection_name(type_: *const Il2CppType) -> *mut ::std::os::raw::c_char; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_type_is_static(type_: *const Il2CppType) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_type_is_pointer_type(type_: *const Il2CppType) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_image_get_assembly(image: *const Il2CppImage) -> *const Il2CppAssembly; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_image_get_name(image: *const Il2CppImage) -> *const ::std::os::raw::c_char; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_image_get_filename(image: *const Il2CppImage) -> *const ::std::os::raw::c_char; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_image_get_entry_point(image: *const Il2CppImage) -> *const MethodInfo; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_image_get_class_count(image: *const Il2CppImage) -> usize; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_image_get_class(image: *const Il2CppImage, index: usize) -> *const Il2CppClass; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_capture_memory_snapshot() -> *mut Il2CppManagedMemorySnapshot; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_free_captured_memory_snapshot(snapshot: *mut Il2CppManagedMemorySnapshot); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_set_find_plugin_callback(method: Il2CppSetFindPlugInCallback); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_register_log_callback(method: Il2CppLogCallback); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_debugger_set_agent_options(options: *const ::std::os::raw::c_char); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_is_debugger_attached() -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_register_debugger_agent_transport( debuggerTransport: *mut Il2CppDebuggerTransport, ); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_debug_get_method_info( arg1: *const MethodInfo, methodDebugInfo: *mut Il2CppMethodDebugInfo, ) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_unity_install_unitytls_interface( unitytlsInterfaceStruct: *const ::std::os::raw::c_void, ); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_custom_attrs_from_class(klass: *mut Il2CppClass) -> *mut Il2CppCustomAttrInfo; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_custom_attrs_from_method(method: *const MethodInfo) -> *mut Il2CppCustomAttrInfo; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_custom_attrs_from_field(field: *const FieldInfo) -> *mut Il2CppCustomAttrInfo; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_custom_attrs_get_attr( ainfo: *mut Il2CppCustomAttrInfo, attr_klass: *mut Il2CppClass, ) -> *mut Il2CppObject; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_custom_attrs_has_attr( ainfo: *mut Il2CppCustomAttrInfo, attr_klass: *mut Il2CppClass, ) -> u8; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_custom_attrs_construct(cinfo: *mut Il2CppCustomAttrInfo) -> *mut Il2CppArray; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_custom_attrs_free(ainfo: *mut Il2CppCustomAttrInfo); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_set_userdata( klass: *mut Il2CppClass, userdata: *mut ::std::os::raw::c_void, ); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_class_get_userdata_offset() -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn il2cpp_set_default_thread_affinity(affinity_mask: i64); } -extern "C" { +unsafe extern "C" { pub fn il2cpp_unity_set_android_network_up_state_func(func: Il2CppAndroidUpStateFunc); } -extern "C" { +unsafe extern "C" { pub fn __doserrno() -> *mut ::std::os::raw::c_ulong; } -extern "C" { +unsafe extern "C" { pub fn _set_doserrno(_Value: ::std::os::raw::c_ulong) -> errno_t; } -extern "C" { +unsafe extern "C" { pub fn _get_doserrno(_Value: *mut ::std::os::raw::c_ulong) -> errno_t; } -extern "C" { +unsafe 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" { +unsafe 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" { +unsafe 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" { +unsafe 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" { +unsafe 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" { +unsafe 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" { +unsafe 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" { +unsafe 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" { +unsafe 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" { +unsafe extern "C" { pub fn wcsrchr(_Str: *const wchar_t, _Ch: wchar_t) -> *mut wchar_t; } -extern "C" { +unsafe extern "C" { pub fn wcsstr(_Str: *const wchar_t, _SubStr: *const wchar_t) -> *mut wchar_t; } -extern "C" { +unsafe 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" { +unsafe extern "C" { pub fn _memicmp_l( _Buf1: *const ::std::os::raw::c_void, _Buf2: *const ::std::os::raw::c_void, @@ -7702,7 +8463,7 @@ extern "C" { _Locale: _locale_t, ) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn memccpy( _Dst: *mut ::std::os::raw::c_void, _Src: *const ::std::os::raw::c_void, @@ -7710,28 +8471,28 @@ extern "C" { _Size: ::std::os::raw::c_ulonglong, ) -> *mut ::std::os::raw::c_void; } -extern "C" { +unsafe 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" { +unsafe extern "C" { pub fn wcscat_s( _Destination: *mut wchar_t, _SizeInWords: rsize_t, _Source: *const wchar_t, ) -> errno_t; } -extern "C" { +unsafe extern "C" { pub fn wcscpy_s( _Destination: *mut wchar_t, _SizeInWords: rsize_t, _Source: *const wchar_t, ) -> errno_t; } -extern "C" { +unsafe extern "C" { pub fn wcsncat_s( _Destination: *mut wchar_t, _SizeInWords: rsize_t, @@ -7739,7 +8500,7 @@ extern "C" { _MaxCount: rsize_t, ) -> errno_t; } -extern "C" { +unsafe extern "C" { pub fn wcsncpy_s( _Destination: *mut wchar_t, _SizeInWords: rsize_t, @@ -7747,109 +8508,109 @@ extern "C" { _MaxCount: rsize_t, ) -> errno_t; } -extern "C" { +unsafe extern "C" { pub fn wcstok_s( _String: *mut wchar_t, _Delimiter: *const wchar_t, _Context: *mut *mut wchar_t, ) -> *mut wchar_t; } -extern "C" { +unsafe extern "C" { pub fn _wcsdup(_String: *const wchar_t) -> *mut wchar_t; } -extern "C" { +unsafe extern "C" { pub fn wcscat(_Destination: *mut wchar_t, _Source: *const wchar_t) -> *mut wchar_t; } -extern "C" { +unsafe 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" { +unsafe extern "C" { pub fn wcscpy(_Destination: *mut wchar_t, _Source: *const wchar_t) -> *mut wchar_t; } -extern "C" { +unsafe extern "C" { pub fn wcscspn(_String: *const wchar_t, _Control: *const wchar_t) -> usize; } -extern "C" { +unsafe extern "C" { pub fn wcslen(_String: *const ::std::os::raw::c_ushort) -> ::std::os::raw::c_ulonglong; } -extern "C" { +unsafe extern "C" { pub fn wcsnlen(_Source: *const wchar_t, _MaxCount: usize) -> usize; } -extern "C" { +unsafe extern "C" { pub fn wcsncat( _Destination: *mut wchar_t, _Source: *const wchar_t, _Count: usize, ) -> *mut wchar_t; } -extern "C" { +unsafe 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" { +unsafe extern "C" { pub fn wcsncpy( _Destination: *mut wchar_t, _Source: *const wchar_t, _Count: usize, ) -> *mut wchar_t; } -extern "C" { +unsafe extern "C" { pub fn wcspbrk(_String: *const wchar_t, _Control: *const wchar_t) -> *mut wchar_t; } -extern "C" { +unsafe extern "C" { pub fn wcsspn(_String: *const wchar_t, _Control: *const wchar_t) -> usize; } -extern "C" { +unsafe extern "C" { pub fn wcstok( _String: *mut wchar_t, _Delimiter: *const wchar_t, _Context: *mut *mut wchar_t, ) -> *mut wchar_t; } -extern "C" { +unsafe extern "C" { pub fn _wcserror(_ErrorNumber: ::std::os::raw::c_int) -> *mut wchar_t; } -extern "C" { +unsafe extern "C" { pub fn _wcserror_s( _Buffer: *mut wchar_t, _SizeInWords: usize, _ErrorNumber: ::std::os::raw::c_int, ) -> errno_t; } -extern "C" { +unsafe extern "C" { pub fn __wcserror(_String: *const wchar_t) -> *mut wchar_t; } -extern "C" { +unsafe extern "C" { pub fn __wcserror_s( _Buffer: *mut wchar_t, _SizeInWords: usize, _ErrorMessage: *const wchar_t, ) -> errno_t; } -extern "C" { +unsafe extern "C" { pub fn _wcsicmp(_String1: *const wchar_t, _String2: *const wchar_t) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn _wcsicmp_l( _String1: *const wchar_t, _String2: *const wchar_t, _Locale: _locale_t, ) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn _wcsnicmp( _String1: *const wchar_t, _String2: *const wchar_t, _MaxCount: usize, ) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn _wcsnicmp_l( _String1: *const wchar_t, _String2: *const wchar_t, @@ -7857,7 +8618,7 @@ extern "C" { _Locale: _locale_t, ) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn _wcsnset_s( _Destination: *mut wchar_t, _SizeInWords: usize, @@ -7865,46 +8626,46 @@ extern "C" { _MaxCount: usize, ) -> errno_t; } -extern "C" { +unsafe extern "C" { pub fn _wcsnset(_String: *mut wchar_t, _Value: wchar_t, _MaxCount: usize) -> *mut wchar_t; } -extern "C" { +unsafe extern "C" { pub fn _wcsrev(_String: *mut wchar_t) -> *mut wchar_t; } -extern "C" { +unsafe extern "C" { pub fn _wcsset_s(_Destination: *mut wchar_t, _SizeInWords: usize, _Value: wchar_t) -> errno_t; } -extern "C" { +unsafe extern "C" { pub fn _wcsset(_String: *mut wchar_t, _Value: wchar_t) -> *mut wchar_t; } -extern "C" { +unsafe extern "C" { pub fn _wcslwr_s(_String: *mut wchar_t, _SizeInWords: usize) -> errno_t; } -extern "C" { +unsafe extern "C" { pub fn _wcslwr(_String: *mut wchar_t) -> *mut wchar_t; } -extern "C" { +unsafe extern "C" { pub fn _wcslwr_s_l(_String: *mut wchar_t, _SizeInWords: usize, _Locale: _locale_t) -> errno_t; } -extern "C" { +unsafe extern "C" { pub fn _wcslwr_l(_String: *mut wchar_t, _Locale: _locale_t) -> *mut wchar_t; } -extern "C" { +unsafe extern "C" { pub fn _wcsupr_s(_String: *mut wchar_t, _Size: usize) -> errno_t; } -extern "C" { +unsafe extern "C" { pub fn _wcsupr(_String: *mut wchar_t) -> *mut wchar_t; } -extern "C" { +unsafe extern "C" { pub fn _wcsupr_s_l(_String: *mut wchar_t, _Size: usize, _Locale: _locale_t) -> errno_t; } -extern "C" { +unsafe extern "C" { pub fn _wcsupr_l(_String: *mut wchar_t, _Locale: _locale_t) -> *mut wchar_t; } -extern "C" { +unsafe extern "C" { pub fn wcsxfrm(_Destination: *mut wchar_t, _Source: *const wchar_t, _MaxCount: usize) -> usize; } -extern "C" { +unsafe extern "C" { pub fn _wcsxfrm_l( _Destination: *mut wchar_t, _Source: *const wchar_t, @@ -7912,34 +8673,34 @@ extern "C" { _Locale: _locale_t, ) -> usize; } -extern "C" { +unsafe extern "C" { pub fn wcscoll(_String1: *const wchar_t, _String2: *const wchar_t) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn _wcscoll_l( _String1: *const wchar_t, _String2: *const wchar_t, _Locale: _locale_t, ) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn _wcsicoll(_String1: *const wchar_t, _String2: *const wchar_t) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn _wcsicoll_l( _String1: *const wchar_t, _String2: *const wchar_t, _Locale: _locale_t, ) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn _wcsncoll( _String1: *const wchar_t, _String2: *const wchar_t, _MaxCount: usize, ) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn _wcsncoll_l( _String1: *const wchar_t, _String2: *const wchar_t, @@ -7947,14 +8708,14 @@ extern "C" { _Locale: _locale_t, ) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn _wcsnicoll( _String1: *const wchar_t, _String2: *const wchar_t, _MaxCount: usize, ) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn _wcsnicoll_l( _String1: *const wchar_t, _String2: *const wchar_t, @@ -7962,59 +8723,59 @@ extern "C" { _Locale: _locale_t, ) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn wcsdup(_String: *const wchar_t) -> *mut wchar_t; } -extern "C" { +unsafe extern "C" { pub fn wcsicmp(_String1: *const wchar_t, _String2: *const wchar_t) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn wcsnicmp( _String1: *const wchar_t, _String2: *const wchar_t, _MaxCount: usize, ) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn wcsnset(_String: *mut wchar_t, _Value: wchar_t, _MaxCount: usize) -> *mut wchar_t; } -extern "C" { +unsafe extern "C" { pub fn wcsrev(_String: *mut wchar_t) -> *mut wchar_t; } -extern "C" { +unsafe extern "C" { pub fn wcsset(_String: *mut wchar_t, _Value: wchar_t) -> *mut wchar_t; } -extern "C" { +unsafe extern "C" { pub fn wcslwr(_String: *mut wchar_t) -> *mut wchar_t; } -extern "C" { +unsafe extern "C" { pub fn wcsupr(_String: *mut wchar_t) -> *mut wchar_t; } -extern "C" { +unsafe extern "C" { pub fn wcsicoll(_String1: *const wchar_t, _String2: *const wchar_t) -> ::std::os::raw::c_int; } -extern "C" { +unsafe 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" { +unsafe 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" { +unsafe 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" { +unsafe extern "C" { pub fn strncat_s( _Destination: *mut ::std::os::raw::c_char, _SizeInBytes: rsize_t, @@ -8022,7 +8783,7 @@ extern "C" { _MaxCount: rsize_t, ) -> errno_t; } -extern "C" { +unsafe extern "C" { pub fn strncpy_s( _Destination: *mut ::std::os::raw::c_char, _SizeInBytes: rsize_t, @@ -8030,14 +8791,14 @@ extern "C" { _MaxCount: rsize_t, ) -> errno_t; } -extern "C" { +unsafe 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" { +unsafe extern "C" { pub fn _memccpy( _Dst: *mut ::std::os::raw::c_void, _Src: *const ::std::os::raw::c_void, @@ -8045,135 +8806,135 @@ extern "C" { _MaxCount: usize, ) -> *mut ::std::os::raw::c_void; } -extern "C" { +unsafe 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" { +unsafe 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" { +unsafe 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" { +unsafe 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" { +unsafe 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" { +unsafe 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" { +unsafe 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" { +unsafe extern "C" { pub fn _strdup(_Source: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; } -extern "C" { +unsafe extern "C" { pub fn _strerror(_ErrorMessage: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; } -extern "C" { +unsafe 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" { +unsafe extern "C" { pub fn strerror(_ErrorMessage: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char; } -extern "C" { +unsafe 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" { +unsafe 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" { +unsafe 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" { +unsafe 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" { +unsafe extern "C" { pub fn strlen(_Str: *const ::std::os::raw::c_char) -> ::std::os::raw::c_ulonglong; } -extern "C" { +unsafe extern "C" { pub fn _strlwr_s(_String: *mut ::std::os::raw::c_char, _Size: usize) -> errno_t; } -extern "C" { +unsafe extern "C" { pub fn _strlwr(_String: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; } -extern "C" { +unsafe extern "C" { pub fn _strlwr_s_l( _String: *mut ::std::os::raw::c_char, _Size: usize, _Locale: _locale_t, ) -> errno_t; } -extern "C" { +unsafe extern "C" { pub fn _strlwr_l( _String: *mut ::std::os::raw::c_char, _Locale: _locale_t, ) -> *mut ::std::os::raw::c_char; } -extern "C" { +unsafe 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" { +unsafe 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" { +unsafe 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" { +unsafe extern "C" { pub fn _strnicmp_l( _String1: *const ::std::os::raw::c_char, _String2: *const ::std::os::raw::c_char, @@ -8181,14 +8942,14 @@ extern "C" { _Locale: _locale_t, ) -> ::std::os::raw::c_int; } -extern "C" { +unsafe 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" { +unsafe extern "C" { pub fn _strnicoll_l( _String1: *const ::std::os::raw::c_char, _String2: *const ::std::os::raw::c_char, @@ -8196,14 +8957,14 @@ extern "C" { _Locale: _locale_t, ) -> ::std::os::raw::c_int; } -extern "C" { +unsafe 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" { +unsafe extern "C" { pub fn _strncoll_l( _String1: *const ::std::os::raw::c_char, _String2: *const ::std::os::raw::c_char, @@ -8211,20 +8972,20 @@ extern "C" { _Locale: _locale_t, ) -> ::std::os::raw::c_int; } -extern "C" { +unsafe extern "C" { pub fn __strncnt(_String: *const ::std::os::raw::c_char, _Count: usize) -> usize; } -extern "C" { +unsafe 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" { +unsafe extern "C" { pub fn strnlen(_String: *const ::std::os::raw::c_char, _MaxCount: usize) -> usize; } -extern "C" { +unsafe extern "C" { pub fn _strnset_s( _String: *mut ::std::os::raw::c_char, _SizeInBytes: usize, @@ -8232,74 +8993,74 @@ extern "C" { _MaxCount: usize, ) -> errno_t; } -extern "C" { +unsafe 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" { +unsafe 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" { +unsafe extern "C" { pub fn _strrev(_Str: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; } -extern "C" { +unsafe 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" { +unsafe 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" { +unsafe 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" { +unsafe 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" { +unsafe extern "C" { pub fn _strupr_s(_String: *mut ::std::os::raw::c_char, _Size: usize) -> errno_t; } -extern "C" { +unsafe extern "C" { pub fn _strupr(_String: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; } -extern "C" { +unsafe extern "C" { pub fn _strupr_s_l( _String: *mut ::std::os::raw::c_char, _Size: usize, _Locale: _locale_t, ) -> errno_t; } -extern "C" { +unsafe extern "C" { pub fn _strupr_l( _String: *mut ::std::os::raw::c_char, _Locale: _locale_t, ) -> *mut ::std::os::raw::c_char; } -extern "C" { +unsafe 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" { +unsafe extern "C" { pub fn _strxfrm_l( _Destination: *mut ::std::os::raw::c_char, _Source: *const ::std::os::raw::c_char, @@ -8307,59 +9068,59 @@ extern "C" { _Locale: _locale_t, ) -> usize; } -extern "C" { +unsafe extern "C" { pub fn strdup(_String: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; } -extern "C" { +unsafe 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" { +unsafe 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" { +unsafe extern "C" { pub fn strlwr(_String: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; } -extern "C" { +unsafe 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" { +unsafe 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" { +unsafe extern "C" { pub fn strrev(_String: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; } -extern "C" { +unsafe 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" { +unsafe extern "C" { pub fn strupr(_String: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char; } -extern "C" { +unsafe extern "C" { pub static kIl2CppUInt64Max: u64; } -extern "C" { +unsafe extern "C" { pub static kIl2CppUIntPtrMax: usize; } -extern "C" { +unsafe extern "C" { pub static kIl2CppNewLine: [Il2CppChar; 3usize]; } -extern "C" { +unsafe extern "C" { pub static mut il2cpp_defaults: Il2CppDefaults; } diff --git a/libil2cpp/src/ty.rs b/libil2cpp/src/ty.rs index a78d7415..77154ed2 100644 --- a/libil2cpp/src/ty.rs +++ b/libil2cpp/src/ty.rs @@ -91,13 +91,13 @@ macro_rules! builtins { #[doc = "Builtin C# types"] #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] - #[cfg_attr(feature = "il2cpp_v31", repr(i32))] + #[cfg_attr(feature = "il2cpp_v31", repr(u32))] #[cfg_attr(feature = "il2cpp_v24", repr(u32))] #[cfg_attr(feature = "unity2018", repr(i32))] pub enum Builtin { $( #[doc = concat!("`", $name, "`")] - $variant = $const, + $variant = $const as u32, )* } @@ -106,7 +106,7 @@ macro_rules! builtins { #[inline] pub fn is_builtin(&self, builtin: Builtin) -> bool { #[cfg(feature = "il2cpp_v31")] - { self.raw().type_() == builtin as i32 } + { self.raw().type_() == (builtin as u32).try_into().unwrap() } #[cfg(feature = "il2cpp_v24")] { self.raw().type_() == builtin as u32 } From d257fcc98e2bc972666f75389ab841fcf873b742 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Tue, 10 Dec 2024 00:03:03 -0400 Subject: [PATCH 36/71] Add types for GC callee --- libil2cpp/src/typecheck/callee.rs | 64 ++++++++++++++++++++++++++++++- 1 file changed, 63 insertions(+), 1 deletion(-) diff --git a/libil2cpp/src/typecheck/callee.rs b/libil2cpp/src/typecheck/callee.rs index c6ccf65e..d8f5c14e 100644 --- a/libil2cpp/src/typecheck/callee.rs +++ b/libil2cpp/src/typecheck/callee.rs @@ -1,6 +1,6 @@ use std::fmt; -use crate::{Builtin, Il2CppType, MethodInfo, Type}; +use crate::{Builtin, Gc, GcType, Il2CppType, MethodInfo, Type}; /// Trait implemented by types that can be used as C# `this` method parameters /// @@ -211,6 +211,68 @@ where Some(self) } } +// TODO: Remove this once rustfmt stops dropping generics on GATs +#[rustfmt::skip] +unsafe impl ThisParameter for Gc +where + T: GcType, + T: for<'a> Type = Option<&'a mut T>>, +{ + type Actual = Self; + + fn matches(ty: &MethodInfo) -> bool { + T::matches_this_parameter(ty) + } + + fn from_actual(actual: Self::Actual) -> Self { + actual + } + fn into_actual(self) -> Self::Actual { + self + } +} + +// TODO: Remove this once rustfmt stops dropping generics on GATs +#[rustfmt::skip] +unsafe impl Parameter for Gc +where + T: GcType, + T: for<'a> Type = Option<&'a mut T>>, +{ + type Actual = Self; + + fn matches(ty: &Il2CppType) -> bool { + T::matches_reference_parameter(ty) + } + + fn from_actual(actual: Self::Actual) -> Self { + actual + } + fn into_actual(self) -> Self::Actual { + self + } +} + +// TODO: Remove this once rustfmt stops dropping generics on GATs +#[rustfmt::skip] +unsafe impl Return for Gc +where + T: GcType, + T: for<'a> Type = Option<&'a mut T>>, +{ + type Actual = Self; + + fn matches(ty: &Il2CppType) -> bool { + T::matches_return(ty) + } + + fn into_actual(self) -> Self::Actual { + self + } + fn from_actual(actual: Self::Actual) -> Self { + actual + } +} // TODO: Remove this once rustfmt stops dropping generics on GATs #[rustfmt::skip] From d059d1ee0913fde0debd8ffb3d2be5915a79b511 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Tue, 10 Dec 2024 00:09:50 -0400 Subject: [PATCH 37/71] Fix GcType argument bound check --- libil2cpp/src/typecheck/callee.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/libil2cpp/src/typecheck/callee.rs b/libil2cpp/src/typecheck/callee.rs index d8f5c14e..c4e02ecf 100644 --- a/libil2cpp/src/typecheck/callee.rs +++ b/libil2cpp/src/typecheck/callee.rs @@ -215,7 +215,7 @@ where #[rustfmt::skip] unsafe impl ThisParameter for Gc where - T: GcType, + *mut T: GcType, T: for<'a> Type = Option<&'a mut T>>, { type Actual = Self; @@ -236,7 +236,7 @@ where #[rustfmt::skip] unsafe impl Parameter for Gc where - T: GcType, + *mut T: GcType, T: for<'a> Type = Option<&'a mut T>>, { type Actual = Self; @@ -257,7 +257,7 @@ where #[rustfmt::skip] unsafe impl Return for Gc where - T: GcType, + *mut T: GcType, T: for<'a> Type = Option<&'a mut T>>, { type Actual = Self; From 401319ba13cb9476aa13e5a3aeae673d49956be7 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Tue, 10 Dec 2024 12:02:39 -0400 Subject: [PATCH 38/71] Add `convert` and documentation --- libil2cpp/src/gc.rs | 29 +++++++++++++++++++++++++---- 1 file changed, 25 insertions(+), 4 deletions(-) diff --git a/libil2cpp/src/gc.rs b/libil2cpp/src/gc.rs index c76de6a7..d580bc12 100644 --- a/libil2cpp/src/gc.rs +++ b/libil2cpp/src/gc.rs @@ -3,13 +3,14 @@ use std::ops::{Deref, DerefMut, Not}; use crate::{Argument, Returned, ThisArgument, Type}; -// Wrapper type which implies the type is GC managed lifetime +/// Wrapper type which implies the type is GC managed lifetime #[repr(transparent)] pub struct Gc(*mut T) where *mut T: GcType, // assert that *mut T is a GcType T: for<'a> Type = Option<&'a mut T>>; +/// Trait alias for types that can be used with the `Gc` wrapper. pub trait GcType = Type + Returned + ThisArgument + Argument; impl Gc @@ -32,21 +33,41 @@ where self.0.is_null() } + /// Returns an `Option` containing a reference to the value if the pointer + /// is not null. pub fn as_opt(&self) -> Option<&T> { self.is_null().not().then(|| unsafe { &*self.0 }) } + /// Returns an `Option` containing a mutable reference to the value if the pointer + /// is not null. pub fn as_opt_mut(&mut self) -> Option<&mut T> { self.is_null().not().then(|| unsafe { &mut *self.0 }) } - pub fn get_pointer(&self) -> *const T { + /// Returns a constant pointer to the value. + pub fn get_pointer(&self) -> *const T { self.0 } - pub fn get_pointer_mut(&mut self) -> *mut T { + /// Returns a mutable pointer to the value. + pub fn get_pointer_mut(&mut self) -> *mut T { self.0 } - + /// Converts the current `Gc` instance to a `Gc` instance of another type. + /// + /// # Safety + /// Relies on the `T` implementation of `AsMut` to be correct. + pub fn convert(mut self) -> Gc + where + *mut U: GcType, + U: for<'a> Type = Option<&'a mut U>>, + T: AsMut, // ensures T is convertible to U + { + match self.as_opt_mut() { + Some(value) => Gc::from(value.as_mut() as &mut U), + None => Gc::null(), + } + } } unsafe impl Type for Gc From 7569a71983526b0391c352bb923d12ee16b5cedd Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Tue, 10 Dec 2024 12:49:30 -0400 Subject: [PATCH 39/71] Change `convert` to `cast` and add `downcast` --- libil2cpp/src/gc.rs | 44 ++++++++++++++++++++++++++++++++++++++------ 1 file changed, 38 insertions(+), 6 deletions(-) diff --git a/libil2cpp/src/gc.rs b/libil2cpp/src/gc.rs index d580bc12..a1e5c89f 100644 --- a/libil2cpp/src/gc.rs +++ b/libil2cpp/src/gc.rs @@ -1,7 +1,8 @@ use std::fmt::{self, Debug, Formatter}; +use std::mem::transmute; use std::ops::{Deref, DerefMut, Not}; -use crate::{Argument, Returned, ThisArgument, Type}; +use crate::{Argument, ObjectType, Returned, ThisArgument, Type}; /// Wrapper type which implies the type is GC managed lifetime #[repr(transparent)] @@ -38,18 +39,18 @@ where pub fn as_opt(&self) -> Option<&T> { self.is_null().not().then(|| unsafe { &*self.0 }) } - /// Returns an `Option` containing a mutable reference to the value if the pointer - /// is not null. + /// Returns an `Option` containing a mutable reference to the value if the + /// pointer is not null. pub fn as_opt_mut(&mut self) -> Option<&mut T> { self.is_null().not().then(|| unsafe { &mut *self.0 }) } /// Returns a constant pointer to the value. - pub fn get_pointer(&self) -> *const T { + pub fn get_pointer(&self) -> *const T { self.0 } /// Returns a mutable pointer to the value. - pub fn get_pointer_mut(&mut self) -> *mut T { + pub fn get_pointer_mut(&mut self) -> *mut T { self.0 } @@ -57,7 +58,7 @@ where /// /// # Safety /// Relies on the `T` implementation of `AsMut` to be correct. - pub fn convert(mut self) -> Gc + pub fn cast(mut self) -> Gc where *mut U: GcType, U: for<'a> Type = Option<&'a mut U>>, @@ -68,6 +69,37 @@ where None => Gc::null(), } } + /// Converts the current `Gc` instance to a `Gc` instance of another type. + /// + /// # Safety + /// Relies on the `T` implementation of `AsMut` to be correct. + /// + /// C++ Implementation + /// + pub fn down_cast(mut self) -> Result, String> + where + *mut U: GcType, + U: for<'a> Type = Option<&'a mut U>>, + T: ObjectType, + { + match self.as_opt_mut() { + Some(value) => { + let value_klass = value.as_object().class(); + + if value_klass != U::class() && !value_klass.is_assignable_from(U::class()) { + return Err(format!( + "Downcast failed: {} is not assignable from {}", + U::class().name(), + value_klass.name() + )); + } + + let cast = (value as *mut T).cast::(); + Ok(Gc(cast)) + } + None => Ok(Gc::null()), + } + } } unsafe impl Type for Gc From 7ef98df6124d0bea4f3f7e71eb8d8ff3a509c839 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Sun, 15 Dec 2024 13:37:34 -0400 Subject: [PATCH 40/71] Add debug logging information for method lookup --- libil2cpp/src/class.rs | 177 +++++++++++++++++++++++++++++++++-------- 1 file changed, 145 insertions(+), 32 deletions(-) diff --git a/libil2cpp/src/class.rs b/libil2cpp/src/class.rs index d9726f3a..50877b71 100644 --- a/libil2cpp/src/class.rs +++ b/libil2cpp/src/class.rs @@ -1,7 +1,8 @@ use std::borrow::Cow; use std::ffi::{CStr, CString}; +use std::fmt::Display; use std::mem::transmute; -use std::{fmt, ptr, slice}; +use std::{fmt, ptr, slice, vec}; use crate::{ raw, Arguments, FieldInfo, Generics, Il2CppException, Il2CppType, MethodInfo, Parameters, @@ -121,22 +122,45 @@ impl Il2CppClass { .filter(|mi| mi.name() == name && A::matches(mi) && R::matches(mi.return_ty())) .copied(); - match match matching.next() { - // If we have no matches, we continue to the parent - None => continue, - Some(mi) => (mi, matching.next()), - } { - (mi, None) => { + match (matching.next(), matching.next()) { + // only one match + (Some(mi), None) => { #[cfg(feature = "cache")] cache::METHOD_CACHE.with(move |c| c.borrow_mut().insert(key.into(), mi)); return Ok(mi); } - _ => return Err(FindMethodError::Many), + + // multiple matches + (Some(mi), Some(mi2)) => { + let found = vec![mi, mi2] + .into_iter() + .chain(matching) + .map(|mi| { + let info = FindMethodParameters { + ty_name: c.to_string(), + method_name: name.to_string(), + parameters: mi.parameters().iter().map(|t| t.to_string()).collect(), + }; + info + }) + .collect(); + + return Err(FindMethodError::Many(found)); + } + + // If we have no matches, we continue to the parent + _ => continue, } } - Err(FindMethodError::None) + let info = FindMethodParameters { + ty_name: self.to_string(), + method_name: name.to_string(), + // TODO! + parameters: vec![format!("UNABLE TO PROVIDE! Count! {N}")], + }; + Err(FindMethodError::None(info)) } /// Find a `static` method belonging to the class by name with type checking @@ -180,22 +204,45 @@ impl Il2CppClass { }) .copied(); - match match matching.next() { - // If we have no matches, we continue to the parent - None => continue, - Some(mi) => (mi, matching.next()), - } { - (mi, None) => { + match (matching.next(), matching.next()) { + // only one match + (Some(mi), None) => { #[cfg(feature = "cache")] cache::METHOD_CACHE.with(move |c| c.borrow_mut().insert(key.into(), mi)); return Ok(mi); } - _ => return Err(FindMethodError::Many), + + // multiple matches + (Some(mi), Some(mi2)) => { + let found = vec![mi, mi2] + .into_iter() + .chain(matching) + .map(|mi| { + let info = FindMethodParameters { + ty_name: c.to_string(), + method_name: name.to_string(), + parameters: mi.parameters().iter().map(|t| t.to_string()).collect(), + }; + info + }) + .collect(); + + return Err(FindMethodError::Many(found)); + } + + // If we have no matches, we continue to the parent + _ => continue, } } - Err(FindMethodError::None) + let info = FindMethodParameters { + ty_name: self.to_string(), + method_name: name.to_string(), + // TODO! + parameters: vec![format!("UNABLE TO PROVIDE! Count! {N}")], + }; + Err(FindMethodError::None(info)) } /// Find a method belonging to the class or its parents by name with type @@ -219,9 +266,35 @@ impl Il2CppClass { .copied(); match (matching.next(), matching.next()) { + // one method found (Some(mi), None) | (None, Some(mi)) => Ok(mi), - (Some(_), Some(_)) => Err(FindMethodError::Many), - (None, None) => Err(FindMethodError::None), + // multiple methods found + (Some(mi1), Some(mi2)) => { + let found = vec![mi1, mi2] + .into_iter() + .chain(matching) + .map(|mi| { + let info = FindMethodParameters { + ty_name: self.to_string(), + method_name: name.to_string(), + parameters: mi.parameters().iter().map(|t| t.to_string()).collect(), + }; + info + }) + .collect(); + + Err(FindMethodError::Many(found)) + } + // none + _ => { + let info = FindMethodParameters { + ty_name: self.to_string(), + method_name: name.to_string(), + // TODO! + parameters: vec![format!("UNABLE TO PROVIDE! Count {}", P::COUNT)], + }; + Err(FindMethodError::None(info)) + } } } @@ -239,17 +312,38 @@ impl Il2CppClass { .filter(|mi| mi.name() == name && mi.parameters().len() == parameters_count) .copied(); - match match matching.next() { + match (matching.next(), matching.next()) { + // only one match + (Some(mi), None) => return Ok(mi), + // multiple matches + (Some(mi), Some(mi2)) => { + let found = vec![mi, mi2] + .into_iter() + .chain(matching) + .map(|mi| { + let info = FindMethodParameters { + ty_name: c.to_string(), + method_name: name.to_string(), + parameters: mi.parameters().iter().map(|t| t.to_string()).collect(), + }; + info + }) + .collect(); + + return Err(FindMethodError::Many(found)); + } // If we have no matches, we continue to the parent - None => continue, - Some(mi) => (mi, matching.next()), - } { - (mi, None) => return Ok(mi), - _ => return Err(FindMethodError::Many), + _ => continue, } } - Err(FindMethodError::None) + let info = FindMethodParameters { + ty_name: self.to_string(), + method_name: name.to_string(), + parameters: vec![format!("UNABLE TO PROVIDE! Count {}", parameters_count)], + }; + + Err(FindMethodError::None(info)) } /// Find a field belonging to the class or its parents by name @@ -469,16 +563,23 @@ impl<'a> From<&'a Il2CppType> for &'a Il2CppClass { } } +/// No matching method were found +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct FindMethodParameters { + pub ty_name: String, + pub method_name: String, + pub parameters: Vec, +} + /// Possible errors when looking up a method -#[derive(Debug, thiserror::Error, Clone, Copy, PartialEq, Eq, Hash)] +#[derive(Debug, thiserror::Error, Clone, PartialEq, Eq, Hash)] pub enum FindMethodError { - /// No matching method were found - #[error("no matching methods found")] - None, + #[error("no matching methods found for {0}")] + None(FindMethodParameters), /// Multiple matching methods were found - #[error("multiple matching methods found")] - Many, + #[error("multiple matching methods found. {0:?}")] + Many(Vec), } #[cfg(feature = "cache")] @@ -540,3 +641,15 @@ mod cache { pub(super) static METHOD_CACHE: RefCell> = Default::default(); } } + +impl Display for FindMethodParameters { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!( + f, + "{}.{}({})", + self.ty_name, + self.method_name, + self.parameters.join(", ") + ) + } +} From 3decad7e29557d49633b0a3efe57fea7b93baa67 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Thu, 2 Jan 2025 00:16:26 -0400 Subject: [PATCH 41/71] Add const T* for Gc --- libil2cpp/src/gc.rs | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/libil2cpp/src/gc.rs b/libil2cpp/src/gc.rs index a1e5c89f..f327bf10 100644 --- a/libil2cpp/src/gc.rs +++ b/libil2cpp/src/gc.rs @@ -256,6 +256,15 @@ where Self(ptr) } } +impl From<*const T> for Gc +where + *mut T: GcType, + T: for<'a> Type = Option<&'a mut T>>, +{ + fn from(ptr: *const T) -> Self { + Self(ptr as *mut T) + } +} impl From<&mut T> for Gc where *mut T: GcType, From 62b6103501a8dff91768583e16402025d857232b Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Sat, 4 Jan 2025 22:19:55 -0400 Subject: [PATCH 42/71] Add Gc specialization for ObjectType --- libil2cpp/src/object.rs | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/libil2cpp/src/object.rs b/libil2cpp/src/object.rs index 48bbcea4..3749617c 100644 --- a/libil2cpp/src/object.rs +++ b/libil2cpp/src/object.rs @@ -148,3 +148,17 @@ where unsafe { self.as_mut().unwrap().as_object_mut() } } } + +impl ObjectType for Gc +where + T: ObjectType, + T: for<'a> Type = std::option::Option<&'a mut T>>, +{ + fn as_object(&self) -> &Il2CppObject { + self.as_ref().as_object() + } + + fn as_object_mut(&mut self) -> &mut Il2CppObject { + self.as_mut().as_object_mut() + } +} From 42b037c7c67e18c0d53594bf15499be755c5c9bd Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Sun, 5 Jan 2025 15:04:43 -0400 Subject: [PATCH 43/71] Add ValueTypePadding type --- libil2cpp/src/lib.rs | 2 +- libil2cpp/src/valuetype.rs | 11 +++++++---- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/libil2cpp/src/lib.rs b/libil2cpp/src/lib.rs index eeed7790..6405fcb5 100644 --- a/libil2cpp/src/lib.rs +++ b/libil2cpp/src/lib.rs @@ -128,5 +128,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 use valuetype::ValueTypeExt; +pub use valuetype::{ValueTypeExt, ValueTypePadding}; pub use gc::{Gc, GcType}; diff --git a/libil2cpp/src/valuetype.rs b/libil2cpp/src/valuetype.rs index 606c1d24..023c225b 100644 --- a/libil2cpp/src/valuetype.rs +++ b/libil2cpp/src/valuetype.rs @@ -39,10 +39,13 @@ pub trait ValueTypeExt: for<'a> Type = Self> + Sized { } } +impl ValueTypeExt for T where T: for<'a> Type = T> {} +#[repr(transparent)] +pub struct ValueTypePadding(pub [u8; N]); -impl ValueTypeExt for T -where - T: for<'a> Type = T>, -{ +impl Default for ValueTypePadding { + fn default() -> Self { + Self([0; N]) + } } From 1acb1ce41e45df89a714fff71dd9bb783c722cc1 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Sun, 5 Jan 2025 15:24:09 -0400 Subject: [PATCH 44/71] Add traits to `ValueTypePadding` --- libil2cpp/src/valuetype.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/libil2cpp/src/valuetype.rs b/libil2cpp/src/valuetype.rs index 023c225b..35d0c952 100644 --- a/libil2cpp/src/valuetype.rs +++ b/libil2cpp/src/valuetype.rs @@ -42,6 +42,7 @@ pub trait ValueTypeExt: for<'a> Type = Self> + Sized { impl ValueTypeExt for T where T: for<'a> Type = T> {} #[repr(transparent)] +#[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct ValueTypePadding(pub [u8; N]); impl Default for ValueTypePadding { From 17552b1db37cf14d75e1f4129d9f62ee28457550 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Sun, 5 Jan 2025 15:31:26 -0400 Subject: [PATCH 45/71] Update beatsaber-hook --- .gitmodules | 2 +- inline_hook/beatsaber-hook | 2 +- inline_hook/build.rs | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.gitmodules b/.gitmodules index 708f621b..ac286525 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +1,3 @@ [submodule "inline_hook/beatsaber-hook"] path = inline_hook/beatsaber-hook - url = https://github.com/sc2ad/beatsaber-hook + url = https://github.com/QuestPackageManager/beatsaber-hook.git diff --git a/inline_hook/beatsaber-hook b/inline_hook/beatsaber-hook index 28cb80ba..9387899b 160000 --- a/inline_hook/beatsaber-hook +++ b/inline_hook/beatsaber-hook @@ -1 +1 @@ -Subproject commit 28cb80ba042e2bb3e304280278aa59c8fd4603d1 +Subproject commit 9387899b77c25f75b5505261ba46bd4ddddbd739 diff --git a/inline_hook/build.rs b/inline_hook/build.rs index 34c456b4..a6f5160e 100644 --- a/inline_hook/build.rs +++ b/inline_hook/build.rs @@ -2,11 +2,11 @@ fn main() { let target = std::env::var("TARGET").unwrap(); if target == "aarch64-linux-android" { cc::Build::new() - .file("beatsaber-hook/src/inline-hook/And64InlineHook.cpp") + .file("beatsaber-hook/shared/inline-hook/And64InlineHook.cpp") .compile("inline_hook"); } else if target == "armv7-linux-androideabi" { cc::Build::new() - .file("beatsaber-hook/src/inline-hook/inlineHook.c") + .file("beatsaber-hook/shared/inline-hook/inlineHook.c") .include("beatsaber-hook/shared/inline-hook") .compile("inline_hook"); } From b0470eff8f9ed2e56e309997202dde945cd572e1 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Sun, 5 Jan 2025 15:49:33 -0400 Subject: [PATCH 46/71] Change Held for Gc --- libil2cpp/src/gc.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libil2cpp/src/gc.rs b/libil2cpp/src/gc.rs index f327bf10..65016ed9 100644 --- a/libil2cpp/src/gc.rs +++ b/libil2cpp/src/gc.rs @@ -107,7 +107,7 @@ where *mut T: GcType, T: for<'a> Type = Option<&'a mut T>>, { - type Held<'a> = Option<&'a mut T>; + type Held<'a> = Self; type HeldRaw = *mut T; From f07aa16b9ffab14bbc0d70447b2aa3e931c5945b Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Sun, 5 Jan 2025 21:55:12 -0400 Subject: [PATCH 47/71] Add Send + Sync to Gc --- libil2cpp/src/gc.rs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/libil2cpp/src/gc.rs b/libil2cpp/src/gc.rs index 65016ed9..bda33467 100644 --- a/libil2cpp/src/gc.rs +++ b/libil2cpp/src/gc.rs @@ -132,6 +132,10 @@ where } } +// Should I do this or force to implement these on a wrapper? +unsafe impl Send for Gc where T: for<'a> Type = Option<&'a mut T>> {} +unsafe impl Sync for Gc where T: for<'a> Type = Option<&'a mut T>> {} + impl From> for Option<&T> where *mut T: GcType, From 1092d6dda16c06ed97b94380a27c6a3f53adf8d4 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Tue, 7 Jan 2025 22:55:23 -0400 Subject: [PATCH 48/71] Refactor error handling for Send/Sync support --- libil2cpp/src/class.rs | 4 ++-- libil2cpp/src/method_info.rs | 16 +++++++--------- libil2cpp/src/object.rs | 4 ++-- libil2cpp/src/typecheck/ty.rs | 4 ++-- libil2cpp/src/valuetype.rs | 4 ++-- 5 files changed, 15 insertions(+), 17 deletions(-) diff --git a/libil2cpp/src/class.rs b/libil2cpp/src/class.rs index 50877b71..f3fae70b 100644 --- a/libil2cpp/src/class.rs +++ b/libil2cpp/src/class.rs @@ -396,7 +396,7 @@ impl Il2CppClass { &self, name: &str, args: A, - ) -> Result + ) -> crate::Result where A: Arguments, R: Returned, @@ -411,7 +411,7 @@ impl Il2CppClass { &self, name: &str, args: A, - ) -> Result<(), &mut Il2CppException> + ) -> crate::Result<()> where A: Arguments, { diff --git a/libil2cpp/src/method_info.rs b/libil2cpp/src/method_info.rs index 00882fb3..226fe8c3 100644 --- a/libil2cpp/src/method_info.rs +++ b/libil2cpp/src/method_info.rs @@ -2,11 +2,12 @@ use std::borrow::Cow; use std::ffi::{c_void, CStr}; use std::mem::transmute; use std::ops::{Deref, DerefMut}; +use std::sync::{Arc, Mutex}; use std::{fmt, slice}; use crate::raw::{METHOD_ATTRIBUTE_ABSTRACT, METHOD_ATTRIBUTE_STATIC, METHOD_ATTRIBUTE_VIRTUAL}; use crate::{ - raw, Arguments, Il2CppClass, Il2CppException, Il2CppObject, Il2CppType, ParameterInfo, + raw, Arguments, Gc, Il2CppClass, Il2CppException, Il2CppObject, Il2CppType, ParameterInfo, Returned, ThisArgument, WrapRaw, }; @@ -25,16 +26,12 @@ unsafe impl Send for MethodInfo {} unsafe impl Sync for MethodInfo {} pub type Void = (); -pub type Result = std::result::Result; +pub type Result = std::result::Result>; // Gc adds Sync and Send bounds, allowing for async support impl MethodInfo { /// Invoke this method, type checking against its signature with the /// provided instance, arguments and return type - pub fn invoke( - &self, - this: T, - args: A, - ) -> Result + pub fn invoke(&self, this: T, args: A) -> Result where T: ThisArgument, A: Arguments, @@ -64,7 +61,7 @@ impl MethodInfo { { match self.invoke_raw(this.invokable(), args.invokable().as_mut()) { Ok(r) => Ok(R::from_object(transmute(r))), - Err(e) => Err(Il2CppException::wrap_mut(e)), + Err(e) => Err(Il2CppException::wrap_mut(e).into()), } } @@ -78,7 +75,8 @@ impl MethodInfo { &self, this: *mut c_void, args: &mut [*mut c_void], - ) -> std::result::Result, &'err mut raw::Il2CppException> { + ) -> std::result::Result, &'err mut raw::Il2CppException> + { let mut exception = None; let r = raw::runtime_invoke(self.raw(), this, args.as_mut_ptr(), &mut exception); match exception { diff --git a/libil2cpp/src/object.rs b/libil2cpp/src/object.rs index 3749617c..9874d7df 100644 --- a/libil2cpp/src/object.rs +++ b/libil2cpp/src/object.rs @@ -29,7 +29,7 @@ impl Il2CppObject { &mut self, name: &str, args: A, - ) -> Result + ) -> crate::Result where A: Arguments, R: Returned, @@ -48,7 +48,7 @@ impl Il2CppObject { &mut self, name: &str, args: A, - ) -> Result<(), &'static mut Il2CppException> + ) -> crate::Result<()> where A: Arguments, { diff --git a/libil2cpp/src/typecheck/ty.rs b/libil2cpp/src/typecheck/ty.rs index a0e7226b..b296cc4b 100644 --- a/libil2cpp/src/typecheck/ty.rs +++ b/libil2cpp/src/typecheck/ty.rs @@ -1,6 +1,5 @@ use crate::{ - Il2CppClass, Il2CppObject, Il2CppReflectionMethod, Il2CppReflectionType, Il2CppString, - Il2CppType, MethodInfo, + Il2CppClass, Il2CppException, Il2CppObject, Il2CppReflectionMethod, Il2CppReflectionType, Il2CppString, Il2CppType, MethodInfo }; /// Trait implemented by Rust types that are also C# types @@ -126,6 +125,7 @@ crate::unsafe_impl_value_type!(in crate for f64 => System.Double); crate::unsafe_impl_value_type!(in crate for bool => System.Boolean); crate::unsafe_impl_value_type!(in crate for char => System.Char); +crate::unsafe_impl_reference_type!(in crate for Il2CppException => System.Exception); crate::unsafe_impl_reference_type!(in crate for Il2CppObject => System.Object); crate::unsafe_impl_reference_type!(in crate for Il2CppString => System.String); crate::unsafe_impl_reference_type!(in crate for Il2CppReflectionType => System.RuntimeType); diff --git a/libil2cpp/src/valuetype.rs b/libil2cpp/src/valuetype.rs index 35d0c952..87ddbcbf 100644 --- a/libil2cpp/src/valuetype.rs +++ b/libil2cpp/src/valuetype.rs @@ -11,7 +11,7 @@ pub trait ValueTypeExt: for<'a> Type = Self> + Sized { &mut self, name: &str, args: A, - ) -> Result + ) -> crate::Result where A: Arguments, R: Returned, @@ -30,7 +30,7 @@ pub trait ValueTypeExt: for<'a> Type = Self> + Sized { &mut self, name: &str, args: A, - ) -> Result<(), &'static mut Il2CppException> + ) -> crate::Result<()> where A: Arguments, { From f0e91f74d320409e957c8e2a02276dc92fc7677c Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Tue, 7 Jan 2025 23:09:20 -0400 Subject: [PATCH 49/71] Implement error for Gc --- libil2cpp/src/exception.rs | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/libil2cpp/src/exception.rs b/libil2cpp/src/exception.rs index 5fe918ab..a54002bc 100644 --- a/libil2cpp/src/exception.rs +++ b/libil2cpp/src/exception.rs @@ -1,7 +1,7 @@ -use std::fmt; +use std::fmt::{self, Debug, Display, Formatter}; use std::ops::{Deref, DerefMut}; -use crate::{raw, Il2CppObject, Il2CppString, WrapRaw}; +use crate::{raw, Gc, Il2CppObject, Il2CppString, WrapRaw}; /// An il2cpp exception #[repr(transparent)] @@ -100,3 +100,10 @@ impl fmt::Debug for Il2CppException { impl std::error::Error for Il2CppException {} impl std::error::Error for &mut Il2CppException {} +impl std::error::Error for Gc {} + +impl Display for Gc { + fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { + Display::fmt(&**self, f) + } +} From d98f1d773e783a0a3cac9132a53a74b665a9dd82 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Sun, 12 Jan 2025 23:33:29 -0400 Subject: [PATCH 50/71] Debug log --- libil2cpp/src/class.rs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/libil2cpp/src/class.rs b/libil2cpp/src/class.rs index f3fae70b..0935b55a 100644 --- a/libil2cpp/src/class.rs +++ b/libil2cpp/src/class.rs @@ -197,6 +197,11 @@ impl Il2CppClass { .methods() .iter() .filter(|mi| { + println!("mi.name() == name: {}", mi.name() == name); + println!("mi.is_static(): {}", mi.is_static()); + println!("A::matches(mi): {}", A::matches(mi)); + println!("R::matches(mi.return_ty()): {}", R::matches(mi.return_ty())); + println!(); mi.name() == name && mi.is_static() && A::matches(mi) From 5b43181b6f98e4aa835481317eb41935f752a2bb Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Sun, 12 Jan 2025 23:56:16 -0400 Subject: [PATCH 51/71] Pretty print --- src/util.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/util.rs b/src/util.rs index 3b6f1128..44112a4d 100644 --- a/src/util.rs +++ b/src/util.rs @@ -40,10 +40,10 @@ pub fn panic_hook( error!(target: "panic", "panicked at '{}', {}", msg, location); if backtrace { - error!(target: "panic", "{:?}", Backtrace::force_capture()); + error!(target: "panic", "{:#?}", Backtrace::force_capture()); } if spantrace { - error!(target: "panic", "{:?}", SpanTrace::capture()); + error!(target: "panic", "{:#?}", SpanTrace::capture()); } }) } From b64b20333d7970000ad3edbaff4b447064bd52c0 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 13 Jan 2025 00:03:17 -0400 Subject: [PATCH 52/71] Debug print lines --- libil2cpp/src/class.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/libil2cpp/src/class.rs b/libil2cpp/src/class.rs index 0935b55a..77834adc 100644 --- a/libil2cpp/src/class.rs +++ b/libil2cpp/src/class.rs @@ -197,11 +197,11 @@ impl Il2CppClass { .methods() .iter() .filter(|mi| { - println!("mi.name() == name: {}", mi.name() == name); - println!("mi.is_static(): {}", mi.is_static()); - println!("A::matches(mi): {}", A::matches(mi)); - println!("R::matches(mi.return_ty()): {}", R::matches(mi.return_ty())); - println!(); + debug!("mi.name() == name: {}", mi.name() == name); + debug!("mi.is_static(): {}", mi.is_static()); + debug!("A::matches(mi): {}", A::matches(mi)); + debug!("R::matches(mi.return_ty()): {}", R::matches(mi.return_ty())); + debug!(""); mi.name() == name && mi.is_static() && A::matches(mi) From a20a10a8e8496ea3ef5652acbf0a19e26936fffa Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 13 Jan 2025 00:22:23 -0400 Subject: [PATCH 53/71] More debug logs --- libil2cpp/src/class.rs | 27 ++++++++++++++------------- libil2cpp/src/lib.rs | 2 +- 2 files changed, 15 insertions(+), 14 deletions(-) diff --git a/libil2cpp/src/class.rs b/libil2cpp/src/class.rs index 77834adc..c072224c 100644 --- a/libil2cpp/src/class.rs +++ b/libil2cpp/src/class.rs @@ -49,6 +49,9 @@ impl Il2CppClass { let mut assemblies_count = 0; let assemblies = unsafe { raw::domain_get_assemblies(domain, &mut assemblies_count) }; + debug!("assemblies_count: {}", assemblies_count); + debug!("Looking for class: {}.{}", namespace, name); + for assembly in assemblies.iter().take(assemblies_count) { // For some reason, an assembly might not have an image let image = match unsafe { raw::assembly_get_image(assembly) } { @@ -57,13 +60,19 @@ impl Il2CppClass { }; let class = - unsafe { raw::class_from_name(image, c_namespace.as_ptr(), c_name.as_ptr()) }; + unsafe { raw::class_from_name(image, c_namespace.as_ptr(), c_name.as_ptr()) } + .map(|class| unsafe { Self::wrap(class) }); + + debug!( + "class: {class:?} in assembly image {image:?}", + ); + if let Some(class) = class { // Ensure class is initialized // TODO: Call Class::Init somehow - let _ = unsafe { raw::class_get_method_from_name(class, b"\0".as_ptr().cast(), 0) }; + let _ = unsafe { raw::class_get_method_from_name(&class.0, c"".as_ptr().cast(), 0) }; - let class = unsafe { Self::wrap(class) }; + debug!("class found: {class}", class = class); #[cfg(feature = "cache")] cache::CLASS_CACHE.with(move |c| c.borrow_mut().insert(key.into(), class)); @@ -397,11 +406,7 @@ impl Il2CppClass { /// Invokes the `static` method with the given name using the given /// arguments, with type checking - pub fn invoke( - &self, - name: &str, - args: A, - ) -> crate::Result + pub fn invoke(&self, name: &str, args: A) -> crate::Result where A: Arguments, R: Returned, @@ -412,11 +417,7 @@ impl Il2CppClass { /// Invokes the `static void` method with the given name using the given /// arguments, with type checking - pub fn invoke_void( - &self, - name: &str, - args: A, - ) -> crate::Result<()> + pub fn invoke_void(&self, name: &str, args: A) -> crate::Result<()> where A: Arguments, { diff --git a/libil2cpp/src/lib.rs b/libil2cpp/src/lib.rs index 6405fcb5..05dd7be2 100644 --- a/libil2cpp/src/lib.rs +++ b/libil2cpp/src/lib.rs @@ -86,7 +86,7 @@ pub use tracing::{debug, instrument}; #[cfg(not(feature = "trace"))] macro_rules! debug { - ($_:tt) => {}; + ($($tt:tt)*) => {}; } #[cfg(not(feature = "trace"))] pub use quest_hook_proc_macros::identity as instrument; From 8d3d014c8a66a156324b3cba85066158581f55cf Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 13 Jan 2025 00:22:38 -0400 Subject: [PATCH 54/71] Improve bindgen --- libil2cpp/build.rs | 1 + libil2cpp/generate_bindings_android.ps1 | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/libil2cpp/build.rs b/libil2cpp/build.rs index e57e59da..07182610 100644 --- a/libil2cpp/build.rs +++ b/libil2cpp/build.rs @@ -20,5 +20,6 @@ fn main() { bindings .write_to_file(&output_path) .expect("Couldn't write bindings!"); + println!("Returning early"); panic!("Written bindings to {}", output_path.display()); } diff --git a/libil2cpp/generate_bindings_android.ps1 b/libil2cpp/generate_bindings_android.ps1 index 8ca27af0..9e200912 100644 --- a/libil2cpp/generate_bindings_android.ps1 +++ b/libil2cpp/generate_bindings_android.ps1 @@ -2,4 +2,4 @@ # $ENV:BINDGEN_EXTRA_CLANG_ARGS="--target=aarch64-linux-android21 -I./extern/includes/libil2cpp/il2cpp/libil2cpp -I$ENV:ANDROID_NDK_HOME/sysroot/usr/include -I$ENV:ANDROID_NDK_HOME/sysroot/usr/include/aarch64-linux-android" # bindgen wrapper.h -o bindings.rs --wrap-unsafe-ops --sort-semantically -RUST_BINDGEN=1 cargo ndk --bindgen -t arm64-v8a build \ No newline at end of file +$ENV:RUN_BINDGEN=1 & cargo ndk --bindgen -t arm64-v8a build \ No newline at end of file From 70804ea1adde38fc236d1c5f56b9018a405fa555 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 13 Jan 2025 00:22:43 -0400 Subject: [PATCH 55/71] Better intellisense --- .vscode/settings.json | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index c45b7300..cb9027ea 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,7 +1,10 @@ { "rust-analyzer.cargo.features": [ "il2cpp_v31", - "serde" + "serde", + "util", + "cache", + "trace" ], "rust-analyzer.imports.granularity.group": "module" } From 202623a7b72eca5a6b1167d583cb719c2fadeed1 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 13 Jan 2025 00:38:45 -0400 Subject: [PATCH 56/71] More logging --- libil2cpp/src/class.rs | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/libil2cpp/src/class.rs b/libil2cpp/src/class.rs index c072224c..307f8f63 100644 --- a/libil2cpp/src/class.rs +++ b/libil2cpp/src/class.rs @@ -81,6 +81,7 @@ impl Il2CppClass { } } + debug!("Class not found {}.{}", namespace, name); None } @@ -271,10 +272,17 @@ impl Il2CppClass { P: Parameters, R: Return, { + debug!("Looking for method: {}", name); + let mut matching = self .methods() .iter() .filter(|mi| { + debug!("mi.name() == name: {}", mi.name() == name); + debug!("T::matches(mi): {}", T::matches(mi)); + debug!("P::matches(mi): {}", P::matches(mi)); + debug!("R::matches(mi.return_ty()): {}", R::matches(mi.return_ty())); + debug!(""); mi.name() == name && T::matches(mi) && P::matches(mi) && R::matches(mi.return_ty()) }) .copied(); From d7b20b06c43a3a5687d5a5df40aa7d9aac302e79 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 13 Jan 2025 00:52:11 -0400 Subject: [PATCH 57/71] More logging --- libil2cpp/src/class.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/libil2cpp/src/class.rs b/libil2cpp/src/class.rs index 307f8f63..3aae47c8 100644 --- a/libil2cpp/src/class.rs +++ b/libil2cpp/src/class.rs @@ -63,14 +63,13 @@ impl Il2CppClass { unsafe { raw::class_from_name(image, c_namespace.as_ptr(), c_name.as_ptr()) } .map(|class| unsafe { Self::wrap(class) }); - debug!( - "class: {class:?} in assembly image {image:?}", - ); + debug!("class: {class:?} in assembly image {image:?}",); if let Some(class) = class { // Ensure class is initialized // TODO: Call Class::Init somehow - let _ = unsafe { raw::class_get_method_from_name(&class.0, c"".as_ptr().cast(), 0) }; + let _ = + unsafe { raw::class_get_method_from_name(&class.0, c"".as_ptr().cast(), 0) }; debug!("class found: {class}", class = class); @@ -278,6 +277,7 @@ impl Il2CppClass { .methods() .iter() .filter(|mi| { + debug!("Looking for method: {}", name); debug!("mi.name() == name: {}", mi.name() == name); debug!("T::matches(mi): {}", T::matches(mi)); debug!("P::matches(mi): {}", P::matches(mi)); From 25a4bdd39bb87b745e9ac8678fecac3c303a63de Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 13 Jan 2025 01:20:41 -0400 Subject: [PATCH 58/71] More logs --- libil2cpp/src/class.rs | 9 +++++++-- proc_macros/src/impl_arguments_parameters.rs | 7 +++++++ 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/libil2cpp/src/class.rs b/libil2cpp/src/class.rs index 3aae47c8..08309a7e 100644 --- a/libil2cpp/src/class.rs +++ b/libil2cpp/src/class.rs @@ -280,7 +280,7 @@ impl Il2CppClass { debug!("Looking for method: {}", name); debug!("mi.name() == name: {}", mi.name() == name); debug!("T::matches(mi): {}", T::matches(mi)); - debug!("P::matches(mi): {}", P::matches(mi)); + debug!("P::matches(mi): {} count {}", P::matches(mi), P::COUNT); debug!("R::matches(mi.return_ty()): {}", R::matches(mi.return_ty())); debug!(""); mi.name() == name && T::matches(mi) && P::matches(mi) && R::matches(mi.return_ty()) @@ -292,7 +292,7 @@ impl Il2CppClass { (Some(mi), None) | (None, Some(mi)) => Ok(mi), // multiple methods found (Some(mi1), Some(mi2)) => { - let found = vec![mi1, mi2] + let found: Vec = vec![mi1, mi2] .into_iter() .chain(matching) .map(|mi| { @@ -500,6 +500,11 @@ impl Il2CppClass { /// Whether the class is assignable from `other` pub fn is_assignable_from(&self, other: &Self) -> bool { + // optimize + if self == other { + return true; + } + unsafe { raw::class_is_assignable_from(self.raw(), other.raw()) } } diff --git a/proc_macros/src/impl_arguments_parameters.rs b/proc_macros/src/impl_arguments_parameters.rs index a1bd10b6..e599dcac 100644 --- a/proc_macros/src/impl_arguments_parameters.rs +++ b/proc_macros/src/impl_arguments_parameters.rs @@ -20,6 +20,12 @@ pub fn expand(range: Range) -> Result { .enumerate() .map(|(n, gp)| quote!(<#gp>::matches(params.get_unchecked(#n).ty()))); + // log params + let log_parameters = generic_params_parameter + .clone() + .enumerate() + .map(|(n, gp)| quote!(unsafe {crate::debug!("\tChecking parameter {} {:?} vs method param {:?}", #n, stringify!(#gp), params.get_unchecked(#n).ty()); })); + let generic_params_argument_tuple = generic_params_argument.clone(); let generic_params_argument_where = generic_params_argument.clone(); let generic_params_argument_type = generic_params_argument.clone(); @@ -52,6 +58,7 @@ pub fn expand(range: Range) -> Result { fn matches(method: &MethodInfo) -> bool { let params = method.parameters(); + #(#log_parameters)*; params.len() == #n && unsafe { #(#matches_parameter) && * } } } From 9c1b5d1d764532c4256da91620fffe0d33969d99 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 13 Jan 2025 01:32:20 -0400 Subject: [PATCH 59/71] Fix logging to safely retrieve method parameter types --- proc_macros/src/impl_arguments_parameters.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/proc_macros/src/impl_arguments_parameters.rs b/proc_macros/src/impl_arguments_parameters.rs index e599dcac..adc68514 100644 --- a/proc_macros/src/impl_arguments_parameters.rs +++ b/proc_macros/src/impl_arguments_parameters.rs @@ -24,7 +24,7 @@ pub fn expand(range: Range) -> Result { let log_parameters = generic_params_parameter .clone() .enumerate() - .map(|(n, gp)| quote!(unsafe {crate::debug!("\tChecking parameter {} {:?} vs method param {:?}", #n, stringify!(#gp), params.get_unchecked(#n).ty()); })); + .map(|(n, gp)| quote!(unsafe {crate::debug!("\tChecking parameter {} {:?} vs method param {:?}", #n, stringify!(#gp), params.get(#n).map(|p| p.ty())); })); let generic_params_argument_tuple = generic_params_argument.clone(); let generic_params_argument_where = generic_params_argument.clone(); From 7397a9889bf5e728db909710b7cf9ac437e161b7 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 13 Jan 2025 01:41:46 -0400 Subject: [PATCH 60/71] Log parameter count --- libil2cpp/src/class.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libil2cpp/src/class.rs b/libil2cpp/src/class.rs index 08309a7e..30c0daa6 100644 --- a/libil2cpp/src/class.rs +++ b/libil2cpp/src/class.rs @@ -280,7 +280,7 @@ impl Il2CppClass { debug!("Looking for method: {}", name); debug!("mi.name() == name: {}", mi.name() == name); debug!("T::matches(mi): {}", T::matches(mi)); - debug!("P::matches(mi): {} count {}", P::matches(mi), P::COUNT); + debug!("P::matches(mi): {} count {} method {}", P::matches(mi), P::COUNT, mi.parameters().len()); debug!("R::matches(mi.return_ty()): {}", R::matches(mi.return_ty())); debug!(""); mi.name() == name && T::matches(mi) && P::matches(mi) && R::matches(mi.return_ty()) From 2757b3ce1b32a612889179d39e593a3f6c069aa9 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 13 Jan 2025 01:44:54 -0400 Subject: [PATCH 61/71] Even more logging --- proc_macros/src/impl_arguments_parameters.rs | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/proc_macros/src/impl_arguments_parameters.rs b/proc_macros/src/impl_arguments_parameters.rs index adc68514..39792e4c 100644 --- a/proc_macros/src/impl_arguments_parameters.rs +++ b/proc_macros/src/impl_arguments_parameters.rs @@ -24,7 +24,15 @@ pub fn expand(range: Range) -> Result { let log_parameters = generic_params_parameter .clone() .enumerate() - .map(|(n, gp)| quote!(unsafe {crate::debug!("\tChecking parameter {} {:?} vs method param {:?}", #n, stringify!(#gp), params.get(#n).map(|p| p.ty())); })); + .map(|(n, gp)| quote!( + unsafe { + crate::debug!("\tChecking parameter {} {:?} vs method param {:?}", + #n, + stringify!(#gp), + params.get(#n).map(|p| (p.ty(), <#gp>::matches(p.ty()))) + ); + } + )); let generic_params_argument_tuple = generic_params_argument.clone(); let generic_params_argument_where = generic_params_argument.clone(); From 9d920ea61ce2d34d1b2f53a6cd818965f8752471 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 13 Jan 2025 02:36:07 -0400 Subject: [PATCH 62/71] Log class not found --- libil2cpp/src/typecheck/ty.rs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/libil2cpp/src/typecheck/ty.rs b/libil2cpp/src/typecheck/ty.rs index b296cc4b..37dbf74d 100644 --- a/libil2cpp/src/typecheck/ty.rs +++ b/libil2cpp/src/typecheck/ty.rs @@ -1,5 +1,6 @@ use crate::{ - Il2CppClass, Il2CppException, Il2CppObject, Il2CppReflectionMethod, Il2CppReflectionType, Il2CppString, Il2CppType, MethodInfo + Il2CppClass, Il2CppException, Il2CppObject, Il2CppReflectionMethod, Il2CppReflectionType, + Il2CppString, Il2CppType, MethodInfo, }; /// Trait implemented by Rust types that are also C# types @@ -20,7 +21,8 @@ pub unsafe trait Type: 'static { /// [`Il2CppClass`] of the type fn class() -> &'static Il2CppClass { - Il2CppClass::find(Self::NAMESPACE, Self::CLASS_NAME).unwrap() + Il2CppClass::find(Self::NAMESPACE, Self::CLASS_NAME) + .unwrap_or_else(|| panic!("Class {}.{} not found", Self::NAMESPACE, Self::CLASS_NAME)) } /// Whether the type can be used as a `this` argument for the given From 85a47e96f283ac0d12ba4f8f6f80153ca0ea2cac Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 13 Jan 2025 16:02:37 -0400 Subject: [PATCH 63/71] Fix typo --- libil2cpp/src/typecheck/caller.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libil2cpp/src/typecheck/caller.rs b/libil2cpp/src/typecheck/caller.rs index c3a1dc27..276296bd 100644 --- a/libil2cpp/src/typecheck/caller.rs +++ b/libil2cpp/src/typecheck/caller.rs @@ -219,7 +219,7 @@ where type Type = T; fn matches(ty: &Il2CppType) -> bool { - T::matches_returned(ty) + T::matches_reference_argument(ty) } fn invokable(&mut self) -> *mut c_void { From 19c792b5bb144750e1aab172d226cd5996b74bdd Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Mon, 13 Jan 2025 17:43:00 -0400 Subject: [PATCH 64/71] Add ByRef wrapper type for representing ref types --- libil2cpp/src/byref.rs | 163 ++++++++++++++++++++++++++++++ libil2cpp/src/lib.rs | 4 +- libil2cpp/src/object.rs | 3 - libil2cpp/src/typecheck/caller.rs | 21 +++- libil2cpp/src/typecheck/ty.rs | 5 + 5 files changed, 191 insertions(+), 5 deletions(-) create mode 100644 libil2cpp/src/byref.rs diff --git a/libil2cpp/src/byref.rs b/libil2cpp/src/byref.rs new file mode 100644 index 00000000..cd90b026 --- /dev/null +++ b/libil2cpp/src/byref.rs @@ -0,0 +1,163 @@ +use std::fmt::{self, Debug, Display, Formatter}; +use std::ops::{Deref, DerefMut}; + +use crate::{Argument, ObjectType, Returned, ThisArgument, Type}; + +/// Wrapper type which implies the type is ByRef managed lifetime +#[repr(transparent)] +pub struct ByRef<'a, T>(&'a mut T) +where + T: ReffableType; + +pub type ByRefMut<'a, T> = ByRef<'a, T>; + +/// Trait alias for types that can be used with the `ByRef` wrapper. +pub trait ReffableType = Type + Returned + ThisArgument + Argument; + +impl<'a, T> ByRef<'a, T> +where + T: ReffableType, +{ + /// Creates a new `ByRef` instance with the given pointer. + pub fn new(ptr: &'a mut T) -> Self { + Self(ptr) + } + + /// Returns a constant pointer to the value. + pub fn get_pointer(&self) -> *const T { + self.0 + } + /// Returns a mutable pointer to the value. + pub fn get_pointer_mut(&mut self) -> *mut T { + self.0 + } + + pub fn into_actual(self) -> &'a T { + self.0 + } + + pub fn from_actual(actual: &'a mut T) -> Self { + Self::new(actual) + } +} + + + +unsafe impl Type for ByRef<'_, T> +where + T: ReffableType, +{ + type Held<'b> = &'b mut T::Held<'b>; + + type HeldRaw = *mut T::HeldRaw; + + const NAMESPACE: &'static str = T::NAMESPACE; + + const CLASS_NAME: &'static str = T::CLASS_NAME; + + fn class() -> &'static crate::Il2CppClass { + T::class() + } + + fn type_() -> &'static crate::Il2CppType { + T::class().this_arg_ty() + } + + fn matches_value_argument(_: &crate::Il2CppType) -> bool { + false + } + fn matches_reference_argument(ty: &crate::Il2CppType) -> bool { + T::class().this_arg_ty() == ty + || ty.is_ref() && ty.class().is_assignable_from(::class()) + } + fn matches_value_parameter(_: &crate::Il2CppType) -> bool { + false + } + fn matches_reference_parameter(ty: &crate::Il2CppType) -> bool { + T::class().this_arg_ty() == ty + || ty.is_ref() && ::class().is_assignable_from(ty.class()) + } +} + +// // Should I do this or force to implement these on a wrapper? +unsafe impl Send for ByRef<'_, T> where T: ReffableType {} +unsafe impl Sync for ByRef<'_, T> where T: ReffableType {} + +impl<'a, T> From<&'a mut T> for ByRef<'a, T> +where + T: ReffableType, +{ + fn from(value: &'a mut T) -> Self { + Self::new(value) + } +} +impl Deref for ByRef<'_, T> +where + T: ReffableType, +{ + type Target = T; + + fn deref(&self) -> &Self::Target { + self.0 + } +} + +impl<'a, T> DerefMut for ByRef<'a, T> +where + T: ReffableType, +{ + fn deref_mut(&mut self) -> &mut Self::Target { + self.0 + } +} +impl<'a, T> PartialEq for ByRef<'_, T> +where + T: PartialEq, + T: ReffableType, +{ + fn eq(&self, other: &Self) -> bool { + self.0.eq(&other.0) + } +} +impl Eq for ByRef<'_, T> +where + T: Eq, + T: ReffableType, +{ +} + +impl Debug for ByRef<'_, T> +where + T: ReffableType, +{ + fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { + write!(f, "ByRef<{}>({:p})", T::CLASS_NAME, self.0) + } +} + +impl Display for ByRef<'_, T> +where + T: Display, + T: ReffableType,{ + fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { + write!(f, "{}", self.0) + } +} + +impl<'a, T> AsRef for ByRef<'a, T> +where + T: ReffableType, +{ + fn as_ref(&self) -> &T { + self.0 + } +} + +impl<'a, T> AsMut for ByRef<'a, T> +where + T: ReffableType, +{ + fn as_mut(&mut self) -> &mut T { + self.0 + } +} \ No newline at end of file diff --git a/libil2cpp/src/lib.rs b/libil2cpp/src/lib.rs index 05dd7be2..da437feb 100644 --- a/libil2cpp/src/lib.rs +++ b/libil2cpp/src/lib.rs @@ -98,6 +98,7 @@ mod field_info; mod method_info; mod object; mod valuetype; +mod byref; mod gc; #[cfg_attr( @@ -119,7 +120,7 @@ pub use class::{FindMethodError, Il2CppClass}; pub use exception::Il2CppException; pub use field_info::FieldInfo; pub use method_info::{Il2CppReflectionMethod, MethodInfo, Result, Void}; -pub use object::{Il2CppObject, ObjectExt, ByRef, ByRefMut, ObjectType}; +pub use object::{Il2CppObject, ObjectExt, ObjectType}; pub use parameter_info::ParameterInfo; pub use raw::{unbox, value_box, WrapRaw}; pub use string::Il2CppString; @@ -130,3 +131,4 @@ pub use typecheck::generic::Generics; pub use typecheck::ty::Type; pub use valuetype::{ValueTypeExt, ValueTypePadding}; pub use gc::{Gc, GcType}; +pub use byref::{ByRef, ByRefMut}; \ No newline at end of file diff --git a/libil2cpp/src/object.rs b/libil2cpp/src/object.rs index 9874d7df..11393b5c 100644 --- a/libil2cpp/src/object.rs +++ b/libil2cpp/src/object.rs @@ -10,9 +10,6 @@ use crate::{ #[repr(transparent)] pub struct Il2CppObject(raw::Il2CppObject); -pub type ByRefMut = T; // TODO: *mut T; -pub type ByRef = T; // TODO: *const T; - impl Il2CppObject { /// [`Il2CppClass`] of the object pub fn class(&self) -> &'static Il2CppClass { diff --git a/libil2cpp/src/typecheck/caller.rs b/libil2cpp/src/typecheck/caller.rs index 276296bd..3aebf8d6 100644 --- a/libil2cpp/src/typecheck/caller.rs +++ b/libil2cpp/src/typecheck/caller.rs @@ -3,6 +3,7 @@ use std::ffi::c_void; use std::mem::transmute; use std::ptr::null_mut; +use crate::byref::{ByRef, ReffableType}; use crate::{Builtin, Gc, GcType, Il2CppObject, Il2CppType, MethodInfo, Type}; /// Trait implemented by types that can be used as a C# `this` arguments @@ -222,11 +223,29 @@ where T::matches_reference_argument(ty) } + fn invokable(&mut self) -> *mut c_void { + <*mut T as Argument>::invokable(&mut self.get_pointer_mut()) + } +} + +#[rustfmt::skip] +unsafe impl<'a, T> Argument for ByRef<'a, T> +where + T: ReffableType, +{ + type Type = T; + + // matches_reference_argument will always return true if ref + // regardless if its value type or ref type + // will also class check + fn matches(ty: &Il2CppType) -> bool { + T::matches_reference_argument(ty) + } + fn invokable(&mut self) -> *mut c_void { unsafe { transmute((self as *mut Self).read()) } } - } // TODO: Remove this once rustfmt stops dropping generics on GATs diff --git a/libil2cpp/src/typecheck/ty.rs b/libil2cpp/src/typecheck/ty.rs index 37dbf74d..a1bdcbfb 100644 --- a/libil2cpp/src/typecheck/ty.rs +++ b/libil2cpp/src/typecheck/ty.rs @@ -25,6 +25,11 @@ pub unsafe trait Type: 'static { .unwrap_or_else(|| panic!("Class {}.{} not found", Self::NAMESPACE, Self::CLASS_NAME)) } + /// Returns the [`Il2CppType`] of this type + fn type_() -> &'static Il2CppType { + Self::class().ty() + } + /// Whether the type can be used as a `this` argument for the given /// [`MethodInfo`] fn matches_this_argument(method: &MethodInfo) -> bool { From 89fbc120ad180b6d873c3ae94062598cc75a199b Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Tue, 14 Jan 2025 13:28:00 -0400 Subject: [PATCH 65/71] Finish ByRef --- libil2cpp/src/byref.rs | 47 ++++++++++---------- libil2cpp/src/typecheck/caller.rs | 2 +- proc_macros/src/impl_arguments_parameters.rs | 1 + 3 files changed, 26 insertions(+), 24 deletions(-) diff --git a/libil2cpp/src/byref.rs b/libil2cpp/src/byref.rs index cd90b026..00686a14 100644 --- a/libil2cpp/src/byref.rs +++ b/libil2cpp/src/byref.rs @@ -3,18 +3,19 @@ use std::ops::{Deref, DerefMut}; use crate::{Argument, ObjectType, Returned, ThisArgument, Type}; +/// TODO: Add lifetime param /// Wrapper type which implies the type is ByRef managed lifetime #[repr(transparent)] -pub struct ByRef<'a, T>(&'a mut T) +pub struct ByRef(*mut T) where T: ReffableType; -pub type ByRefMut<'a, T> = ByRef<'a, T>; +pub type ByRefMut = ByRef< T>; /// Trait alias for types that can be used with the `ByRef` wrapper. pub trait ReffableType = Type + Returned + ThisArgument + Argument; -impl<'a, T> ByRef<'a, T> +impl<'a, T> ByRef where T: ReffableType, { @@ -33,7 +34,7 @@ where } pub fn into_actual(self) -> &'a T { - self.0 + unsafe { &*self.0 } } pub fn from_actual(actual: &'a mut T) -> Self { @@ -43,13 +44,13 @@ where -unsafe impl Type for ByRef<'_, T> +unsafe impl Type for ByRef where T: ReffableType, { - type Held<'b> = &'b mut T::Held<'b>; + type Held<'b> = ByRef< T>; - type HeldRaw = *mut T::HeldRaw; + type HeldRaw = *mut T; const NAMESPACE: &'static str = T::NAMESPACE; @@ -80,10 +81,10 @@ where } // // Should I do this or force to implement these on a wrapper? -unsafe impl Send for ByRef<'_, T> where T: ReffableType {} -unsafe impl Sync for ByRef<'_, T> where T: ReffableType {} +unsafe impl Send for ByRef< T> where T: ReffableType {} +unsafe impl Sync for ByRef< T> where T: ReffableType {} -impl<'a, T> From<&'a mut T> for ByRef<'a, T> +impl<'a, T> From<&'a mut T> for ByRef< T> where T: ReffableType, { @@ -91,26 +92,26 @@ where Self::new(value) } } -impl Deref for ByRef<'_, T> +impl Deref for ByRef< T> where T: ReffableType, { type Target = T; fn deref(&self) -> &Self::Target { - self.0 + unsafe { &*self.0 } } } -impl<'a, T> DerefMut for ByRef<'a, T> +impl<'a, T> DerefMut for ByRef< T> where T: ReffableType, { fn deref_mut(&mut self) -> &mut Self::Target { - self.0 + unsafe { &mut *self.0 } } } -impl<'a, T> PartialEq for ByRef<'_, T> +impl<'a, T> PartialEq for ByRef< T> where T: PartialEq, T: ReffableType, @@ -119,14 +120,14 @@ where self.0.eq(&other.0) } } -impl Eq for ByRef<'_, T> +impl Eq for ByRef where T: Eq, T: ReffableType, { } -impl Debug for ByRef<'_, T> +impl Debug for ByRef< T> where T: ReffableType, { @@ -135,29 +136,29 @@ where } } -impl Display for ByRef<'_, T> +impl Display for ByRef< T> where T: Display, T: ReffableType,{ fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { - write!(f, "{}", self.0) + write!(f, "{}", self.as_ref()) } } -impl<'a, T> AsRef for ByRef<'a, T> +impl<'a, T> AsRef for ByRef< T> where T: ReffableType, { fn as_ref(&self) -> &T { - self.0 + unsafe { &*self.0 } } } -impl<'a, T> AsMut for ByRef<'a, T> +impl<'a, T> AsMut for ByRef< T> where T: ReffableType, { fn as_mut(&mut self) -> &mut T { - self.0 + unsafe { &mut *self.0 } } } \ No newline at end of file diff --git a/libil2cpp/src/typecheck/caller.rs b/libil2cpp/src/typecheck/caller.rs index 3aebf8d6..1a97b3ff 100644 --- a/libil2cpp/src/typecheck/caller.rs +++ b/libil2cpp/src/typecheck/caller.rs @@ -229,7 +229,7 @@ where } #[rustfmt::skip] -unsafe impl<'a, T> Argument for ByRef<'a, T> +unsafe impl< T> Argument for ByRef< T> where T: ReffableType, { diff --git a/proc_macros/src/impl_arguments_parameters.rs b/proc_macros/src/impl_arguments_parameters.rs index 39792e4c..5db22d1d 100644 --- a/proc_macros/src/impl_arguments_parameters.rs +++ b/proc_macros/src/impl_arguments_parameters.rs @@ -26,6 +26,7 @@ pub fn expand(range: Range) -> Result { .enumerate() .map(|(n, gp)| quote!( unsafe { + #[cfg(feature = trace)] crate::debug!("\tChecking parameter {} {:?} vs method param {:?}", #n, stringify!(#gp), From 008101e1bd4521076bc6800ecc0af72b029ce1c8 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Tue, 14 Jan 2025 13:36:32 -0400 Subject: [PATCH 66/71] Fix feature lock --- proc_macros/src/impl_arguments_parameters.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/proc_macros/src/impl_arguments_parameters.rs b/proc_macros/src/impl_arguments_parameters.rs index 5db22d1d..b71d3d7a 100644 --- a/proc_macros/src/impl_arguments_parameters.rs +++ b/proc_macros/src/impl_arguments_parameters.rs @@ -26,7 +26,7 @@ pub fn expand(range: Range) -> Result { .enumerate() .map(|(n, gp)| quote!( unsafe { - #[cfg(feature = trace)] + #[cfg(feature = "trace")] crate::debug!("\tChecking parameter {} {:?} vs method param {:?}", #n, stringify!(#gp), From a2f699d018a5b4fec9c63f6cc376edfc61b62ae6 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Tue, 14 Jan 2025 13:40:05 -0400 Subject: [PATCH 67/71] ByRef is not a ThisArgument --- libil2cpp/src/byref.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libil2cpp/src/byref.rs b/libil2cpp/src/byref.rs index 00686a14..6613543f 100644 --- a/libil2cpp/src/byref.rs +++ b/libil2cpp/src/byref.rs @@ -13,7 +13,7 @@ where pub type ByRefMut = ByRef< T>; /// Trait alias for types that can be used with the `ByRef` wrapper. -pub trait ReffableType = Type + Returned + ThisArgument + Argument; +pub trait ReffableType = Type + Returned + Argument; impl<'a, T> ByRef where From 8abbbb417da8f7442a6e1b900f9c0fb92d8f580e Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Tue, 14 Jan 2025 13:49:26 -0400 Subject: [PATCH 68/71] Add Returned and ThisArgument --- libil2cpp/src/typecheck/caller.rs | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/libil2cpp/src/typecheck/caller.rs b/libil2cpp/src/typecheck/caller.rs index 1a97b3ff..19d5167a 100644 --- a/libil2cpp/src/typecheck/caller.rs +++ b/libil2cpp/src/typecheck/caller.rs @@ -132,6 +132,20 @@ where unsafe { transmute((self as *mut Self).read()) } } } +unsafe impl ThisArgument for ByRef +where + T: ReffableType, +{ + type Type = T; + + fn matches(method: &MethodInfo) -> bool { + T::matches_this_argument(method) + } + + fn invokable(&mut self) -> *mut c_void { + unsafe { transmute((self as *mut Self).read()) } + } +} unsafe impl ThisArgument for &mut T where @@ -279,6 +293,21 @@ where *mut T: GcType, unsafe { transmute(object) } } } +// Can we even return refs? +#[rustfmt::skip] +unsafe impl Returned for ByRef +where T: ReffableType, +{ + type Type = T; + + fn matches(ty: &Il2CppType) -> bool { + T::matches_returned(ty) + } + + fn from_object(object: Option<&mut Il2CppObject>) -> Self { + unsafe { transmute(object) } + } +} #[rustfmt::skip] unsafe impl Returned for *mut T where From b8d35ecfbecafea145a09efb2875b0024363a05c Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Tue, 14 Jan 2025 14:43:58 -0400 Subject: [PATCH 69/71] Add Type traits to ByRef for callee --- libil2cpp/src/typecheck/callee.rs | 56 ++++++++++++++++++++++++++++++- 1 file changed, 55 insertions(+), 1 deletion(-) diff --git a/libil2cpp/src/typecheck/callee.rs b/libil2cpp/src/typecheck/callee.rs index c4e02ecf..ed95afd2 100644 --- a/libil2cpp/src/typecheck/callee.rs +++ b/libil2cpp/src/typecheck/callee.rs @@ -1,6 +1,7 @@ use std::fmt; -use crate::{Builtin, Gc, GcType, Il2CppType, MethodInfo, Type}; +use crate::byref::ReffableType; +use crate::{Builtin, ByRef, Gc, GcType, Il2CppType, MethodInfo, Type}; /// Trait implemented by types that can be used as C# `this` method parameters /// @@ -231,6 +232,24 @@ where self } } +#[rustfmt::skip] +unsafe impl ThisParameter for ByRef +where + T: ReffableType, +{ + type Actual = Self; + + fn matches(ty: &MethodInfo) -> bool { + T::matches_this_parameter(ty) + } + + fn from_actual(actual: Self::Actual) -> Self { + actual + } + fn into_actual(self) -> Self::Actual { + self + } +} // TODO: Remove this once rustfmt stops dropping generics on GATs #[rustfmt::skip] @@ -252,6 +271,23 @@ where self } } +#[rustfmt::skip] +unsafe impl Parameter for ByRef +where T: ReffableType, +{ + type Actual = Self; + + fn matches(ty: &Il2CppType) -> bool { + T::matches_reference_parameter(ty) + } + + fn from_actual(actual: Self::Actual) -> Self { + actual + } + fn into_actual(self) -> Self::Actual { + self + } +} // TODO: Remove this once rustfmt stops dropping generics on GATs #[rustfmt::skip] @@ -273,6 +309,24 @@ where actual } } +// TODO: Remove this once rustfmt stops dropping generics on GATs +#[rustfmt::skip] +unsafe impl Return for ByRef +where T: ReffableType +{ + type Actual = Self; + + fn matches(ty: &Il2CppType) -> bool { + T::matches_return(ty) + } + + fn into_actual(self) -> Self::Actual { + self + } + fn from_actual(actual: Self::Actual) -> Self { + actual + } +} // TODO: Remove this once rustfmt stops dropping generics on GATs #[rustfmt::skip] From cd491afe53653e212d22a6e4156c90be22060769 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Tue, 14 Jan 2025 15:23:14 -0400 Subject: [PATCH 70/71] Log method name --- libil2cpp/src/class.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/libil2cpp/src/class.rs b/libil2cpp/src/class.rs index 30c0daa6..39ac7a8d 100644 --- a/libil2cpp/src/class.rs +++ b/libil2cpp/src/class.rs @@ -206,6 +206,7 @@ impl Il2CppClass { .methods() .iter() .filter(|mi| { + debug!("Looking for method: {}.{}", self, name); debug!("mi.name() == name: {}", mi.name() == name); debug!("mi.is_static(): {}", mi.is_static()); debug!("A::matches(mi): {}", A::matches(mi)); From 0b6fec33a961b01b74f1db9b8dca173fa0fb4ac9 Mon Sep 17 00:00:00 2001 From: FernTheDev <15272073+Fernthedev@users.noreply.github.com> Date: Tue, 14 Jan 2025 15:58:20 -0400 Subject: [PATCH 71/71] More log information --- libil2cpp/src/class.rs | 27 +++++++++++++++++++++++---- 1 file changed, 23 insertions(+), 4 deletions(-) diff --git a/libil2cpp/src/class.rs b/libil2cpp/src/class.rs index 39ac7a8d..48083e83 100644 --- a/libil2cpp/src/class.rs +++ b/libil2cpp/src/class.rs @@ -224,7 +224,7 @@ impl Il2CppClass { (Some(mi), None) => { #[cfg(feature = "cache")] cache::METHOD_CACHE.with(move |c| c.borrow_mut().insert(key.into(), mi)); - + debug!("Found method: {}.{}", self, name); return Ok(mi); } @@ -281,7 +281,12 @@ impl Il2CppClass { debug!("Looking for method: {}", name); debug!("mi.name() == name: {}", mi.name() == name); debug!("T::matches(mi): {}", T::matches(mi)); - debug!("P::matches(mi): {} count {} method {}", P::matches(mi), P::COUNT, mi.parameters().len()); + debug!( + "P::matches(mi): {} count {} method {}", + P::matches(mi), + P::COUNT, + mi.parameters().len() + ); debug!("R::matches(mi.return_ty()): {}", R::matches(mi.return_ty())); debug!(""); mi.name() == name && T::matches(mi) && P::matches(mi) && R::matches(mi.return_ty()) @@ -420,7 +425,14 @@ impl Il2CppClass { A: Arguments, R: Returned, { - let method = self.find_static_method::(name).unwrap(); + let method = self.find_static_method::(name).unwrap_or_else(|e| { + panic!( + "no matching methods found for non-void {}.{}({}) Cause: {e:?}", + self, + name, + N + ) + }); unsafe { method.invoke_unchecked((), args) } } @@ -430,7 +442,14 @@ impl Il2CppClass { where A: Arguments, { - let method = self.find_static_method::(name).unwrap(); + let method = self.find_static_method::(name).unwrap_or_else(|e| { + panic!( + "no matching methods found for void {}.{}({}) Cause: {e:?}", + self, + name, + N + ) + }); unsafe { method.invoke_unchecked((), args) } }