diff --git a/Il2CppDumper/Il2Cpp/Metadata.cs b/Il2CppDumper/Il2Cpp/Metadata.cs index 1aced1b..18c9615 100644 --- a/Il2CppDumper/Il2Cpp/Metadata.cs +++ b/Il2CppDumper/Il2Cpp/Metadata.cs @@ -1,8 +1,10 @@ using System; using System.Collections.Generic; +using System.Drawing; using System.IO; using System.Linq; using System.Reflection; +using System.Runtime.InteropServices; using System.Text; namespace Il2CppDumper @@ -58,7 +60,9 @@ public Metadata(Stream stream) : base(stream) throw new NotSupportedException($"ERROR: Metadata file supplied is not a supported version[{version}]."); } Version = version; - header = ReadClass(0); + // header = ReadClass(0); + header = restructMetadata(); + imageDefs = ReadMetadataClassArray(header.imagesOffset, header.imagesSize); if (Version == 24.2 && header.assembliesSize / 68 < imageDefs.Length) { @@ -99,15 +103,12 @@ public Metadata(Stream stream) : base(stream) if (Version > 16) { fieldRefs = ReadMetadataClassArray(header.fieldRefsOffset, header.fieldRefsSize); - if (Version < 27) - { - ProcessingMetadataUsage(); - } } if (Version >= 29) { attributeDataRanges = ReadMetadataClassArray(header.attributeDataRangeOffset, header.attributeDataRangeSize); } + if (Version > 24) { attributeTypeRangesDic = new Dictionary>(); @@ -130,7 +131,514 @@ public Metadata(Stream stream) : base(stream) } } + } + + private Il2CppGlobalMetadataHeader restructMetadata() + { + Il2CppGlobalMetadataHeader header = new(); + int[] data = ReadClassArray(0, SizeOf(typeof(Il2CppGlobalMetadataHeader)) / 4); + + header.sanity = (uint)data[0]; + header.version = data[1]; + header.stringLiteralOffset = (uint)data[2]; + header.stringLiteralSize = data[3]; + + List> list = new(); + Dictionary seenValues = new Dictionary(); + + for (int i = 4; i < data.Length; i += 2) + { + for (int j = 5; j < data.Length; j += 2) + { + if (data[i] == 0 || data[j] == 0) + continue; + + if (seenValues.ContainsKey(data[i])) + continue; + + for (int k = 4; k < data.Length; k += 2) + { + if (Math.Abs(data[i] + data[j] - data[k]) <= 8 && data[i] < data[k]) + { + seenValues.Add(data[i], data[j]); + list.Add(new Tuple((uint)data[i], data[j])); + break; + } + } + } + } + + for (int i = 5; i < data.Length; i += 2) { + if (data[i] == 0) continue; + if (seenValues.ContainsKey(data[i])) continue; + list.Add(new Tuple((uint)data[data.Length - 2], data[i])); + break; + } + + // for (int i = 0; i < list.Count; i++) + // { + // Console.WriteLine($"0x{list[i].Item1:X} - 0x{list[i].Item2:X}"); + // } + + int checkDone = 0; + bool check = false; + + float range = 0.4f; + + // uint stringLiteralDataSize_MIN = 0x90000; + // uint stringSize_MIN = 0x1B0000; + uint eventsSize_MIN = 0x2A00; + uint propertiesSize_MIN = 0x57000; + uint methodsSize_MIN = 0x2E0000; + uint parameterDefaultValuesSize_MIN = 0x4000; + uint fieldDefaultValuesSize_MIN = 0x28000; + // uint fieldAndParameterDefaultValueDataSize_MIN = 0x20000; + uint parametersSize_MIN = 0x111000; + + uint fieldsSize_MIN = 0xA0000; + uint genericParametersSize_MIN = 0xB000; + uint genericParameterConstraintsSize_MIN = 0xA00; + uint genericContainersSize_MIN = 0x7000; + uint nestedTypesSize_MIN = 0x4800; + uint interfacesSize_MIN = 0x6800; + uint vtableMethodsSize_MIN = 0x8D000; + uint typeDefinitionsSize_MIN = 0x13C000; + uint imagesSize_MIN = 0xE00; + uint assembliesSize_MIN = 0x1700; + uint fieldRefsSize_MIN = 0x1200; + uint attributeDataSize_MIN = 0x8C000; + uint attributeDataRangeSize_MIN = 0x3B000; + + + // stringLiteralDataOffset + if (header.stringLiteralDataOffset == 0) + { + byte[] checkString = new byte[] { + 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, + 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, + 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, + 0x59, 0x5A, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, + 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, + 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, + 0x77, 0x78, 0x79, 0x7A + }; // ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz + + for (int i = 0; i < list.Count; i++) + { + // if (list[i].Item2 < stringLiteralDataSize_MIN || list[i].Item2 > stringLiteralDataSize_MIN * (1 + range)) continue; + for (int j = 0; j < 0x200; j++) + { + Position = (ulong)(list[i].Item1 + j); + byte[] subBytes = ReadBytes(0x34); + if (subBytes.SequenceEqual(checkString)) + { + header.stringLiteralDataOffset = list[i].Item1; + header.stringLiteralDataSize = list[i].Item2; + list.RemoveAt(i); + checkDone++; + check = true; + break; + } + } + if (check) break; + } + check = false; + } + + // stringOffset + if (header.stringOffset == 0) + { + // for (int i = 0; i < list.Count; i++) + // { + // // if (list[i].Item2 < stringSize_MIN || list[i].Item2 > stringSize_MIN * (1 + range)) continue; + // for (int j = 0; j < 0x200; j++) + // { + // string str = ReadStringToNull((ulong)(list[i].Item1 + j)); + // if (str == "Assembly-CSharp") + // { + // header.stringOffset = list[i].Item1; + // header.stringSize = list[i].Item2; + // list.RemoveAt(i); + // checkDone++; + // check = true; + // break; + // } + // } + // if (check) break; + // } + // check = false; + int firstMax = int.MinValue; + int secondMax = int.MinValue; + + foreach (var tuple in list) + { + if (tuple.Item2 > firstMax) + { + secondMax = firstMax; + firstMax = tuple.Item2; + } + else if (tuple.Item2 > secondMax && tuple.Item2 != firstMax) + { + secondMax = tuple.Item2; + } + } + + for (int i = 0; i < list.Count; i++) + { + if (list[i].Item2 == secondMax) + { + header.stringOffset = list[i].Item1; + header.stringSize = list[i].Item2; + list.RemoveAt(i); + checkDone++; + break; + } + } + } + + // typeDefinitionsOffset + if (header.typeDefinitionsOffset == 0) + { + for (int i = 0; i < list.Count; i++) + { + if (list[i].Item2 < typeDefinitionsSize_MIN || list[i].Item2 > typeDefinitionsSize_MIN * (1 + range)) continue; + if (list[i].Item2 % SizeOf(typeof(Il2CppTypeDefinition)) != 0) continue; + header.typeDefinitionsOffset = list[i].Item1; + header.typeDefinitionsSize = list[i].Item2; + list.RemoveAt(i); + checkDone++; + break; + } + } + + // Il2CppAssemblyDefinition + if (header.assembliesOffset == 0) + { + for (int i = 0; i < list.Count; i++) + { + if (list[i].Item2 < assembliesSize_MIN || list[i].Item2 > assembliesSize_MIN * (1 + range)) continue; + if (list[i].Item2 % SizeOf(typeof(Il2CppAssemblyDefinition)) != 0) continue; + header.assembliesOffset = list[i].Item1; + header.assembliesSize = list[i].Item2; + list.RemoveAt(i); + checkDone++; + break; + } + } + + // Il2CppImageDefinition + if (header.imagesOffset == 0) + { + for (int i = 0; i < list.Count; i++) + { + if (list[i].Item2 < imagesSize_MIN || list[i].Item2 > imagesSize_MIN * (1 + range)) continue; + if (list[i].Item2 % SizeOf(typeof(Il2CppImageDefinition)) != 0) continue; + header.imagesOffset = list[i].Item1; + header.imagesSize = list[i].Item2; + list.RemoveAt(i); + checkDone++; + break; + } + } + + // Il2CppMethodDefinition + if (header.methodsOffset == 0) + { + for (int i = 0; i < list.Count; i++) + { + if (list[i].Item2 < methodsSize_MIN || list[i].Item2 > methodsSize_MIN * (1 + range)) continue; + if (list[i].Item2 % SizeOf(typeof(Il2CppMethodDefinition)) != 0) continue; + header.methodsOffset = list[i].Item1; + header.methodsSize = list[i].Item2; + list.RemoveAt(i); + checkDone++; + break; + } + } + + // Il2CppEventDefinition + if (header.eventsOffset == 0) + { + for (int i = 0; i < list.Count; i++) + { + if (list[i].Item2 < eventsSize_MIN || list[i].Item2 > eventsSize_MIN * (1 + range)) continue; + if (list[i].Item2 % SizeOf(typeof(Il2CppEventDefinition)) != 0) continue; + header.eventsOffset = list[i].Item1; + header.eventsSize = list[i].Item2; + list.RemoveAt(i); + checkDone++; + break; + } + } + + // Il2CppPropertyDefinition + if (header.propertiesOffset == 0) + { + for (int i = 0; i < list.Count; i++) + { + if (list[i].Item2 < propertiesSize_MIN || list[i].Item2 > propertiesSize_MIN * (1 + range)) continue; + if (list[i].Item2 % SizeOf(typeof(Il2CppPropertyDefinition)) != 0) continue; + header.propertiesOffset = list[i].Item1; + header.propertiesSize = list[i].Item2; + list.RemoveAt(i); + checkDone++; + break; + } + } + + // Il2CppGenericContainer + if (header.genericContainersOffset == 0) + { + for (int i = 0; i < list.Count; i++) + { + if (list[i].Item2 < genericContainersSize_MIN || list[i].Item2 > genericContainersSize_MIN * (1 + range)) continue; + if (list[i].Item2 % SizeOf(typeof(Il2CppGenericContainer)) != 0) continue; + header.genericContainersOffset = list[i].Item1; + header.genericContainersSize = list[i].Item2; + list.RemoveAt(i); + checkDone++; + break; + } + } + + // Il2CppGenericParameter + if (header.genericParametersOffset == 0) + { + for (int i = 0; i < list.Count; i++) + { + if (list[i].Item2 < genericParametersSize_MIN || list[i].Item2 > genericParametersSize_MIN * (1 + range)) continue; + if (list[i].Item2 % SizeOf(typeof(Il2CppGenericParameter)) != 0) continue; + header.genericParametersOffset = list[i].Item1; + header.genericParametersSize = list[i].Item2; + list.RemoveAt(i); + checkDone++; + break; + } + } + + // Il2CppParameterDefinition + if (header.parametersOffset == 0) + { + for (int i = 0; i < list.Count; i++) + { + if (list[i].Item2 < parametersSize_MIN || list[i].Item2 > parametersSize_MIN * (1 + range)) continue; + if (list[i].Item2 % SizeOf(typeof(Il2CppParameterDefinition)) != 0) continue; + header.parametersOffset = list[i].Item1; + header.parametersSize = list[i].Item2; + list.RemoveAt(i); + checkDone++; + break; + } + } + + // Il2CppFieldDefinition + if (header.fieldsOffset == 0) + { + for (int i = 0; i < list.Count; i++) + { + if (list[i].Item2 < fieldsSize_MIN || list[i].Item2 > fieldsSize_MIN * (1 + range)) continue; + if (list[i].Item2 % SizeOf(typeof(Il2CppFieldDefinition)) != 0) continue; + header.fieldsOffset = list[i].Item1; + header.fieldsSize = list[i].Item2; + list.RemoveAt(i); + checkDone++; + break; + } + } + + // Il2CppFieldDefaultValue + if (header.fieldDefaultValuesOffset == 0) + { + for (int i = 0; i < list.Count; i++) + { + if (list[i].Item2 < fieldDefaultValuesSize_MIN || list[i].Item2 > fieldDefaultValuesSize_MIN * (1 + range)) continue; + if (list[i].Item2 % SizeOf(typeof(Il2CppFieldDefaultValue)) != 0) continue; + header.fieldDefaultValuesOffset = list[i].Item1; + header.fieldDefaultValuesSize = list[i].Item2; + list.RemoveAt(i); + checkDone++; + break; + } + } + + // Il2CppParameterDefaultValue + if (header.parameterDefaultValuesOffset == 0) + { + for (int i = 0; i < list.Count; i++) + { + if (list[i].Item2 < parameterDefaultValuesSize_MIN || list[i].Item2 > parameterDefaultValuesSize_MIN * (1 + range)) continue; + if (list[i].Item2 % SizeOf(typeof(Il2CppParameterDefaultValue)) != 0) continue; + header.parameterDefaultValuesOffset = list[i].Item1; + header.parameterDefaultValuesSize = list[i].Item2; + list.RemoveAt(i); + checkDone++; + break; + } + } + + // Il2CppFieldRef + if (header.fieldRefsOffset == 0) + { + for (int i = 0; i < list.Count; i++) + { + if (list[i].Item2 < fieldRefsSize_MIN || list[i].Item2 > fieldRefsSize_MIN * (1 + range)) continue; + if (list[i].Item2 % SizeOf(typeof(Il2CppFieldRef)) != 0) continue; + header.fieldRefsOffset = list[i].Item1; + header.fieldRefsSize = list[i].Item2; + list.RemoveAt(i); + checkDone++; + break; + } + } + + // Il2CppCustomAttributeDataRange + if (header.attributeDataRangeOffset == 0) + { + for (int i = 0; i < list.Count; i++) + { + if (list[i].Item2 < attributeDataRangeSize_MIN || list[i].Item2 > attributeDataRangeSize_MIN * (1 + range)) continue; + if (list[i].Item2 % SizeOf(typeof(Il2CppCustomAttributeDataRange)) != 0) continue; + + Il2CppCustomAttributeDataRange entry = ReadClass(list[i].Item1); + if (entry.startOffset != 0) continue; + + header.attributeDataRangeOffset = list[i].Item1; + header.attributeDataRangeSize = list[i].Item2; + list.RemoveAt(i); + checkDone++; + break; + } + } + + // fieldAndParameterDefaultValueDataOffset + if (header.fieldAndParameterDefaultValueDataOffset == 0) + { + byte[] checkString = new byte[] { + 0x22, 0x55, 0x49, 0x5F, 0x4C, 0x6F, 0x63, 0x61, + 0x6C, 0x69, 0x7A, 0x65, 0x64, 0x46, 0x6F, 0x6E, + 0x74, 0x73 + }; // "UI_LocalizedFonts + + for (int i = 0; i < list.Count; i++) + { + // if (list[i].Item2 < fieldAndParameterDefaultValueDataSize_MIN || list[i].Item2 > fieldAndParameterDefaultValueDataSize_MIN * (1 + range)) continue; + for (int j = 0; j < list[i].Item2 - 0x12; j++) + { + Position = (ulong)(list[i].Item1 + j); + byte[] subBytes = ReadBytes(0x12); + if (subBytes.SequenceEqual(checkString)) + { + header.fieldAndParameterDefaultValueDataOffset = list[i].Item1; + header.fieldAndParameterDefaultValueDataSize = list[i].Item2; + list.RemoveAt(i); + checkDone++; + check = true; + break; + } + } + if (check) break; + } + check = false; + } + + // genericParameterConstraintsOffset + if (header.genericParameterConstraintsOffset == 0) + { + for (int i = 0; i < list.Count; i++) + { + if (list[i].Item2 < genericParameterConstraintsSize_MIN || list[i].Item2 > genericParameterConstraintsSize_MIN * (1 + range)) continue; + if (list[i].Item2 % 4 != 0) continue; + header.genericParameterConstraintsOffset = list[i].Item1; + header.genericParameterConstraintsSize = list[i].Item2; + list.RemoveAt(i); + checkDone++; + break; + } + } + + // nestedTypesOffset + if (header.nestedTypesOffset == 0) + { + for (int i = 0; i < list.Count; i++) + { + if (list[i].Item2 < nestedTypesSize_MIN || list[i].Item2 > nestedTypesSize_MIN * (1 + range)) continue; + if (list[i].Item2 % 4 != 0) continue; + header.nestedTypesOffset = list[i].Item1; + header.nestedTypesSize = list[i].Item2; + list.RemoveAt(i); + checkDone++; + break; + } + } + + // interfacesOffset + if (header.interfacesOffset == 0) + { + for (int i = 0; i < list.Count; i++) + { + if (list[i].Item2 < interfacesSize_MIN || list[i].Item2 > interfacesSize_MIN * (1 + range)) continue; + if (list[i].Item2 % 4 != 0) continue; + header.interfacesOffset = list[i].Item1; + header.interfacesSize = list[i].Item2; + list.RemoveAt(i); + checkDone++; + break; + } + } + + // attributeDataOffset + if (header.attributeDataOffset == 0) + { + byte[] checkString = new byte[] { + 0x4E, 0x65, 0x77, 0x20, 0x41, 0x70, 0x70, 0x20, + 0x53, 0x65, 0x74, 0x74 + }; // "New App Sett + + for (int i = 0; i < list.Count; i++) + { + if (list[i].Item2 < attributeDataSize_MIN || list[i].Item2 > attributeDataSize_MIN * (1 + range)) continue; + for (int j = 0; j < list[i].Item2 - 0x0C; j++) + { + Position = (ulong)(list[i].Item1 + j); + byte[] subBytes = ReadBytes(0x0C); + if (subBytes.SequenceEqual(checkString)) + { + header.attributeDataOffset = list[i].Item1; + header.attributeDataSize = list[i].Item2; + list.RemoveAt(i); + checkDone++; + check = true; + break; + } + } + if (check) break; + } + check = false; + } + + // vtableMethodsOffset + if (header.vtableMethodsOffset == 0) + { + for (int i = 0; i < list.Count; i++) + { + if (list[i].Item2 < vtableMethodsSize_MIN || list[i].Item2 > vtableMethodsSize_MIN * (1 + range)) continue; + if (list[i].Item2 % 4 != 0) continue; + header.vtableMethodsOffset = list[i].Item1; + header.vtableMethodsSize = list[i].Item2; + list.RemoveAt(i); + checkDone++; + break; + } + } + + // header.PrintAll(); + + if (checkDone != 22) + { + throw new InvalidDataException("ERROR: Metadata file supplied is not valid metadata file."); + } + return header; } private T[] ReadMetadataClassArray(uint addr, int count) where T : new() diff --git a/Il2CppDumper/Il2Cpp/MetadataClass.cs b/Il2CppDumper/Il2Cpp/MetadataClass.cs index 70819c3..f68f404 100644 --- a/Il2CppDumper/Il2Cpp/MetadataClass.cs +++ b/Il2CppDumper/Il2Cpp/MetadataClass.cs @@ -8,69 +8,137 @@ public class Il2CppGlobalMetadataHeader { public uint sanity; public int version; - public uint stringLiteralOffset; + public uint stringLiteralOffset; // string data for managed code public int stringLiteralSize; public uint stringLiteralDataOffset; - public int unknown14; - public uint stringOffset; - public int unknown1C; - public uint exportedTypeDefinitionsOffset; - public int attributeDataRangeSize; - public uint attributeDataOffset; + public int stringLiteralDataSize; + public uint stringOffset; // string data for metadata + public int stringSize; + public uint eventsOffset; // Il2CppEventDefinition public int eventsSize; - public uint methodsOffset; + public uint propertiesOffset; // Il2CppPropertyDefinition + public int propertiesSize; + public uint methodsOffset; // Il2CppMethodDefinition + public int methodsSize; + public uint parameterDefaultValuesOffset; // Il2CppParameterDefaultValue + public int parameterDefaultValuesSize; + public uint fieldDefaultValuesOffset; // Il2CppFieldDefaultValue public int fieldDefaultValuesSize; - public uint windowsRuntimeStringsOffset; - public int typeDefinitionsSize; - public uint fieldDefaultValuesOffset; - public int assembliesSize; - public uint genericContainersOffset; + public uint fieldAndParameterDefaultValueDataOffset; // uint8_t + public int fieldAndParameterDefaultValueDataSize; + public int fieldMarshaledSizesOffset; // Il2CppFieldMarshaledSize + public int fieldMarshaledSizesSize; + public uint parametersOffset; // Il2CppParameterDefinition public int parametersSize; - public uint unknown50; - public int propertiesSize; - public uint propertiesOffset; + public uint fieldsOffset; // Il2CppFieldDefinition + public int fieldsSize; + public uint genericParametersOffset; // Il2CppGenericParameter public int genericParametersSize; - public uint parameterDefaultValuesOffset; - public int unknown64; - public uint attributeDataRangeOffset; - public int unknown6C; - public uint parametersOffset; + public uint genericParameterConstraintsOffset; // TypeIndex + public int genericParameterConstraintsSize; + public uint genericContainersOffset; // Il2CppGenericContainer + public int genericContainersSize; + public uint nestedTypesOffset; // TypeDefinitionIndex public int nestedTypesSize; - public uint unknown78; + public uint interfacesOffset; // TypeIndex + public int interfacesSize; + public uint vtableMethodsOffset; // EncodedMethodIndex public int vtableMethodsSize; - public uint typeDefinitionsOffset; - public int methodsSize; - public uint unresolvedVirtualCallParameterRangesOffset; + public int interfaceOffsetsOffset; // Il2CppInterfaceOffsetPair + public int interfaceOffsetsSize; + public uint typeDefinitionsOffset; // Il2CppTypeDefinition + public int typeDefinitionsSize; + public uint imagesOffset; // Il2CppImageDefinition public int imagesSize; - public uint nestedTypesOffset; - public int fieldsSize; - public uint fieldRefsOffset; - public int unknown9C; - public uint genericParameterConstraintsOffset; - public int unknownA4; - public uint interfaceOffsetsOffset; - public int windowsRuntimeTypeNamesSize; - public uint windowsRuntimeTypeNamesOffset; - public int unknownB4; - public uint genericParametersOffset; - public int genericContainersSize; - public uint vtableMethodsOffset; - public int interfacesSize; - public uint assembliesOffset; + public uint assembliesOffset; // Il2CppAssemblyDefinition + public int assembliesSize; + public uint fieldRefsOffset; // Il2CppFieldRef public int fieldRefsSize; - public uint eventsOffset; - public int unknownD4; - public uint imagesOffset; - public int genericParameterConstraintsSize; - public uint unresolvedVirtualCallParameterTypesOffset; - public int unknownE4; - public uint interfacesOffset; - public int unknownEC; - public uint fieldsOffset; - public int unknownF4; - public uint fieldAndParameterDefaultValueDataOffset; - public int parameterDefaultValuesSize; - }; + public int referencedAssembliesOffset; // int32_t + public int referencedAssembliesSize; + public uint attributeDataOffset; + public int attributeDataSize; + public uint attributeDataRangeOffset; + public int attributeDataRangeSize; + public int unresolvedVirtualCallParameterTypesOffset; // TypeIndex + public int unresolvedVirtualCallParameterTypesSize; + public int unresolvedVirtualCallParameterRangesOffset; // Il2CppRange + public int unresolvedVirtualCallParameterRangesSize; + public int windowsRuntimeTypeNamesOffset; // Il2CppWindowsRuntimeTypeNamePair + public int windowsRuntimeTypeNamesSize; + public int windowsRuntimeStringsOffset; // const char* + public int windowsRuntimeStringsSize; + public int exportedTypeDefinitionsOffset; // TypeDefinitionIndex + public int exportedTypeDefinitionsSize; + + public void PrintAll() + { + Console.WriteLine($"sanity: {sanity}"); + Console.WriteLine($"version: {version}"); + Console.WriteLine($"stringLiteralOffset: {stringLiteralOffset}"); + Console.WriteLine($"stringLiteralSize: {stringLiteralSize}"); + Console.WriteLine($"stringLiteralDataOffset: {stringLiteralDataOffset}"); + Console.WriteLine($"stringLiteralDataSize: {stringLiteralDataSize}"); + Console.WriteLine($"stringOffset: {stringOffset}"); + Console.WriteLine($"stringSize: {stringSize}"); + Console.WriteLine($"eventsOffset: {eventsOffset}"); + Console.WriteLine($"eventsSize: {eventsSize}"); + Console.WriteLine($"propertiesOffset: {propertiesOffset}"); + Console.WriteLine($"propertiesSize: {propertiesSize}"); + Console.WriteLine($"methodsOffset: {methodsOffset}"); + Console.WriteLine($"methodsSize: {methodsSize}"); + Console.WriteLine($"parameterDefaultValuesOffset: {parameterDefaultValuesOffset}"); + Console.WriteLine($"parameterDefaultValuesSize: {parameterDefaultValuesSize}"); + Console.WriteLine($"fieldDefaultValuesOffset: {fieldDefaultValuesOffset}"); + Console.WriteLine($"fieldDefaultValuesSize: {fieldDefaultValuesSize}"); + Console.WriteLine($"fieldAndParameterDefaultValueDataOffset: {fieldAndParameterDefaultValueDataOffset}"); + Console.WriteLine($"fieldAndParameterDefaultValueDataSize: {fieldAndParameterDefaultValueDataSize}"); + Console.WriteLine($"fieldMarshaledSizesOffset: {fieldMarshaledSizesOffset}"); + Console.WriteLine($"fieldMarshaledSizesSize: {fieldMarshaledSizesSize}"); + Console.WriteLine($"parametersOffset: {parametersOffset}"); + Console.WriteLine($"parametersSize: {parametersSize}"); + Console.WriteLine($"fieldsOffset: {fieldsOffset}"); + Console.WriteLine($"fieldsSize: {fieldsSize}"); + Console.WriteLine($"genericParametersOffset: {genericParametersOffset}"); + Console.WriteLine($"genericParametersSize: {genericParametersSize}"); + Console.WriteLine($"genericParameterConstraintsOffset: {genericParameterConstraintsOffset}"); + Console.WriteLine($"genericParameterConstraintsSize: {genericParameterConstraintsSize}"); + Console.WriteLine($"genericContainersOffset: {genericContainersOffset}"); + Console.WriteLine($"genericContainersSize: {genericContainersSize}"); + Console.WriteLine($"nestedTypesOffset: {nestedTypesOffset}"); + Console.WriteLine($"nestedTypesSize: {nestedTypesSize}"); + Console.WriteLine($"interfacesOffset: {interfacesOffset}"); + Console.WriteLine($"interfacesSize: {interfacesSize}"); + Console.WriteLine($"vtableMethodsOffset: {vtableMethodsOffset}"); + Console.WriteLine($"vtableMethodsSize: {vtableMethodsSize}"); + Console.WriteLine($"interfaceOffsetsOffset: {interfaceOffsetsOffset}"); + Console.WriteLine($"interfaceOffsetsSize: {interfaceOffsetsSize}"); + Console.WriteLine($"typeDefinitionsOffset: {typeDefinitionsOffset}"); + Console.WriteLine($"typeDefinitionsSize: {typeDefinitionsSize}"); + Console.WriteLine($"imagesOffset: {imagesOffset}"); + Console.WriteLine($"imagesSize: {imagesSize}"); + Console.WriteLine($"assembliesOffset: {assembliesOffset}"); + Console.WriteLine($"assembliesSize: {assembliesSize}"); + Console.WriteLine($"fieldRefsOffset: {fieldRefsOffset}"); + Console.WriteLine($"fieldRefsSize: {fieldRefsSize}"); + Console.WriteLine($"referencedAssembliesOffset: {referencedAssembliesOffset}"); + Console.WriteLine($"referencedAssembliesSize: {referencedAssembliesSize}"); + Console.WriteLine($"attributeDataOffset: {attributeDataOffset}"); + Console.WriteLine($"attributeDataSize: {attributeDataSize}"); + Console.WriteLine($"attributeDataRangeOffset: {attributeDataRangeOffset}"); + Console.WriteLine($"attributeDataRangeSize: {attributeDataRangeSize}"); + Console.WriteLine($"unresolvedVirtualCallParameterTypesOffset: {unresolvedVirtualCallParameterTypesOffset}"); + Console.WriteLine($"unresolvedVirtualCallParameterTypesSize: {unresolvedVirtualCallParameterTypesSize}"); + Console.WriteLine($"unresolvedVirtualCallParameterRangesOffset: {unresolvedVirtualCallParameterRangesOffset}"); + Console.WriteLine($"unresolvedVirtualCallParameterRangesSize: {unresolvedVirtualCallParameterRangesSize}"); + Console.WriteLine($"windowsRuntimeTypeNamesOffset: {windowsRuntimeTypeNamesOffset}"); + Console.WriteLine($"windowsRuntimeTypeNamesSize: {windowsRuntimeTypeNamesSize}"); + Console.WriteLine($"windowsRuntimeStringsOffset: {windowsRuntimeStringsOffset}"); + Console.WriteLine($"windowsRuntimeStringsSize: {windowsRuntimeStringsSize}"); + Console.WriteLine($"exportedTypeDefinitionsOffset: {exportedTypeDefinitionsOffset}"); + Console.WriteLine($"exportedTypeDefinitionsSize: {exportedTypeDefinitionsSize}"); + } + } public class Il2CppAssemblyDefinition {