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 1/9] 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 2/9] 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 3/9] 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 4/9] 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 5/9] 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 6/9] 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 7/9] 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 8/9] 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 89bed2217b549e205621c23f16a0abddc93c729d 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 9/9] 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