From c196f1ea29155f3eec5571a403545defeb09941d Mon Sep 17 00:00:00 2001
From: OrangeSummer <2286401259@qq.com>
Date: Fri, 9 Dec 2022 22:10:48 +0800
Subject: [PATCH] v1.42 update(add obfusfunc)

---
 O&Z_IL2CPP_Security/JsonManager.cs            |    2 +
 O&Z_IL2CPP_Security/Progarm.cs                |   29 +-
 .../Properties/launchSettings.json            |    4 +-
 O&Z_IL2CPP_Security/resource/Config.json      |   19 +
 O&Z_IL2CPP_Security/resource/keyfunc.json     |  126 ++
 .../resource/src-res/24.4/MetadataCache.cpp   | 1725 +++++++++++++++++
 .../resource/src-res/24.4/il2cpp-metadata.h   |  490 +++++
 .../resource/src-res/28/GlobalMetadata.cpp    | 1687 ++++++++++++++++
 .../src-res/28/GlobalMetadataFileInternals.h  |  353 ++++
 .../resource/src-res/xxtea.cpp                |  260 +++
 O&Z_IL2CPP_Security/resource/src-res/xxtea.h  |   54 +
 O&Z_Obfuscator/LitJson/AssemblyInfo.cs.in     |   18 +
 O&Z_Obfuscator/LitJson/IJsonWrapper.cs        |   60 +
 O&Z_Obfuscator/LitJson/JsonData.cs            | 1142 +++++++++++
 O&Z_Obfuscator/LitJson/JsonException.cs       |   65 +
 O&Z_Obfuscator/LitJson/JsonMapper.cs          | 1098 +++++++++++
 O&Z_Obfuscator/LitJson/JsonMockWrapper.cs     |  109 ++
 O&Z_Obfuscator/LitJson/JsonReader.cs          |  523 +++++
 O&Z_Obfuscator/LitJson/JsonWriter.cs          |  499 +++++
 O&Z_Obfuscator/LitJson/Lexer.cs               |  971 ++++++++++
 O&Z_Obfuscator/LitJson/LitJSON.csproj         |   61 +
 .../LitJson/Netstandard15Polyfill.cs          |   24 +
 O&Z_Obfuscator/LitJson/ParserToken.cs         |   45 +
 O&Z_Obfuscator/LitJson/litjson.png            |  Bin 0 -> 3356 bytes
 O&Z_Obfuscator/OZ_Obfuscator.csproj           |   18 +
 O&Z_Obfuscator/Ofbuscators/ObfusFunc.cs       |   90 +
 O&Z_Obfuscator/Program.cs                     |    7 +
 O&Z_Obfuscator/README.md                      |   31 +-
 O&Z_Obfuscator/img/config.png                 |  Bin 22462 -> 38205 bytes
 O&Z_Obfuscator/img/funcobfus.png              |  Bin 0 -> 68721 bytes
 O&Z_Obfuscator/img/keyfunc.png                |  Bin 0 -> 110303 bytes
 O&Z_Obfuscator/utils.cs                       |    9 +-
 README.md                                     |   20 +-
 33 files changed, 9500 insertions(+), 39 deletions(-)
 create mode 100644 O&Z_IL2CPP_Security/resource/Config.json
 create mode 100644 O&Z_IL2CPP_Security/resource/keyfunc.json
 create mode 100644 O&Z_IL2CPP_Security/resource/src-res/24.4/MetadataCache.cpp
 create mode 100644 O&Z_IL2CPP_Security/resource/src-res/24.4/il2cpp-metadata.h
 create mode 100644 O&Z_IL2CPP_Security/resource/src-res/28/GlobalMetadata.cpp
 create mode 100644 O&Z_IL2CPP_Security/resource/src-res/28/GlobalMetadataFileInternals.h
 create mode 100644 O&Z_IL2CPP_Security/resource/src-res/xxtea.cpp
 create mode 100644 O&Z_IL2CPP_Security/resource/src-res/xxtea.h
 create mode 100644 O&Z_Obfuscator/LitJson/AssemblyInfo.cs.in
 create mode 100644 O&Z_Obfuscator/LitJson/IJsonWrapper.cs
 create mode 100644 O&Z_Obfuscator/LitJson/JsonData.cs
 create mode 100644 O&Z_Obfuscator/LitJson/JsonException.cs
 create mode 100644 O&Z_Obfuscator/LitJson/JsonMapper.cs
 create mode 100644 O&Z_Obfuscator/LitJson/JsonMockWrapper.cs
 create mode 100644 O&Z_Obfuscator/LitJson/JsonReader.cs
 create mode 100644 O&Z_Obfuscator/LitJson/JsonWriter.cs
 create mode 100644 O&Z_Obfuscator/LitJson/Lexer.cs
 create mode 100644 O&Z_Obfuscator/LitJson/LitJSON.csproj
 create mode 100644 O&Z_Obfuscator/LitJson/Netstandard15Polyfill.cs
 create mode 100644 O&Z_Obfuscator/LitJson/ParserToken.cs
 create mode 100644 O&Z_Obfuscator/LitJson/litjson.png
 create mode 100644 O&Z_Obfuscator/Ofbuscators/ObfusFunc.cs
 create mode 100644 O&Z_Obfuscator/img/funcobfus.png
 create mode 100644 O&Z_Obfuscator/img/keyfunc.png

diff --git a/O&Z_IL2CPP_Security/JsonManager.cs b/O&Z_IL2CPP_Security/JsonManager.cs
index 1ffbfde..e1e8466 100644
--- a/O&Z_IL2CPP_Security/JsonManager.cs
+++ b/O&Z_IL2CPP_Security/JsonManager.cs
@@ -19,11 +19,13 @@ public class ObfusConfig
         public int NumObfus { get; set; }
         public int LocalVariables2Field { get; set; }
         public int StrCrypter { get; set; }
+        public int Obfusfunc { get; set; }
     }
     public class JsonManager
     {
         public JsonIndex index;
         public string path;
+        public static string origin = "ewogICAgImtleSI6MTE0NTE0LAogICAgIlZlcnNpb24iOiIyNC40IiwKICAgICIvLyI6IuaUr+aMgTI4IDI0LjQiLAogICAgIk9iZnVzIjoKICAgIHsKICAgICAgICAiQ29udHJvbEZsb3ciOjEsCiAgICAgICAgIk51bU9iZnVzIjoxLAogICAgICAgICJMb2NhbFZhcmlhYmxlczJGaWVsZCI6MSwKICAgICAgICAiU3RyQ3J5cHRlciI6MSwKICAgICAgICAiT2JmdXNmdW5jIjoxLAogICAgICAgICIvLyI6IjA95YWz6ZetIDE95byA5ZCvIiwKICAgICAgICAiLy8iOiJDb250cm9sRmxvd++8muaOp+WItua1geeoi+a3t+a3hiIsCiAgICAgICAgIi8vIjoiTnVtT2JmdXPvvJrmlbDlrZfmt7fmt4YiLAogICAgICAgICIvLyI6IkxvY2FsVmFyaWFibGVzMkZpZWxk77ya5bGA6YOo5Y+Y6YeP6L2s5o2i5Li65a2X5q61IiwKICAgICAgICAiLy8iOiJTdHJDcnlwdGVy77ya5a2X56ym5Liy5Yqg5a+GIiwKICAgICAgICAiLy8iOiJPYmZ1c2Z1bmPvvJroh6rlrprkuYnmt7fmt4bnsbvlkozmlrnms5XlkI3np7As5Y+v5Lul5Zyoa2V5ZnVuY+S4reiHquWumuS5iea3t+a3huaooeW8jyjlpoLnlKjliLDkuoblj43lsITnrYnnsbvlnospIgoKICAgIH0KfQ==";
         public JsonManager(string _path)
         {
             path = _path;
diff --git a/O&Z_IL2CPP_Security/Progarm.cs b/O&Z_IL2CPP_Security/Progarm.cs
index 860fac9..ed5271a 100644
--- a/O&Z_IL2CPP_Security/Progarm.cs
+++ b/O&Z_IL2CPP_Security/Progarm.cs
@@ -16,22 +16,13 @@
 Console.WriteLine("O&Z_IL2CPP_Security");
 if (!File.Exists("Config.json"))
 {
+    Console.ForegroundColor = ConsoleColor.Red;
     Console.WriteLine("Config.json not found!");
-    Console.WriteLine("正在生成默认配置文件...");
-    JsonIndex index = new JsonIndex()
-    {
-        key = 114514,
-        Version = "24.4",
-        Obfus = new ObfusConfig()
-        {
-            ControlFlow = 1,
-            NumObfus = 1,
-            LocalVariables2Field = 1,
-            StrCrypter = 1
-        }
-    };
-    File.WriteAllText("Config.json", JsonMapper.ToJson(index));
+    Console.ForegroundColor = ConsoleColor.Yellow;
+    Console.WriteLine("正在生成默认配置文件..."); 
+    File.WriteAllBytes("Config.json", Convert.FromBase64String(JsonManager.origin));
     if (File.Exists("Config.json")) Console.WriteLine("已重新生成默认配置文件...\nDone!");
+    Console.ForegroundColor = ConsoleColor.White;
 }
 if (args.Length == 0)
 {
@@ -193,7 +184,10 @@ bool CheckMetadataFile()
 }
 void _Test()
 {
-    Console.WriteLine(XXTEA.EncryptToBase64String("HelloWorld", "123456"));
+    AssemblyLoader loader = new AssemblyLoader(OpenFilePath);
+    ObfusFunc obfusFunc = new ObfusFunc(loader.Module);
+    obfusFunc.Excute();
+    loader.Save();
 }
 void CheckVersion()
 {
@@ -220,6 +214,11 @@ void MonoObfus()
         ControlFlow controlFlow = new ControlFlow(loader.Module);
         controlFlow.Execute();
     }
+    if (jsonManager.index.Obfus.Obfusfunc == 1)
+    {
+        ObfusFunc obfusFunc = new ObfusFunc(loader.Module);
+        obfusFunc.Excute();
+    }
     if (jsonManager.index.Obfus.NumObfus == 1)
     {
         NumObfus numObfus = new NumObfus(loader.Module);
diff --git a/O&Z_IL2CPP_Security/Properties/launchSettings.json b/O&Z_IL2CPP_Security/Properties/launchSettings.json
index 4b7c6ef..747e55d 100644
--- a/O&Z_IL2CPP_Security/Properties/launchSettings.json
+++ b/O&Z_IL2CPP_Security/Properties/launchSettings.json
@@ -10,7 +10,7 @@
     },
     "Test": {
       "commandName": "Project",
-      "commandLineArgs": "\"global-metadata.dat\" Test"
+      "commandLineArgs": "\"C:\\Users\\22864\\Desktop\\2019Testbuild\\O&Z_2019_4_32_f1_Data\\Managed\\Assembly-CSharp - 副本.dll\" Test"
     },
     "Generate": {
       "commandName": "Project",
@@ -18,7 +18,7 @@
     },
     "Obfus": {
       "commandName": "Project",
-      "commandLineArgs": "\"C:\\Users\\22864\\Desktop\\END_AUTO V2\\END_Data\\Managed\\Assembly-CSharp.dll.bak\" MonoObfus"
+      "commandLineArgs": "\"C:\\Users\\22864\\Desktop\\2019Testbuild\\O&Z_2019_4_32_f1_Data\\Managed\\Assembly-CSharp - 副本.dll\" MonoObfus"
     }
   }
 }
\ No newline at end of file
diff --git a/O&Z_IL2CPP_Security/resource/Config.json b/O&Z_IL2CPP_Security/resource/Config.json
new file mode 100644
index 0000000..62c7848
--- /dev/null
+++ b/O&Z_IL2CPP_Security/resource/Config.json
@@ -0,0 +1,19 @@
+{
+    "key":114514,
+    "Version":"24.4",
+    "//":"支持28 24.4",
+    "Obfus":
+    {
+        "ControlFlow":1,
+        "NumObfus":1,
+        "LocalVariables2Field":1,
+        "StrCrypter":1,
+        "StrObfus":1,
+        "//":"0=关闭 1=开启",
+        "//":"ControlFlow:控制流程混淆",
+        "//":"NumObfus:数字混淆",
+        "//":"LocalVariables2Field:局部变量转换为字段",
+        "//":"StrCrypter:字符串加密",
+        "//":"StrObfus:方法加密混淆,可以在keyfunc中添加自定义需要排除的方法(如用到了反射等类型)"
+    }
+}
\ No newline at end of file
diff --git a/O&Z_IL2CPP_Security/resource/keyfunc.json b/O&Z_IL2CPP_Security/resource/keyfunc.json
new file mode 100644
index 0000000..7494ca9
--- /dev/null
+++ b/O&Z_IL2CPP_Security/resource/keyfunc.json
@@ -0,0 +1,126 @@
+{
+    "ignoreMethod": [
+        "Awake",
+        "OnEnable",
+        "Start",
+        "FixedUpdate",
+        "Update",
+        "OnDisable",
+        "LateUpdate",
+        "Reset",
+        "OnValidate",
+        "FixedUpdate",
+        "OnTriggerEnter",
+        "OnTriggerEnter2D",
+        "OnTriggerExit",
+        "OnTriggerExit2D",
+        "OnTriggerStay2D",
+        "OnCollisionEnter",
+        "OnCollisionEnter2D",
+        "OnCollisionExit",
+        "OnCollisionExit2D",
+        "OnCollisionStay",
+        "OnCollisionStay2D",
+        "OnMouseDown",
+        "OnMouseDrag",
+        "OnMouseEnter",
+        "OnMouseExit",
+        "OnMouseOver",
+        "OnMouseUp",
+        "OnMouseUpAsButton",
+        "OnPreCull",
+        "OnBecameVisible",
+        "OnBecameInvisible",
+        "OnWillRenderObject",
+        "OnPreRender",
+        "OnRenderObject",
+        "OnPostRender",
+        "OnRenderImage",
+        "OnGUI",
+        "OnDrawGizmos",
+        "OnDrawGizmosSelected",
+        "OnApplicationFocus",
+        "OnApplicationPause",
+        "OnApplicationQuit",
+        "OnDisable",
+        "OnDestory",
+        "OnLevelWasLoaded",
+        "OnAnimatorIK",
+        "OnAnimatorMove",
+        "OnApplicationFocus",
+        "OnApplicationPause",
+        "OnApplicationQuit",
+        "OnAudioFilterRead",
+        "OnBecameInvisible",
+        "OnBecameVisible",
+        "OnConnectedToServer",
+        "OnControllerColliderHit",
+        "OnEnable",
+        "OnFailedToConnect",
+        "OnDisconnectedFromServer",
+        "OnDrawGizmos",
+        "OnDrawGizmosSelected",
+        "OnEnable",
+        "OnFailedToConnect",
+        "OnFailedToConnectToMasterServer",
+        "OnJointBreak",
+        "OnJointBreak2D",
+        "OnMasterServerEvent",
+        "OnNetworkInstantiate",
+        "OnParticleCollision",
+        "OnParticleSystemStopped",
+        "OnParticleTrigger",
+        "OnParticleUpdateJobScheduled",
+        "OnPlayerConnected",
+        "OnPlayerDisconnected",
+        "OnPostRender",
+        "OnPreCull",
+        "OnPreRender",
+        "OnRenderImage",
+        "OnRenderObject",
+        "OnSerializeNetworkView",
+        "OnServerInitialized",
+        "OnTransformChildrenChanged",
+        "OnTransformParentChanged",
+        "OnValidate",
+        "OnWillRenderObject",
+        "Reset",
+        "__",
+        "incontrol",
+        "stop",
+        "option",
+        "pausemanager",
+        "fallingrock",
+        "postfix",
+        "prefix",
+        "transpiler"
+    ],
+    "ignoreField":[
+        "incontrol",
+        "enum",
+        "optional",
+        "__"
+    ],
+    "//":"以上为默认忽略列表,默认包含全部的Unity关键方法,建议不要修改,以下为自定义忽略列表,可以根据需要自行添加(如果需要用到反射或者动态调用的方法,建议添加到这里))",
+
+    "//":"关于如何是使用自定义忽略列表,这里有几点建议",
+    "//":"1.在Unity中,GameObject或者prefabs初始绑定了脚本,则该脚本的类名不可混淆,方法名和字段名可以混淆",
+    "//":"2.在Unity中,GameObject或者prefabs初始没有绑定脚本,但是在代码中动态添加了脚本,则该脚本的类名、方法名和字段名都可以混淆",
+    "//":"3.如果该脚本中涉及到了UI的事件响应(如Button.OnClick),则该脚本的类名和该方法名都不可混淆,字段名可以混淆",
+    "//":"4.Unity的生命周期方法和回调方法不能混淆,上方的忽略列表包含了大多数常用的生命周期和回调方法,如果有遗漏,可以自行添加",
+    "//":"5.Unity中的Invoke等特殊方法所调用的函数方法不可混淆,同理协程类的方法也不可混淆,请自行添加到自定义忽略列表",
+    "//":"6.部分涉及反射类的代码不能混淆,如System.Reflection(GetField,GetMethod,Invoke等),请自行添加到自定义忽略列表",
+    "//":"7.Native层里直接调用C#或通过Unity内置API发送事件到C#的类和方法不可混淆(大多数在移动平台中)",
+    "//":"8.一些特殊插件对应的脚本不可混淆,例如xLua和与之绑定的C#脚本",
+
+    
+    "//":"对于方法名的混淆采用的是白名单模式,即默认混淆,如果不需要混淆,可以添加到这里",
+    "customignoreMethod":[
+    ],
+    "//":"对于字段名的混淆采用的是白名单模式,即默认混淆,如果不需要混淆,可以添加到这里",
+    "customignoreField":[
+    ],
+    "//":"对于类名的混淆采用的是黑名单模式,即默认不混淆,如果需要混淆,可以添加到这里",
+    "customignoreClass":[
+    ]
+}
\ No newline at end of file
diff --git a/O&Z_IL2CPP_Security/resource/src-res/24.4/MetadataCache.cpp b/O&Z_IL2CPP_Security/resource/src-res/24.4/MetadataCache.cpp
new file mode 100644
index 0000000..933dca0
--- /dev/null
+++ b/O&Z_IL2CPP_Security/resource/src-res/24.4/MetadataCache.cpp
@@ -0,0 +1,1725 @@
+#include "il2cpp-config.h"
+#include "MetadataCache.h"
+
+#include <map>
+#include <limits>
+#include "il2cpp-class-internals.h"
+#include "il2cpp-tabledefs.h"
+#include "il2cpp-runtime-stats.h"
+#include "gc/GarbageCollector.h"
+#include "metadata/ArrayMetadata.h"
+#include "metadata/GenericMetadata.h"
+#include "metadata/GenericMethod.h"
+#include "metadata/Il2CppTypeCompare.h"
+#include "metadata/Il2CppTypeHash.h"
+#include "metadata/Il2CppTypeVector.h"
+#include "metadata/Il2CppGenericContextCompare.h"
+#include "metadata/Il2CppGenericContextHash.h"
+#include "metadata/Il2CppGenericInstCompare.h"
+#include "metadata/Il2CppGenericInstHash.h"
+#include "metadata/Il2CppGenericMethodCompare.h"
+#include "metadata/Il2CppGenericMethodHash.h"
+#include "metadata/Il2CppSignatureCompare.h"
+#include "metadata/Il2CppSignatureHash.h"
+#include "os/Atomic.h"
+#include "os/Mutex.h"
+#include "utils/CallOnce.h"
+#include "utils/Collections.h"
+#include "utils/HashUtils.h"
+#include "utils/Il2CppHashMap.h"
+#include "utils/Il2CppHashSet.h"
+#include "utils/Memory.h"
+#include "utils/StringUtils.h"
+#include "utils/PathUtils.h"
+#include "vm/Assembly.h"
+#include "vm/Class.h"
+#include "vm/ClassInlines.h"
+#include "vm/GenericClass.h"
+#include "vm/MetadataAlloc.h"
+#include "vm/MetadataLoader.h"
+#include "vm/MetadataLock.h"
+#include "vm/Method.h"
+#include "vm/Object.h"
+#include "vm/String.h"
+#include "vm/Type.h"
+#include "mono-runtime/il2cpp-mapping.h"
+#include "vm-utils/NativeSymbol.h"
+#include "vm-utils/VmStringUtils.h"
+#include "vm/xxtea.h"
+typedef std::map<Il2CppClass*, Il2CppClass*> PointerTypeMap;
+typedef Il2CppHashMap<const char*, Il2CppClass*, il2cpp::utils::StringUtils::StringHasher<const char*>, il2cpp::utils::VmStringUtils::CaseSensitiveComparer> WindowsRuntimeTypeNameToClassMap;
+typedef Il2CppHashMap<const Il2CppClass*, const char*, il2cpp::utils::PointerHash<Il2CppClass> > ClassToWindowsRuntimeTypeNameMap;
+
+typedef Il2CppHashSet<const Il2CppGenericMethod*, il2cpp::metadata::Il2CppGenericMethodHash, il2cpp::metadata::Il2CppGenericMethodCompare> Il2CppGenericMethodSet;
+typedef Il2CppGenericMethodSet::const_iterator Il2CppGenericMethodSetIter;
+static Il2CppGenericMethodSet s_GenericMethodSet;
+
+struct Il2CppMetadataCache
+{
+    il2cpp::os::FastMutex m_CacheMutex;
+    PointerTypeMap m_PointerTypes;
+};
+
+static Il2CppMetadataCache s_MetadataCache;
+static Il2CppClass** s_TypeInfoTable = NULL;
+static Il2CppClass** s_TypeInfoDefinitionTable = NULL;
+static const MethodInfo** s_MethodInfoDefinitionTable = NULL;
+static Il2CppString** s_StringLiteralTable = NULL;
+static const Il2CppGenericMethod** s_GenericMethodTable = NULL;
+static int32_t s_ImagesCount = 0;
+static Il2CppImage* s_ImagesTable = NULL;
+static int32_t s_AssembliesCount = 0;
+static Il2CppAssembly* s_AssembliesTable = NULL;
+
+
+typedef Il2CppHashSet<const Il2CppGenericInst*, il2cpp::metadata::Il2CppGenericInstHash, il2cpp::metadata::Il2CppGenericInstCompare> Il2CppGenericInstSet;
+static Il2CppGenericInstSet s_GenericInstSet;
+
+typedef Il2CppHashMap<const Il2CppGenericMethod*, const Il2CppGenericMethodIndices*, il2cpp::metadata::Il2CppGenericMethodHash, il2cpp::metadata::Il2CppGenericMethodCompare> Il2CppMethodTableMap;
+typedef Il2CppMethodTableMap::const_iterator Il2CppMethodTableMapIter;
+static Il2CppMethodTableMap s_MethodTableMap;
+
+typedef Il2CppHashMap<il2cpp::utils::dynamic_array<const Il2CppType*>, Il2CppMethodPointer, il2cpp::metadata::Il2CppSignatureHash, il2cpp::metadata::Il2CppSignatureCompare> Il2CppUnresolvedSignatureMap;
+typedef Il2CppUnresolvedSignatureMap::const_iterator Il2CppUnresolvedSignatureMapIter;
+static Il2CppUnresolvedSignatureMap *s_pUnresolvedSignatureMap;
+
+typedef Il2CppHashMap<FieldInfo*, int32_t, il2cpp::utils::PointerHash<FieldInfo> > Il2CppThreadLocalStaticOffsetHashMap;
+typedef Il2CppThreadLocalStaticOffsetHashMap::iterator Il2CppThreadLocalStaticOffsetHashMapIter;
+static Il2CppThreadLocalStaticOffsetHashMap s_ThreadLocalStaticOffsetMap;
+
+static const Il2CppCodeRegistration * s_Il2CppCodeRegistration;
+static const Il2CppMetadataRegistration * s_Il2CppMetadataRegistration;
+static const Il2CppCodeGenOptions* s_Il2CppCodeGenOptions;
+static CustomAttributesCache** s_CustomAttributesCaches;
+
+static WindowsRuntimeTypeNameToClassMap s_WindowsRuntimeTypeNameToClassMap;
+static ClassToWindowsRuntimeTypeNameMap s_ClassToWindowsRuntimeTypeNameMap;
+
+struct InteropDataToTypeConverter
+{
+    inline const Il2CppType* operator()(const Il2CppInteropData& interopData) const
+    {
+        return interopData.type;
+    }
+};
+
+typedef il2cpp::utils::collections::ArrayValueMap<const Il2CppType*, Il2CppInteropData, InteropDataToTypeConverter, il2cpp::metadata::Il2CppTypeLess, il2cpp::metadata::Il2CppTypeEqualityComparer> InteropDataMap;
+static InteropDataMap s_InteropData;
+
+struct WindowsRuntimeFactoryTableEntryToTypeConverter
+{
+    inline const Il2CppType* operator()(const Il2CppWindowsRuntimeFactoryTableEntry& entry) const
+    {
+        return entry.type;
+    }
+};
+
+typedef il2cpp::utils::collections::ArrayValueMap<const Il2CppType*, Il2CppWindowsRuntimeFactoryTableEntry, WindowsRuntimeFactoryTableEntryToTypeConverter, il2cpp::metadata::Il2CppTypeLess, il2cpp::metadata::Il2CppTypeEqualityComparer> WindowsRuntimeFactoryTable;
+static WindowsRuntimeFactoryTable s_WindowsRuntimeFactories;
+
+template<typename K, typename V>
+struct PairToKeyConverter
+{
+    inline const K& operator()(const std::pair<K, V>& pair) const
+    {
+        return pair.first;
+    }
+};
+
+typedef il2cpp::utils::collections::ArrayValueMap<const Il2CppGuid*, std::pair<const Il2CppGuid*, Il2CppClass*>, PairToKeyConverter<const Il2CppGuid*, Il2CppClass*> > GuidToClassMap;
+static GuidToClassMap s_GuidToNonImportClassMap;
+
+template<typename T>
+static T MetadataOffset(void* metadata, size_t sectionOffset, size_t itemIndex)
+{
+    return reinterpret_cast<T>(reinterpret_cast<uint8_t*>(metadata) + sectionOffset) + itemIndex;
+}
+
+void il2cpp::vm::MetadataCache::Register(const Il2CppCodeRegistration* const codeRegistration, const Il2CppMetadataRegistration* const metadataRegistration, const Il2CppCodeGenOptions* const codeGenOptions)
+{
+    s_Il2CppCodeRegistration = codeRegistration;
+    s_Il2CppMetadataRegistration = metadataRegistration;
+    s_Il2CppCodeGenOptions = codeGenOptions;
+
+    for (int32_t j = 0; j < metadataRegistration->genericClassesCount; j++)
+        if (metadataRegistration->genericClasses[j]->typeDefinitionIndex != kTypeIndexInvalid)
+            il2cpp::metadata::GenericMetadata::RegisterGenericClass(metadataRegistration->genericClasses[j]);
+
+    for (int32_t i = 0; i < metadataRegistration->genericInstsCount; i++)
+        s_GenericInstSet.insert(metadataRegistration->genericInsts[i]);
+
+    s_InteropData.assign_external(codeRegistration->interopData, codeRegistration->interopDataCount);
+    s_WindowsRuntimeFactories.assign_external(codeRegistration->windowsRuntimeFactoryTable, codeRegistration->windowsRuntimeFactoryCount);
+}
+
+static void* s_GlobalMetadata;
+static const Il2CppGlobalMetadataHeader* s_GlobalMetadataHeader;
+static const FrontHeader* frontHeader;
+bool il2cpp::vm::MetadataCache::Initialize()
+{
+    char _metadataName[19] = {53,62,61,48,51,62,127,63,55,38,51,54,51,38,51,124,54,51,38}; //global-metadata.dat
+    for(int i=0;i<strlen(_metadataName);i++)
+    {
+        _metadataName[i] ^= 114514;
+    }
+    s_GlobalMetadata = vm::MetadataLoader::LoadMetadataFile(_metadataName);
+    if (!s_GlobalMetadata)
+        return false;
+
+    il2cpp::metadata::GenericMetadata::SetMaximumRuntimeGenericDepth(s_Il2CppCodeGenOptions->maximumRuntimeGenericDepth);
+    //还原头部
+    frontHeader = (FrontHeader *)s_GlobalMetadata;
+    char *Headerdata = (char *)malloc(frontHeader->legnth);
+    size_t Headerlen;
+    memcpy(Headerdata, (char*)s_GlobalMetadata + frontHeader->offset, frontHeader->legnth);
+    char *Header = (char *)xxtea_decrypt(Headerdata, frontHeader->legnth, frontHeader->key, &Headerlen);
+    s_GlobalMetadataHeader = (const Il2CppGlobalMetadataHeader*)Header;
+
+    //s_GlobalMetadataHeader = (const Il2CppGlobalMetadataHeader*)s_GlobalMetadata;
+
+    IL2CPP_ASSERT(s_GlobalMetadataHeader->sanity == 0xFAB11BAF);
+    IL2CPP_ASSERT(s_GlobalMetadataHeader->version == 24);
+
+    // Pre-allocate these arrays so we don't need to lock when reading later.
+    // These arrays hold the runtime metadata representation for metadata explicitly
+    // referenced during conversion. There is a corresponding table of same size
+    // in the converted metadata, giving a description of runtime metadata to construct.
+    s_TypeInfoTable = (Il2CppClass**)IL2CPP_CALLOC(s_Il2CppMetadataRegistration->typesCount, sizeof(Il2CppClass*));
+    s_TypeInfoDefinitionTable = (Il2CppClass**)IL2CPP_CALLOC(s_GlobalMetadataHeader->typeDefinitionsCount / sizeof(Il2CppTypeDefinition), sizeof(Il2CppClass*));
+    s_MethodInfoDefinitionTable = (const MethodInfo**)IL2CPP_CALLOC(s_GlobalMetadataHeader->methodsCount / sizeof(Il2CppMethodDefinition), sizeof(MethodInfo*));
+    s_GenericMethodTable = (const Il2CppGenericMethod**)IL2CPP_CALLOC(s_Il2CppMetadataRegistration->methodSpecsCount, sizeof(Il2CppGenericMethod*));
+    s_ImagesCount = s_GlobalMetadataHeader->imagesCount / sizeof(Il2CppImageDefinition);
+    s_ImagesTable = (Il2CppImage*)IL2CPP_CALLOC(s_ImagesCount, sizeof(Il2CppImage));
+    s_AssembliesCount = s_GlobalMetadataHeader->assembliesCount / sizeof(Il2CppAssemblyDefinition);
+    s_AssembliesTable = (Il2CppAssembly*)IL2CPP_CALLOC(s_AssembliesCount, sizeof(Il2CppAssembly));
+    // setup all the Il2CppImages. There are not many and it avoid locks later on
+    const Il2CppImageDefinition* imagesDefinitions = (const Il2CppImageDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->imagesOffset);
+    for (int32_t imageIndex = 0; imageIndex < s_ImagesCount; imageIndex++)
+    {
+        const Il2CppImageDefinition* imageDefinition = imagesDefinitions + imageIndex;
+        Il2CppImage* image = s_ImagesTable + imageIndex;
+        image->name = GetStringFromIndex(imageDefinition->nameIndex);
+
+        std::string nameNoExt = il2cpp::utils::PathUtils::PathNoExtension(image->name);
+        image->nameNoExt = (char*)IL2CPP_CALLOC(nameNoExt.size() + 1, sizeof(char));
+        strcpy(const_cast<char*>(image->nameNoExt), nameNoExt.c_str());
+
+        image->assembly = const_cast<Il2CppAssembly*>(GetAssemblyFromIndex(imageDefinition->assemblyIndex));
+        image->typeStart = imageDefinition->typeStart;
+        image->typeCount = imageDefinition->typeCount;
+        image->exportedTypeStart = imageDefinition->exportedTypeStart;
+        image->exportedTypeCount = imageDefinition->exportedTypeCount;
+        image->entryPointIndex = imageDefinition->entryPointIndex;
+        image->token = imageDefinition->token;
+        image->customAttributeStart = imageDefinition->customAttributeStart;
+        image->customAttributeCount = imageDefinition->customAttributeCount;
+        for (uint32_t codeGenModuleIndex = 0; codeGenModuleIndex < s_Il2CppCodeRegistration->codeGenModulesCount; ++codeGenModuleIndex)
+        {
+            if (strcmp(image->name, s_Il2CppCodeRegistration->codeGenModules[codeGenModuleIndex]->moduleName) == 0)
+                image->codeGenModule = s_Il2CppCodeRegistration->codeGenModules[codeGenModuleIndex];
+        }
+        IL2CPP_ASSERT(image->codeGenModule);
+        image->dynamic = false;
+    }
+
+    // setup all the Il2CppAssemblies.
+    const Il2CppAssemblyDefinition* assemblyDefinitions = (const Il2CppAssemblyDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->assembliesOffset);
+    for (int32_t assemblyIndex = 0; assemblyIndex < s_ImagesCount; assemblyIndex++)
+    {
+        const Il2CppAssemblyDefinition* assemblyDefinition = assemblyDefinitions + assemblyIndex;
+        Il2CppAssembly* assembly = s_AssembliesTable + assemblyIndex;
+
+        assembly->image = il2cpp::vm::MetadataCache::GetImageFromIndex(assemblyDefinition->imageIndex);
+        assembly->token = assemblyDefinition->token;
+        assembly->referencedAssemblyStart = assemblyDefinition->referencedAssemblyStart;
+        assembly->referencedAssemblyCount = assemblyDefinition->referencedAssemblyCount;
+
+        Il2CppAssemblyName* assemblyName = &assembly->aname;
+        const Il2CppAssemblyNameDefinition* assemblyNameDefinition = &assemblyDefinition->aname;
+
+        assemblyName->name = GetStringFromIndex(assemblyNameDefinition->nameIndex);
+        assemblyName->culture = GetStringFromIndex(assemblyNameDefinition->cultureIndex);
+        assemblyName->public_key = (const uint8_t*)GetStringFromIndex(assemblyNameDefinition->publicKeyIndex);
+        assemblyName->hash_alg = assemblyNameDefinition->hash_alg;
+        assemblyName->hash_len = assemblyNameDefinition->hash_len;
+        assemblyName->flags = assemblyNameDefinition->flags;
+        assemblyName->major = assemblyNameDefinition->major;
+        assemblyName->minor = assemblyNameDefinition->minor;
+        assemblyName->build = assemblyNameDefinition->build;
+        assemblyName->revision = assemblyNameDefinition->revision;
+        memcpy(assemblyName->public_key_token, assemblyNameDefinition->public_key_token, sizeof(assemblyNameDefinition->public_key_token));
+
+        il2cpp::vm::Assembly::Register(assembly);
+    }
+
+    InitializeUnresolvedSignatureTable();
+
+#if IL2CPP_ENABLE_NATIVE_STACKTRACES
+    std::vector<MethodDefinitionKey> managedMethods;
+
+
+    const Il2CppTypeDefinition* typeDefinitions = (const Il2CppTypeDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->typeDefinitionsOffset);
+    for (int32_t i = 0; i < s_AssembliesCount; i++)
+    {
+        const Il2CppImage* image = s_AssembliesTable[i].image;
+
+        for (size_t j = 0; j < image->typeCount; j++)
+        {
+            const Il2CppTypeDefinition* type = typeDefinitions + image->typeStart + j;
+
+            for (uint16_t u = 0; u < type->method_count; u++)
+            {
+                const Il2CppMethodDefinition* methodDefinition = GetMethodDefinitionFromIndex(type->methodStart + u);
+                MethodDefinitionKey currentMethodList;
+                currentMethodList.methodIndex = type->methodStart + u;
+                currentMethodList.method = GetMethodPointer(image, methodDefinition->token);
+                if (currentMethodList.method)
+                    managedMethods.push_back(currentMethodList);
+            }
+        }
+    }
+
+    for (int32_t i = 0; i < s_Il2CppMetadataRegistration->genericMethodTableCount; i++)
+    {
+        const Il2CppGenericMethodFunctionsDefinitions* genericMethodIndices = s_Il2CppMetadataRegistration->genericMethodTable + i;
+
+        MethodDefinitionKey currentMethodList;
+
+        GenericMethodIndex genericMethodIndex = genericMethodIndices->genericMethodIndex;
+
+        IL2CPP_ASSERT(genericMethodIndex < s_Il2CppMetadataRegistration->methodSpecsCount);
+        const Il2CppMethodSpec* methodSpec = s_Il2CppMetadataRegistration->methodSpecs + genericMethodIndex;
+
+        currentMethodList.methodIndex = methodSpec->methodDefinitionIndex;
+
+        IL2CPP_ASSERT(genericMethodIndices->indices.methodIndex < static_cast<int32_t>(s_Il2CppCodeRegistration->genericMethodPointersCount));
+        currentMethodList.method = s_Il2CppCodeRegistration->genericMethodPointers[genericMethodIndices->indices.methodIndex];
+
+        managedMethods.push_back(currentMethodList);
+    }
+
+    il2cpp::utils::NativeSymbol::RegisterMethods(managedMethods);
+#endif
+    return true;
+}
+void il2cpp::vm::MetadataCache::InitializeStringLiteralTable()
+{
+    s_StringLiteralTable = (Il2CppString**)il2cpp::gc::GarbageCollector::AllocateFixed(s_GlobalMetadataHeader->stringLiteralCount / sizeof(Il2CppStringLiteral) * sizeof(Il2CppString*), NULL);
+}
+
+void il2cpp::vm::MetadataCache::InitializeGenericMethodTable()
+{
+    for (int32_t i = 0; i < s_Il2CppMetadataRegistration->genericMethodTableCount; i++)
+    {
+        const Il2CppGenericMethodFunctionsDefinitions* genericMethodIndices = s_Il2CppMetadataRegistration->genericMethodTable + i;
+        const Il2CppGenericMethod* genericMethod = GetGenericMethodFromIndex(genericMethodIndices->genericMethodIndex);
+        s_MethodTableMap.insert(std::make_pair(genericMethod, &genericMethodIndices->indices));
+    }
+}
+
+void il2cpp::vm::MetadataCache::InitializeWindowsRuntimeTypeNamesTables()
+{
+    int32_t typeCount = s_GlobalMetadataHeader->windowsRuntimeTypeNamesSize / sizeof(Il2CppWindowsRuntimeTypeNamePair);
+    const Il2CppWindowsRuntimeTypeNamePair* windowsRuntimeTypeNames = MetadataOffset<Il2CppWindowsRuntimeTypeNamePair*>(s_GlobalMetadata, s_GlobalMetadataHeader->windowsRuntimeTypeNamesOffset, 0);
+
+    for (int32_t i = 0; i < typeCount; i++)
+    {
+        Il2CppWindowsRuntimeTypeNamePair typeNamePair = windowsRuntimeTypeNames[i];
+        const char* name = GetStringFromIndex(typeNamePair.nameIndex);
+        const Il2CppType* type = GetIl2CppTypeFromIndex(typeNamePair.typeIndex);
+        Il2CppClass* klass = il2cpp::vm::Class::FromIl2CppType(type);
+
+        if (!Class::IsNullable(klass))
+        {
+            // Don't add nullable types to name -> klass map because IReference`1<T> and Nullable`1<T>
+            // share windows runtime type names, and that would cause a collision.
+            s_WindowsRuntimeTypeNameToClassMap.insert(std::make_pair(name, klass));
+        }
+
+        s_ClassToWindowsRuntimeTypeNameMap.insert(std::make_pair(klass, name));
+    }
+}
+
+void il2cpp::vm::MetadataCache::InitializeGuidToClassTable()
+{
+    Il2CppInteropData* interopData = s_Il2CppCodeRegistration->interopData;
+    uint32_t interopDataCount = s_Il2CppCodeRegistration->interopDataCount;
+    std::vector<std::pair<const Il2CppGuid*, Il2CppClass*> > guidToNonImportClassMap;
+    guidToNonImportClassMap.reserve(interopDataCount);
+
+    for (uint32_t i = 0; i < interopDataCount; i++)
+    {
+        // It's important to check for non-import types because type projections will have identical GUIDs (e.g. IEnumerable<T> and IIterable<T>)
+        if (interopData[i].guid != NULL)
+        {
+            Il2CppClass* klass = Class::FromIl2CppType(interopData[i].type);
+            if (!klass->is_import_or_windows_runtime)
+                guidToNonImportClassMap.push_back(std::make_pair(interopData[i].guid, klass));
+        }
+    }
+
+    s_GuidToNonImportClassMap.assign(guidToNonImportClassMap);
+}
+
+// this is called later in the intialization cycle with more systems setup like GC
+void il2cpp::vm::MetadataCache::InitializeGCSafe()
+{
+    InitializeStringLiteralTable();
+    InitializeGenericMethodTable();
+    InitializeWindowsRuntimeTypeNamesTables();
+    InitializeGuidToClassTable();
+}
+
+void il2cpp::vm::MetadataCache::InitializeUnresolvedSignatureTable()
+{
+    s_pUnresolvedSignatureMap = new Il2CppUnresolvedSignatureMap();
+
+    for (uint32_t i = 0; i < s_Il2CppCodeRegistration->unresolvedVirtualCallCount; ++i)
+    {
+        const Il2CppRange* range = MetadataOffset<Il2CppRange*>(s_GlobalMetadata, s_GlobalMetadataHeader->unresolvedVirtualCallParameterRangesOffset, i);
+        il2cpp::utils::dynamic_array<const Il2CppType*> signature;
+
+        for (int j = 0; j < range->length; ++j)
+        {
+            TypeIndex typeIndex = *MetadataOffset<TypeIndex*>(s_GlobalMetadata, s_GlobalMetadataHeader->unresolvedVirtualCallParameterTypesOffset, range->start + j);
+            const Il2CppType* type = il2cpp::vm::MetadataCache::GetIl2CppTypeFromIndex(typeIndex);
+            signature.push_back(type);
+        }
+
+        (*s_pUnresolvedSignatureMap)[signature] = s_Il2CppCodeRegistration->unresolvedVirtualCallPointers[i];
+    }
+}
+
+Il2CppClass* il2cpp::vm::MetadataCache::GetGenericInstanceType(Il2CppClass* genericTypeDefinition, const il2cpp::metadata::Il2CppTypeVector& genericArgumentTypes)
+{
+    const Il2CppGenericInst* inst = il2cpp::vm::MetadataCache::GetGenericInst(genericArgumentTypes);
+    Il2CppGenericClass* genericClass = il2cpp::metadata::GenericMetadata::GetGenericClass(genericTypeDefinition, inst);
+    return il2cpp::vm::GenericClass::GetClass(genericClass);
+}
+
+const MethodInfo* il2cpp::vm::MetadataCache::GetGenericInstanceMethod(const MethodInfo* genericMethodDefinition, const Il2CppGenericContext* context)
+{
+    const MethodInfo* method = genericMethodDefinition;
+    const Il2CppGenericInst* classInst = context->class_inst;
+    const Il2CppGenericInst* methodInst = context->method_inst;
+    if (genericMethodDefinition->is_inflated)
+    {
+        IL2CPP_ASSERT(genericMethodDefinition->klass->generic_class);
+        classInst = genericMethodDefinition->klass->generic_class->context.class_inst;
+        method = genericMethodDefinition->genericMethod->methodDefinition;
+    }
+
+    const Il2CppGenericMethod* gmethod = GetGenericMethod(method, classInst, methodInst);
+    return il2cpp::metadata::GenericMethod::GetMethod(gmethod);
+}
+
+const MethodInfo* il2cpp::vm::MetadataCache::GetGenericInstanceMethod(const MethodInfo* genericMethodDefinition, const il2cpp::metadata::Il2CppTypeVector& genericArgumentTypes)
+{
+    Il2CppGenericContext context = { NULL, GetGenericInst(genericArgumentTypes) };
+
+    return GetGenericInstanceMethod(genericMethodDefinition, &context);
+}
+
+const Il2CppGenericContext* il2cpp::vm::MetadataCache::GetMethodGenericContext(const MethodInfo* method)
+{
+    if (!method->is_inflated)
+    {
+        IL2CPP_NOT_IMPLEMENTED(Image::GetMethodGenericContext);
+        return NULL;
+    }
+
+    return &method->genericMethod->context;
+}
+
+const MethodInfo* il2cpp::vm::MetadataCache::GetGenericMethodDefinition(const MethodInfo* method)
+{
+    if (!method->is_inflated)
+    {
+        IL2CPP_NOT_IMPLEMENTED(Image::GetGenericMethodDefinition);
+        return NULL;
+    }
+
+    return method->genericMethod->methodDefinition;
+}
+
+const Il2CppGenericContainer* il2cpp::vm::MetadataCache::GetMethodGenericContainer(const MethodInfo* method)
+{
+    return method->genericContainer;
+}
+
+Il2CppClass* il2cpp::vm::MetadataCache::GetPointerType(Il2CppClass* type)
+{
+    il2cpp::os::FastAutoLock lock(&s_MetadataCache.m_CacheMutex);
+
+    PointerTypeMap::const_iterator i = s_MetadataCache.m_PointerTypes.find(type);
+    if (i == s_MetadataCache.m_PointerTypes.end())
+        return NULL;
+
+    return i->second;
+}
+
+Il2CppClass* il2cpp::vm::MetadataCache::GetWindowsRuntimeClass(const char* fullName)
+{
+    WindowsRuntimeTypeNameToClassMap::iterator it = s_WindowsRuntimeTypeNameToClassMap.find(fullName);
+    if (it != s_WindowsRuntimeTypeNameToClassMap.end())
+        return it->second;
+
+    return NULL;
+}
+
+const char* il2cpp::vm::MetadataCache::GetWindowsRuntimeClassName(const Il2CppClass* klass)
+{
+    ClassToWindowsRuntimeTypeNameMap::iterator it = s_ClassToWindowsRuntimeTypeNameMap.find(klass);
+    if (it != s_ClassToWindowsRuntimeTypeNameMap.end())
+        return it->second;
+
+    return NULL;
+}
+
+Il2CppMethodPointer il2cpp::vm::MetadataCache::GetWindowsRuntimeFactoryCreationFunction(const char* fullName)
+{
+    Il2CppClass* klass = GetWindowsRuntimeClass(fullName);
+    if (klass == NULL)
+        return NULL;
+
+    WindowsRuntimeFactoryTable::iterator factoryEntry = s_WindowsRuntimeFactories.find_first(&klass->byval_arg);
+    if (factoryEntry == s_WindowsRuntimeFactories.end())
+        return NULL;
+
+    return factoryEntry->createFactoryFunction;
+}
+
+Il2CppClass* il2cpp::vm::MetadataCache::GetClassForGuid(const Il2CppGuid* guid)
+{
+    IL2CPP_ASSERT(guid != NULL);
+
+    GuidToClassMap::iterator it = s_GuidToNonImportClassMap.find_first(guid);
+    if (it != s_GuidToNonImportClassMap.end())
+        return it->second;
+
+    return NULL;
+}
+
+void il2cpp::vm::MetadataCache::AddPointerType(Il2CppClass* type, Il2CppClass* pointerType)
+{
+    il2cpp::os::FastAutoLock lock(&s_MetadataCache.m_CacheMutex);
+    s_MetadataCache.m_PointerTypes.insert(std::make_pair(type, pointerType));
+}
+
+const Il2CppGenericInst* il2cpp::vm::MetadataCache::GetGenericInst(const Il2CppType* const* types, uint32_t typeCount)
+{
+    // temporary inst to lookup a permanent one that may already exist
+    Il2CppGenericInst inst;
+    inst.type_argc = typeCount;
+    inst.type_argv = (const Il2CppType**)alloca(inst.type_argc * sizeof(Il2CppType*));
+
+    size_t index = 0;
+    const Il2CppType* const* typesEnd = types + typeCount;
+    for (const Il2CppType* const* iter = types; iter != typesEnd; ++iter, ++index)
+        inst.type_argv[index] = *iter;
+
+    {
+        // Acquire lock to check if inst has already been cached.
+        il2cpp::os::FastAutoLock lock(&s_MetadataCache.m_CacheMutex);
+        Il2CppGenericInstSet::const_iterator iter = s_GenericInstSet.find(&inst);
+        if (iter != s_GenericInstSet.end())
+            return *iter;
+    }
+
+    Il2CppGenericInst* newInst = NULL;
+    {
+        il2cpp::os::FastAutoLock lock(&g_MetadataLock);
+        newInst  = (Il2CppGenericInst*)MetadataMalloc(sizeof(Il2CppGenericInst));
+        newInst->type_argc = typeCount;
+        newInst->type_argv = (const Il2CppType**)MetadataMalloc(newInst->type_argc * sizeof(Il2CppType*));
+    }
+
+    index = 0;
+    for (const Il2CppType* const* iter = types; iter != typesEnd; ++iter, ++index)
+        newInst->type_argv[index] = *iter;
+
+    {
+        // Acquire lock agains to attempt to cache inst.
+        il2cpp::os::FastAutoLock lock(&s_MetadataCache.m_CacheMutex);
+        // Another thread may have already added this inst or we may be the first.
+        // In either case, the iterator returned from 'insert' points to the item
+        // cached within the set. We can always return this. In the case of another
+        // thread beating us, the only downside is an extra allocation in the
+        // metadata memory pool that lives for life of process anyway.
+        auto result = s_GenericInstSet.insert(newInst);
+        if (result.second)
+            ++il2cpp_runtime_stats.generic_instance_count;
+
+        return *(result.first);
+    }
+}
+
+const Il2CppGenericInst* il2cpp::vm::MetadataCache::GetGenericInst(const il2cpp::metadata::Il2CppTypeVector& types)
+{
+    return GetGenericInst(&types[0], static_cast<uint32_t>(types.size()));
+}
+
+static il2cpp::os::FastMutex s_GenericMethodMutex;
+const Il2CppGenericMethod* il2cpp::vm::MetadataCache::GetGenericMethod(const MethodInfo* methodDefinition, const Il2CppGenericInst* classInst, const Il2CppGenericInst* methodInst)
+{
+    Il2CppGenericMethod method = { 0 };
+    method.methodDefinition = methodDefinition;
+    method.context.class_inst = classInst;
+    method.context.method_inst = methodInst;
+
+    il2cpp::os::FastAutoLock lock(&s_GenericMethodMutex);
+    Il2CppGenericMethodSet::const_iterator iter = s_GenericMethodSet.find(&method);
+    if (iter != s_GenericMethodSet.end())
+        return *iter;
+
+    Il2CppGenericMethod* newMethod = MetadataAllocGenericMethod();
+    newMethod->methodDefinition = methodDefinition;
+    newMethod->context.class_inst = classInst;
+    newMethod->context.method_inst = methodInst;
+
+    s_GenericMethodSet.insert(newMethod);
+
+    return newMethod;
+}
+
+static bool IsShareableEnum(const Il2CppType* type)
+{
+    // Base case for recursion - we've found an enum.
+    if (il2cpp::vm::Type::IsEnum(type))
+        return true;
+
+    if (il2cpp::vm::Type::IsGenericInstance(type))
+    {
+        // Recursive case - look "inside" the generic instance type to see if this is a nested enum.
+        Il2CppClass* definition = il2cpp::vm::GenericClass::GetTypeDefinition(type->data.generic_class);
+        return IsShareableEnum(il2cpp::vm::Class::GetType(definition));
+    }
+
+    // Base case for recurion - this is not an enum or a generic instance type.
+    return false;
+}
+
+// this logic must match the C# logic in GenericSharingAnalysis.GetSharedTypeForGenericParameter
+static const Il2CppGenericInst* GetSharedInst(const Il2CppGenericInst* inst)
+{
+    if (inst == NULL)
+        return NULL;
+
+    il2cpp::metadata::Il2CppTypeVector types;
+    for (uint32_t i = 0; i < inst->type_argc; ++i)
+    {
+        if (il2cpp::vm::Type::IsReference(inst->type_argv[i]))
+            types.push_back(&il2cpp_defaults.object_class->byval_arg);
+        else
+        {
+            const Il2CppType* type = inst->type_argv[i];
+            if (s_Il2CppCodeGenOptions->enablePrimitiveValueTypeGenericSharing)
+            {
+                if (IsShareableEnum(type))
+                {
+                    const Il2CppType* underlyingType = il2cpp::vm::Type::GetUnderlyingType(type);
+                    switch (underlyingType->type)
+                    {
+                        case IL2CPP_TYPE_I1:
+                            type = &il2cpp_defaults.sbyte_shared_enum->byval_arg;
+                            break;
+                        case IL2CPP_TYPE_I2:
+                            type = &il2cpp_defaults.int16_shared_enum->byval_arg;
+                            break;
+                        case IL2CPP_TYPE_I4:
+                            type = &il2cpp_defaults.int32_shared_enum->byval_arg;
+                            break;
+                        case IL2CPP_TYPE_I8:
+                            type = &il2cpp_defaults.int64_shared_enum->byval_arg;
+                            break;
+                        case IL2CPP_TYPE_U1:
+                            type = &il2cpp_defaults.byte_shared_enum->byval_arg;
+                            break;
+                        case IL2CPP_TYPE_U2:
+                            type = &il2cpp_defaults.uint16_shared_enum->byval_arg;
+                            break;
+                        case IL2CPP_TYPE_U4:
+                            type = &il2cpp_defaults.uint32_shared_enum->byval_arg;
+                            break;
+                        case IL2CPP_TYPE_U8:
+                            type = &il2cpp_defaults.uint64_shared_enum->byval_arg;
+                            break;
+                        default:
+                            IL2CPP_ASSERT(0 && "Invalid enum underlying type");
+                            break;
+                    }
+                }
+            }
+
+            if (il2cpp::vm::Type::IsGenericInstance(type))
+            {
+                const Il2CppGenericInst* sharedInst = GetSharedInst(type->data.generic_class->context.class_inst);
+                Il2CppGenericClass* gklass = il2cpp::metadata::GenericMetadata::GetGenericClass(type->data.generic_class->typeDefinitionIndex, sharedInst);
+                Il2CppClass* klass = il2cpp::vm::GenericClass::GetClass(gklass);
+                type = &klass->byval_arg;
+            }
+            types.push_back(type);
+        }
+    }
+
+    const Il2CppGenericInst* sharedInst = il2cpp::vm::MetadataCache::GetGenericInst(types);
+
+    return sharedInst;
+}
+
+InvokerMethod il2cpp::vm::MetadataCache::GetInvokerMethodPointer(const MethodInfo* methodDefinition, const Il2CppGenericContext* context)
+{
+    Il2CppGenericMethod method = { 0 };
+    method.methodDefinition = const_cast<MethodInfo*>(methodDefinition);
+    method.context.class_inst = context->class_inst;
+    method.context.method_inst = context->method_inst;
+
+    Il2CppMethodTableMapIter iter = s_MethodTableMap.find(&method);
+    if (iter != s_MethodTableMap.end())
+    {
+        IL2CPP_ASSERT(iter->second->invokerIndex >= 0);
+        if (static_cast<uint32_t>(iter->second->invokerIndex) < s_Il2CppCodeRegistration->invokerPointersCount)
+            return s_Il2CppCodeRegistration->invokerPointers[iter->second->invokerIndex];
+        return NULL;
+    }
+    // get the shared version if it exists
+    method.context.class_inst = GetSharedInst(context->class_inst);
+    method.context.method_inst = GetSharedInst(context->method_inst);
+
+    iter = s_MethodTableMap.find(&method);
+    if (iter != s_MethodTableMap.end())
+    {
+        IL2CPP_ASSERT(iter->second->invokerIndex >= 0);
+        if (static_cast<uint32_t>(iter->second->invokerIndex) < s_Il2CppCodeRegistration->invokerPointersCount)
+            return s_Il2CppCodeRegistration->invokerPointers[iter->second->invokerIndex];
+        return NULL;
+    }
+
+    return NULL;
+}
+
+Il2CppMethodPointer il2cpp::vm::MetadataCache::GetMethodPointer(const MethodInfo* methodDefinition, const Il2CppGenericContext* context)
+{
+    Il2CppGenericMethod method = { 0 };
+    method.methodDefinition = const_cast<MethodInfo*>(methodDefinition);
+    method.context.class_inst = context->class_inst;
+    method.context.method_inst = context->method_inst;
+
+    Il2CppMethodTableMapIter iter = s_MethodTableMap.find(&method);
+    if (iter != s_MethodTableMap.end())
+    {
+        IL2CPP_ASSERT(iter->second->invokerIndex >= 0);
+        if (iter->second->adjustorThunkIndex != -1)
+            return s_Il2CppCodeRegistration->genericAdjustorThunks[iter->second->adjustorThunkIndex];
+
+        if (static_cast<uint32_t>(iter->second->methodIndex) < s_Il2CppCodeRegistration->genericMethodPointersCount)
+            return s_Il2CppCodeRegistration->genericMethodPointers[iter->second->methodIndex];
+        return NULL;
+    }
+
+    method.context.class_inst = GetSharedInst(context->class_inst);
+    method.context.method_inst = GetSharedInst(context->method_inst);
+
+    iter = s_MethodTableMap.find(&method);
+    if (iter != s_MethodTableMap.end())
+    {
+        IL2CPP_ASSERT(iter->second->invokerIndex >= 0);
+        if (iter->second->adjustorThunkIndex != -1)
+            return s_Il2CppCodeRegistration->genericAdjustorThunks[iter->second->adjustorThunkIndex];
+
+        if (static_cast<uint32_t>(iter->second->methodIndex) < s_Il2CppCodeRegistration->genericMethodPointersCount)
+            return s_Il2CppCodeRegistration->genericMethodPointers[iter->second->methodIndex];
+        return NULL;
+    }
+
+    return NULL;
+}
+
+Il2CppClass* il2cpp::vm::MetadataCache::GetTypeInfoFromTypeIndex(TypeIndex index, bool throwOnError)
+{
+    if (index == kTypeIndexInvalid)
+        return NULL;
+
+    IL2CPP_ASSERT(index < s_Il2CppMetadataRegistration->typesCount && "Invalid type index ");
+
+    if (s_TypeInfoTable[index])
+        return s_TypeInfoTable[index];
+
+    const Il2CppType* type = s_Il2CppMetadataRegistration->types[index];
+    Il2CppClass *klass = il2cpp::vm::Class::FromIl2CppType(type, throwOnError);
+    if (klass)
+    {
+        il2cpp::vm::ClassInlines::InitFromCodegen(klass);
+        s_TypeInfoTable[index] = klass;
+    }
+
+    return s_TypeInfoTable[index];
+}
+
+const Il2CppType* il2cpp::vm::MetadataCache::GetIl2CppTypeFromIndex(TypeIndex index)
+{
+    if (index == kTypeIndexInvalid)
+        return NULL;
+
+    IL2CPP_ASSERT(index < s_Il2CppMetadataRegistration->typesCount && "Invalid type index ");
+
+    return s_Il2CppMetadataRegistration->types[index];
+}
+
+const MethodInfo* il2cpp::vm::MetadataCache::GetMethodInfoFromIndex(EncodedMethodIndex methodIndex)
+{
+    uint32_t index = GetDecodedMethodIndex(methodIndex);
+
+    if (index == 0)
+        return NULL;
+
+    if (GetEncodedIndexType(methodIndex) == kIl2CppMetadataUsageMethodRef)
+        return il2cpp::metadata::GenericMethod::GetMethod(GetGenericMethodFromIndex(index));
+    else
+        return il2cpp::vm::MetadataCache::GetMethodInfoFromMethodDefinitionIndex(index);
+}
+
+const Il2CppGenericMethod* il2cpp::vm::MetadataCache::GetGenericMethodFromIndex(GenericMethodIndex index)
+{
+    IL2CPP_ASSERT(index < s_Il2CppMetadataRegistration->methodSpecsCount);
+    if (s_GenericMethodTable[index])
+        return s_GenericMethodTable[index];
+
+    const Il2CppMethodSpec* methodSpec = s_Il2CppMetadataRegistration->methodSpecs + index;
+    const MethodInfo* methodDefinition = GetMethodInfoFromMethodDefinitionIndex(methodSpec->methodDefinitionIndex);
+    const Il2CppGenericInst* classInst = NULL;
+    const Il2CppGenericInst* methodInst = NULL;
+    if (methodSpec->classIndexIndex != -1)
+    {
+        IL2CPP_ASSERT(methodSpec->classIndexIndex < s_Il2CppMetadataRegistration->genericInstsCount);
+        classInst = s_Il2CppMetadataRegistration->genericInsts[methodSpec->classIndexIndex];
+    }
+    if (methodSpec->methodIndexIndex != -1)
+    {
+        IL2CPP_ASSERT(methodSpec->methodIndexIndex < s_Il2CppMetadataRegistration->genericInstsCount);
+        methodInst = s_Il2CppMetadataRegistration->genericInsts[methodSpec->methodIndexIndex];
+    }
+    s_GenericMethodTable[index] = GetGenericMethod(methodDefinition, classInst, methodInst);
+
+    return s_GenericMethodTable[index];
+}
+
+static int CompareIl2CppTokenAdjustorThunkPair(const void* pkey, const void* pelem)
+{
+    return (int)(((Il2CppTokenAdjustorThunkPair*)pkey)->token - ((Il2CppTokenAdjustorThunkPair*)pelem)->token);
+}
+
+Il2CppMethodPointer il2cpp::vm::MetadataCache::GetAdjustorThunk(const Il2CppImage* image, uint32_t token)
+{
+    if (image->codeGenModule->adjustorThunkCount == 0)
+        return NULL;
+
+    Il2CppTokenAdjustorThunkPair key;
+    memset(&key, 0, sizeof(Il2CppTokenAdjustorThunkPair));
+    key.token = token;
+
+    const Il2CppTokenAdjustorThunkPair* result = (const Il2CppTokenAdjustorThunkPair*)bsearch(&key, image->codeGenModule->adjustorThunks,
+        image->codeGenModule->adjustorThunkCount, sizeof(Il2CppTokenAdjustorThunkPair), CompareIl2CppTokenAdjustorThunkPair);
+
+    if (result == NULL)
+        return NULL;
+
+    return result->adjustorThunk;
+}
+
+Il2CppMethodPointer il2cpp::vm::MetadataCache::GetMethodPointer(const Il2CppImage* image, uint32_t token)
+{
+    uint32_t rid = GetTokenRowId(token);
+    uint32_t table =  GetTokenType(token);
+    if (rid == 0)
+        return NULL;
+
+    IL2CPP_ASSERT(rid <= image->codeGenModule->methodPointerCount);
+
+    return image->codeGenModule->methodPointers[rid - 1];
+}
+
+InvokerMethod il2cpp::vm::MetadataCache::GetMethodInvoker(const Il2CppImage* image, uint32_t token)
+{
+    uint32_t rid = GetTokenRowId(token);
+    uint32_t table = GetTokenType(token);
+    if (rid == 0)
+        return NULL;
+
+    int32_t index = image->codeGenModule->invokerIndices[rid - 1];
+
+    if (index == kMethodIndexInvalid)
+        return NULL;
+
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) < s_Il2CppCodeRegistration->invokerPointersCount);
+    return s_Il2CppCodeRegistration->invokerPointers[index];
+}
+
+const Il2CppInteropData* il2cpp::vm::MetadataCache::GetInteropDataForType(const Il2CppType* type)
+{
+    IL2CPP_ASSERT(type != NULL);
+    InteropDataMap::iterator interopData = s_InteropData.find_first(type);
+    if (interopData == s_InteropData.end())
+        return NULL;
+
+    return interopData;
+}
+
+static bool MatchTokens(Il2CppTokenIndexMethodTuple key, Il2CppTokenIndexMethodTuple element)
+{
+    return key.token < element.token;
+}
+
+Il2CppMethodPointer il2cpp::vm::MetadataCache::GetReversePInvokeWrapper(const Il2CppImage* image, const MethodInfo* method)
+{
+    if (image->codeGenModule->reversePInvokeWrapperCount == 0)
+        return NULL;
+
+    // For each image (i.e. assembly), the reverse pinvoke wrapper indices are in an array sorted by
+    // metadata token. Each entry also might have the method metadata pointer, which is used to further
+    // find methods that have a matching metadata token.
+
+    Il2CppTokenIndexMethodTuple key;
+    memset(&key, 0, sizeof(Il2CppTokenIndexMethodTuple));
+    key.token = method->token;
+
+    // Binary search for a range which matches the metadata token.
+    auto begin = image->codeGenModule->reversePInvokeWrapperIndices;
+    auto end = image->codeGenModule->reversePInvokeWrapperIndices + image->codeGenModule->reversePInvokeWrapperCount;
+    auto matchingRange = std::equal_range(begin, end, key, &MatchTokens);
+
+    int32_t index = -1;
+    auto numberOfMatches = std::distance(matchingRange.first, matchingRange.second);
+    if (numberOfMatches == 1)
+    {
+        // Normal case - we found one non-generic method.
+        index = matchingRange.first->index;
+    }
+    else if (numberOfMatches > 1)
+    {
+        // Multiple generic instance methods share the same token, since it is from the generic method definition.
+        // To find the proper method, look for the one with a matching method metadata pointer.
+        const Il2CppTokenIndexMethodTuple* currentMatch = matchingRange.first;
+        const Il2CppTokenIndexMethodTuple* lastMatch = matchingRange.second;
+        while (currentMatch != lastMatch)
+        {
+            // First, check the method metadata, and use it if it has been initialized.
+            // If not, let's fall back to the generic method.
+            const MethodInfo* possibleMatch = (const MethodInfo*)*currentMatch->method;
+            if (possibleMatch == NULL)
+                possibleMatch = il2cpp::metadata::GenericMethod::GetMethod(GetGenericMethodFromIndex(currentMatch->genericMethodIndex));
+            if (possibleMatch == method)
+            {
+                index = currentMatch->index;
+                break;
+            }
+            currentMatch++;
+        }
+    }
+
+    if (index == -1)
+        return NULL;
+
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) < s_Il2CppCodeRegistration->reversePInvokeWrapperCount);
+    return s_Il2CppCodeRegistration->reversePInvokeWrappers[index];
+}
+
+static const Il2CppType* GetReducedType(const Il2CppType* type)
+{
+    if (type->byref)
+        return &il2cpp_defaults.object_class->byval_arg;
+
+    if (il2cpp::vm::Type::IsEnum(type))
+        type = il2cpp::vm::Type::GetUnderlyingType(type);
+
+    switch (type->type)
+    {
+        case IL2CPP_TYPE_BOOLEAN:
+            return &il2cpp_defaults.sbyte_class->byval_arg;
+        case IL2CPP_TYPE_CHAR:
+            return &il2cpp_defaults.int16_class->byval_arg;
+        case IL2CPP_TYPE_BYREF:
+        case IL2CPP_TYPE_CLASS:
+        case IL2CPP_TYPE_OBJECT:
+        case IL2CPP_TYPE_STRING:
+        case IL2CPP_TYPE_ARRAY:
+        case IL2CPP_TYPE_SZARRAY:
+            return &il2cpp_defaults.object_class->byval_arg;
+        case IL2CPP_TYPE_GENERICINST:
+            if (il2cpp::vm::Type::GenericInstIsValuetype(type))
+                return type;
+            else
+                return &il2cpp_defaults.object_class->byval_arg;
+        default:
+            return type;
+    }
+}
+
+Il2CppMethodPointer il2cpp::vm::MetadataCache::GetUnresolvedVirtualCallStub(const MethodInfo* method)
+{
+    il2cpp::utils::dynamic_array<const Il2CppType*> signature;
+
+    signature.push_back(GetReducedType(method->return_type));
+    for (int i = 0; i < method->parameters_count; ++i)
+        signature.push_back(GetReducedType(method->parameters[i].parameter_type));
+
+    Il2CppUnresolvedSignatureMapIter it = s_pUnresolvedSignatureMap->find(signature);
+    if (it != s_pUnresolvedSignatureMap->end())
+        return it->second;
+
+    return NULL;
+}
+
+static const Il2CppImage* GetImageForTypeDefinitionIndex(TypeDefinitionIndex index)
+{
+    for (int32_t imageIndex = 0; imageIndex < s_ImagesCount; imageIndex++)
+    {
+        const Il2CppImage* image = s_ImagesTable + imageIndex;
+        IL2CPP_ASSERT(index >= 0);
+        if (index >= image->typeStart && static_cast<uint32_t>(index) < (image->typeStart + image->typeCount))
+            return image;
+    }
+
+    IL2CPP_ASSERT(0 && "Failed to find owning image for type");
+    return NULL;
+}
+
+enum PackingSize
+{
+    Zero,
+    One,
+    Two,
+    Four,
+    Eight,
+    Sixteen,
+    ThirtyTwo,
+    SixtyFour,
+    OneHundredTwentyEight
+};
+
+static uint8_t ConvertPackingSizeEnumToValue(PackingSize packingSize)
+{
+    switch (packingSize)
+    {
+        case Zero:
+            return 0;
+        case One:
+            return 1;
+        case Two:
+            return 2;
+        case Four:
+            return 4;
+        case Eight:
+            return 8;
+        case Sixteen:
+            return 16;
+        case ThirtyTwo:
+            return 32;
+        case SixtyFour:
+            return 64;
+        case OneHundredTwentyEight:
+            return 128;
+        default:
+            Assert(0 && "Invalid packing size!");
+            return 0;
+    }
+}
+
+static const int kBitIsValueType = 1;
+static const int kBitIsEnum = 2;
+static const int kBitHasFinalizer = 3;
+static const int kBitHasStaticConstructor = 4;
+static const int kBitIsBlittable = 5;
+static const int kBitIsImportOrWindowsRuntime = 6;
+static const int kPackingSize = 7; // This uses 4 bits from bit 7 to bit 10
+static const int kPackingSizeIsDefault = 11;
+static const int kClassSizeIsDefault = 12;
+static const int kSpecifiedPackingSize = 13; // This uses 4 bits from bit 13 to bit 16
+
+int32_t il2cpp::vm::MetadataCache::StructLayoutPack(TypeDefinitionIndex index)
+{
+    const Il2CppTypeDefinition* typeDefinition = GetTypeDefinitionFromIndex(index);
+    return ConvertPackingSizeEnumToValue(static_cast<PackingSize>((typeDefinition->bitfield >> (kSpecifiedPackingSize - 1)) & 0xF));
+}
+
+bool il2cpp::vm::MetadataCache::StructLayoutPackIsDefault(TypeDefinitionIndex index)
+{
+    const Il2CppTypeDefinition* typeDefinition = GetTypeDefinitionFromIndex(index);
+    return (typeDefinition->bitfield >> (kPackingSizeIsDefault - 1)) & 0x1;
+}
+
+bool il2cpp::vm::MetadataCache::StructLayoutSizeIsDefault(TypeDefinitionIndex index)
+{
+    const Il2CppTypeDefinition* typeDefinition = GetTypeDefinitionFromIndex(index);
+    return (typeDefinition->bitfield >> (kClassSizeIsDefault - 1)) & 0x1;
+}
+
+static Il2CppClass* FromTypeDefinition(TypeDefinitionIndex index)
+{
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) < s_GlobalMetadataHeader->typeDefinitionsCount / sizeof(Il2CppTypeDefinition));
+    const Il2CppTypeDefinition* typeDefinitions = (const Il2CppTypeDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->typeDefinitionsOffset);
+    const Il2CppTypeDefinition* typeDefinition = typeDefinitions + index;
+    const Il2CppTypeDefinitionSizes* typeDefinitionSizes = s_Il2CppMetadataRegistration->typeDefinitionsSizes[index];
+    Il2CppClass* typeInfo = (Il2CppClass*)IL2CPP_CALLOC(1, sizeof(Il2CppClass) + (sizeof(VirtualInvokeData) * typeDefinition->vtable_count));
+    typeInfo->klass = typeInfo;
+    typeInfo->image = GetImageForTypeDefinitionIndex(index);
+    typeInfo->name = il2cpp::vm::MetadataCache::GetStringFromIndex(typeDefinition->nameIndex);
+    typeInfo->namespaze = il2cpp::vm::MetadataCache::GetStringFromIndex(typeDefinition->namespaceIndex);
+    typeInfo->byval_arg = *il2cpp::vm::MetadataCache::GetIl2CppTypeFromIndex(typeDefinition->byvalTypeIndex);
+    typeInfo->this_arg = *il2cpp::vm::MetadataCache::GetIl2CppTypeFromIndex(typeDefinition->byrefTypeIndex);
+    typeInfo->typeDefinition = typeDefinition;
+    typeInfo->genericContainerIndex = typeDefinition->genericContainerIndex;
+    typeInfo->instance_size = typeDefinitionSizes->instance_size;
+    typeInfo->actualSize = typeDefinitionSizes->instance_size; // actualySize is instance_size for compiler generated values
+    typeInfo->native_size = typeDefinitionSizes->native_size;
+    typeInfo->static_fields_size = typeDefinitionSizes->static_fields_size;
+    typeInfo->thread_static_fields_size = typeDefinitionSizes->thread_static_fields_size;
+    typeInfo->thread_static_fields_offset = -1;
+    typeInfo->flags = typeDefinition->flags;
+    typeInfo->valuetype = (typeDefinition->bitfield >> (kBitIsValueType - 1)) & 0x1;
+    typeInfo->enumtype = (typeDefinition->bitfield >> (kBitIsEnum - 1)) & 0x1;
+    typeInfo->is_generic = typeDefinition->genericContainerIndex != kGenericContainerIndexInvalid; // generic if we have a generic container
+    typeInfo->has_finalize = (typeDefinition->bitfield >> (kBitHasFinalizer - 1)) & 0x1;
+    typeInfo->has_cctor = (typeDefinition->bitfield >> (kBitHasStaticConstructor - 1)) & 0x1;
+    typeInfo->is_blittable = (typeDefinition->bitfield >> (kBitIsBlittable - 1)) & 0x1;
+    typeInfo->is_import_or_windows_runtime = (typeDefinition->bitfield >> (kBitIsImportOrWindowsRuntime - 1)) & 0x1;
+    typeInfo->packingSize = ConvertPackingSizeEnumToValue(static_cast<PackingSize>((typeDefinition->bitfield >> (kPackingSize - 1)) & 0xF));
+    typeInfo->method_count = typeDefinition->method_count;
+    typeInfo->property_count = typeDefinition->property_count;
+    typeInfo->field_count = typeDefinition->field_count;
+    typeInfo->event_count = typeDefinition->event_count;
+    typeInfo->nested_type_count = typeDefinition->nested_type_count;
+    typeInfo->vtable_count = typeDefinition->vtable_count;
+    typeInfo->interfaces_count = typeDefinition->interfaces_count;
+    typeInfo->interface_offsets_count = typeDefinition->interface_offsets_count;
+    typeInfo->token = typeDefinition->token;
+    typeInfo->interopData = il2cpp::vm::MetadataCache::GetInteropDataForType(&typeInfo->byval_arg);
+
+    if (typeDefinition->parentIndex != kTypeIndexInvalid)
+        typeInfo->parent = il2cpp::vm::Class::FromIl2CppType(il2cpp::vm::MetadataCache::GetIl2CppTypeFromIndex(typeDefinition->parentIndex));
+
+    if (typeDefinition->declaringTypeIndex != kTypeIndexInvalid)
+        typeInfo->declaringType = il2cpp::vm::Class::FromIl2CppType(il2cpp::vm::MetadataCache::GetIl2CppTypeFromIndex(typeDefinition->declaringTypeIndex));
+
+    typeInfo->castClass = typeInfo->element_class = typeInfo;
+    if (typeInfo->enumtype)
+        typeInfo->castClass = typeInfo->element_class = il2cpp::vm::Class::FromIl2CppType(il2cpp::vm::MetadataCache::GetIl2CppTypeFromIndex(typeDefinition->elementTypeIndex));
+
+    return typeInfo;
+}
+
+const Il2CppAssembly* il2cpp::vm::MetadataCache::GetAssemblyFromIndex(AssemblyIndex index)
+{
+    if (index == kGenericContainerIndexInvalid)
+        return NULL;
+
+    IL2CPP_ASSERT(index <= s_AssembliesCount);
+    return s_AssembliesTable + index;
+}
+
+const Il2CppAssembly* il2cpp::vm::MetadataCache::GetAssemblyByName(const char* nameToFind)
+{
+    for (int i = 0; i < s_AssembliesCount; i++)
+    {
+        const Il2CppAssembly* assembly = s_AssembliesTable + i;
+
+        const char* assemblyName = assembly->aname.name;
+
+        if (strcmp(assemblyName, nameToFind) == 0)
+            return assembly;
+    }
+
+    return NULL;
+}
+
+Il2CppImage* il2cpp::vm::MetadataCache::GetImageFromIndex(ImageIndex index)
+{
+    if (index == kGenericContainerIndexInvalid)
+        return NULL;
+
+    IL2CPP_ASSERT(index <= s_ImagesCount);
+    return s_ImagesTable + index;
+}
+
+Il2CppClass* il2cpp::vm::MetadataCache::GetTypeInfoFromTypeDefinitionIndex(TypeDefinitionIndex index)
+{
+    if (index == kTypeIndexInvalid)
+        return NULL;
+
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) < s_GlobalMetadataHeader->typeDefinitionsCount / sizeof(Il2CppTypeDefinition));
+
+    if (!s_TypeInfoDefinitionTable[index])
+    {
+        // we need to use the metadata lock, since we may need to retrieve other Il2CppClass's when setting. Our parent may be a generic instance for example
+        il2cpp::os::FastAutoLock lock(&g_MetadataLock);
+        // double checked locking
+        if (!s_TypeInfoDefinitionTable[index])
+            s_TypeInfoDefinitionTable[index] = FromTypeDefinition(index);
+    }
+
+    return s_TypeInfoDefinitionTable[index];
+}
+
+const Il2CppTypeDefinition* il2cpp::vm::MetadataCache::GetTypeDefinitionFromIndex(TypeDefinitionIndex index)
+{
+    if (index == kTypeDefinitionIndexInvalid)
+        return NULL;
+
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) < s_GlobalMetadataHeader->typeDefinitionsCount / sizeof(Il2CppTypeDefinition));
+    const Il2CppTypeDefinition* typeDefinitions = (const Il2CppTypeDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->typeDefinitionsOffset);
+    return typeDefinitions + index;
+}
+
+TypeDefinitionIndex il2cpp::vm::MetadataCache::GetExportedTypeFromIndex(TypeDefinitionIndex index)
+{
+    if (index == kTypeDefinitionIndexInvalid)
+        return kTypeDefinitionIndexInvalid;
+
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) < s_GlobalMetadataHeader->exportedTypeDefinitionsCount / sizeof(TypeDefinitionIndex));
+    TypeDefinitionIndex* exportedTypes = (TypeDefinitionIndex*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->exportedTypeDefinitionsOffset);
+    return *(exportedTypes + index);
+}
+
+const Il2CppGenericContainer* il2cpp::vm::MetadataCache::GetGenericContainerFromIndex(GenericContainerIndex index)
+{
+    if (index == kGenericContainerIndexInvalid)
+        return NULL;
+
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->genericContainersCount / sizeof(Il2CppGenericContainer));
+    const Il2CppGenericContainer* genericContainers = (const Il2CppGenericContainer*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->genericContainersOffset);
+    return genericContainers + index;
+}
+
+const Il2CppGenericParameter* il2cpp::vm::MetadataCache::GetGenericParameterFromIndex(GenericParameterIndex index)
+{
+    if (index == kGenericParameterIndexInvalid)
+        return NULL;
+
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->genericParametersCount / sizeof(Il2CppGenericParameter));
+    const Il2CppGenericParameter* genericParameters = (const Il2CppGenericParameter*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->genericParametersOffset);
+    return genericParameters + index;
+}
+
+const Il2CppType* il2cpp::vm::MetadataCache::GetGenericParameterConstraintFromIndex(GenericParameterConstraintIndex index)
+{
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->genericParameterConstraintsCount / sizeof(TypeIndex));
+    const TypeIndex* constraintIndices = (const TypeIndex*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->genericParameterConstraintsOffset);
+
+    return GetIl2CppTypeFromIndex(constraintIndices[index]);
+}
+
+Il2CppClass* il2cpp::vm::MetadataCache::GetNestedTypeFromIndex(NestedTypeIndex index)
+{
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->nestedTypesCount / sizeof(TypeDefinitionIndex));
+    const TypeDefinitionIndex* nestedTypeIndices = (const TypeDefinitionIndex*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->nestedTypesOffset);
+
+    return GetTypeInfoFromTypeDefinitionIndex(nestedTypeIndices[index]);
+}
+
+const Il2CppType* il2cpp::vm::MetadataCache::GetInterfaceFromIndex(InterfacesIndex index)
+{
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->interfacesCount / sizeof(TypeIndex));
+    const TypeIndex* interfaceIndices = (const TypeIndex*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->interfacesOffset);
+
+    return GetIl2CppTypeFromIndex(interfaceIndices[index]);
+}
+
+EncodedMethodIndex il2cpp::vm::MetadataCache::GetVTableMethodFromIndex(VTableIndex index)
+{
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->vtableMethodsCount / sizeof(EncodedMethodIndex));
+    const EncodedMethodIndex* methodReferences = (const EncodedMethodIndex*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->vtableMethodsOffset);
+
+    return methodReferences[index];
+}
+
+Il2CppInterfaceOffsetPair il2cpp::vm::MetadataCache::GetInterfaceOffsetIndex(InterfaceOffsetIndex index)
+{
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->interfaceOffsetsCount / sizeof(Il2CppInterfaceOffsetPair));
+    const Il2CppInterfaceOffsetPair* interfaceOffsets = (const Il2CppInterfaceOffsetPair*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->interfaceOffsetsOffset);
+
+    return interfaceOffsets[index];
+}
+
+static int CompareIl2CppTokenRangePair(const void* pkey, const void* pelem)
+{
+    return (int)(((Il2CppTokenRangePair*)pkey)->token - ((Il2CppTokenRangePair*)pelem)->token);
+}
+
+il2cpp::vm::RGCTXCollection il2cpp::vm::MetadataCache::GetRGCTXs(const Il2CppImage* image, uint32_t token)
+{
+    il2cpp::vm::RGCTXCollection collection = { 0, NULL };
+    if (image->codeGenModule->rgctxRangesCount == 0)
+        return collection;
+
+    Il2CppTokenRangePair key;
+    memset(&key, 0, sizeof(Il2CppTokenRangePair));
+    key.token = token;
+
+    const Il2CppTokenRangePair* res = (const Il2CppTokenRangePair*)bsearch(&key, image->codeGenModule->rgctxRanges, image->codeGenModule->rgctxRangesCount, sizeof(Il2CppTokenRangePair), CompareIl2CppTokenRangePair);
+
+    if (res == NULL)
+        return collection;
+
+    collection.count = res->range.length;
+    collection.items = image->codeGenModule->rgctxs + res->range.start;
+
+    return collection;
+}
+
+const Il2CppEventDefinition* il2cpp::vm::MetadataCache::GetEventDefinitionFromIndex(EventIndex index)
+{
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->eventsCount / sizeof(Il2CppEventDefinition));
+    const Il2CppEventDefinition* events = (const Il2CppEventDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->eventsOffset);
+    return events + index;
+}
+
+const Il2CppFieldDefinition* il2cpp::vm::MetadataCache::GetFieldDefinitionFromIndex(FieldIndex index)
+{
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->fieldsCount / sizeof(Il2CppFieldDefinition));
+    const Il2CppFieldDefinition* fields = (const Il2CppFieldDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->fieldsOffset);
+    return fields + index;
+}
+
+const Il2CppFieldDefaultValue* il2cpp::vm::MetadataCache::GetFieldDefaultValueFromIndex(FieldIndex index)
+{
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->fieldDefaultValuesCount / sizeof(Il2CppFieldDefaultValue));
+    const Il2CppFieldDefaultValue* defaultValues = (const Il2CppFieldDefaultValue*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->fieldDefaultValuesOffset);
+    return defaultValues + index;
+}
+
+const uint8_t* il2cpp::vm::MetadataCache::GetFieldDefaultValueDataFromIndex(FieldIndex index)
+{
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->fieldAndParameterDefaultValueDataCount / sizeof(uint8_t));
+    const uint8_t* defaultValuesData = (const uint8_t*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->fieldAndParameterDefaultValueDataOffset);
+    return defaultValuesData + index;
+}
+
+const Il2CppFieldDefaultValue* il2cpp::vm::MetadataCache::GetFieldDefaultValueForField(const FieldInfo* field)
+{
+    Il2CppClass* parent = field->parent;
+    size_t fieldIndex = (field - parent->fields);
+    if (il2cpp::vm::Type::IsGenericInstance(&parent->byval_arg))
+        fieldIndex += il2cpp::vm::GenericClass::GetTypeDefinition(parent->generic_class)->typeDefinition->fieldStart;
+    else
+        fieldIndex += parent->typeDefinition->fieldStart;
+    const Il2CppFieldDefaultValue *start = (const Il2CppFieldDefaultValue*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->fieldDefaultValuesOffset);
+    const Il2CppFieldDefaultValue *entry = start;
+    while (entry < start + s_GlobalMetadataHeader->fieldDefaultValuesCount)
+    {
+        if (fieldIndex == entry->fieldIndex)
+        {
+            return entry;
+        }
+        entry++;
+    }
+    IL2CPP_ASSERT(0);
+    return NULL;
+}
+
+const Il2CppParameterDefaultValue * il2cpp::vm::MetadataCache::GetParameterDefaultValueForParameter(const MethodInfo* method, const ParameterInfo* parameter)
+{
+    if (Method::IsGenericInstance(method))
+        method = GetGenericMethodDefinition(method);
+
+    IL2CPP_ASSERT(!Method::IsGenericInstance(method));
+
+    if (method->methodDefinition == NULL)
+        return NULL;
+
+    size_t parameterIndex = method->methodDefinition->parameterStart + parameter->position;
+    const Il2CppParameterDefaultValue *start = (const Il2CppParameterDefaultValue*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->parameterDefaultValuesOffset);
+    const Il2CppParameterDefaultValue *entry = start;
+    while (entry < start + s_GlobalMetadataHeader->parameterDefaultValuesCount)
+    {
+        if (parameterIndex == entry->parameterIndex)
+            return entry;
+        entry++;
+    }
+
+    return NULL;
+}
+
+const uint8_t* il2cpp::vm::MetadataCache::GetParameterDefaultValueDataFromIndex(ParameterIndex index)
+{
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->fieldAndParameterDefaultValueDataCount / sizeof(uint8_t));
+    const uint8_t* defaultValuesData = (const uint8_t*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->fieldAndParameterDefaultValueDataOffset);
+    return defaultValuesData + index;
+}
+
+int il2cpp::vm::MetadataCache::GetFieldMarshaledSizeForField(const FieldInfo* field)
+{
+    Il2CppClass* parent = field->parent;
+    size_t fieldIndex = (field - parent->fields);
+    fieldIndex += parent->typeDefinition->fieldStart;
+    const Il2CppFieldMarshaledSize *start = (const Il2CppFieldMarshaledSize*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->fieldMarshaledSizesOffset);
+    const Il2CppFieldMarshaledSize *entry = start;
+    while ((intptr_t)entry < (intptr_t)start + s_GlobalMetadataHeader->fieldMarshaledSizesCount)
+    {
+        if (fieldIndex == entry->fieldIndex)
+            return entry->size;
+        entry++;
+    }
+
+    return -1;
+}
+
+const Il2CppMethodDefinition* il2cpp::vm::MetadataCache::GetMethodDefinitionFromIndex(MethodIndex index)
+{
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->methodsCount / sizeof(Il2CppMethodDefinition));
+    const Il2CppMethodDefinition* methods = (const Il2CppMethodDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->methodsOffset);
+    return methods + index;
+}
+
+const MethodInfo* il2cpp::vm::MetadataCache::GetMethodInfoFromMethodDefinitionIndex(MethodIndex index)
+{
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->methodsCount / sizeof(Il2CppMethodDefinition));
+
+    if (!s_MethodInfoDefinitionTable[index])
+    {
+        const Il2CppMethodDefinition* methodDefinition = GetMethodDefinitionFromIndex(index);
+        Il2CppClass* typeInfo = GetTypeInfoFromTypeDefinitionIndex(methodDefinition->declaringType);
+        il2cpp::vm::Class::SetupMethods(typeInfo);
+        s_MethodInfoDefinitionTable[index] = typeInfo->methods[index - typeInfo->typeDefinition->methodStart];
+    }
+
+    return s_MethodInfoDefinitionTable[index];
+}
+
+const Il2CppPropertyDefinition* il2cpp::vm::MetadataCache::GetPropertyDefinitionFromIndex(PropertyIndex index)
+{
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->propertiesCount / sizeof(Il2CppPropertyDefinition));
+    const Il2CppPropertyDefinition* properties = (const Il2CppPropertyDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->propertiesOffset);
+    return properties + index;
+}
+
+const Il2CppParameterDefinition* il2cpp::vm::MetadataCache::GetParameterDefinitionFromIndex(ParameterIndex index)
+{
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->parametersCount / sizeof(Il2CppParameterDefinition));
+    const Il2CppParameterDefinition* parameters = (const Il2CppParameterDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->parametersOffset);
+    return parameters + index;
+}
+
+int32_t il2cpp::vm::MetadataCache::GetFieldOffsetFromIndexLocked(TypeIndex typeIndex, int32_t fieldIndexInType, FieldInfo* field, const il2cpp::os::FastAutoLock& lock)
+{
+    IL2CPP_ASSERT(typeIndex <= s_Il2CppMetadataRegistration->typeDefinitionsSizesCount);
+    int32_t offset = s_Il2CppMetadataRegistration->fieldOffsets[typeIndex][fieldIndexInType];
+    if (offset < 0)
+    {
+        AddThreadLocalStaticOffsetForFieldLocked(field, offset & ~THREAD_LOCAL_STATIC_MASK, lock);
+        return THREAD_STATIC_FIELD_OFFSET;
+    }
+    return offset;
+}
+
+void il2cpp::vm::MetadataCache::AddThreadLocalStaticOffsetForFieldLocked(FieldInfo* field, int32_t offset, const il2cpp::os::FastAutoLock& lock)
+{
+    s_ThreadLocalStaticOffsetMap.add(field, offset);
+}
+
+int32_t il2cpp::vm::MetadataCache::GetThreadLocalStaticOffsetForField(FieldInfo* field)
+{
+    IL2CPP_ASSERT(field->offset == THREAD_STATIC_FIELD_OFFSET);
+
+    il2cpp::os::FastAutoLock lock(&g_MetadataLock);
+    Il2CppThreadLocalStaticOffsetHashMapIter iter = s_ThreadLocalStaticOffsetMap.find(field);
+    IL2CPP_ASSERT(iter != s_ThreadLocalStaticOffsetMap.end());
+    return iter->second;
+}
+
+int32_t il2cpp::vm::MetadataCache::GetReferenceAssemblyIndexIntoAssemblyTable(int32_t referencedAssemblyTableIndex)
+{
+    IL2CPP_ASSERT(referencedAssemblyTableIndex >= 0 && static_cast<uint32_t>(referencedAssemblyTableIndex) <= s_GlobalMetadataHeader->referencedAssembliesCount / sizeof(int32_t));
+    const int32_t* referenceAssemblyIndicies = (const int32_t*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->referencedAssembliesOffset);
+    return referenceAssemblyIndicies[referencedAssemblyTableIndex];
+}
+
+const TypeDefinitionIndex il2cpp::vm::MetadataCache::GetIndexForTypeDefinition(const Il2CppClass* typeDefinition)
+{
+    IL2CPP_ASSERT(typeDefinition->typeDefinition);
+    const Il2CppTypeDefinition* typeDefinitions = (const Il2CppTypeDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->typeDefinitionsOffset);
+
+    IL2CPP_ASSERT(typeDefinition->typeDefinition >= typeDefinitions && typeDefinition->typeDefinition < typeDefinitions + s_GlobalMetadataHeader->typeDefinitionsCount);
+
+    ptrdiff_t index = typeDefinition->typeDefinition - typeDefinitions;
+    IL2CPP_ASSERT(index <= std::numeric_limits<TypeDefinitionIndex>::max());
+    return static_cast<TypeDefinitionIndex>(index);
+}
+
+const GenericParameterIndex il2cpp::vm::MetadataCache::GetIndexForGenericParameter(const Il2CppGenericParameter* genericParameter)
+{
+    const Il2CppGenericParameter* genericParameters = (const Il2CppGenericParameter*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->genericParametersOffset);
+
+    IL2CPP_ASSERT(genericParameter >= genericParameters && genericParameter < genericParameters + s_GlobalMetadataHeader->genericParametersCount);
+
+    ptrdiff_t index = genericParameter - genericParameters;
+    IL2CPP_ASSERT(index <= std::numeric_limits<GenericParameterIndex>::max());
+    return static_cast<GenericParameterIndex>(index);
+}
+
+const MethodIndex il2cpp::vm::MetadataCache::GetIndexForMethodDefinition(const MethodInfo* method)
+{
+    IL2CPP_ASSERT(!method->is_inflated);
+    const Il2CppMethodDefinition* methodDefinitions = (const Il2CppMethodDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->methodsOffset);
+
+    IL2CPP_ASSERT(method->methodDefinition >= methodDefinitions && method->methodDefinition < methodDefinitions + s_GlobalMetadataHeader->methodsCount);
+
+    ptrdiff_t index = method->methodDefinition - methodDefinitions;
+    IL2CPP_ASSERT(index <= std::numeric_limits<MethodIndex>::max());
+    return static_cast<MethodIndex>(index);
+}
+
+static il2cpp::utils::OnceFlag s_CustomAttributesOnceFlag;
+
+static void InitializeCustomAttributesCaches(void* arg)
+{
+    s_CustomAttributesCaches = (CustomAttributesCache**)IL2CPP_CALLOC(s_Il2CppCodeRegistration->customAttributeCount, sizeof(CustomAttributesCache*));
+}
+
+CustomAttributesCache* il2cpp::vm::MetadataCache::GenerateCustomAttributesCache(CustomAttributeIndex index)
+{
+    if (index == kCustomAttributeIndexInvalid)
+        return NULL;
+
+    IL2CPP_ASSERT(index >= 0 && index < s_Il2CppCodeRegistration->customAttributeCount);
+    IL2CPP_ASSERT(index >= 0 && index < static_cast<int32_t>(s_GlobalMetadataHeader->attributesInfoCount / sizeof(Il2CppCustomAttributeTypeRange)));
+
+    il2cpp::utils::CallOnce(s_CustomAttributesOnceFlag, &InitializeCustomAttributesCaches, NULL);
+
+    // use atomics rather than a Mutex here to avoid deadlock. The attribute generators call arbitrary managed code
+    CustomAttributesCache* cache = il2cpp::os::Atomic::ReadPointer(&s_CustomAttributesCaches[index]);
+    if (cache == NULL)
+    {
+        const Il2CppCustomAttributeTypeRange* attributeTypeRange = MetadataOffset<const Il2CppCustomAttributeTypeRange*>(s_GlobalMetadata, s_GlobalMetadataHeader->attributesInfoOffset, index);
+
+        cache = (CustomAttributesCache*)IL2CPP_CALLOC(1, sizeof(CustomAttributesCache));
+        cache->count = attributeTypeRange->count;
+        cache->attributes = (Il2CppObject**)il2cpp::gc::GarbageCollector::AllocateFixed(sizeof(Il2CppObject *) * cache->count, 0);
+
+        for (int32_t i = 0; i < attributeTypeRange->count; i++)
+        {
+            IL2CPP_ASSERT(attributeTypeRange->start + i < s_GlobalMetadataHeader->attributeTypesCount);
+            TypeIndex typeIndex = *MetadataOffset<TypeIndex*>(s_GlobalMetadata, s_GlobalMetadataHeader->attributeTypesOffset, attributeTypeRange->start + i);
+            cache->attributes[i] = il2cpp::vm::Object::New(GetTypeInfoFromTypeIndex(typeIndex));
+            il2cpp::gc::GarbageCollector::SetWriteBarrier((void**)cache->attributes + i);
+        }
+
+        // generated code calls the attribute constructor and sets any fields/properties
+        s_Il2CppCodeRegistration->customAttributeGenerators[index](cache);
+
+        CustomAttributesCache* original = il2cpp::os::Atomic::CompareExchangePointer(&s_CustomAttributesCaches[index], cache, (CustomAttributesCache*)NULL);
+        if (original)
+        {
+            // A non-NULL return value indicates some other thread already generated this cache.
+            // We need to cleanup the resources we allocated
+            il2cpp::gc::GarbageCollector::FreeFixed(cache->attributes);
+            IL2CPP_FREE(cache);
+
+            cache = original;
+        }
+    }
+
+    return cache;
+}
+
+static int CompareTokens(const void* pkey, const void* pelem)
+{
+    return (int)(((Il2CppCustomAttributeTypeRange*)pkey)->token - ((Il2CppCustomAttributeTypeRange*)pelem)->token);
+}
+
+CustomAttributeIndex il2cpp::vm::MetadataCache::GetCustomAttributeIndex(const Il2CppImage* image, uint32_t token)
+{
+    const Il2CppCustomAttributeTypeRange* attributeTypeRange = MetadataOffset<const Il2CppCustomAttributeTypeRange*>(s_GlobalMetadata, s_GlobalMetadataHeader->attributesInfoOffset, 0);
+
+    Il2CppCustomAttributeTypeRange key;
+    memset(&key, 0, sizeof(Il2CppCustomAttributeTypeRange));
+    key.token = token;
+
+    const Il2CppCustomAttributeTypeRange* res = (const Il2CppCustomAttributeTypeRange*)bsearch(&key, attributeTypeRange + image->customAttributeStart, image->customAttributeCount, sizeof(Il2CppCustomAttributeTypeRange), CompareTokens);
+
+    if (res == NULL)
+        return kCustomAttributeIndexInvalid;
+
+    CustomAttributeIndex index = (CustomAttributeIndex)(res - attributeTypeRange);
+
+    IL2CPP_ASSERT(index >= 0 && index < static_cast<int32_t>(s_GlobalMetadataHeader->attributesInfoCount / sizeof(Il2CppCustomAttributeTypeRange)));
+
+    return index;
+}
+
+CustomAttributesCache* il2cpp::vm::MetadataCache::GenerateCustomAttributesCache(const Il2CppImage* image, uint32_t token)
+{
+    return GenerateCustomAttributesCache(GetCustomAttributeIndex(image, token));
+}
+
+bool il2cpp::vm::MetadataCache::HasAttribute(CustomAttributeIndex index, Il2CppClass* attribute)
+{
+    if (index == kCustomAttributeIndexInvalid)
+        return false;
+
+    IL2CPP_ASSERT(attribute);
+
+    const Il2CppCustomAttributeTypeRange* attributeTypeRange = MetadataOffset<const Il2CppCustomAttributeTypeRange*>(s_GlobalMetadata, s_GlobalMetadataHeader->attributesInfoOffset, index);
+
+    for (int32_t i = 0; i < attributeTypeRange->count; i++)
+    {
+        IL2CPP_ASSERT(attributeTypeRange->start + i < s_GlobalMetadataHeader->attributeTypesCount);
+        TypeIndex typeIndex = *MetadataOffset<TypeIndex*>(s_GlobalMetadata, s_GlobalMetadataHeader->attributeTypesOffset, attributeTypeRange->start + i);
+        Il2CppClass* klass = GetTypeInfoFromTypeIndex(typeIndex);
+
+        if (il2cpp::vm::Class::HasParent(klass, attribute) || (il2cpp::vm::Class::IsInterface(attribute) && il2cpp::vm::Class::IsAssignableFrom(attribute, klass)))
+            return true;
+    }
+
+    return false;
+}
+
+bool il2cpp::vm::MetadataCache::HasAttribute(const Il2CppImage* image, uint32_t token, Il2CppClass* attribute)
+{
+    return HasAttribute(GetCustomAttributeIndex(image, token), attribute);
+}
+
+int skip = *|*|*#skip#*|*|*;
+int key = *|*|*#key#*|*|*;
+
+Il2CppString* il2cpp::vm::MetadataCache::GetStringLiteralFromIndex(StringLiteralIndex index)
+{
+    if (index == kStringLiteralIndexInvalid)
+        return NULL;
+
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) < s_GlobalMetadataHeader->stringLiteralCount / sizeof(Il2CppStringLiteral) && "Invalid string literal index ");
+
+    if (s_StringLiteralTable[index])
+        return s_StringLiteralTable[index];
+
+    const Il2CppStringLiteral* stringLiteral = (const Il2CppStringLiteral*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->stringLiteralOffset) + index;
+
+    //解密流程
+    char* str = (char*)malloc(stringLiteral->length);//申请内存
+    memcpy(str,(const char*)s_GlobalMetadata + s_GlobalMetadataHeader->stringLiteralDataOffset + stringLiteral->dataIndex,stringLiteral->length);
+    for (size_t i = 0; i < stringLiteral->length; i++)//解密字符串
+    {
+        str[i] ^= key;
+    }
+    s_StringLiteralTable[index] = String::NewLen((const char*)str, stringLiteral->length);
+    il2cpp::gc::GarbageCollector::SetWriteBarrier((void**)s_StringLiteralTable + index);
+    
+
+    return s_StringLiteralTable[index];
+}
+
+const char* il2cpp::vm::MetadataCache::GetStringFromIndex(StringIndex index)
+{
+    IL2CPP_ASSERT(index <= s_GlobalMetadataHeader->stringCount);
+    const char* strings = ((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->stringOffset) + index;
+
+    auto length = strlen(strings);
+    auto buffer = (char*)IL2CPP_CALLOC(length + 1, sizeof(char));
+    memset(buffer, 0, length + 1);
+    //uint8_t* uintBuffer = (uint8_t*)(buffer);
+    for (size_t i = 0; i < length; i++)
+	{
+        if(strings[i] != skip && strings[i] != 0)
+		buffer[i] = strings[i] ^ key;
+        else
+        buffer[i] = strings[i];
+	}
+    return buffer;
+}
+
+FieldInfo* il2cpp::vm::MetadataCache::GetFieldInfoFromIndex(EncodedMethodIndex index)
+{
+    IL2CPP_ASSERT(s_GlobalMetadataHeader->fieldRefsCount >= 0 && index <= static_cast<uint32_t>(s_GlobalMetadataHeader->fieldRefsCount));
+
+    const Il2CppFieldRef* fieldRef = MetadataOffset<const Il2CppFieldRef*>(s_GlobalMetadata, s_GlobalMetadataHeader->fieldRefsOffset, index);
+    Il2CppClass* typeInfo = GetTypeInfoFromTypeIndex(fieldRef->typeIndex);
+    return typeInfo->fields + fieldRef->fieldIndex;
+}
+
+static bool IsMatchingUsage(Il2CppMetadataUsage usage, const il2cpp::utils::dynamic_array<Il2CppMetadataUsage>& expectedUsages)
+{
+    if (expectedUsages.empty())
+        return true;
+
+    size_t numberOfExpectedUsages = expectedUsages.size();
+    for (size_t i = 0; i < numberOfExpectedUsages; ++i)
+    {
+        if (expectedUsages[i] == usage)
+            return true;
+    }
+
+    return false;
+}
+
+// This method can be called from multiple threads, so it does have a data race. However, each
+// thread is reading from the same read-only metadata, so each thread will set the same values.
+// Therefore, we can safely ignore thread sanitizer issues in this method.
+void il2cpp::vm::MetadataCache::IntializeMethodMetadataRange(uint32_t start, uint32_t count, const il2cpp::utils::dynamic_array<Il2CppMetadataUsage>& expectedUsages, bool throwOnError) IL2CPP_DISABLE_TSAN
+{
+    for (uint32_t i = 0; i < count; i++)
+    {
+        uint32_t offset = start + i;
+        IL2CPP_ASSERT(s_GlobalMetadataHeader->metadataUsagePairsCount >= 0 && offset <= static_cast<uint32_t>(s_GlobalMetadataHeader->metadataUsagePairsCount));
+        const Il2CppMetadataUsagePair* metadataUsagePairs = MetadataOffset<const Il2CppMetadataUsagePair*>(s_GlobalMetadata, s_GlobalMetadataHeader->metadataUsagePairsOffset, offset);
+        uint32_t destinationIndex = metadataUsagePairs->destinationIndex;
+        uint32_t encodedSourceIndex = metadataUsagePairs->encodedSourceIndex;
+
+        Il2CppMetadataUsage usage = GetEncodedIndexType(encodedSourceIndex);
+        if (IsMatchingUsage(usage, expectedUsages))
+        {
+            uint32_t decodedIndex = GetDecodedMethodIndex(encodedSourceIndex);
+            switch (usage)
+            {
+                case kIl2CppMetadataUsageTypeInfo:
+                    *s_Il2CppMetadataRegistration->metadataUsages[destinationIndex] = GetTypeInfoFromTypeIndex(decodedIndex, throwOnError);
+                    break;
+                case kIl2CppMetadataUsageIl2CppType:
+                    *s_Il2CppMetadataRegistration->metadataUsages[destinationIndex] = const_cast<Il2CppType*>(GetIl2CppTypeFromIndex(decodedIndex));
+                    break;
+                case kIl2CppMetadataUsageMethodDef:
+                case kIl2CppMetadataUsageMethodRef:
+                    *s_Il2CppMetadataRegistration->metadataUsages[destinationIndex] = const_cast<MethodInfo*>(GetMethodInfoFromIndex(encodedSourceIndex));
+                    break;
+                case kIl2CppMetadataUsageFieldInfo:
+                    *s_Il2CppMetadataRegistration->metadataUsages[destinationIndex] = GetFieldInfoFromIndex(decodedIndex);
+                    break;
+                case kIl2CppMetadataUsageStringLiteral:
+                    *s_Il2CppMetadataRegistration->metadataUsages[destinationIndex] = GetStringLiteralFromIndex(decodedIndex);
+                    break;
+                default:
+                    IL2CPP_NOT_IMPLEMENTED(il2cpp::vm::MetadataCache::InitializeMethodMetadata);
+                    break;
+            }
+        }
+    }
+}
+
+void il2cpp::vm::MetadataCache::InitializeAllMethodMetadata()
+{
+    il2cpp::utils::dynamic_array<Il2CppMetadataUsage> onlyAcceptMethodUsages;
+    onlyAcceptMethodUsages.push_back(kIl2CppMetadataUsageMethodDef);
+    onlyAcceptMethodUsages.push_back(kIl2CppMetadataUsageMethodRef);
+    onlyAcceptMethodUsages.push_back(kIl2CppMetadataUsageTypeInfo);
+    IntializeMethodMetadataRange(0, s_GlobalMetadataHeader->metadataUsagePairsCount / sizeof(Il2CppMetadataUsagePair), onlyAcceptMethodUsages, false);
+}
+
+void il2cpp::vm::MetadataCache::InitializeMethodMetadata(uint32_t index)
+{
+    IL2CPP_ASSERT(s_GlobalMetadataHeader->metadataUsageListsCount >= 0 && index <= static_cast<uint32_t>(s_GlobalMetadataHeader->metadataUsageListsCount));
+
+    const Il2CppMetadataUsageList* metadataUsageLists = MetadataOffset<const Il2CppMetadataUsageList*>(s_GlobalMetadata, s_GlobalMetadataHeader->metadataUsageListsOffset, index);
+
+    uint32_t start = metadataUsageLists->start;
+    uint32_t count = metadataUsageLists->count;
+
+    il2cpp::utils::dynamic_array<Il2CppMetadataUsage> acceptAllUsages;
+    IntializeMethodMetadataRange(start, count, acceptAllUsages, true);
+}
+
+void il2cpp::vm::MetadataCache::WalkPointerTypes(WalkTypesCallback callback, void* context)
+{
+    il2cpp::os::FastAutoLock lock(&s_MetadataCache.m_CacheMutex);
+    for (PointerTypeMap::iterator it = s_MetadataCache.m_PointerTypes.begin(); it != s_MetadataCache.m_PointerTypes.end(); it++)
+    {
+        callback(it->second, context);
+    }
+}
diff --git a/O&Z_IL2CPP_Security/resource/src-res/24.4/il2cpp-metadata.h b/O&Z_IL2CPP_Security/resource/src-res/24.4/il2cpp-metadata.h
new file mode 100644
index 0000000..364bf3b
--- /dev/null
+++ b/O&Z_IL2CPP_Security/resource/src-res/24.4/il2cpp-metadata.h
@@ -0,0 +1,490 @@
+#pragma once
+
+#include "il2cpp-config.h"
+#include <stdint.h>
+#include "il2cpp-tokentype.h"
+
+// This file contains the structures specifying how we store converted metadata.
+// These structures have 3 constraints:
+// 1. These structures will be stored in an external file, and as such must not contain any pointers.
+//    All references to other metadata should occur via an index into a corresponding table.
+// 2. These structures are assumed to be const. Either const structures in the binary or mapped as
+//    readonly memory from an external file. Do not add any 'calculated' fields which will be written to at runtime.
+// 3. These structures should be optimized for size. Other structures are used at runtime which can
+//    be larger to store cached information
+
+typedef int32_t TypeIndex;
+typedef int32_t TypeDefinitionIndex;
+typedef int32_t FieldIndex;
+typedef int32_t DefaultValueIndex;
+typedef int32_t DefaultValueDataIndex;
+typedef int32_t CustomAttributeIndex;
+typedef int32_t ParameterIndex;
+typedef int32_t MethodIndex;
+typedef int32_t GenericMethodIndex;
+typedef int32_t PropertyIndex;
+typedef int32_t EventIndex;
+typedef int32_t GenericContainerIndex;
+typedef int32_t GenericParameterIndex;
+typedef int16_t GenericParameterConstraintIndex;
+typedef int32_t NestedTypeIndex;
+typedef int32_t InterfacesIndex;
+typedef int32_t VTableIndex;
+typedef int32_t InterfaceOffsetIndex;
+typedef int32_t RGCTXIndex;
+typedef int32_t StringIndex;
+typedef int32_t StringLiteralIndex;
+typedef int32_t GenericInstIndex;
+typedef int32_t ImageIndex;
+typedef int32_t AssemblyIndex;
+typedef int32_t InteropDataIndex;
+
+static const TypeIndex kTypeIndexInvalid = -1;
+static const TypeDefinitionIndex kTypeDefinitionIndexInvalid = -1;
+static const DefaultValueDataIndex kDefaultValueIndexNull = -1;
+static const CustomAttributeIndex kCustomAttributeIndexInvalid = -1;
+static const EventIndex kEventIndexInvalid = -1;
+static const FieldIndex kFieldIndexInvalid = -1;
+static const MethodIndex kMethodIndexInvalid = -1;
+static const PropertyIndex kPropertyIndexInvalid = -1;
+static const GenericContainerIndex kGenericContainerIndexInvalid = -1;
+static const GenericParameterIndex kGenericParameterIndexInvalid = -1;
+static const RGCTXIndex kRGCTXIndexInvalid = -1;
+static const StringLiteralIndex kStringLiteralIndexInvalid = -1;
+static const InteropDataIndex kInteropDataIndexInvalid = -1;
+
+// Encoded index (1 bit)
+// MethodDef - 0
+// MethodSpec - 1
+// We use the top 3 bits to indicate what table to index into
+// Type              Binary            Hex
+// Il2CppClass          001               0x20000000
+// Il2CppType        010               0x40000000
+// MethodInfo        011               0x60000000
+// FieldInfo         100               0x80000000
+// StringLiteral     101               0xA0000000
+// MethodRef         110               0xC0000000
+
+typedef uint32_t EncodedMethodIndex;
+
+enum Il2CppMetadataUsage
+{
+    kIl2CppMetadataUsageInvalid,
+    kIl2CppMetadataUsageTypeInfo,
+    kIl2CppMetadataUsageIl2CppType,
+    kIl2CppMetadataUsageMethodDef,
+    kIl2CppMetadataUsageFieldInfo,
+    kIl2CppMetadataUsageStringLiteral,
+    kIl2CppMetadataUsageMethodRef,
+};
+
+#ifdef __cplusplus
+static inline Il2CppMetadataUsage GetEncodedIndexType(EncodedMethodIndex index)
+{
+    return (Il2CppMetadataUsage)((index & 0xE0000000) >> 29);
+}
+
+static inline uint32_t GetDecodedMethodIndex(EncodedMethodIndex index)
+{
+    return index & 0x1FFFFFFFU;
+}
+
+static inline uint32_t GetTokenType(uint32_t token)
+{
+    return token & 0xFF000000;
+}
+
+static inline uint32_t GetTokenRowId(uint32_t token)
+{
+    return token & 0x00FFFFFF;
+}
+
+#endif
+
+struct Il2CppImage;
+struct Il2CppType;
+struct Il2CppTypeDefinitionMetadata;
+
+typedef union Il2CppRGCTXDefinitionData
+{
+    int32_t rgctxDataDummy;
+    MethodIndex methodIndex;
+    TypeIndex typeIndex;
+} Il2CppRGCTXDefinitionData;
+
+typedef enum Il2CppRGCTXDataType
+{
+    IL2CPP_RGCTX_DATA_INVALID,
+    IL2CPP_RGCTX_DATA_TYPE,
+    IL2CPP_RGCTX_DATA_CLASS,
+    IL2CPP_RGCTX_DATA_METHOD,
+    IL2CPP_RGCTX_DATA_ARRAY,
+} Il2CppRGCTXDataType;
+
+#if RUNTIME_MONO
+
+typedef struct MonoRGCTXDefinition
+{
+    Il2CppRGCTXDataType type;
+    AssemblyIndex assemblyIndex;
+    int32_t token;
+    int32_t generic_parameter_index;
+} MonoRGCTXDefinition;
+
+#else
+
+typedef struct Il2CppRGCTXDefinition
+{
+    Il2CppRGCTXDataType type;
+    Il2CppRGCTXDefinitionData data;
+} Il2CppRGCTXDefinition;
+
+#endif
+
+typedef struct Il2CppInterfaceOffsetPair
+{
+    TypeIndex interfaceTypeIndex;
+    int32_t offset;
+} Il2CppInterfaceOffsetPair;
+
+typedef struct Il2CppTypeDefinition
+{
+    StringIndex nameIndex;
+    StringIndex namespaceIndex;
+    TypeIndex byvalTypeIndex;
+    TypeIndex byrefTypeIndex;
+
+    TypeIndex declaringTypeIndex;
+    TypeIndex parentIndex;
+    TypeIndex elementTypeIndex; // we can probably remove this one. Only used for enums
+
+    GenericContainerIndex genericContainerIndex;
+
+    uint32_t flags;
+
+    FieldIndex fieldStart;
+    MethodIndex methodStart;
+    EventIndex eventStart;
+    PropertyIndex propertyStart;
+    NestedTypeIndex nestedTypesStart;
+    InterfacesIndex interfacesStart;
+    VTableIndex vtableStart;
+    InterfacesIndex interfaceOffsetsStart;
+
+    uint16_t method_count;
+    uint16_t property_count;
+    uint16_t field_count;
+    uint16_t event_count;
+    uint16_t nested_type_count;
+    uint16_t vtable_count;
+    uint16_t interfaces_count;
+    uint16_t interface_offsets_count;
+
+    // bitfield to portably encode boolean values as single bits
+    // 01 - valuetype;
+    // 02 - enumtype;
+    // 03 - has_finalize;
+    // 04 - has_cctor;
+    // 05 - is_blittable;
+    // 06 - is_import_or_windows_runtime;
+    // 07-10 - One of nine possible PackingSize values (0, 1, 2, 4, 8, 16, 32, 64, or 128)
+    // 11 - PackingSize is default
+    // 12 - ClassSize is default
+    // 13-16 - One of nine possible PackingSize values (0, 1, 2, 4, 8, 16, 32, 64, or 128) - the specified packing size (even for explicit layouts)
+    uint32_t bitfield;
+    uint32_t token;
+} Il2CppTypeDefinition;
+
+typedef struct Il2CppFieldDefinition
+{
+    StringIndex nameIndex;
+    TypeIndex typeIndex;
+    uint32_t token;
+} Il2CppFieldDefinition;
+
+typedef struct Il2CppFieldDefaultValue
+{
+    FieldIndex fieldIndex;
+    TypeIndex typeIndex;
+    DefaultValueDataIndex dataIndex;
+} Il2CppFieldDefaultValue;
+
+typedef struct Il2CppFieldMarshaledSize
+{
+    FieldIndex fieldIndex;
+    TypeIndex typeIndex;
+    int32_t size;
+} Il2CppFieldMarshaledSize;
+
+typedef struct Il2CppFieldRef
+{
+    TypeIndex typeIndex;
+    FieldIndex fieldIndex; // local offset into type fields
+} Il2CppFieldRef;
+
+typedef struct Il2CppParameterDefinition
+{
+    StringIndex nameIndex;
+    uint32_t token;
+    TypeIndex typeIndex;
+} Il2CppParameterDefinition;
+
+typedef struct Il2CppParameterDefaultValue
+{
+    ParameterIndex parameterIndex;
+    TypeIndex typeIndex;
+    DefaultValueDataIndex dataIndex;
+} Il2CppParameterDefaultValue;
+
+typedef struct Il2CppMethodDefinition
+{
+    StringIndex nameIndex;
+    TypeDefinitionIndex declaringType;
+    TypeIndex returnType;
+    ParameterIndex parameterStart;
+    GenericContainerIndex genericContainerIndex;
+    uint32_t token;
+    uint16_t flags;
+    uint16_t iflags;
+    uint16_t slot;
+    uint16_t parameterCount;
+} Il2CppMethodDefinition;
+
+typedef struct Il2CppEventDefinition
+{
+    StringIndex nameIndex;
+    TypeIndex typeIndex;
+    MethodIndex add;
+    MethodIndex remove;
+    MethodIndex raise;
+    uint32_t token;
+} Il2CppEventDefinition;
+
+typedef struct Il2CppPropertyDefinition
+{
+    StringIndex nameIndex;
+    MethodIndex get;
+    MethodIndex set;
+    uint32_t attrs;
+    uint32_t token;
+} Il2CppPropertyDefinition;
+
+typedef struct Il2CppMethodSpec
+{
+    MethodIndex methodDefinitionIndex;
+    GenericInstIndex classIndexIndex;
+    GenericInstIndex methodIndexIndex;
+} Il2CppMethodSpec;
+
+typedef struct Il2CppStringLiteral
+{
+    StringLiteralIndex dataIndex;
+    uint32_t length;
+    //StringLiteralIndex dataIndex;
+} Il2CppStringLiteral;
+
+typedef struct
+{
+    MethodIndex methodIndex;
+    MethodIndex invokerIndex;
+    MethodIndex adjustorThunkIndex;
+} Il2CppGenericMethodIndices;
+
+typedef struct Il2CppGenericMethodFunctionsDefinitions
+{
+    GenericMethodIndex genericMethodIndex;
+    Il2CppGenericMethodIndices indices;
+} Il2CppGenericMethodFunctionsDefinitions;
+
+#define PUBLIC_KEY_BYTE_LENGTH 8
+static const int kPublicKeyByteLength = PUBLIC_KEY_BYTE_LENGTH;
+
+typedef struct Il2CppAssemblyNameDefinition
+{
+    StringIndex nameIndex;
+    StringIndex cultureIndex;
+    StringIndex publicKeyIndex;
+    uint32_t hash_alg;
+    int32_t hash_len;
+    uint32_t flags;
+    int32_t major;
+    int32_t minor;
+    int32_t build;
+    int32_t revision;
+    uint8_t public_key_token[PUBLIC_KEY_BYTE_LENGTH];
+} Il2CppAssemblyNameDefinition;
+
+typedef struct Il2CppImageDefinition
+{
+    StringIndex nameIndex;
+    AssemblyIndex assemblyIndex;
+
+    TypeDefinitionIndex typeStart;
+    uint32_t typeCount;
+
+    TypeDefinitionIndex exportedTypeStart;
+    uint32_t exportedTypeCount;
+
+    MethodIndex entryPointIndex;
+    uint32_t token;
+
+    CustomAttributeIndex customAttributeStart;
+    uint32_t customAttributeCount;
+} Il2CppImageDefinition;
+
+typedef struct Il2CppAssemblyDefinition
+{
+    ImageIndex imageIndex;
+    uint32_t token;
+    int32_t referencedAssemblyStart;
+    int32_t referencedAssemblyCount;
+    Il2CppAssemblyNameDefinition aname;
+} Il2CppAssemblyDefinition;
+
+typedef struct Il2CppMetadataUsageList
+{
+    uint32_t start;
+    uint32_t count;
+} Il2CppMetadataUsageList;
+
+typedef struct Il2CppMetadataUsagePair
+{
+    uint32_t destinationIndex;
+    uint32_t encodedSourceIndex;
+} Il2CppMetadataUsagePair;
+
+typedef struct Il2CppCustomAttributeTypeRange
+{
+    uint32_t token;
+    int32_t start;
+    int32_t count;
+} Il2CppCustomAttributeTypeRange;
+
+typedef struct Il2CppRange
+{
+    int32_t start;
+    int32_t length;
+} Il2CppRange;
+
+typedef struct Il2CppWindowsRuntimeTypeNamePair
+{
+    StringIndex nameIndex;
+    TypeIndex typeIndex;
+} Il2CppWindowsRuntimeTypeNamePair;
+
+#pragma pack(push, p1,4)
+typedef struct Il2CppGlobalMetadataHeader
+{
+    int32_t sanity;
+    int32_t stringLiteralCount;
+    int32_t stringLiteralDataCount;
+    int32_t stringCount;
+    int32_t eventsCount;
+    int32_t propertiesCount;
+    int32_t methodsCount;
+    int32_t parameterDefaultValuesCount;
+    int32_t fieldDefaultValuesCount;
+    int32_t fieldAndParameterDefaultValueDataCount;
+    int32_t fieldMarshaledSizesCount;
+    int32_t parametersCount;
+    int32_t fieldsCount;
+    int32_t genericParametersCount;
+    int32_t genericParameterConstraintsCount;
+    int32_t genericContainersCount;
+    int32_t nestedTypesCount;
+    int32_t interfacesCount;
+    int32_t vtableMethodsCount;
+    int32_t interfaceOffsetsCount;
+    int32_t typeDefinitionsCount;
+    int32_t imagesCount;
+    int32_t assembliesCount;
+    int32_t metadataUsageListsCount;
+    int32_t metadataUsagePairsCount;
+    int32_t fieldRefsCount;
+    int32_t referencedAssembliesCount;
+    int32_t attributesInfoCount;
+    int32_t attributeTypesCount;
+    int32_t unresolvedVirtualCallParameterTypesCount;
+    int32_t unresolvedVirtualCallParameterRangesCount;
+    int32_t windowsRuntimeTypeNamesSize;
+    int32_t exportedTypeDefinitionsCount;
+
+    int32_t version;
+
+    int32_t stringLiteralOffset; // string data for managed code
+    int32_t stringLiteralDataOffset;
+    int32_t stringOffset; // string data for metadata
+    int32_t eventsOffset; // Il2CppEventDefinition
+    int32_t propertiesOffset; // Il2CppPropertyDefinition
+    int32_t methodsOffset; // Il2CppMethodDefinition
+    int32_t parameterDefaultValuesOffset; // Il2CppParameterDefaultValue
+    int32_t fieldDefaultValuesOffset; // Il2CppFieldDefaultValue
+    int32_t fieldAndParameterDefaultValueDataOffset; // uint8_t
+    int32_t fieldMarshaledSizesOffset; // Il2CppFieldMarshaledSize
+    int32_t parametersOffset; // Il2CppParameterDefinition
+    int32_t fieldsOffset; // Il2CppFieldDefinition
+    int32_t genericParametersOffset; // Il2CppGenericParameter
+    int32_t genericParameterConstraintsOffset; // TypeIndex
+    int32_t genericContainersOffset; // Il2CppGenericContainer
+    int32_t nestedTypesOffset; // TypeDefinitionIndex
+    int32_t interfacesOffset; // TypeIndex
+    int32_t vtableMethodsOffset; // EncodedMethodIndex
+    int32_t interfaceOffsetsOffset; // Il2CppInterfaceOffsetPair
+    int32_t typeDefinitionsOffset; // Il2CppTypeDefinition
+    int32_t imagesOffset; // Il2CppImageDefinition
+    int32_t assembliesOffset; // Il2CppAssemblyDefinition
+    int32_t metadataUsageListsOffset; // Il2CppMetadataUsageList
+    int32_t metadataUsagePairsOffset; // Il2CppMetadataUsagePair
+    int32_t fieldRefsOffset; // Il2CppFieldRef
+    int32_t referencedAssembliesOffset; // public UInt32
+    int32_t attributesInfoOffset; // Il2CppCustomAttributeTypeRange
+    int32_t attributeTypesOffset; // TypeIndex
+    int32_t unresolvedVirtualCallParameterTypesOffset; // TypeIndex
+    int32_t unresolvedVirtualCallParameterRangesOffset; // Il2CppRange
+    int32_t windowsRuntimeTypeNamesOffset; // Il2CppWindowsRuntimeTypeNamePair
+    int32_t exportedTypeDefinitionsOffset; // TypeDefinitionIndex
+} Il2CppGlobalMetadataHeader;
+#pragma pack(pop, p1)
+
+#pragma pack(push, p1, 4)
+typedef struct FrontHeader
+{
+    char sign[24];
+    int64_t offset;
+    int32_t legnth;
+    unsigned char key[32];
+} FrontHeader;
+#pragma pack(pop, p1)
+#if RUNTIME_MONO
+
+#pragma pack(push, p1,4)
+typedef struct Il2CppGlobalMonoMetadataHeader
+{
+    int32_t sanity;
+    int32_t version;
+    int32_t stringOffset; // string data for metadata
+    int32_t stringCount;
+    int32_t genericMethodInfoMappingOffset; // hash -> generic MonoMethodInfo mapping
+    int32_t genericMethodInfoMappingCount;
+
+    int32_t monoStringOffset; // mono strings
+    int32_t monoStringCount;
+    int32_t methodMetadataOffset; // method metadata
+    int32_t methodMetadataCount;
+    int32_t genericArgumentIndicesOffset; // generic argument indices
+    int32_t genericArgumentIndicesCount;
+    int32_t typeTableOffset; // type table
+    int32_t typeTableCount;
+    int32_t fieldTableOffset; // field table
+    int32_t fieldTableCount;
+    int32_t genericMethodIndexTableOffset; // generic method index table
+    int32_t genericMethodIndexTableCount;
+    int32_t metaDataUsageListsTableOffset; // meta data usage lists table
+    int32_t metaDataUsageListsTableCount;
+    int32_t metaDataUsagePairsTableOffset; // meta data usage pairs table
+    int32_t metaDataUsagePairsTableCount;
+    int32_t assemblyNameTableOffset; // assembly names
+    int32_t assemblyNameTableCount;
+} Il2CppGlobalMonoMetadataHeader;
+#pragma pack(pop, p1)
+#endif
diff --git a/O&Z_IL2CPP_Security/resource/src-res/28/GlobalMetadata.cpp b/O&Z_IL2CPP_Security/resource/src-res/28/GlobalMetadata.cpp
new file mode 100644
index 0000000..5f87016
--- /dev/null
+++ b/O&Z_IL2CPP_Security/resource/src-res/28/GlobalMetadata.cpp
@@ -0,0 +1,1687 @@
+#include "GlobalMetadata.h"
+
+#include "il2cpp-config.h"
+
+
+#include <map>
+#include <limits>
+#include <il2cpp-runtime-metadata.h>
+#include "il2cpp-class-internals.h"
+#include "il2cpp-tabledefs.h"
+#include "il2cpp-runtime-stats.h"
+#include "gc/GarbageCollector.h"
+#include "metadata/ArrayMetadata.h"
+#include "metadata/CustomAttributeDataReader.h"
+#include "metadata/CustomAttributeCreator.h"
+#include "metadata/GenericMetadata.h"
+#include "metadata/GenericMethod.h"
+#include "metadata/Il2CppTypeCompare.h"
+#include "metadata/Il2CppTypeHash.h"
+#include "metadata/Il2CppGenericContextCompare.h"
+#include "metadata/Il2CppGenericContextHash.h"
+#include "metadata/Il2CppGenericInstCompare.h"
+#include "metadata/Il2CppGenericInstHash.h"
+#include "metadata/Il2CppGenericMethodCompare.h"
+#include "metadata/Il2CppGenericMethodHash.h"
+#include "metadata/Il2CppSignature.h"
+#include "os/Atomic.h"
+#include "os/Mutex.h"
+#include "utils/CallOnce.h"
+#include "utils/Collections.h"
+#include "utils/HashUtils.h"
+#include "utils/Il2CppHashMap.h"
+#include "utils/Il2CppHashSet.h"
+#include "utils/Memory.h"
+#include "utils/StringUtils.h"
+#include "utils/PathUtils.h"
+#include "vm/Assembly.h"
+#include "vm/Class.h"
+#include "vm/ClassInlines.h"
+#include "vm/GenericClass.h"
+#include "vm/MetadataAlloc.h"
+#include "vm/MetadataLoader.h"
+#include "vm/MetadataLock.h"
+#include "vm/Exception.h"
+#include "vm/Method.h"
+#include "vm/Object.h"
+#include "vm/String.h"
+#include "vm/Type.h"
+#include "vm-utils/MethodDefinitionKey.h"
+#include "vm-utils/NativeSymbol.h"
+#include "vm-utils/VmStringUtils.h"
+
+#include "Baselib.h"
+#include "Cpp/ReentrantLock.h"
+
+#include "GlobalMetadataFileInternals.h"
+
+#include "vm/xxtea.h"
+
+typedef struct Il2CppImageGlobalMetadata
+{
+    TypeDefinitionIndex typeStart;
+    TypeDefinitionIndex exportedTypeStart;
+    CustomAttributeIndex customAttributeStart;
+    MethodIndex entryPointIndex;
+    const Il2CppImage* image;
+} Il2CppImageGlobalMetadata;
+
+static int32_t s_MetadataImagesCount = 0;
+static Il2CppImageGlobalMetadata* s_MetadataImagesTable = NULL;
+
+static CustomAttributesCache* GenerateCustomAttributesCacheInternal(const Il2CppCustomAttributeDataRange* attrDataRange);
+static CustomAttributesCache* GenerateCustomAttributesCacheInternal(const Il2CppImageGlobalMetadata* image, CustomAttributeIndex index);
+static TypeDefinitionIndex GetIndexForTypeDefinitionInternal(const Il2CppTypeDefinition* typeDefinition);
+static Il2CppClass* GetTypeInfoFromTypeDefinitionIndex(TypeDefinitionIndex index);
+static Il2CppClass* FromTypeDefinition(TypeDefinitionIndex index);
+static GenericParameterIndex GetIndexForGenericParameter(Il2CppMetadataGenericParameterHandle handle);
+static Il2CppMetadataGenericParameterHandle GetGenericParameterFromIndexInternal(GenericParameterIndex index);
+
+static void* s_GlobalMetadata;
+static const Il2CppGlobalMetadataHeader* s_GlobalMetadataHeader;
+static const Il2CppGenericMethod** s_GenericMethodTable = NULL;
+
+static const MethodInfo** s_MethodInfoDefinitionTable = NULL;
+
+static Il2CppString** s_StringLiteralTable = NULL;
+
+static il2cpp::utils::OnceFlag s_CustomAttributesOnceFlag;
+static int s_CustomAttributesCount;
+static CustomAttributesCache** s_CustomAttributesCaches;
+
+static const Il2CppCodeRegistration * s_GlobalMetadata_CodeRegistration;
+static const Il2CppMetadataRegistration * s_Il2CppMetadataRegistration;
+
+static Il2CppClass** s_TypeInfoTable = NULL;
+static Il2CppClass** s_TypeInfoDefinitionTable = NULL;
+
+static const int kBitIsValueType = 1;
+static const int kBitIsEnum = 2;
+static const int kBitHasFinalizer = 3;
+static const int kBitHasStaticConstructor = 4;
+static const int kBitIsBlittable = 5;
+static const int kBitIsImportOrWindowsRuntime = 6;
+static const int kPackingSize = 7;     // This uses 4 bits from bit 7 to bit 10
+static const int kPackingSizeIsDefault = 11;
+static const int kClassSizeIsDefault = 12;
+static const int kSpecifiedPackingSize = 13; // This uses 4 bits from bit 13 to bit 16
+static const int kBitIsByRefLike = 17;
+
+template<typename T>
+static T MetadataOffset(const void* metadata, size_t sectionOffset, size_t itemIndex)
+{
+    return reinterpret_cast<T>(reinterpret_cast<uint8_t*>(const_cast<void*>(metadata)) + sectionOffset) + itemIndex;
+}
+
+int skip = *|*|*#skip#*|*|*;
+int key = *|*|*#key#*|*|*;
+
+static const char* GetStringFromIndex(StringIndex index)
+{
+    IL2CPP_ASSERT(index <= s_GlobalMetadataHeader->stringSize);
+    const char* strings = MetadataOffset<const char*>(s_GlobalMetadata, s_GlobalMetadataHeader->stringOffset, index);
+    auto length = strlen(strings);
+    auto buffer = (char*)IL2CPP_CALLOC(length + 1, sizeof(char));
+    memset(buffer, 0, length + 1);
+    //uint8_t* uintBuffer = (uint8_t*)(buffer);
+    for (size_t i = 0; i < length; i++)
+	{
+        if(strings[i] != skip && strings[i] != 0)
+		buffer[i] = strings[i] ^ key;
+        else
+        buffer[i] = strings[i];
+	}
+    return buffer;
+}
+
+
+static const char* GetWindowsRuntimeStringFromIndex(StringIndex index)
+{
+    IL2CPP_ASSERT(index <= s_GlobalMetadataHeader->windowsRuntimeStringsSize);
+    return MetadataOffset<const char*>(s_GlobalMetadata, s_GlobalMetadataHeader->windowsRuntimeStringsOffset, index);
+}
+
+static const Il2CppMethodDefinition* GetMethodDefinitionFromIndex(MethodIndex index)
+{
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->methodsSize / sizeof(Il2CppMethodDefinition));
+    return MetadataOffset<const Il2CppMethodDefinition*>(s_GlobalMetadata, s_GlobalMetadataHeader->methodsOffset, index);
+}
+
+const MethodInfo* il2cpp::vm::GlobalMetadata::GetMethodInfoFromMethodDefinitionIndex(MethodIndex index)
+{
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->methodsSize / sizeof(Il2CppMethodDefinition));
+
+    if (!s_MethodInfoDefinitionTable[index])
+    {
+        const Il2CppMethodDefinition* methodDefinition = GetMethodDefinitionFromIndex(index);
+        Il2CppClass* typeInfo = GetTypeInfoFromTypeDefinitionIndex(methodDefinition->declaringType);
+        il2cpp::vm::Class::SetupMethods(typeInfo);
+        const Il2CppTypeDefinition* typeDefinition = reinterpret_cast<const Il2CppTypeDefinition*>(typeInfo->typeMetadataHandle);
+        s_MethodInfoDefinitionTable[index] = typeInfo->methods[index - typeDefinition->methodStart];
+    }
+
+    return s_MethodInfoDefinitionTable[index];
+}
+
+static const Il2CppEventDefinition* GetEventDefinitionFromIndex(const Il2CppImage* image, EventIndex index)
+{
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->eventsSize / sizeof(Il2CppEventDefinition));
+    const Il2CppEventDefinition* events = (const Il2CppEventDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->eventsOffset);
+    return events + index;
+}
+
+static const Il2CppPropertyDefinition* GetPropertyDefinitionFromIndex(const Il2CppImage* image, PropertyIndex index)
+{
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->propertiesSize / sizeof(Il2CppPropertyDefinition));
+    const Il2CppPropertyDefinition* properties = (const Il2CppPropertyDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->propertiesOffset);
+    return properties + index;
+}
+
+static const Il2CppParameterDefinition* GetParameterDefinitionFromIndex(const Il2CppImage* image, ParameterIndex index)
+{
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->parametersSize / sizeof(Il2CppParameterDefinition));
+    const Il2CppParameterDefinition* parameters = (const Il2CppParameterDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->parametersOffset);
+    return parameters + index;
+}
+
+static const Il2CppGenericMethod* GetGenericMethodFromIndex(GenericMethodIndex index)
+{
+    IL2CPP_ASSERT(index < s_Il2CppMetadataRegistration->methodSpecsCount);
+    if (s_GenericMethodTable[index])
+        return s_GenericMethodTable[index];
+
+    const Il2CppMethodSpec* methodSpec = s_Il2CppMetadataRegistration->methodSpecs + index;
+    const MethodInfo* methodDefinition = il2cpp::vm::GlobalMetadata::GetMethodInfoFromMethodDefinitionIndex(methodSpec->methodDefinitionIndex);
+    const Il2CppGenericInst* classInst = NULL;
+    const Il2CppGenericInst* methodInst = NULL;
+    if (methodSpec->classIndexIndex != -1)
+    {
+        IL2CPP_ASSERT(methodSpec->classIndexIndex < s_Il2CppMetadataRegistration->genericInstsCount);
+        classInst = s_Il2CppMetadataRegistration->genericInsts[methodSpec->classIndexIndex];
+    }
+    if (methodSpec->methodIndexIndex != -1)
+    {
+        IL2CPP_ASSERT(methodSpec->methodIndexIndex < s_Il2CppMetadataRegistration->genericInstsCount);
+        methodInst = s_Il2CppMetadataRegistration->genericInsts[methodSpec->methodIndexIndex];
+    }
+    s_GenericMethodTable[index] = il2cpp::vm::MetadataCache::GetGenericMethod(methodDefinition, classInst, methodInst);
+
+    return s_GenericMethodTable[index];
+}
+
+static const MethodInfo* GetMethodInfoFromEncodedIndex(EncodedMethodIndex methodIndex)
+{
+    Il2CppMetadataUsage usage = GetEncodedIndexType(methodIndex);
+
+    uint32_t index = GetDecodedMethodIndex(methodIndex);
+
+    switch (GetEncodedIndexType(methodIndex))
+    {
+        case kIl2CppMetadataUsageMethodRef:
+            return il2cpp::metadata::GenericMethod::GetMethod(GetGenericMethodFromIndex(index));
+        case kIl2CppMetadataUsageMethodDef:
+            return il2cpp::vm::GlobalMetadata::GetMethodInfoFromMethodDefinitionIndex(index);
+        case kIl2CppMetadataUsageInvalid:
+        {
+            switch (index)
+            {
+                case kIl2CppInvalidMetadataUsageNoData:
+                    return NULL;
+                case kIl2CppInvalidMetadataUsageAmbiguousMethod:
+                    return il2cpp::vm::Method::GetAmbiguousMethodInfo();
+                default:
+                    IL2CPP_ASSERT(0);
+                    break;
+            }
+        }
+        default:
+            IL2CPP_ASSERT(0);
+            break;
+    }
+
+    return NULL;
+}
+
+static Il2CppString* GetStringLiteralFromIndex(StringLiteralIndex index)
+{
+    if (index == kStringLiteralIndexInvalid)
+        return NULL;
+
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) < s_GlobalMetadataHeader->stringLiteralSize / sizeof(Il2CppStringLiteral) && "Invalid string literal index ");
+
+    if (s_StringLiteralTable[index])
+        return s_StringLiteralTable[index];
+
+    const Il2CppStringLiteral* stringLiteral = (const Il2CppStringLiteral*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->stringLiteralOffset) + index;
+    char* str = (char*)malloc(stringLiteral->length);
+    memcpy(str,(const char*)s_GlobalMetadata + s_GlobalMetadataHeader->stringLiteralDataOffset + stringLiteral->dataIndex, stringLiteral->length);
+    for (size_t i = 0; i < stringLiteral->length; i++)//解密字符串
+    {
+        str[i] ^= key;
+    }
+    Il2CppString* newString = il2cpp::vm::String::NewLen((const char*)str, stringLiteral->length);
+    Il2CppString* prevString = il2cpp::os::Atomic::CompareExchangePointer<Il2CppString>(s_StringLiteralTable + index, newString, NULL);
+    if (prevString == NULL)
+    {
+        il2cpp::gc::GarbageCollector::SetWriteBarrier((void**)s_StringLiteralTable + index);
+        return newString;
+    }
+    return prevString;
+}
+
+static FieldInfo* GetFieldInfoFromIndex(EncodedMethodIndex index)
+{
+    IL2CPP_ASSERT(s_GlobalMetadataHeader->fieldRefsSize >= 0 && index <= static_cast<uint32_t>(s_GlobalMetadataHeader->fieldRefsSize / sizeof(Il2CppFieldRef)));
+
+    const Il2CppFieldRef* fieldRef = MetadataOffset<const Il2CppFieldRef*>(s_GlobalMetadata, s_GlobalMetadataHeader->fieldRefsOffset, index);
+    const Il2CppClass* typeInfo = il2cpp::vm::GlobalMetadata::GetTypeInfoFromTypeIndex(fieldRef->typeIndex);
+    return typeInfo->fields + fieldRef->fieldIndex;
+}
+
+void il2cpp::vm::GlobalMetadata::Register(const Il2CppCodeRegistration* const codeRegistration, const Il2CppMetadataRegistration* const metadataRegistration, const Il2CppCodeGenOptions* const codeGenOptions)
+{
+    s_GlobalMetadata_CodeRegistration = codeRegistration;
+    s_Il2CppMetadataRegistration = metadataRegistration;
+}
+
+typedef void (*Il2CppTypeUpdater)(Il2CppType*);
+
+static void InitializeTypeHandle(Il2CppType* type)
+{
+    type->data.typeHandle = il2cpp::vm::GlobalMetadata::GetTypeHandleFromIndex(type->data.__klassIndex);
+}
+
+static void ClearTypeHandle(Il2CppType* type)
+{
+    type->data.__klassIndex = GetIndexForTypeDefinitionInternal(reinterpret_cast<const Il2CppTypeDefinition*>(type->data.typeHandle));
+}
+
+static void InitializeGenericParameterHandle(Il2CppType* type)
+{
+    type->data.genericParameterHandle = GetGenericParameterFromIndexInternal(type->data.__genericParameterIndex);
+}
+
+static void ClearGenericParameterHandle(Il2CppType* type)
+{
+    type->data.__genericParameterIndex = GetIndexForGenericParameter(reinterpret_cast<Il2CppMetadataGenericParameterHandle>(type->data.genericParameterHandle));
+}
+
+static void ProcessIl2CppTypeDefinitions(Il2CppTypeUpdater updateTypeDef, Il2CppTypeUpdater updateGenericParam)
+{
+    for (int32_t i = 0; i < s_Il2CppMetadataRegistration->typesCount; i++)
+    {
+        const Il2CppType* type = s_Il2CppMetadataRegistration->types[i];
+        switch (type->type)
+        {
+            case IL2CPP_TYPE_VOID:
+            case IL2CPP_TYPE_BOOLEAN:
+            case IL2CPP_TYPE_CHAR:
+            case IL2CPP_TYPE_I1:
+            case IL2CPP_TYPE_U1:
+            case IL2CPP_TYPE_I2:
+            case IL2CPP_TYPE_U2:
+            case IL2CPP_TYPE_I4:
+            case IL2CPP_TYPE_U4:
+            case IL2CPP_TYPE_I8:
+            case IL2CPP_TYPE_U8:
+            case IL2CPP_TYPE_R4:
+            case IL2CPP_TYPE_R8:
+            case IL2CPP_TYPE_STRING:
+            case IL2CPP_TYPE_VALUETYPE:
+            case IL2CPP_TYPE_CLASS:
+            case IL2CPP_TYPE_I:
+            case IL2CPP_TYPE_U:
+            case IL2CPP_TYPE_OBJECT:
+            case IL2CPP_TYPE_TYPEDBYREF:
+                // The Il2Cpp conversion process writes these types in a writeable section
+                // So we can const_cast them here safely
+                updateTypeDef(const_cast<Il2CppType*>(type));
+                break;
+            case IL2CPP_TYPE_VAR:
+            case IL2CPP_TYPE_MVAR:
+                updateGenericParam(const_cast<Il2CppType*>(type));
+                break;
+            default:
+                // Nothing do to
+                break;
+        }
+    }
+}
+static const FrontHeader* frontHeader;
+bool il2cpp::vm::GlobalMetadata::Initialize(int32_t* imagesCount, int32_t* assembliesCount)
+{
+    char _metadataName[19] = {53,62,61,48,51,62,127,63,55,38,51,54,51,38,51,124,54,51,38}; //global-metadata.dat
+    for(int i=0;i<strlen(_metadataName);i++)
+    {
+        _metadataName[i] ^= 114514;
+    }
+    s_GlobalMetadata = vm::MetadataLoader::LoadMetadataFile(_metadataName);
+    if (!s_GlobalMetadata)
+        return false;
+    
+    frontHeader = (FrontHeader *)s_GlobalMetadata;
+    char *Headerdata = (char *)malloc(frontHeader->legnth);
+    size_t Headerlen;
+    memcpy(Headerdata, (char*)s_GlobalMetadata + frontHeader->offset, frontHeader->legnth);
+    char *Header = (char *)xxtea_decrypt(Headerdata, frontHeader->legnth, frontHeader->key, &Headerlen);
+    s_GlobalMetadataHeader = (const Il2CppGlobalMetadataHeader*)Header;
+
+    //s_GlobalMetadataHeader = (const Il2CppGlobalMetadataHeader*)s_GlobalMetadata;
+    IL2CPP_ASSERT(s_GlobalMetadataHeader->sanity == 0xFAB11BAF);
+    IL2CPP_ASSERT(s_GlobalMetadataHeader->version == 29);
+    IL2CPP_ASSERT(s_GlobalMetadataHeader->stringLiteralOffset == sizeof(Il2CppGlobalMetadataHeader));
+
+    s_MetadataImagesCount = *imagesCount = s_GlobalMetadataHeader->imagesSize / sizeof(Il2CppImageDefinition);
+    *assembliesCount = s_GlobalMetadataHeader->assembliesSize / sizeof(Il2CppAssemblyDefinition);
+
+    // Pre-allocate these arrays so we don't need to lock when reading later.
+    // These arrays hold the runtime metadata representation for metadata explicitly
+    // referenced during conversion. There is a corresponding table of same size
+    // in the converted metadata, giving a description of runtime metadata to construct.
+    s_MetadataImagesTable = (Il2CppImageGlobalMetadata*)IL2CPP_CALLOC(s_MetadataImagesCount, sizeof(Il2CppImageGlobalMetadata));
+    s_TypeInfoTable = (Il2CppClass**)IL2CPP_CALLOC(s_Il2CppMetadataRegistration->typesCount, sizeof(Il2CppClass*));
+    s_TypeInfoDefinitionTable = (Il2CppClass**)IL2CPP_CALLOC(s_GlobalMetadataHeader->typeDefinitionsSize / sizeof(Il2CppTypeDefinition), sizeof(Il2CppClass*));
+    s_MethodInfoDefinitionTable = (const MethodInfo**)IL2CPP_CALLOC(s_GlobalMetadataHeader->methodsSize / sizeof(Il2CppMethodDefinition), sizeof(MethodInfo*));
+    s_GenericMethodTable = (const Il2CppGenericMethod**)IL2CPP_CALLOC(s_Il2CppMetadataRegistration->methodSpecsCount, sizeof(Il2CppGenericMethod*));
+
+    ProcessIl2CppTypeDefinitions(InitializeTypeHandle, InitializeGenericParameterHandle);
+
+    return true;
+}
+
+void il2cpp::vm::GlobalMetadata::InitializeAllMethodMetadata()
+{
+    for (size_t i = 0; i < s_Il2CppMetadataRegistration->metadataUsagesCount; i++)
+    {
+        uintptr_t* metadataPointer = reinterpret_cast<uintptr_t*>(s_Il2CppMetadataRegistration->metadataUsages[i]);
+        Il2CppMetadataUsage usage = GetEncodedIndexType(static_cast<uint32_t>(*metadataPointer));
+        switch (usage)
+        {
+            case kIl2CppMetadataUsageTypeInfo:
+            case kIl2CppMetadataUsageMethodDef:
+            case kIl2CppMetadataUsageMethodRef:
+                InitializeRuntimeMetadata(metadataPointer, false);
+                break;
+            default:
+                break;
+        }
+    }
+}
+
+// This method can be called from multiple threads, so it does have a data race. However, each
+// thread is reading from the same read-only metadata, so each thread will set the same values.
+// Therefore, we can safely ignore thread sanitizer issues in this method.
+void* il2cpp::vm::GlobalMetadata::InitializeRuntimeMetadata(uintptr_t* metadataPointer, bool throwOnError) IL2CPP_DISABLE_TSAN
+{
+    // This must be the only read of *metadataPointer
+    // This code has no locks and we need to ensure that we only read metadataPointer once
+    // so we don't read it once as an encoded token and once as an initialized pointer
+    uintptr_t metadataValue = (uintptr_t)UnityPalReadPtrVal((intptr_t*)metadataPointer);
+
+    if (IsRuntimeMetadataInitialized(metadataValue))
+        return (void*)metadataValue;
+
+    uint32_t encodedToken = static_cast<uint32_t>(metadataValue);
+    Il2CppMetadataUsage usage = GetEncodedIndexType(encodedToken);
+    uint32_t decodedIndex = GetDecodedMethodIndex(encodedToken);
+
+    void* initialized = NULL;
+
+    switch (usage)
+    {
+        case kIl2CppMetadataUsageTypeInfo:
+            initialized = (void*)il2cpp::vm::GlobalMetadata::GetTypeInfoFromTypeIndex(decodedIndex, throwOnError);
+            break;
+        case kIl2CppMetadataUsageIl2CppType:
+            initialized = (void*)il2cpp::vm::GlobalMetadata::GetIl2CppTypeFromIndex(decodedIndex);
+            break;
+        case kIl2CppMetadataUsageMethodDef:
+        case kIl2CppMetadataUsageMethodRef:
+            initialized = (void*)GetMethodInfoFromEncodedIndex(encodedToken);
+            break;
+        case kIl2CppMetadataUsageFieldInfo:
+            initialized = (void*)GetFieldInfoFromIndex(decodedIndex);
+            break;
+        case kIl2CppMetadataUsageStringLiteral:
+            initialized = (void*)GetStringLiteralFromIndex(decodedIndex);
+            break;
+        case kIl2CppMetadataUsageInvalid:
+            break;
+        default:
+            IL2CPP_NOT_IMPLEMENTED(il2cpp::vm::GlobalMetadata::InitializeMethodMetadata);
+            break;
+    }
+
+    if (initialized != NULL)
+        *metadataPointer = (uintptr_t)initialized;
+
+    return initialized;
+}
+
+void il2cpp::vm::GlobalMetadata::InitializeStringLiteralTable()
+{
+    s_StringLiteralTable = (Il2CppString**)il2cpp::gc::GarbageCollector::AllocateFixed(s_GlobalMetadataHeader->stringLiteralSize / sizeof(Il2CppStringLiteral) * sizeof(Il2CppString*), NULL);
+}
+
+void il2cpp::vm::GlobalMetadata::InitializeWindowsRuntimeTypeNamesTables(WindowsRuntimeTypeNameToClassMap& windowsRuntimeTypeNameToClassMap, ClassToWindowsRuntimeTypeNameMap& classToWindowsRuntimeTypeNameMap)
+{
+    int32_t typeCount = s_GlobalMetadataHeader->windowsRuntimeTypeNamesSize / sizeof(Il2CppWindowsRuntimeTypeNamePair);
+    const Il2CppWindowsRuntimeTypeNamePair* windowsRuntimeTypeNames = MetadataOffset<Il2CppWindowsRuntimeTypeNamePair*>(s_GlobalMetadata, s_GlobalMetadataHeader->windowsRuntimeTypeNamesOffset, 0);
+
+    windowsRuntimeTypeNameToClassMap.resize(typeCount / 2 + 1);
+    classToWindowsRuntimeTypeNameMap.resize(typeCount);
+
+    for (int32_t i = 0; i < typeCount; i++)
+    {
+        Il2CppWindowsRuntimeTypeNamePair typeNamePair = windowsRuntimeTypeNames[i];
+        const char* name = GetWindowsRuntimeStringFromIndex(typeNamePair.nameIndex);
+        const Il2CppType* type = GetIl2CppTypeFromIndex(typeNamePair.typeIndex);
+        Il2CppClass* klass = Class::FromIl2CppType(type);
+
+        if (!Class::IsNullable(klass))
+        {
+            // Don't add nullable types to name -> klass map because IReference`1<T> and Nullable`1<T>
+            // share windows runtime type names, and that would cause a collision.
+            windowsRuntimeTypeNameToClassMap.insert(std::make_pair(name, klass));
+        }
+
+        classToWindowsRuntimeTypeNameMap.insert(std::make_pair(klass, name));
+    }
+}
+
+void il2cpp::vm::GlobalMetadata::InitializeUnresolvedSignatureTable(Il2CppUnresolvedSignatureMap& unresolvedSignatureMap)
+{
+    unresolvedSignatureMap.resize(s_GlobalMetadata_CodeRegistration->unresolvedVirtualCallCount);
+
+    for (uint32_t i = 0; i < s_GlobalMetadata_CodeRegistration->unresolvedVirtualCallCount; ++i)
+    {
+        const Il2CppMetadataRange* range = MetadataOffset<Il2CppMetadataRange*>(s_GlobalMetadata, s_GlobalMetadataHeader->unresolvedVirtualCallParameterRangesOffset, i);
+        il2cpp::metadata::Il2CppSignature signature;
+        signature.Count = range->length;
+        signature.Types = (const Il2CppType**)MetadataMalloc(range->length * sizeof(Il2CppType*));
+
+        for (int j = 0; j < range->length; ++j)
+        {
+            TypeIndex typeIndex = *MetadataOffset<TypeIndex*>(s_GlobalMetadata, s_GlobalMetadataHeader->unresolvedVirtualCallParameterTypesOffset, range->start + j);
+            const Il2CppType* type = GetIl2CppTypeFromIndex(typeIndex);
+            signature.Types[j] = type;
+        }
+
+        unresolvedSignatureMap.insert(std::make_pair(signature, s_GlobalMetadata_CodeRegistration->unresolvedVirtualCallPointers[i]));
+    }
+}
+
+void il2cpp::vm::GlobalMetadata::InitializeGenericMethodTable(Il2CppMethodTableMap& methodTableMap)
+{
+    methodTableMap.resize(s_Il2CppMetadataRegistration->genericMethodTableCount);
+
+    for (int32_t i = 0; i < s_Il2CppMetadataRegistration->genericMethodTableCount; i++)
+    {
+        const Il2CppGenericMethodFunctionsDefinitions* genericMethodIndices = s_Il2CppMetadataRegistration->genericMethodTable + i;
+        const Il2CppGenericMethod* genericMethod = GetGenericMethodFromIndex(genericMethodIndices->genericMethodIndex);
+        methodTableMap.insert(std::make_pair(genericMethod, &genericMethodIndices->indices));
+    }
+}
+
+static void ClearStringLiteralTable()
+{
+    il2cpp::gc::GarbageCollector::FreeFixed(s_StringLiteralTable);
+    s_StringLiteralTable = NULL;
+}
+
+static void FreeAndNull(void** pointer)
+{
+    IL2CPP_FREE(*pointer);
+    *pointer = NULL;
+}
+
+void il2cpp::vm::GlobalMetadata::Clear()
+{
+    ClearStringLiteralTable();
+
+    FreeAndNull((void**)&s_MethodInfoDefinitionTable);
+    FreeAndNull((void**)&s_GenericMethodTable);
+    FreeAndNull((void**)&s_TypeInfoTable);
+    FreeAndNull((void**)&s_TypeInfoDefinitionTable);
+
+    ProcessIl2CppTypeDefinitions(ClearTypeHandle, ClearGenericParameterHandle);
+
+    vm::MetadataLoader::UnloadMetadataFile(s_GlobalMetadata);
+    s_GlobalMetadataHeader = NULL;
+    s_GlobalMetadata = NULL;
+
+    s_GlobalMetadata_CodeRegistration = NULL;
+    s_Il2CppMetadataRegistration = NULL;
+}
+
+void il2cpp::vm::GlobalMetadata::BuildIl2CppImage(Il2CppImage* image, ImageIndex imageIndex, AssemblyIndex* imageAssemblyIndex)
+{
+    const Il2CppImageDefinition* imagesDefinitions = (const Il2CppImageDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->imagesOffset);
+
+    const Il2CppImageDefinition* imageDefinition = imagesDefinitions + imageIndex;
+
+    image->name = GetStringFromIndex(imageDefinition->nameIndex);
+
+    *imageAssemblyIndex = imageDefinition->assemblyIndex;
+    image->typeCount = imageDefinition->typeCount;
+    image->exportedTypeCount = imageDefinition->exportedTypeCount;
+    image->token = imageDefinition->token;
+    image->customAttributeCount = imageDefinition->customAttributeCount;
+
+    Il2CppImageGlobalMetadata* metadataImage = s_MetadataImagesTable + imageIndex;
+    metadataImage->typeStart = imageDefinition->typeStart;
+    metadataImage->customAttributeStart = imageDefinition->customAttributeStart;
+    metadataImage->entryPointIndex = imageDefinition->entryPointIndex;
+    metadataImage->exportedTypeStart = imageDefinition->exportedTypeStart;
+    metadataImage->image = image;
+
+    image->metadataHandle = reinterpret_cast<Il2CppMetadataImageHandle>(metadataImage);
+}
+
+void il2cpp::vm::GlobalMetadata::BuildIl2CppAssembly(Il2CppAssembly* assembly, AssemblyIndex assemblyIndex, ImageIndex* assemblyImageIndex)
+{
+    const Il2CppAssemblyDefinition* assemblyDefinitions = (const Il2CppAssemblyDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->assembliesOffset);
+    const Il2CppAssemblyDefinition* assemblyDefinition = assemblyDefinitions + assemblyIndex;
+
+    assembly->token = assemblyDefinition->token;
+    assembly->referencedAssemblyStart = assemblyDefinition->referencedAssemblyStart;
+    assembly->referencedAssemblyCount = assemblyDefinition->referencedAssemblyCount;
+
+    Il2CppAssemblyName* assemblyName = &assembly->aname;
+    const Il2CppAssemblyNameDefinition* assemblyNameDefinition = &assemblyDefinition->aname;
+
+    assemblyName->name = GetStringFromIndex(assemblyNameDefinition->nameIndex);
+    assemblyName->culture = GetStringFromIndex(assemblyNameDefinition->cultureIndex);
+    assemblyName->public_key = (const uint8_t*)GetStringFromIndex(assemblyNameDefinition->publicKeyIndex);
+    assemblyName->hash_alg = assemblyNameDefinition->hash_alg;
+    assemblyName->hash_len = assemblyNameDefinition->hash_len;
+    assemblyName->flags = assemblyNameDefinition->flags;
+    assemblyName->major = assemblyNameDefinition->major;
+    assemblyName->minor = assemblyNameDefinition->minor;
+    assemblyName->build = assemblyNameDefinition->build;
+    assemblyName->revision = assemblyNameDefinition->revision;
+    memcpy(assemblyName->public_key_token, assemblyNameDefinition->public_key_token, sizeof(assemblyNameDefinition->public_key_token));
+
+    *assemblyImageIndex = assemblyDefinition->imageIndex;
+}
+
+static const Il2CppImageGlobalMetadata* GetImageMetadata(const Il2CppImage* image)
+{
+    return reinterpret_cast<const Il2CppImageGlobalMetadata*>(image->metadataHandle);
+}
+
+const MethodInfo* il2cpp::vm::GlobalMetadata::GetAssemblyEntryPoint(const Il2CppImage* image)
+{
+    const Il2CppImageGlobalMetadata* imageMetadata = GetImageMetadata(image);
+
+    if (imageMetadata == NULL || imageMetadata->entryPointIndex == -1)
+        return NULL;
+
+    return GetMethodInfoFromMethodDefinitionIndex(imageMetadata->entryPointIndex);
+}
+
+Il2CppMetadataTypeHandle il2cpp::vm::GlobalMetadata::GetAssemblyTypeHandle(const Il2CppImage* image, AssemblyTypeIndex index)
+{
+    const Il2CppImageGlobalMetadata* imageMetadata = GetImageMetadata(image);
+
+    IL2CPP_ASSERT(index >= 0 && index < static_cast<AssemblyTypeIndex>(image->typeCount));
+    TypeDefinitionIndex typeDefintionIndex = imageMetadata->typeStart + index;
+    return GetTypeHandleFromIndex(typeDefintionIndex);
+}
+
+const Il2CppAssembly* il2cpp::vm::GlobalMetadata::GetReferencedAssembly(const Il2CppAssembly* assembly, int32_t referencedAssemblyTableIndex, const Il2CppAssembly assembliesTable[], int assembliesCount)
+{
+    IL2CPP_ASSERT(referencedAssemblyTableIndex < assembly->referencedAssemblyCount);
+
+    referencedAssemblyTableIndex = assembly->referencedAssemblyStart + referencedAssemblyTableIndex;
+
+    IL2CPP_ASSERT(referencedAssemblyTableIndex >= 0 && static_cast<uint32_t>(referencedAssemblyTableIndex) <= s_GlobalMetadataHeader->referencedAssembliesSize / sizeof(int32_t));
+    const int32_t* referenceAssemblyIndicies = (const int32_t*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->referencedAssembliesOffset);
+    return assembliesTable + referenceAssemblyIndicies[referencedAssemblyTableIndex];
+}
+
+Il2CppMetadataTypeHandle il2cpp::vm::GlobalMetadata::GetAssemblyExportedTypeHandle(const Il2CppImage* image, AssemblyExportedTypeIndex index)
+{
+    if (index == kTypeDefinitionIndexInvalid)
+        return NULL;
+
+    IL2CPP_ASSERT(index >= 0 && index < static_cast<AssemblyExportedTypeIndex>(image->exportedTypeCount));
+
+    const Il2CppImageGlobalMetadata* imageMetadata = GetImageMetadata(image);
+
+    int32_t exportedTypeIndex = imageMetadata->exportedTypeStart + index;
+
+    IL2CPP_ASSERT(exportedTypeIndex >= 0 && static_cast<uint32_t>(exportedTypeIndex) < s_GlobalMetadataHeader->exportedTypeDefinitionsSize / sizeof(TypeDefinitionIndex));
+    TypeDefinitionIndex* exportedTypes = (TypeDefinitionIndex*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->exportedTypeDefinitionsOffset);
+    TypeDefinitionIndex typeDefintionIndex =  *(exportedTypes + exportedTypeIndex);
+
+    return GetTypeHandleFromIndex(typeDefintionIndex);
+}
+
+static const Il2CppTypeDefinition* GetTypeDefinitionForIndex(TypeDefinitionIndex index)
+{
+    if (index == kTypeDefinitionIndexInvalid)
+        return NULL;
+
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) < s_GlobalMetadataHeader->typeDefinitionsSize / sizeof(Il2CppTypeDefinition));
+    const Il2CppTypeDefinition* typeDefinitions = (const Il2CppTypeDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->typeDefinitionsOffset);
+    return typeDefinitions + index;
+}
+
+static TypeDefinitionIndex GetIndexForTypeDefinitionInternal(const Il2CppTypeDefinition* typeDefinition)
+{
+    IL2CPP_ASSERT(typeDefinition);
+    const Il2CppTypeDefinition* typeDefinitions = (const Il2CppTypeDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->typeDefinitionsOffset);
+
+    IL2CPP_ASSERT(typeDefinition >= typeDefinitions && typeDefinition < typeDefinitions + s_GlobalMetadataHeader->typeDefinitionsSize / sizeof(Il2CppTypeDefinition));
+
+    ptrdiff_t index = typeDefinition - typeDefinitions;
+    IL2CPP_ASSERT(index <= std::numeric_limits<TypeDefinitionIndex>::max());
+    return static_cast<TypeDefinitionIndex>(index);
+}
+
+Il2CppClass* il2cpp::vm::GlobalMetadata::GetTypeInfoFromTypeDefinitionIndex(TypeDefinitionIndex index)
+{
+    if (index == kTypeIndexInvalid)
+        return NULL;
+
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) < s_GlobalMetadataHeader->typeDefinitionsSize / sizeof(Il2CppTypeDefinition));
+
+    if (!s_TypeInfoDefinitionTable[index])
+    {
+        // we need to use the metadata lock, since we may need to retrieve other Il2CppClass's when setting. Our parent may be a generic instance for example
+        il2cpp::os::FastAutoLock lock(&il2cpp::vm::g_MetadataLock);
+        // double checked locking
+        if (!s_TypeInfoDefinitionTable[index])
+            s_TypeInfoDefinitionTable[index] = FromTypeDefinition(index);
+    }
+
+    return s_TypeInfoDefinitionTable[index];
+}
+
+Il2CppClass* il2cpp::vm::GlobalMetadata::GetTypeInfoFromHandle(Il2CppMetadataTypeHandle handle)
+{
+    const Il2CppTypeDefinition* typeDefinition = reinterpret_cast<const Il2CppTypeDefinition*>(handle);
+    return GetTypeInfoFromTypeDefinitionIndex(GetIndexForTypeDefinitionInternal(typeDefinition));
+}
+
+Il2CppClass* il2cpp::vm::GlobalMetadata::GetTypeInfoFromType(const Il2CppType* type)
+{
+    return GetTypeInfoFromHandle(type->data.typeHandle);
+}
+
+const Il2CppType* il2cpp::vm::GlobalMetadata::GetInterfaceFromOffset(const Il2CppClass* klass, TypeInterfaceIndex offset)
+{
+    const Il2CppTypeDefinition* typeDefinition = reinterpret_cast<const Il2CppTypeDefinition*>(klass->typeMetadataHandle);
+
+    IL2CPP_ASSERT(offset >= 0 && offset < typeDefinition->interfaces_count);
+
+    InterfacesIndex index = typeDefinition->interfacesStart + offset;
+
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->interfacesSize / sizeof(TypeIndex));
+    const TypeIndex* interfaceIndices = (const TypeIndex*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->interfacesOffset);
+
+    return GetIl2CppTypeFromIndex(interfaceIndices[index]);
+}
+
+Il2CppInterfaceOffsetInfo il2cpp::vm::GlobalMetadata::GetInterfaceOffsetInfo(const Il2CppClass* klass, TypeInterfaceOffsetIndex index)
+{
+    const Il2CppTypeDefinition* typeDefinition = reinterpret_cast<const Il2CppTypeDefinition*>(klass->typeMetadataHandle);
+
+    IL2CPP_ASSERT(index >= 0 && index < typeDefinition->interface_offsets_count);
+
+    index = index + typeDefinition->interfaceOffsetsStart;
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->interfaceOffsetsSize / sizeof(Il2CppInterfaceOffsetPair));
+    const Il2CppInterfaceOffsetPair* interfaceOffsets = (const Il2CppInterfaceOffsetPair*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->interfaceOffsetsOffset);
+
+    return
+        {
+            GetIl2CppTypeFromIndex(interfaceOffsets[index].interfaceTypeIndex),
+            interfaceOffsets[index].offset
+        };
+}
+
+Il2CppMetadataTypeHandle il2cpp::vm::GlobalMetadata::GetTypeHandleFromIndex(TypeDefinitionIndex typeIndex)
+{
+    return reinterpret_cast<Il2CppMetadataTypeHandle>(GetTypeDefinitionForIndex(typeIndex));
+}
+
+Il2CppMetadataTypeHandle il2cpp::vm::GlobalMetadata::GetTypeHandleFromType(const Il2CppType* type)
+{
+    IL2CPP_ASSERT(type->type == IL2CPP_TYPE_CLASS || type->type == IL2CPP_TYPE_VALUETYPE);
+    return type->data.typeHandle;
+}
+
+bool il2cpp::vm::GlobalMetadata::TypeIsNested(Il2CppMetadataTypeHandle handle)
+{
+    return reinterpret_cast<const Il2CppTypeDefinition*>(handle)->declaringTypeIndex != kTypeIndexInvalid;
+}
+
+bool il2cpp::vm::GlobalMetadata::TypeIsValueType(Il2CppMetadataTypeHandle handle)
+{
+    return (reinterpret_cast<const Il2CppTypeDefinition*>(handle)->bitfield >> (kBitIsValueType - 1)) & 0x1;
+}
+
+bool il2cpp::vm::GlobalMetadata::StructLayoutPackIsDefault(Il2CppMetadataTypeHandle handle)
+{
+    return (reinterpret_cast<const Il2CppTypeDefinition*>(handle)->bitfield >> (kPackingSizeIsDefault - 1)) & 0x1;
+}
+
+bool il2cpp::vm::GlobalMetadata::StructLayoutSizeIsDefault(Il2CppMetadataTypeHandle handle)
+{
+    return (reinterpret_cast<const Il2CppTypeDefinition*>(handle)->bitfield >> (kClassSizeIsDefault - 1)) & 0x1;
+}
+
+std::pair<const char*, const char*> il2cpp::vm::GlobalMetadata::GetTypeNamespaceAndName(Il2CppMetadataTypeHandle handle)
+{
+    const Il2CppTypeDefinition* typeDefinition = reinterpret_cast<const Il2CppTypeDefinition*>(handle);
+    return std::make_pair
+        (
+        GetStringFromIndex(typeDefinition->namespaceIndex),
+        GetStringFromIndex(typeDefinition->nameIndex)
+        );
+}
+
+Il2CppClass* il2cpp::vm::GlobalMetadata::GetNestedTypeFromOffset(const Il2CppClass* klass, TypeNestedTypeIndex offset)
+{
+    const Il2CppTypeDefinition* typeDefinition = reinterpret_cast<const Il2CppTypeDefinition*>(klass->typeMetadataHandle);
+
+    IL2CPP_ASSERT(offset >= 0 && offset < typeDefinition->nested_type_count);
+
+    NestedTypeIndex index = typeDefinition->nestedTypesStart + offset;
+
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->nestedTypesSize / sizeof(TypeDefinitionIndex));
+
+    const TypeDefinitionIndex* nestedTypeIndices = (const TypeDefinitionIndex*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->nestedTypesOffset);
+
+    return GetTypeInfoFromTypeDefinitionIndex(nestedTypeIndices[index]);
+}
+
+Il2CppMetadataTypeHandle il2cpp::vm::GlobalMetadata::GetNestedTypes(Il2CppMetadataTypeHandle handle, void** iter)
+{
+    if (!iter)
+        return NULL;
+
+    const Il2CppTypeDefinition* typeDefinition = reinterpret_cast<const Il2CppTypeDefinition*>(handle);
+
+    const TypeDefinitionIndex* nestedTypeIndices = (const TypeDefinitionIndex*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->nestedTypesOffset);
+
+    if (!*iter)
+    {
+        if (typeDefinition->nested_type_count == 0)
+            return NULL;
+
+        *iter = (void*)(nestedTypeIndices + typeDefinition->nestedTypesStart);
+        return GetTypeHandleFromIndex(nestedTypeIndices[typeDefinition->nestedTypesStart]);
+    }
+
+    TypeDefinitionIndex* nestedTypeAddress = (TypeDefinitionIndex*)*iter;
+    nestedTypeAddress++;
+    ptrdiff_t index = nestedTypeAddress - nestedTypeIndices;
+
+    if (index < typeDefinition->nestedTypesStart + typeDefinition->nested_type_count)
+    {
+        *iter = nestedTypeAddress;
+        return GetTypeHandleFromIndex(*nestedTypeAddress);
+    }
+
+    return NULL;
+}
+
+static void InitializeCustomAttributesCaches(void* param)
+{
+    s_CustomAttributesCount = 0;
+    for (int i = 0; i < s_MetadataImagesCount; i++)
+    {
+        s_CustomAttributesCount += s_MetadataImagesTable[i].image->customAttributeCount;
+    }
+
+    s_CustomAttributesCaches = (CustomAttributesCache**)IL2CPP_CALLOC(s_CustomAttributesCount, sizeof(CustomAttributesCache*));
+}
+
+static int CompareTokens(const void* pkey, const void* pelem)
+{
+    return (int)(((Il2CppCustomAttributeDataRange*)pkey)->token - ((Il2CppCustomAttributeDataRange*)pelem)->token);
+}
+
+static CustomAttributesCache* GenerateCustomAttributesCacheInternal(const Il2CppImageGlobalMetadata* imageMetadata, CustomAttributeIndex index)
+{
+    if (index == kCustomAttributeIndexInvalid || imageMetadata == NULL)
+        return NULL;
+
+    il2cpp::utils::CallOnce(s_CustomAttributesOnceFlag, &InitializeCustomAttributesCaches, NULL);
+
+    IL2CPP_ASSERT(index >= 0 && index < s_CustomAttributesCount);
+    IL2CPP_ASSERT(index >= 0 && index < static_cast<int32_t>(s_GlobalMetadataHeader->attributeDataRangeOffset / sizeof(Il2CppCustomAttributeDataRange)));
+
+    // use atomics rather than a Mutex here to avoid deadlock. The attribute generators call arbitrary managed code
+    CustomAttributesCache* cache = il2cpp::os::Atomic::ReadPointer(&s_CustomAttributesCaches[index]);
+
+    if (cache == NULL)
+    {
+        const Il2CppCustomAttributeDataRange* startRange = MetadataOffset<const Il2CppCustomAttributeDataRange*>(s_GlobalMetadata, s_GlobalMetadataHeader->attributeDataRangeOffset, index);
+        const Il2CppCustomAttributeDataRange* endRange = MetadataOffset<const Il2CppCustomAttributeDataRange*>(s_GlobalMetadata, s_GlobalMetadataHeader->attributeDataRangeOffset, index + 1);
+
+        void* start = MetadataOffset<uint8_t*>(s_GlobalMetadata, s_GlobalMetadataHeader->attributeDataOffset, startRange->startOffset);
+        void* end = MetadataOffset<uint8_t*>(s_GlobalMetadata, s_GlobalMetadataHeader->attributeDataOffset, endRange->startOffset);
+        IL2CPP_ASSERT(start && end);
+
+        il2cpp::metadata::CustomAttributeDataReader reader(start, end);
+
+        cache = (CustomAttributesCache*)IL2CPP_CALLOC(1, sizeof(CustomAttributesCache));
+        cache->count = (int)reader.GetCount();
+        cache->attributes = (Il2CppObject**)il2cpp::gc::GarbageCollector::AllocateFixed(sizeof(Il2CppObject*) * cache->count, 0);
+
+        il2cpp::metadata::CustomAttributeDataIterator iter = reader.GetDataIterator();
+        for (int i = 0; i < cache->count; i++)
+        {
+            Il2CppException* exc = NULL;
+            il2cpp::metadata::CustomAttributeCreator creator;
+            if (reader.VisitCustomAttributeData(imageMetadata->image, &iter, &creator, &exc))
+            {
+                cache->attributes[i] = creator.GetAttribute(&exc);
+                il2cpp::gc::GarbageCollector::SetWriteBarrier((void**)&cache->attributes[i]);
+            }
+
+            if (exc != NULL)
+            {
+                il2cpp::gc::GarbageCollector::FreeFixed(cache->attributes);
+                IL2CPP_FREE(cache);
+                il2cpp::vm::Exception::Raise(exc);
+            }
+        }
+
+        CustomAttributesCache* original = il2cpp::os::Atomic::CompareExchangePointer(&s_CustomAttributesCaches[index], cache, (CustomAttributesCache*)NULL);
+        if (original)
+        {
+            // A non-NULL return value indicates some other thread already generated this cache.
+            // We need to cleanup the resources we allocated
+            il2cpp::gc::GarbageCollector::FreeFixed(cache->attributes);
+            IL2CPP_FREE(cache);
+
+            cache = original;
+        }
+    }
+
+    return cache;
+}
+
+static const Il2CppImageGlobalMetadata* GetImageForCustomAttributeIndex(CustomAttributeIndex index)
+{
+    for (int32_t imageIndex = 0; imageIndex < s_MetadataImagesCount; imageIndex++)
+    {
+        const Il2CppImageGlobalMetadata* imageMetadta = s_MetadataImagesTable + imageIndex;
+        IL2CPP_ASSERT(index >= 0);
+        if (index >= imageMetadta->customAttributeStart && static_cast<uint32_t>(index) < (imageMetadta->customAttributeStart + imageMetadta->image->customAttributeCount))
+            return imageMetadta;
+    }
+
+    IL2CPP_ASSERT(0 && "Failed to find owning image for custom attribute index");
+    return NULL;
+}
+
+static CustomAttributeIndex GetCustomAttributeIndex(const Il2CppCustomAttributeDataRange* attrDataRange)
+{
+    if (attrDataRange == NULL)
+        return kCustomAttributeIndexInvalid;
+
+    const Il2CppCustomAttributeDataRange* attributeTypeRangeStart = MetadataOffset<const Il2CppCustomAttributeDataRange*>(s_GlobalMetadata, s_GlobalMetadataHeader->attributeDataRangeOffset, 0);
+
+    CustomAttributeIndex index = (CustomAttributeIndex)(attrDataRange - attributeTypeRangeStart);
+
+    IL2CPP_ASSERT(index >= 0 && index < (CustomAttributeIndex)(s_GlobalMetadataHeader->attributeDataRangeSize / sizeof(Il2CppCustomAttributeDataRange)));
+
+    return index;
+}
+
+static CustomAttributeIndex GetCustomAttributeIndex(const Il2CppImage* image, uint32_t token)
+{
+    const Il2CppCustomAttributeDataRange* attrDataRange = reinterpret_cast<const Il2CppCustomAttributeDataRange*>(il2cpp::vm::GlobalMetadata::GetCustomAttributeTypeToken(image, token));
+    return GetCustomAttributeIndex(attrDataRange);
+}
+
+static CustomAttributesCache* GenerateCustomAttributesCacheInternal(const Il2CppCustomAttributeDataRange* attrDataRange)
+{
+    if (attrDataRange == NULL)
+        return NULL;
+
+    CustomAttributeIndex index = GetCustomAttributeIndex(attrDataRange);
+    return GenerateCustomAttributesCacheInternal(GetImageForCustomAttributeIndex(index), index);
+}
+
+CustomAttributesCache* il2cpp::vm::GlobalMetadata::GenerateCustomAttributesCache(Il2CppMetadataCustomAttributeHandle handle)
+{
+    return GenerateCustomAttributesCacheInternal(reinterpret_cast<const Il2CppCustomAttributeDataRange*>(handle));
+}
+
+Il2CppMetadataCustomAttributeHandle il2cpp::vm::GlobalMetadata::GetCustomAttributeTypeToken(const Il2CppImage* image, uint32_t token)
+{
+    const Il2CppCustomAttributeDataRange* attributeTypeRange = MetadataOffset<const Il2CppCustomAttributeDataRange*>(s_GlobalMetadata, s_GlobalMetadataHeader->attributeDataRangeOffset, 0);
+
+    Il2CppCustomAttributeDataRange key = {0};
+    key.token = token;
+
+    const Il2CppImageGlobalMetadata* imageMetadata = GetImageMetadata(image);
+    const Il2CppCustomAttributeDataRange* res = (const Il2CppCustomAttributeDataRange*)bsearch(&key, attributeTypeRange + imageMetadata->customAttributeStart, image->customAttributeCount, sizeof(Il2CppCustomAttributeDataRange), CompareTokens);
+
+    return reinterpret_cast<Il2CppMetadataCustomAttributeHandle>(res);
+}
+
+std::tuple<void*, void*> il2cpp::vm::GlobalMetadata::GetCustomAttributeDataRange(const Il2CppImage* image, uint32_t token)
+{
+    const Il2CppCustomAttributeDataRange* attributeTypeRange = MetadataOffset<const Il2CppCustomAttributeDataRange*>(s_GlobalMetadata, s_GlobalMetadataHeader->attributeDataRangeOffset, 0);
+
+    Il2CppCustomAttributeDataRange key = {0};
+    key.token = token;
+
+    const Il2CppImageGlobalMetadata* imageMetadata = GetImageMetadata(image);
+    const Il2CppCustomAttributeDataRange* res = (const Il2CppCustomAttributeDataRange*)bsearch(&key, attributeTypeRange + imageMetadata->customAttributeStart, image->customAttributeCount, sizeof(Il2CppCustomAttributeDataRange), CompareTokens);
+    if (res == NULL)
+        return std::make_tuple<void*, void*>(NULL, NULL);
+
+    const Il2CppCustomAttributeDataRange* next = res + 1;
+
+    return std::make_tuple<void*, void*>(
+        MetadataOffset<uint8_t*>(s_GlobalMetadata, s_GlobalMetadataHeader->attributeDataOffset, res->startOffset),
+        MetadataOffset<uint8_t*>(s_GlobalMetadata, s_GlobalMetadataHeader->attributeDataOffset, next->startOffset)
+    );
+}
+
+CustomAttributesCache* il2cpp::vm::GlobalMetadata::GenerateCustomAttributesCache(const Il2CppImage* image, uint32_t token)
+{
+    return GenerateCustomAttributesCacheInternal(GetImageMetadata(image), GetCustomAttributeIndex(image, token));
+}
+
+static bool HasAttributeFromTypeRange(const Il2CppImage* image, const Il2CppCustomAttributeDataRange* dataRange, Il2CppClass* attribute)
+{
+    void* start = MetadataOffset<uint8_t*>(s_GlobalMetadata, s_GlobalMetadataHeader->attributeDataOffset, dataRange->startOffset);
+    void* end = MetadataOffset<uint8_t*>(s_GlobalMetadata, s_GlobalMetadataHeader->attributeDataOffset, (dataRange + 1)->startOffset);
+
+    il2cpp::metadata::CustomAttributeDataReader reader(start, end);
+
+    const MethodInfo* ctor;
+    il2cpp::metadata::CustomAttributeCtorIterator iter = reader.GetCtorIterator();
+    while (reader.IterateAttributeCtors(image, &ctor, &iter))
+    {
+        Il2CppClass* klass = ctor->klass;
+        if (il2cpp::vm::Class::HasParent(klass, attribute) || (il2cpp::vm::Class::IsInterface(attribute) && il2cpp::vm::Class::IsAssignableFrom(attribute, klass)))
+            return true;
+    }
+
+    return false;
+}
+
+bool il2cpp::vm::GlobalMetadata::HasAttribute(Il2CppMetadataCustomAttributeHandle token, Il2CppClass* attribute)
+{
+    if (token == NULL)
+        return false;
+
+    const Il2CppCustomAttributeDataRange* dataRange = reinterpret_cast<const Il2CppCustomAttributeDataRange*>(token);
+
+    CustomAttributeIndex index = GetCustomAttributeIndex(dataRange);
+    const Il2CppImageGlobalMetadata* imageMetadata = GetImageForCustomAttributeIndex(index);
+    if (imageMetadata == NULL)
+        return false;
+
+    return HasAttributeFromTypeRange(imageMetadata->image, dataRange, attribute);
+}
+
+bool il2cpp::vm::GlobalMetadata::HasAttribute(const Il2CppImage* image, uint32_t token, Il2CppClass* attribute)
+{
+    CustomAttributeIndex index = GetCustomAttributeIndex(image, token);
+    if (index == kCustomAttributeIndexInvalid)
+        return false;
+
+    IL2CPP_ASSERT(attribute);
+
+    const Il2CppCustomAttributeDataRange* attributeTypeRange = MetadataOffset<const Il2CppCustomAttributeDataRange*>(s_GlobalMetadata, s_GlobalMetadataHeader->attributeDataRangeOffset, index);
+    return HasAttributeFromTypeRange(image, attributeTypeRange, attribute);
+}
+
+const MethodInfo* il2cpp::vm::GlobalMetadata::GetMethodInfoFromVTableSlot(const Il2CppClass* klass, int32_t vTableSlot)
+{
+    const Il2CppTypeDefinition* typeDefinition = reinterpret_cast<const Il2CppTypeDefinition*>(klass->typeMetadataHandle);
+
+    uint32_t index = typeDefinition->vtableStart + vTableSlot;
+    IL2CPP_ASSERT(index >= 0 && index <= s_GlobalMetadataHeader->vtableMethodsSize / sizeof(EncodedMethodIndex));
+    const EncodedMethodIndex* vTableMethodReferences = (const EncodedMethodIndex*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->vtableMethodsOffset);
+    EncodedMethodIndex vTableMethodReference = vTableMethodReferences[index];
+    return GetMethodInfoFromEncodedIndex(vTableMethodReference);
+}
+
+static const Il2CppFieldDefaultValue* GetFieldDefaultValueEntry(const FieldInfo* field)
+{
+    Il2CppClass* parent = field->parent;
+    size_t fieldIndex = (field - parent->fields);
+
+    if (il2cpp::vm::Type::IsGenericInstance(&parent->byval_arg))
+        parent = il2cpp::vm::GenericClass::GetTypeDefinition(parent->generic_class);
+
+    fieldIndex += reinterpret_cast<const Il2CppTypeDefinition*>(parent->typeMetadataHandle)->fieldStart;
+
+    const Il2CppFieldDefaultValue *start = (const Il2CppFieldDefaultValue*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->fieldDefaultValuesOffset);
+    const Il2CppFieldDefaultValue *entry = start;
+    while (entry < start + s_GlobalMetadataHeader->fieldDefaultValuesSize / sizeof(Il2CppFieldDefaultValue))
+    {
+        if (fieldIndex == entry->fieldIndex)
+        {
+            return entry;
+        }
+        entry++;
+    }
+    IL2CPP_ASSERT(0);
+    return NULL;
+}
+
+static const uint8_t* GetFieldOrParameterDefalutValue(uint32_t index)
+{
+    if (index == kDefaultValueIndexNull)
+        return NULL;
+
+    IL2CPP_ASSERT(index >= 0 && index <= s_GlobalMetadataHeader->fieldAndParameterDefaultValueDataSize / sizeof(uint8_t));
+    const uint8_t* defaultValuesData =  (const uint8_t*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->fieldAndParameterDefaultValueDataOffset);
+    return defaultValuesData + index;
+}
+
+const uint8_t* il2cpp::vm::GlobalMetadata::GetFieldDefaultValue(const FieldInfo* field, const Il2CppType** type)
+{
+    const Il2CppFieldDefaultValue* entry = GetFieldDefaultValueEntry(field);
+
+    if (entry != NULL)
+    {
+        *type = GetIl2CppTypeFromIndex(entry->typeIndex);
+        return GetFieldOrParameterDefalutValue(entry->dataIndex);
+    }
+
+    return NULL;
+}
+
+static const Il2CppParameterDefaultValue * GetParameterDefaultValueEntry(const MethodInfo* method, int32_t parameterPosition)
+{
+    if (il2cpp::vm::Method::IsGenericInstance(method))
+        method = il2cpp::vm::MetadataCache::GetGenericMethodDefinition(method);
+
+    IL2CPP_ASSERT(!il2cpp::vm::Method::IsGenericInstance(method));
+
+    const Il2CppMethodDefinition* methodDefinition = reinterpret_cast<const Il2CppMethodDefinition*>(method->methodMetadataHandle);
+
+    if (methodDefinition == NULL)
+        return NULL;
+
+    size_t parameterIndex = methodDefinition->parameterStart + parameterPosition;
+    const Il2CppParameterDefaultValue *start = (const Il2CppParameterDefaultValue*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->parameterDefaultValuesOffset);
+    const Il2CppParameterDefaultValue *entry = start;
+    while (entry < start + s_GlobalMetadataHeader->parameterDefaultValuesSize / sizeof(Il2CppParameterDefaultValue))
+    {
+        if (parameterIndex == entry->parameterIndex)
+            return entry;
+        entry++;
+    }
+
+    return NULL;
+}
+
+const uint8_t* il2cpp::vm::GlobalMetadata::GetParameterDefaultValue(const MethodInfo* method, int32_t parameterPosition, const Il2CppType** type, bool* isExplicitySetNullDefaultValue)
+{
+    *isExplicitySetNullDefaultValue = false;
+    const Il2CppParameterDefaultValue* parameterDefaultValue = GetParameterDefaultValueEntry(method, parameterPosition);
+
+    if (parameterDefaultValue != NULL)
+    {
+        *type = GetIl2CppTypeFromIndex(parameterDefaultValue->typeIndex);
+        *isExplicitySetNullDefaultValue = parameterDefaultValue->dataIndex == kDefaultValueIndexNull;
+        return GetFieldOrParameterDefalutValue(parameterDefaultValue->dataIndex);
+    }
+
+    return NULL;
+}
+
+static TypeDefinitionIndex GetIndexForTypeDefinition(const Il2CppClass* klass)
+{
+    const Il2CppTypeDefinition* typeDefinition = reinterpret_cast<const Il2CppTypeDefinition*>(klass->typeMetadataHandle);
+    return GetIndexForTypeDefinitionInternal(typeDefinition);
+}
+
+uint32_t il2cpp::vm::GlobalMetadata::GetFieldOffset(const Il2CppClass* klass, int32_t fieldIndexInType, FieldInfo* field)
+{
+    uint32_t typeIndex = GetIndexForTypeDefinition(klass);
+    IL2CPP_ASSERT(typeIndex <= static_cast<uint32_t>(s_Il2CppMetadataRegistration->typeDefinitionsSizesCount));
+    int32_t offset = s_Il2CppMetadataRegistration->fieldOffsets[typeIndex][fieldIndexInType];
+    return offset;
+}
+
+int il2cpp::vm::GlobalMetadata::GetFieldMarshaledSizeForField(const FieldInfo* field)
+{
+    Il2CppClass* parent = field->parent;
+    size_t fieldIndex = (field - parent->fields);
+    fieldIndex += reinterpret_cast<const Il2CppTypeDefinition*>(parent->typeMetadataHandle)->fieldStart;
+
+    const Il2CppFieldMarshaledSize *start = (const Il2CppFieldMarshaledSize*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->fieldMarshaledSizesOffset);
+    const Il2CppFieldMarshaledSize *entry = start;
+    while (entry < start + s_GlobalMetadataHeader->fieldMarshaledSizesSize / sizeof(Il2CppFieldMarshaledSize))
+    {
+        if (fieldIndex == entry->fieldIndex)
+            return entry->size;
+        entry++;
+    }
+
+    return -1;
+}
+
+static const Il2CppFieldDefinition* GetFieldDefinitionFromIndex(const Il2CppImage* image, FieldIndex index)
+{
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->fieldsSize / sizeof(Il2CppFieldDefinition));
+    const Il2CppFieldDefinition* fields = (const Il2CppFieldDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->fieldsOffset);
+    return fields + index;
+}
+
+Il2CppMetadataFieldInfo il2cpp::vm::GlobalMetadata::GetFieldInfo(const Il2CppClass* klass, TypeFieldIndex fieldIndex)
+{
+    const Il2CppTypeDefinition* typeDefinition = reinterpret_cast<const Il2CppTypeDefinition*>(klass->typeMetadataHandle);
+
+    IL2CPP_ASSERT(typeDefinition != NULL);
+    IL2CPP_ASSERT(fieldIndex >= 0 && fieldIndex < typeDefinition->field_count);
+    IL2CPP_ASSERT(typeDefinition->fieldStart != kFieldIndexInvalid);
+
+    const Il2CppFieldDefinition* fieldDefinition = GetFieldDefinitionFromIndex(klass->image, typeDefinition->fieldStart + fieldIndex);
+
+    return {
+            GetIl2CppTypeFromIndex(fieldDefinition->typeIndex),
+            GetStringFromIndex(fieldDefinition->nameIndex),
+            fieldDefinition->token
+    };
+}
+
+Il2CppMetadataMethodInfo il2cpp::vm::GlobalMetadata::GetMethodInfo(const Il2CppClass* klass, TypeMethodIndex index)
+{
+    const Il2CppTypeDefinition* typeDefinition = reinterpret_cast<const Il2CppTypeDefinition*>(klass->typeMetadataHandle);
+
+    IL2CPP_ASSERT(typeDefinition != NULL);
+    IL2CPP_ASSERT(index >= 0 && index < typeDefinition->method_count);
+    IL2CPP_ASSERT(typeDefinition->methodStart != kMethodIndexInvalid);
+
+    const Il2CppMethodDefinition* methodDefinition = GetMethodDefinitionFromIndex(typeDefinition->methodStart + index);
+
+    return {
+            reinterpret_cast<Il2CppMetadataMethodDefinitionHandle>(methodDefinition),
+            GetStringFromIndex(methodDefinition->nameIndex),
+            GetIl2CppTypeFromIndex(methodDefinition->returnType),
+            methodDefinition->token,
+            methodDefinition->flags,
+            methodDefinition->iflags,
+            methodDefinition->slot,
+            methodDefinition->parameterCount,
+    };
+}
+
+Il2CppMetadataParameterInfo il2cpp::vm::GlobalMetadata::GetParameterInfo(const Il2CppClass* klass, Il2CppMetadataMethodDefinitionHandle handle, MethodParameterIndex paramIndex)
+{
+    const Il2CppMethodDefinition* methodDefinition = reinterpret_cast<const Il2CppMethodDefinition*>(handle);
+
+    IL2CPP_ASSERT(methodDefinition != NULL);
+    IL2CPP_ASSERT(paramIndex >= 0 && paramIndex < methodDefinition->parameterCount);
+
+    const Il2CppParameterDefinition* parameterDefinition = GetParameterDefinitionFromIndex(klass->image, methodDefinition->parameterStart + paramIndex);
+
+    return {
+            GetStringFromIndex(parameterDefinition->nameIndex),
+            parameterDefinition->token,
+            GetIl2CppTypeFromIndex(parameterDefinition->typeIndex),
+    };
+}
+
+Il2CppMetadataPropertyInfo il2cpp::vm::GlobalMetadata::GetPropertyInfo(const Il2CppClass* klass, TypePropertyIndex index)
+{
+    const Il2CppTypeDefinition* typeDefintion = reinterpret_cast<const Il2CppTypeDefinition*>(klass->typeMetadataHandle);
+
+    IL2CPP_ASSERT(typeDefintion != NULL);
+    IL2CPP_ASSERT(index >= 0 && index < typeDefintion->property_count);
+    IL2CPP_ASSERT(typeDefintion->propertyStart != kPropertyIndexInvalid);
+
+    const Il2CppPropertyDefinition* propertyDefintion = GetPropertyDefinitionFromIndex(klass->image, typeDefintion->propertyStart + index);
+
+    return {
+            GetStringFromIndex(propertyDefintion->nameIndex),
+            propertyDefintion->get != kMethodIndexInvalid ? klass->methods[propertyDefintion->get] : NULL,
+            propertyDefintion->set != kMethodIndexInvalid ? klass->methods[propertyDefintion->set] : NULL,
+            propertyDefintion->attrs,
+            propertyDefintion->token,
+    };
+}
+
+Il2CppMetadataEventInfo il2cpp::vm::GlobalMetadata::GetEventInfo(const Il2CppClass* klass, TypeEventIndex index)
+{
+    const Il2CppTypeDefinition* typeDefintion = reinterpret_cast<const Il2CppTypeDefinition*>(klass->typeMetadataHandle);
+
+    IL2CPP_ASSERT(typeDefintion != NULL);
+    IL2CPP_ASSERT(index >= 0 && index < typeDefintion->event_count);
+
+    const Il2CppEventDefinition* eventDefintion = GetEventDefinitionFromIndex(klass->image, typeDefintion->eventStart + index);
+
+    return {
+            GetStringFromIndex(eventDefintion->nameIndex),
+            GetIl2CppTypeFromIndex(eventDefintion->typeIndex),
+            eventDefintion->add != kMethodIndexInvalid ? klass->methods[eventDefintion->add] : NULL,
+            eventDefintion->remove != kMethodIndexInvalid ? klass->methods[eventDefintion->remove] : NULL,
+            eventDefintion->raise != kMethodIndexInvalid ? klass->methods[eventDefintion->raise] : NULL,
+            eventDefintion->token,
+    };
+}
+
+static const Il2CppGenericContainer* GetGenericContainerFromIndexInternal(GenericContainerIndex index)
+{
+    if (index == kGenericContainerIndexInvalid)
+        return NULL;
+
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->genericContainersSize / sizeof(Il2CppGenericContainer));
+    const Il2CppGenericContainer* genericContainers = (const Il2CppGenericContainer*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->genericContainersOffset);
+    return genericContainers + index;
+}
+
+static Il2CppMetadataGenericContainerHandle GetGenericContainerFromIndex(GenericContainerIndex index)
+{
+    const Il2CppGenericContainer* container = GetGenericContainerFromIndexInternal(index);
+    return reinterpret_cast<Il2CppMetadataGenericContainerHandle>(container);
+}
+
+Il2CppMetadataGenericContainerHandle il2cpp::vm::GlobalMetadata::GetGenericContainerFromGenericClass(const Il2CppGenericClass* genericClass)
+{
+    const Il2CppTypeDefinition* genericType = reinterpret_cast<const Il2CppTypeDefinition*>(GetTypeHandleFromType(genericClass->type));
+    return GetGenericContainerFromIndex(genericType->genericContainerIndex);
+}
+
+Il2CppMetadataGenericContainerHandle il2cpp::vm::GlobalMetadata::GetGenericContainerFromMethod(Il2CppMetadataMethodDefinitionHandle handle)
+{
+    const Il2CppMethodDefinition* methodDefinition = reinterpret_cast<const Il2CppMethodDefinition*>(handle);
+    return GetGenericContainerFromIndex(methodDefinition->genericContainerIndex);
+}
+
+const Il2CppGenericMethod* il2cpp::vm::GlobalMetadata::GetGenericMethodFromTokenMethodTuple(const Il2CppTokenIndexMethodTuple* tuple)
+{
+    return GetGenericMethodFromIndex(tuple->__genericMethodIndex);
+}
+
+static Il2CppMetadataGenericParameterHandle GetGenericParameterFromIndexInternal(GenericParameterIndex index)
+{
+    if (index == kGenericParameterIndexInvalid)
+        return NULL;
+
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->genericParametersSize / sizeof(Il2CppGenericParameter));
+    const Il2CppGenericParameter* genericParameters = (const Il2CppGenericParameter*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->genericParametersOffset);
+    return reinterpret_cast<Il2CppMetadataGenericParameterHandle>(genericParameters + index);
+}
+
+Il2CppMetadataGenericParameterHandle il2cpp::vm::GlobalMetadata::GetGenericParameterFromType(const Il2CppType* type)
+{
+    IL2CPP_ASSERT(type->type == IL2CPP_TYPE_VAR || type->type == IL2CPP_TYPE_MVAR);
+    return type->data.genericParameterHandle;
+}
+
+Il2CppClass* il2cpp::vm::GlobalMetadata::GetContainerDeclaringType(Il2CppMetadataGenericContainerHandle handle)
+{
+    const Il2CppGenericContainer* genericContainer = reinterpret_cast<const Il2CppGenericContainer*>(handle);
+
+    if (genericContainer->is_method)
+        return GetMethodInfoFromMethodDefinitionIndex(genericContainer->ownerIndex)->klass;
+
+    return GetTypeInfoFromTypeDefinitionIndex(genericContainer->ownerIndex);
+}
+
+Il2CppClass* il2cpp::vm::GlobalMetadata::GetParameterDeclaringType(Il2CppMetadataGenericParameterHandle handle)
+{
+    const Il2CppGenericParameter* genericParameter = reinterpret_cast<const Il2CppGenericParameter*>(handle);
+
+    const Il2CppGenericContainer* genericContainer =  GetGenericContainerFromIndexInternal(genericParameter->ownerIndex);
+
+    if (genericContainer->is_method)
+        return GetMethodInfoFromMethodDefinitionIndex(genericContainer->ownerIndex)->klass;
+
+    return GetTypeInfoFromTypeDefinitionIndex(genericContainer->ownerIndex);
+}
+
+Il2CppMetadataGenericParameterHandle il2cpp::vm::GlobalMetadata::GetGenericParameterFromIndex(Il2CppMetadataGenericContainerHandle handle, GenericContainerParameterIndex index)
+{
+    const Il2CppGenericContainer* genericContainer = reinterpret_cast<const Il2CppGenericContainer*>(handle);
+
+    IL2CPP_ASSERT(index >= 0 && index < genericContainer->type_argc);
+
+    return GetGenericParameterFromIndexInternal(genericContainer->genericParameterStart + index);
+}
+
+const Il2CppType* il2cpp::vm::GlobalMetadata::GetGenericParameterConstraintFromIndex(Il2CppMetadataGenericParameterHandle handle, GenericParameterConstraintIndex index)
+{
+    const Il2CppGenericParameter* genericParameter = reinterpret_cast<const Il2CppGenericParameter*>(handle);
+
+    IL2CPP_ASSERT(index >= 0 && index < genericParameter->constraintsCount);
+
+    index = genericParameter->constraintsStart + index;
+
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->genericParameterConstraintsSize / sizeof(TypeIndex));
+    const TypeIndex* constraintIndices = (const TypeIndex*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->genericParameterConstraintsOffset);
+
+    return GetIl2CppTypeFromIndex(constraintIndices[index]);
+}
+
+static GenericParameterIndex GetIndexForGenericParameter(Il2CppMetadataGenericParameterHandle handle)
+{
+    const Il2CppGenericParameter* genericParameter = reinterpret_cast<const Il2CppGenericParameter*>(handle);
+    const Il2CppGenericParameter* genericParameters = (const Il2CppGenericParameter*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->genericParametersOffset);
+
+    IL2CPP_ASSERT(genericParameter >= genericParameters && genericParameter < genericParameters + s_GlobalMetadataHeader->genericParametersSize / sizeof(Il2CppGenericParameter));
+
+    ptrdiff_t index = genericParameter - genericParameters;
+    IL2CPP_ASSERT(index <= std::numeric_limits<GenericParameterIndex>::max());
+    return static_cast<GenericParameterIndex>(index);
+}
+
+const MethodInfo* il2cpp::vm::GlobalMetadata::GetGenericInstanceMethod(const MethodInfo* genericMethodDefinition, const Il2CppGenericContext* context)
+{
+    const MethodInfo* method = genericMethodDefinition;
+    const Il2CppGenericInst* classInst = context->class_inst;
+    const Il2CppGenericInst* methodInst = context->method_inst;
+    if (genericMethodDefinition->is_inflated)
+    {
+        IL2CPP_ASSERT(genericMethodDefinition->klass->generic_class);
+        classInst = genericMethodDefinition->klass->generic_class->context.class_inst;
+        method = genericMethodDefinition->genericMethod->methodDefinition;
+    }
+
+    return il2cpp::metadata::GenericMethod::GetMethod(method, classInst, methodInst);
+}
+
+const Il2CppType* il2cpp::vm::GlobalMetadata::GetTypeFromRgctxDefinition(const Il2CppRGCTXDefinition* rgctxDef)
+{
+    IL2CPP_ASSERT(rgctxDef->type == IL2CPP_RGCTX_DATA_TYPE || rgctxDef->type == IL2CPP_RGCTX_DATA_CLASS);
+    return GetIl2CppTypeFromIndex(((const Il2CppRGCTXDefinitionData*)rgctxDef->data)->__typeIndex);
+}
+
+const Il2CppGenericMethod* il2cpp::vm::GlobalMetadata::GetGenericMethodFromRgctxDefinition(const Il2CppRGCTXDefinition* rgctxDef)
+{
+    IL2CPP_ASSERT(rgctxDef->type == IL2CPP_RGCTX_DATA_METHOD);
+    return GetGenericMethodFromIndex(((const Il2CppRGCTXDefinitionData*)rgctxDef->data)->__methodIndex);
+}
+
+std::pair<const Il2CppType*, const MethodInfo*> il2cpp::vm::GlobalMetadata::GetConstrainedCallFromRgctxDefinition(const Il2CppRGCTXDefinition* rgctxDef)
+{
+    IL2CPP_ASSERT(rgctxDef->type == IL2CPP_RGCTX_DATA_CONSTRAINED);
+
+    const Il2CppRGCTXConstrainedData* constrainedData = (const Il2CppRGCTXConstrainedData*)rgctxDef->data;
+
+    const Il2CppType* type = GetIl2CppTypeFromIndex(constrainedData->__typeIndex);
+    const MethodInfo* method = GetMethodInfoFromEncodedIndex(constrainedData->__encodedMethodIndex);
+    return std::make_pair(type, method);
+}
+
+enum PackingSize
+{
+    Zero,
+    One,
+    Two,
+    Four,
+    Eight,
+    Sixteen,
+    ThirtyTwo,
+    SixtyFour,
+    OneHundredTwentyEight
+};
+
+static uint8_t ConvertPackingSizeEnumToValue(PackingSize packingSize)
+{
+    switch (packingSize)
+    {
+        case Zero:
+            return 0;
+        case One:
+            return 1;
+        case Two:
+            return 2;
+        case Four:
+            return 4;
+        case Eight:
+            return 8;
+        case Sixteen:
+            return 16;
+        case ThirtyTwo:
+            return 32;
+        case SixtyFour:
+            return 64;
+        case OneHundredTwentyEight:
+            return 128;
+        default:
+            Assert(0 && "Invalid packing size!");
+            return 0;
+    }
+}
+
+int32_t il2cpp::vm::GlobalMetadata::StructLayoutPack(Il2CppMetadataTypeHandle handle)
+{
+    return ConvertPackingSizeEnumToValue(static_cast<PackingSize>((reinterpret_cast<const Il2CppTypeDefinition*>(handle)->bitfield >> (kSpecifiedPackingSize - 1)) & 0xF));
+}
+
+static const Il2CppImage* GetImageForTypeDefinitionIndex(TypeDefinitionIndex index)
+{
+    for (int32_t imageIndex = 0; imageIndex < s_MetadataImagesCount; imageIndex++)
+    {
+        const Il2CppImageGlobalMetadata* imageMetadata = s_MetadataImagesTable + imageIndex;
+        IL2CPP_ASSERT(index >= 0);
+        if (index >= imageMetadata->typeStart && static_cast<uint32_t>(index) < (imageMetadata->typeStart + imageMetadata->image->typeCount))
+            return imageMetadata->image;
+    }
+
+    IL2CPP_ASSERT(0 && "Failed to find owning image for type defintion index");
+    return NULL;
+}
+
+static Il2CppClass* FromTypeDefinition(TypeDefinitionIndex index)
+{
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) < s_GlobalMetadataHeader->typeDefinitionsSize / sizeof(Il2CppTypeDefinition));
+    const Il2CppTypeDefinition* typeDefinitions = (const Il2CppTypeDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->typeDefinitionsOffset);
+    const Il2CppTypeDefinition* typeDefinition = typeDefinitions + index;
+    const Il2CppTypeDefinitionSizes* typeDefinitionSizes = s_Il2CppMetadataRegistration->typeDefinitionsSizes[index];
+    Il2CppClass* typeInfo = (Il2CppClass*)IL2CPP_CALLOC(1, sizeof(Il2CppClass) + (sizeof(VirtualInvokeData) * typeDefinition->vtable_count));
+    typeInfo->klass = typeInfo;
+    typeInfo->image = GetImageForTypeDefinitionIndex(index);
+    typeInfo->name = GetStringFromIndex(typeDefinition->nameIndex);
+    typeInfo->namespaze = GetStringFromIndex(typeDefinition->namespaceIndex);
+    typeInfo->byval_arg = *il2cpp::vm::GlobalMetadata::GetIl2CppTypeFromIndex(typeDefinition->byvalTypeIndex);
+    typeInfo->this_arg = typeInfo->byval_arg;
+    typeInfo->this_arg.byref = true;
+    typeInfo->this_arg.valuetype = 0;
+    typeInfo->typeMetadataHandle = reinterpret_cast<const Il2CppMetadataTypeHandle>(typeDefinition);
+    typeInfo->genericContainerHandle = GetGenericContainerFromIndex(typeDefinition->genericContainerIndex);
+    typeInfo->instance_size = typeDefinitionSizes->instance_size;
+    typeInfo->actualSize = typeDefinitionSizes->instance_size;     // actualySize is instance_size for compiler generated values
+    typeInfo->native_size = typeDefinitionSizes->native_size;
+    typeInfo->static_fields_size = typeDefinitionSizes->static_fields_size;
+    typeInfo->thread_static_fields_size = typeDefinitionSizes->thread_static_fields_size;
+    typeInfo->thread_static_fields_offset = -1;
+    typeInfo->flags = typeDefinition->flags;
+    typeInfo->enumtype = (typeDefinition->bitfield >> (kBitIsEnum - 1)) & 0x1;
+    typeInfo->is_generic = typeDefinition->genericContainerIndex != kGenericContainerIndexInvalid;     // generic if we have a generic container
+    typeInfo->has_finalize = (typeDefinition->bitfield >> (kBitHasFinalizer - 1)) & 0x1;
+    typeInfo->has_cctor = (typeDefinition->bitfield >> (kBitHasStaticConstructor - 1)) & 0x1;
+    typeInfo->cctor_finished_or_no_cctor = !typeInfo->has_cctor;
+    typeInfo->is_blittable = (typeDefinition->bitfield >> (kBitIsBlittable - 1)) & 0x1;
+    typeInfo->is_import_or_windows_runtime = (typeDefinition->bitfield >> (kBitIsImportOrWindowsRuntime - 1)) & 0x1;
+    typeInfo->packingSize = ConvertPackingSizeEnumToValue(static_cast<PackingSize>((typeDefinition->bitfield >> (kPackingSize - 1)) & 0xF));
+    typeInfo->is_byref_like = (typeDefinition->bitfield >> (kBitIsByRefLike - 1)) & 0x1;
+    typeInfo->method_count = typeDefinition->method_count;
+    typeInfo->property_count = typeDefinition->property_count;
+    typeInfo->field_count = typeDefinition->field_count;
+    typeInfo->event_count = typeDefinition->event_count;
+    typeInfo->nested_type_count = typeDefinition->nested_type_count;
+    typeInfo->vtable_count = typeDefinition->vtable_count;
+    typeInfo->interfaces_count = typeDefinition->interfaces_count;
+    typeInfo->interface_offsets_count = typeDefinition->interface_offsets_count;
+    typeInfo->token = typeDefinition->token;
+    typeInfo->interopData = il2cpp::vm::MetadataCache::GetInteropDataForType(&typeInfo->byval_arg);
+
+    if (typeDefinition->parentIndex != kTypeIndexInvalid)
+        typeInfo->parent = il2cpp::vm::Class::FromIl2CppType(il2cpp::vm::GlobalMetadata::GetIl2CppTypeFromIndex(typeDefinition->parentIndex));
+
+    if (typeDefinition->declaringTypeIndex != kTypeIndexInvalid)
+        typeInfo->declaringType = il2cpp::vm::Class::FromIl2CppType(il2cpp::vm::GlobalMetadata::GetIl2CppTypeFromIndex(typeDefinition->declaringTypeIndex));
+
+    typeInfo->castClass = typeInfo->element_class = typeInfo;
+    if (typeInfo->enumtype)
+        typeInfo->castClass = typeInfo->element_class = il2cpp::vm::Class::FromIl2CppType(il2cpp::vm::GlobalMetadata::GetIl2CppTypeFromIndex(typeDefinition->elementTypeIndex));
+
+    return typeInfo;
+}
+
+const Il2CppType* il2cpp::vm::GlobalMetadata::GetIl2CppTypeFromIndex(TypeIndex index)
+{
+    if (index == kTypeIndexInvalid)
+        return NULL;
+
+    IL2CPP_ASSERT(index < s_Il2CppMetadataRegistration->typesCount && "Invalid type index ");
+
+    return s_Il2CppMetadataRegistration->types[index];
+}
+
+uint32_t il2cpp::vm::GlobalMetadata::GetGenericContainerCount(Il2CppMetadataGenericContainerHandle handle)
+{
+    const Il2CppGenericContainer* container = reinterpret_cast<const Il2CppGenericContainer*>(handle);
+    return container != NULL ? container->type_argc : 0;
+}
+
+void il2cpp::vm::GlobalMetadata::MakeGenericArgType(Il2CppMetadataGenericContainerHandle containerHandle, Il2CppMetadataGenericParameterHandle paramHandle, Il2CppType* arg)
+{
+    const Il2CppGenericContainer* container = reinterpret_cast<const Il2CppGenericContainer*>(containerHandle);
+
+    arg->type = container->is_method ? IL2CPP_TYPE_MVAR : IL2CPP_TYPE_VAR;
+    arg->data.genericParameterHandle = paramHandle;
+}
+
+bool il2cpp::vm::GlobalMetadata::GetGenericContainerIsMethod(Il2CppMetadataGenericContainerHandle handle)
+{
+    const Il2CppGenericContainer* container = reinterpret_cast<const Il2CppGenericContainer*>(handle);
+    IL2CPP_ASSERT(container != NULL);
+    return container != NULL ? container->is_method : false;
+}
+
+int16_t il2cpp::vm::GlobalMetadata::GetGenericConstraintCount(Il2CppMetadataGenericParameterHandle handle)
+{
+    const Il2CppGenericParameter* genericParameter = reinterpret_cast<const Il2CppGenericParameter*>(handle);
+    return genericParameter->constraintsCount;
+}
+
+const char* il2cpp::vm::GlobalMetadata::GetGenericParameterName(Il2CppMetadataGenericParameterHandle handle)
+{
+    const Il2CppGenericParameter* genericParameter = reinterpret_cast<const Il2CppGenericParameter*>(handle);
+    return GetStringFromIndex(genericParameter->nameIndex);
+}
+
+Il2CppGenericParameterInfo il2cpp::vm::GlobalMetadata::GetGenericParameterInfo(Il2CppMetadataGenericParameterHandle handle)
+{
+    const Il2CppGenericParameter* genericParameter = reinterpret_cast<const Il2CppGenericParameter*>(handle);
+
+    return {
+            reinterpret_cast<Il2CppMetadataGenericContainerHandle>(GetGenericContainerFromIndexInternal(genericParameter->ownerIndex)),
+            GetStringFromIndex(genericParameter->nameIndex),
+            genericParameter->num,
+            genericParameter->flags
+    };
+}
+
+uint16_t il2cpp::vm::GlobalMetadata::GetGenericParameterFlags(Il2CppMetadataGenericParameterHandle handle)
+{
+    const Il2CppGenericParameter* genericParameter = reinterpret_cast<const Il2CppGenericParameter*>(handle);
+    return genericParameter->flags;
+}
+
+const MethodInfo* il2cpp::vm::GlobalMetadata::GetMethodInfoFromCatchPoint(const Il2CppCatchPoint* cp)
+{
+    return GetMethodInfoFromMethodDefinitionIndex(cp->__methodDefinitionIndex);
+}
+
+const MethodInfo* il2cpp::vm::GlobalMetadata::GetMethodInfoFromSequencePoint(const Il2CppSequencePoint* seqPoint)
+{
+    return GetMethodInfoFromMethodDefinitionIndex(seqPoint->__methodDefinitionIndex);
+}
+
+Il2CppClass* il2cpp::vm::GlobalMetadata::GetTypeInfoFromTypeSourcePair(const Il2CppTypeSourceFilePair* pair)
+{
+    return GetTypeInfoFromTypeDefinitionIndex(pair->__klassIndex);
+}
+
+Il2CppClass* il2cpp::vm::GlobalMetadata::GetTypeInfoFromTypeIndex(TypeIndex index, bool throwOnError)
+{
+    if (index == kTypeIndexInvalid)
+        return NULL;
+
+    IL2CPP_ASSERT(index < s_Il2CppMetadataRegistration->typesCount && "Invalid type index ");
+
+    if (s_TypeInfoTable[index])
+        return s_TypeInfoTable[index];
+
+    const Il2CppType* type = s_Il2CppMetadataRegistration->types[index];
+
+    Il2CppClass *klass = Class::FromIl2CppType(type, throwOnError);
+    if (klass != NULL)
+    {
+        s_TypeInfoTable[index] = ClassInlines::InitFromCodegenSlow(klass, throwOnError);
+    }
+    return s_TypeInfoTable[index];
+}
+
+const MethodInfo* il2cpp::vm::GlobalMetadata::GetMethodInfoFromMethodHandle(Il2CppMetadataMethodDefinitionHandle handle)
+{
+    const Il2CppMethodDefinition* methodDefinition = reinterpret_cast<const Il2CppMethodDefinition*>(handle);
+    const Il2CppMethodDefinition* methods = (const Il2CppMethodDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->methodsOffset);
+
+    const MethodIndex index = static_cast<MethodIndex>(methodDefinition - methods);
+
+    IL2CPP_ASSERT(index >= 0 && static_cast<uint32_t>(index) <= s_GlobalMetadataHeader->methodsSize / sizeof(Il2CppMethodDefinition));
+
+    return GetMethodInfoFromMethodDefinitionIndex(index);
+}
+
+#if IL2CPP_ENABLE_NATIVE_STACKTRACES
+void il2cpp::vm::GlobalMetadata::GetAllManagedMethods(std::vector<MethodDefinitionKey>& managedMethods)
+{
+    size_t methodDefinitionsCount = s_GlobalMetadataHeader->methodsSize / sizeof(Il2CppMethodDefinition);
+    managedMethods.reserve(methodDefinitionsCount + s_Il2CppMetadataRegistration->genericMethodTableCount);
+
+    const Il2CppTypeDefinition* typeDefinitions = (const Il2CppTypeDefinition*)((const char*)s_GlobalMetadata + s_GlobalMetadataHeader->typeDefinitionsOffset);
+    for (int32_t i = 0; i < s_MetadataImagesCount; i++)
+    {
+        const Il2CppImageGlobalMetadata* image = s_MetadataImagesTable + i;
+
+        for (size_t j = 0; j < image->image->typeCount; j++)
+        {
+            const Il2CppTypeDefinition* type = typeDefinitions + image->typeStart + j;
+
+            for (uint16_t u = 0; u < type->method_count; u++)
+            {
+                const Il2CppMethodDefinition* methodDefinition = GetMethodDefinitionFromIndex(type->methodStart + u);
+                MethodDefinitionKey currentMethodList;
+                currentMethodList.methodHandle = reinterpret_cast<Il2CppMetadataMethodDefinitionHandle>(methodDefinition);
+                currentMethodList.method = il2cpp::vm::MetadataCache::GetMethodPointer(image->image, methodDefinition->token);
+                if (currentMethodList.method)
+                    managedMethods.push_back(currentMethodList);
+            }
+        }
+    }
+
+    for (int32_t i = 0; i < s_Il2CppMetadataRegistration->genericMethodTableCount; i++)
+    {
+        const Il2CppGenericMethodFunctionsDefinitions* genericMethodIndices = s_Il2CppMetadataRegistration->genericMethodTable + i;
+
+        MethodDefinitionKey currentMethodList;
+
+        GenericMethodIndex genericMethodIndex = genericMethodIndices->genericMethodIndex;
+
+        IL2CPP_ASSERT(genericMethodIndex < s_Il2CppMetadataRegistration->methodSpecsCount);
+        const Il2CppMethodSpec* methodSpec = s_Il2CppMetadataRegistration->methodSpecs + genericMethodIndex;
+        const Il2CppMethodDefinition* methodDefinition = GetMethodDefinitionFromIndex(methodSpec->methodDefinitionIndex);
+        currentMethodList.methodHandle = reinterpret_cast<Il2CppMetadataMethodDefinitionHandle>(methodDefinition);
+
+        IL2CPP_ASSERT(genericMethodIndices->indices.methodIndex < static_cast<int32_t>(s_GlobalMetadata_CodeRegistration->genericMethodPointersCount));
+        currentMethodList.method = s_GlobalMetadata_CodeRegistration->genericMethodPointers[genericMethodIndices->indices.methodIndex];
+
+        managedMethods.push_back(currentMethodList);
+    }
+}
+
+#endif
diff --git a/O&Z_IL2CPP_Security/resource/src-res/28/GlobalMetadataFileInternals.h b/O&Z_IL2CPP_Security/resource/src-res/28/GlobalMetadataFileInternals.h
new file mode 100644
index 0000000..b11ef55
--- /dev/null
+++ b/O&Z_IL2CPP_Security/resource/src-res/28/GlobalMetadataFileInternals.h
@@ -0,0 +1,353 @@
+#pragma once
+
+#include "il2cpp-metadata.h"
+
+// This file contains the structures specifying how we store converted metadata.
+// These structures have 3 constraints:
+// 1. These structures will be stored in an external file, and as such must not contain any pointers.
+//    All references to other metadata should occur via an index into a corresponding table.
+// 2. These structures are assumed to be const. Either const structures in the binary or mapped as
+//    readonly memory from an external file. Do not add any 'calculated' fields which will be written to at runtime.
+// 3. These structures should be optimized for size. Other structures are used at runtime which can
+//    be larger to store cached information
+
+// Encoded index (1 bit)
+// MethodDef - 0
+// MethodSpec - 1
+// We use the top 3 bits to indicate what table to index into
+// Type              Binary            Hex
+// Il2CppClass       001               0x20000000
+// Il2CppType        010               0x40000000
+// MethodInfo        011               0x60000000
+// FieldInfo         100               0x80000000
+// StringLiteral     101               0xA0000000
+// MethodRef         110               0xC0000000
+
+typedef uint32_t EncodedMethodIndex;
+
+enum Il2CppMetadataUsage
+{
+    kIl2CppMetadataUsageInvalid,
+    kIl2CppMetadataUsageTypeInfo,
+    kIl2CppMetadataUsageIl2CppType,
+    kIl2CppMetadataUsageMethodDef,
+    kIl2CppMetadataUsageFieldInfo,
+    kIl2CppMetadataUsageStringLiteral,
+    kIl2CppMetadataUsageMethodRef,
+};
+
+enum Il2CppInvalidMetadataUsageToken
+{
+    kIl2CppInvalidMetadataUsageNoData = 0,
+    kIl2CppInvalidMetadataUsageAmbiguousMethod = 1,
+};
+
+#ifdef __cplusplus
+static inline Il2CppMetadataUsage GetEncodedIndexType(EncodedMethodIndex index)
+{
+    return (Il2CppMetadataUsage)((index & 0xE0000000) >> 29);
+}
+
+static inline uint32_t GetDecodedMethodIndex(EncodedMethodIndex index)
+{
+    return (index & 0x1FFFFFFEU) >> 1;
+}
+
+#endif
+
+typedef struct Il2CppInterfaceOffsetPair
+{
+    TypeIndex interfaceTypeIndex;
+    int32_t offset;
+} Il2CppInterfaceOffsetPair;
+
+typedef struct Il2CppTypeDefinition
+{
+    StringIndex nameIndex;
+    StringIndex namespaceIndex;
+    TypeIndex byvalTypeIndex;
+
+    TypeIndex declaringTypeIndex;
+    TypeIndex parentIndex;
+    TypeIndex elementTypeIndex; // we can probably remove this one. Only used for enums
+
+    GenericContainerIndex genericContainerIndex;
+
+    uint32_t flags;
+
+    FieldIndex fieldStart;
+    MethodIndex methodStart;
+    EventIndex eventStart;
+    PropertyIndex propertyStart;
+    NestedTypeIndex nestedTypesStart;
+    InterfacesIndex interfacesStart;
+    VTableIndex vtableStart;
+    InterfacesIndex interfaceOffsetsStart;
+
+    uint16_t method_count;
+    uint16_t property_count;
+    uint16_t field_count;
+    uint16_t event_count;
+    uint16_t nested_type_count;
+    uint16_t vtable_count;
+    uint16_t interfaces_count;
+    uint16_t interface_offsets_count;
+
+    // bitfield to portably encode boolean values as single bits
+    // 01 - valuetype;
+    // 02 - enumtype;
+    // 03 - has_finalize;
+    // 04 - has_cctor;
+    // 05 - is_blittable;
+    // 06 - is_import_or_windows_runtime;
+    // 07-10 - One of nine possible PackingSize values (0, 1, 2, 4, 8, 16, 32, 64, or 128)
+    // 11 - PackingSize is default
+    // 12 - ClassSize is default
+    // 13-16 - One of nine possible PackingSize values (0, 1, 2, 4, 8, 16, 32, 64, or 128) - the specified packing size (even for explicit layouts)
+    uint32_t bitfield;
+    uint32_t token;
+} Il2CppTypeDefinition;
+
+typedef struct Il2CppFieldDefinition
+{
+    StringIndex nameIndex;
+    TypeIndex typeIndex;
+    uint32_t token;
+} Il2CppFieldDefinition;
+
+typedef struct Il2CppFieldDefaultValue
+{
+    FieldIndex fieldIndex;
+    TypeIndex typeIndex;
+    DefaultValueDataIndex dataIndex;
+} Il2CppFieldDefaultValue;
+
+typedef struct Il2CppFieldMarshaledSize
+{
+    FieldIndex fieldIndex;
+    TypeIndex typeIndex;
+    int32_t size;
+} Il2CppFieldMarshaledSize;
+
+typedef struct Il2CppFieldRef
+{
+    TypeIndex typeIndex;
+    FieldIndex fieldIndex; // local offset into type fields
+} Il2CppFieldRef;
+
+typedef struct Il2CppParameterDefinition
+{
+    StringIndex nameIndex;
+    uint32_t token;
+    TypeIndex typeIndex;
+} Il2CppParameterDefinition;
+
+typedef struct Il2CppParameterDefaultValue
+{
+    ParameterIndex parameterIndex;
+    TypeIndex typeIndex;
+    DefaultValueDataIndex dataIndex;
+} Il2CppParameterDefaultValue;
+
+typedef struct Il2CppMethodDefinition
+{
+    StringIndex nameIndex;
+    TypeDefinitionIndex declaringType;
+    TypeIndex returnType;
+    ParameterIndex parameterStart;
+    GenericContainerIndex genericContainerIndex;
+    uint32_t token;
+    uint16_t flags;
+    uint16_t iflags;
+    uint16_t slot;
+    uint16_t parameterCount;
+} Il2CppMethodDefinition;
+
+typedef struct Il2CppEventDefinition
+{
+    StringIndex nameIndex;
+    TypeIndex typeIndex;
+    MethodIndex add;
+    MethodIndex remove;
+    MethodIndex raise;
+    uint32_t token;
+} Il2CppEventDefinition;
+
+typedef struct Il2CppPropertyDefinition
+{
+    StringIndex nameIndex;
+    MethodIndex get;
+    MethodIndex set;
+    uint32_t attrs;
+    uint32_t token;
+} Il2CppPropertyDefinition;
+
+typedef struct Il2CppStringLiteral
+{
+    StringLiteralIndex dataIndex;
+    uint32_t length;
+} Il2CppStringLiteral;
+
+typedef struct Il2CppAssemblyNameDefinition
+{
+    StringIndex nameIndex;
+    StringIndex cultureIndex;
+    StringIndex publicKeyIndex;
+    uint32_t hash_alg;
+    int32_t hash_len;
+    uint32_t flags;
+    int32_t major;
+    int32_t minor;
+    int32_t build;
+    int32_t revision;
+    uint8_t public_key_token[PUBLIC_KEY_BYTE_LENGTH];
+} Il2CppAssemblyNameDefinition;
+
+typedef struct Il2CppImageDefinition
+{
+    StringIndex nameIndex;
+    AssemblyIndex assemblyIndex;
+
+    TypeDefinitionIndex typeStart;
+    uint32_t typeCount;
+
+    TypeDefinitionIndex exportedTypeStart;
+    uint32_t exportedTypeCount;
+
+    MethodIndex entryPointIndex;
+    uint32_t token;
+
+    CustomAttributeIndex customAttributeStart;
+    uint32_t customAttributeCount;
+} Il2CppImageDefinition;
+
+typedef struct Il2CppAssemblyDefinition
+{
+    ImageIndex imageIndex;
+    uint32_t token;
+    int32_t referencedAssemblyStart;
+    int32_t referencedAssemblyCount;
+    Il2CppAssemblyNameDefinition aname;
+} Il2CppAssemblyDefinition;
+
+typedef struct Il2CppCustomAttributeDataRange
+{
+    uint32_t token;
+    uint32_t startOffset;
+} Il2CppCustomAttributeDataRange;
+
+typedef struct Il2CppMetadataRange
+{
+    int32_t start;
+    int32_t length;
+} Il2CppMetadataRange;
+
+typedef struct Il2CppGenericContainer
+{
+    /* index of the generic type definition or the generic method definition corresponding to this container */
+    int32_t ownerIndex; // either index into Il2CppClass metadata array or Il2CppMethodDefinition array
+    int32_t type_argc;
+    /* If true, we're a generic method, otherwise a generic type definition. */
+    int32_t is_method;
+    /* Our type parameters. */
+    GenericParameterIndex genericParameterStart;
+} Il2CppGenericContainer;
+
+typedef struct Il2CppGenericParameter
+{
+    GenericContainerIndex ownerIndex; /* Type or method this parameter was defined in. */
+    StringIndex nameIndex;
+    GenericParameterConstraintIndex constraintsStart;
+    int16_t constraintsCount;
+    uint16_t num;
+    uint16_t flags;
+} Il2CppGenericParameter;
+
+typedef struct Il2CppWindowsRuntimeTypeNamePair
+{
+    StringIndex nameIndex;
+    TypeIndex typeIndex;
+} Il2CppWindowsRuntimeTypeNamePair;
+
+#pragma pack(push, p1, 4)
+typedef struct Il2CppGlobalMetadataHeader
+{
+    int32_t sanity;
+
+    int32_t stringLiteralOffset; // string data for managed code
+    int32_t interfacesOffset;    // TypeIndex
+    int32_t stringLiteralDataOffset;
+    int32_t stringOffset;                               // string data for metadata
+    int32_t vtableMethodsOffset;                        // EncodedMethodIndex
+    int32_t eventsOffset;                               // Il2CppEventDefinition
+    int32_t interfaceOffsetsOffset;                     // Il2CppInterfaceOffsetPair
+    int32_t propertiesOffset;                           // Il2CppPropertyDefinition
+    int32_t assembliesOffset;                           // Il2CppAssemblyDefinition
+    int32_t methodsOffset;                              // Il2CppMethodDefinition
+    int32_t fieldRefsOffset;                            // Il2CppFieldRef
+    int32_t parameterDefaultValuesOffset;               // Il2CppParameterDefaultValue
+    int32_t typeDefinitionsOffset;                      // Il2CppTypeDefinition
+    int32_t fieldDefaultValuesOffset;                   // Il2CppFieldDefaultValue
+    int32_t imagesOffset;                               // Il2CppImageDefinition
+    int32_t fieldAndParameterDefaultValueDataOffset;    // uint8_t
+    int32_t referencedAssembliesOffset;                 // int32_t
+    int32_t fieldMarshaledSizesOffset;                  // Il2CppFieldMarshaledSize
+    int32_t unresolvedVirtualCallParameterTypesOffset;  // TypeIndex
+    int32_t parametersOffset;                           // Il2CppParameterDefinition
+    int32_t unresolvedVirtualCallParameterRangesOffset; // Il2CppMetadataRange
+    int32_t fieldsOffset;                               // Il2CppFieldDefinition
+    int32_t windowsRuntimeTypeNamesOffset;              // Il2CppWindowsRuntimeTypeNamePair
+    int32_t genericParametersOffset;                    // Il2CppGenericParameter
+    int32_t windowsRuntimeStringsOffset;                // const char*
+    int32_t genericParameterConstraintsOffset;          // TypeIndex
+    int32_t exportedTypeDefinitionsOffset;              // TypeDefinitionIndex
+    int32_t genericContainersOffset;                    // Il2CppGenericContainer
+    int32_t nestedTypesOffset;                          // TypeDefinitionIndex
+
+    int32_t version;
+    int32_t genericContainersSize;
+    int32_t stringLiteralSize;
+    int32_t nestedTypesSize;
+    int32_t interfacesSize;
+    int32_t stringLiteralDataSize;
+    int32_t vtableMethodsSize;
+    int32_t stringSize;
+    int32_t interfaceOffsetsSize;
+    int32_t eventsSize;
+    int32_t typeDefinitionsSize;
+    int32_t parameterDefaultValuesSize;
+    int32_t imagesSize;
+    int32_t fieldDefaultValuesSize;
+    int32_t assembliesSize;
+    int32_t propertiesSize;
+    int32_t fieldRefsSize;
+    int32_t methodsSize;
+    int32_t referencedAssembliesSize;
+    int32_t attributeDataOffset;
+    int32_t attributeDataSize;
+    int32_t attributeDataRangeOffset;
+    int32_t attributeDataRangeSize;
+    int32_t fieldAndParameterDefaultValueDataSize;
+    int32_t unresolvedVirtualCallParameterTypesSize;
+    int32_t fieldMarshaledSizesSize;
+    int32_t unresolvedVirtualCallParameterRangesSize;
+    int32_t parametersSize;
+    int32_t windowsRuntimeTypeNamesSize;
+    int32_t fieldsSize;
+    int32_t windowsRuntimeStringsSize;
+    int32_t genericParametersSize;
+    int32_t exportedTypeDefinitionsSize;
+    int32_t genericParameterConstraintsSize;
+} Il2CppGlobalMetadataHeader;
+#pragma pack(pop, p1)
+
+//FrontHeader
+#pragma pack(push, p1, 4)
+typedef struct FrontHeader
+{
+    char sign[24];
+    int64_t offset;
+    int32_t legnth;
+    unsigned char key[32];
+} FrontHeader;
+#pragma pack(pop, p1)
\ No newline at end of file
diff --git a/O&Z_IL2CPP_Security/resource/src-res/xxtea.cpp b/O&Z_IL2CPP_Security/resource/src-res/xxtea.cpp
new file mode 100644
index 0000000..0e6ab68
--- /dev/null
+++ b/O&Z_IL2CPP_Security/resource/src-res/xxtea.cpp
@@ -0,0 +1,260 @@
+/**********************************************************\
+|                                                          |
+| xxtea.c                                                  |
+|                                                          |
+| XXTEA encryption algorithm library for C.                |
+|                                                          |
+| Encryption Algorithm Authors:                            |
+|      David J. Wheeler                                    |
+|      Roger M. Needham                                    |
+|                                                          |
+| Code Authors: Chen fei <cf850118@163.com>                |
+|               Ma Bingyao <mabingyao@gmail.com>           |
+| LastModified: Feb 7, 2016                                |
+|                                                          |
+\**********************************************************/
+
+
+#include "xxtea.h"
+
+#include <string.h>
+#if defined(_MSC_VER) && _MSC_VER < 1600
+typedef unsigned __int8 uint8_t;
+typedef unsigned __int32 uint32_t;
+#else
+#if defined(__FreeBSD__) && __FreeBSD__ < 5
+/* FreeBSD 4 doesn't have stdint.h file */
+#include <inttypes.h>
+#else
+#include <stdint.h>
+#endif
+#endif
+
+#include <sys/types.h> /* This will likely define BYTE_ORDER */
+
+#ifndef BYTE_ORDER
+#if (BSD >= 199103)
+# include <machine/endian.h>
+#else
+#if defined(linux) || defined(__linux__)
+# include <endian.h>
+#else
+#define LITTLE_ENDIAN   1234    /* least-significant byte first (vax, pc) */
+#define BIG_ENDIAN  4321    /* most-significant byte first (IBM, net) */
+#define PDP_ENDIAN  3412    /* LSB first in word, MSW first in long (pdp)*/
+
+#if defined(__i386__) || defined(__x86_64__) || defined(__amd64__) || \
+   defined(vax) || defined(ns32000) || defined(sun386) || \
+   defined(MIPSEL) || defined(_MIPSEL) || defined(BIT_ZERO_ON_RIGHT) || \
+   defined(__alpha__) || defined(__alpha)
+#define BYTE_ORDER    LITTLE_ENDIAN
+#endif
+
+#if defined(sel) || defined(pyr) || defined(mc68000) || defined(sparc) || \
+    defined(is68k) || defined(tahoe) || defined(ibm032) || defined(ibm370) || \
+    defined(MIPSEB) || defined(_MIPSEB) || defined(_IBMR2) || defined(DGUX) ||\
+    defined(apollo) || defined(__convex__) || defined(_CRAY) || \
+    defined(__hppa) || defined(__hp9000) || \
+    defined(__hp9000s300) || defined(__hp9000s700) || \
+    defined (BIT_ZERO_ON_LEFT) || defined(m68k) || defined(__sparc)
+#define BYTE_ORDER  BIG_ENDIAN
+#endif
+#endif /* linux */
+#endif /* BSD */
+#endif /* BYTE_ORDER */
+
+#ifndef BYTE_ORDER
+#ifdef __BYTE_ORDER
+#if defined(__LITTLE_ENDIAN) && defined(__BIG_ENDIAN)
+#ifndef LITTLE_ENDIAN
+#define LITTLE_ENDIAN __LITTLE_ENDIAN
+#endif
+#ifndef BIG_ENDIAN
+#define BIG_ENDIAN __BIG_ENDIAN
+#endif
+#if (__BYTE_ORDER == __LITTLE_ENDIAN)
+#define BYTE_ORDER LITTLE_ENDIAN
+#else
+#define BYTE_ORDER BIG_ENDIAN
+#endif
+#endif
+#endif
+#endif
+
+#define MX (((z >> 5) ^ (y << 2)) + ((y >> 3) ^ (z << 4))) ^ ((sum ^ y) + (key[(p & 3) ^ e] ^ z))
+#define DELTA 0x9e3779b9
+
+#define FIXED_KEY \
+    size_t i;\
+    uint8_t fixed_key[16];\
+    memcpy(fixed_key, key, 16);\
+    for (i = 0; (i < 16) && (fixed_key[i] != 0); ++i);\
+    for (++i; i < 16; ++i) fixed_key[i] = 0;\
+
+
+static uint32_t * xxtea_to_uint_array(const uint8_t * data, size_t len, int inc_len, size_t * out_len) {
+    uint32_t *out;
+#if !(defined(BYTE_ORDER) && (BYTE_ORDER == LITTLE_ENDIAN))
+    size_t i;
+#endif
+    size_t n;
+
+    n = (((len & 3) == 0) ? (len >> 2) : ((len >> 2) + 1));
+
+    if (inc_len) {
+        out = (uint32_t *)calloc(n + 1, sizeof(uint32_t));
+        if (!out) return NULL;
+        out[n] = (uint32_t)len;
+        *out_len = n + 1;
+    }
+    else {
+        out = (uint32_t *)calloc(n, sizeof(uint32_t));
+        if (!out) return NULL;
+        *out_len = n;
+    }
+#if defined(BYTE_ORDER) && (BYTE_ORDER == LITTLE_ENDIAN)
+    memcpy(out, data, len);
+#else
+    for (i = 0; i < len; ++i) {
+        out[i >> 2] |= (uint32_t)data[i] << ((i & 3) << 3);
+    }
+#endif
+
+    return out;
+}
+
+static uint8_t * xxtea_to_ubyte_array(const uint32_t * data, size_t len, int inc_len, size_t * out_len) {
+    uint8_t *out;
+#if !(defined(BYTE_ORDER) && (BYTE_ORDER == LITTLE_ENDIAN))
+    size_t i;
+#endif
+    size_t m, n;
+
+    n = len << 2;
+
+    if (inc_len) {
+        m = data[len - 1];
+        n -= 4;
+        if ((m < n - 3) || (m > n)) return NULL;
+        n = m;
+    }
+
+    out = (uint8_t *)malloc(n + 1);
+
+#if defined(BYTE_ORDER) && (BYTE_ORDER == LITTLE_ENDIAN)
+    memcpy(out, data, n);
+#else
+    for (i = 0; i < n; ++i) {
+        out[i] = (uint8_t)(data[i >> 2] >> ((i & 3) << 3));
+    }
+#endif
+
+    out[n] = '\0';
+    *out_len = n;
+
+    return out;
+}
+
+static uint32_t * xxtea_uint_encrypt(uint32_t * data, size_t len, uint32_t * key) {
+    uint32_t n = (uint32_t)len - 1;
+    uint32_t z = data[n], y, p, q = 6 + 52 / (n + 1), sum = 0, e;
+
+    if (n < 1) return data;
+
+    while (0 < q--) {
+        sum += DELTA;
+        e = sum >> 2 & 3;
+
+        for (p = 0; p < n; p++) {
+            y = data[p + 1];
+            z = data[p] += MX;
+        }
+
+        y = data[0];
+        z = data[n] += MX;
+    }
+
+    return data;
+}
+
+static uint32_t * xxtea_uint_decrypt(uint32_t * data, size_t len, uint32_t * key) {
+    uint32_t n = (uint32_t)len - 1;
+    uint32_t z, y = data[0], p, q = 6 + 52 / (n + 1), sum = q * DELTA, e;
+
+    if (n < 1) return data;
+
+    while (sum != 0) {
+        e = sum >> 2 & 3;
+
+        for (p = n; p > 0; p--) {
+            z = data[p - 1];
+            y = data[p] -= MX;
+        }
+
+        z = data[n];
+        y = data[0] -= MX;
+        sum -= DELTA;
+    }
+
+    return data;
+}
+
+static uint8_t * xxtea_ubyte_encrypt(const uint8_t * data, size_t len, const uint8_t * key, size_t * out_len) {
+    uint8_t *out;
+    uint32_t *data_array, *key_array;
+    size_t data_len, key_len;
+
+    if (!len) return NULL;
+
+    data_array = xxtea_to_uint_array(data, len, 1, &data_len);
+    if (!data_array) return NULL;
+
+    key_array  = xxtea_to_uint_array(key, 16, 0, &key_len);
+    if (!key_array) {
+        free(data_array);
+        return NULL;
+    }
+
+    out = xxtea_to_ubyte_array(xxtea_uint_encrypt(data_array, data_len, key_array), data_len, 0, out_len);
+
+    free(data_array);
+    free(key_array);
+
+    return out;
+}
+
+static uint8_t * xxtea_ubyte_decrypt(const uint8_t * data, size_t len, const uint8_t * key, size_t * out_len) {
+    uint8_t *out;
+    uint32_t *data_array, *key_array;
+    size_t data_len, key_len;
+
+    if (!len) return NULL;
+
+    data_array = xxtea_to_uint_array(data, len, 0, &data_len);
+    if (!data_array) return NULL;
+
+    key_array  = xxtea_to_uint_array(key, 16, 0, &key_len);
+    if (!key_array) {
+        free(data_array);
+        return NULL;
+    }
+
+    out = xxtea_to_ubyte_array(xxtea_uint_decrypt(data_array, data_len, key_array), data_len, 1, out_len);
+
+    free(data_array);
+    free(key_array);
+
+    return out;
+}
+
+// public functions
+
+void * xxtea_encrypt(const void * data, size_t len, const void * key, size_t * out_len) {
+    FIXED_KEY
+    return xxtea_ubyte_encrypt((const uint8_t *)data, len, fixed_key, out_len);
+}
+
+void * xxtea_decrypt(const void * data, size_t len, const void * key, size_t * out_len) {
+    FIXED_KEY
+    return xxtea_ubyte_decrypt((const uint8_t *)data, len, fixed_key, out_len);
+}
diff --git a/O&Z_IL2CPP_Security/resource/src-res/xxtea.h b/O&Z_IL2CPP_Security/resource/src-res/xxtea.h
new file mode 100644
index 0000000..a54a700
--- /dev/null
+++ b/O&Z_IL2CPP_Security/resource/src-res/xxtea.h
@@ -0,0 +1,54 @@
+/**********************************************************\
+|                                                          |
+| xxtea.h                                                  |
+|                                                          |
+| XXTEA encryption algorithm library for C.                |
+|                                                          |
+| Encryption Algorithm Authors:                            |
+|      David J. Wheeler                                    |
+|      Roger M. Needham                                    |
+|                                                          |
+| Code Authors: Chen fei <cf850118@163.com>                |
+|               Ma Bingyao <mabingyao@gmail.com>           |
+| LastModified: Mar 3, 2015                                |
+|                                                          |
+\**********************************************************/
+
+#ifndef XXTEA_INCLUDED
+#define XXTEA_INCLUDED
+
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Function: xxtea_encrypt
+ * @data:    Data to be encrypted
+ * @len:     Length of the data to be encrypted
+ * @key:     Symmetric key
+ * @out_len: Pointer to output length variable
+ * Returns:  Encrypted data or %NULL on failure
+ *
+ * Caller is responsible for freeing the returned buffer.
+ */
+void * xxtea_encrypt(const void * data, size_t len, const void * key, size_t * out_len);
+
+/**
+ * Function: xxtea_decrypt
+ * @data:    Data to be decrypted
+ * @len:     Length of the data to be decrypted
+ * @key:     Symmetric key
+ * @out_len: Pointer to output length variable
+ * Returns:  Decrypted data or %NULL on failure
+ *
+ * Caller is responsible for freeing the returned buffer.
+ */
+void * xxtea_decrypt(const void * data, size_t len, const void * key, size_t * out_len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/O&Z_Obfuscator/LitJson/AssemblyInfo.cs.in b/O&Z_Obfuscator/LitJson/AssemblyInfo.cs.in
new file mode 100644
index 0000000..2cd1f90
--- /dev/null
+++ b/O&Z_Obfuscator/LitJson/AssemblyInfo.cs.in
@@ -0,0 +1,18 @@
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+
+[assembly: CLSCompliant (true)]
+
+[assembly: AssemblyTitle ("LitJson")]
+[assembly: AssemblyDescription ("LitJSON library")]
+[assembly: AssemblyConfiguration ("")]
+[assembly: AssemblyCompany ("")]
+[assembly: AssemblyProduct ("LitJSON")]
+[assembly: AssemblyCopyright (
+    "The authors disclaim copyright to this source code")]
+[assembly: AssemblyTrademark ("")]
+[assembly: AssemblyCulture ("")]
+
+[assembly: AssemblyVersion ("@ASSEMBLY_VERSION@")]
diff --git a/O&Z_Obfuscator/LitJson/IJsonWrapper.cs b/O&Z_Obfuscator/LitJson/IJsonWrapper.cs
new file mode 100644
index 0000000..afa7a1f
--- /dev/null
+++ b/O&Z_Obfuscator/LitJson/IJsonWrapper.cs
@@ -0,0 +1,60 @@
+#region Header
+/**
+ * IJsonWrapper.cs
+ *   Interface that represents a type capable of handling all kinds of JSON
+ *   data. This is mainly used when mapping objects through JsonMapper, and
+ *   it's implemented by JsonData.
+ *
+ * The authors disclaim copyright to this source code. For more details, see
+ * the COPYING file included with this distribution.
+ **/
+#endregion
+
+
+using System.Collections;
+using System.Collections.Specialized;
+
+
+namespace O_Z_IL2CPP_Security.LitJson
+{
+    public enum JsonType
+    {
+        None,
+
+        Object,
+        Array,
+        String,
+        Int,
+        Long,
+        Double,
+        Boolean
+    }
+
+    public interface IJsonWrapper : IList, IOrderedDictionary
+    {
+        bool IsArray { get; }
+        bool IsBoolean { get; }
+        bool IsDouble { get; }
+        bool IsInt { get; }
+        bool IsLong { get; }
+        bool IsObject { get; }
+        bool IsString { get; }
+
+        bool GetBoolean();
+        double GetDouble();
+        int GetInt();
+        JsonType GetJsonType();
+        long GetLong();
+        string GetString();
+
+        void SetBoolean(bool val);
+        void SetDouble(double val);
+        void SetInt(int val);
+        void SetJsonType(JsonType type);
+        void SetLong(long val);
+        void SetString(string val);
+
+        string ToJson();
+        void ToJson(JsonWriter writer);
+    }
+}
diff --git a/O&Z_Obfuscator/LitJson/JsonData.cs b/O&Z_Obfuscator/LitJson/JsonData.cs
new file mode 100644
index 0000000..926ce0c
--- /dev/null
+++ b/O&Z_Obfuscator/LitJson/JsonData.cs
@@ -0,0 +1,1142 @@
+#region Header
+/**
+ * JsonData.cs
+ *   Generic type to hold JSON data (objects, arrays, and so on). This is
+ *   the default type returned by JsonMapper.ToObject().
+ *
+ * The authors disclaim copyright to this source code. For more details, see
+ * the COPYING file included with this distribution.
+ **/
+#endregion
+
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.IO;
+
+
+namespace O_Z_IL2CPP_Security.LitJson
+{
+    public class JsonData : IJsonWrapper, IEquatable<JsonData>
+    {
+        #region Fields
+        private IList<JsonData> inst_array;
+        private bool inst_boolean;
+        private double inst_double;
+        private int inst_int;
+        private long inst_long;
+        private IDictionary<string, JsonData> inst_object;
+        private string inst_string;
+        private string json;
+        private JsonType type;
+
+        // Used to implement the IOrderedDictionary interface
+        private IList<KeyValuePair<string, JsonData>> object_list;
+        #endregion
+
+
+        #region Properties
+        public int Count
+        {
+            get { return EnsureCollection().Count; }
+        }
+
+        public bool IsArray
+        {
+            get { return type == JsonType.Array; }
+        }
+
+        public bool IsBoolean
+        {
+            get { return type == JsonType.Boolean; }
+        }
+
+        public bool IsDouble
+        {
+            get { return type == JsonType.Double; }
+        }
+
+        public bool IsInt
+        {
+            get { return type == JsonType.Int; }
+        }
+
+        public bool IsLong
+        {
+            get { return type == JsonType.Long; }
+        }
+
+        public bool IsObject
+        {
+            get { return type == JsonType.Object; }
+        }
+
+        public bool IsString
+        {
+            get { return type == JsonType.String; }
+        }
+
+        public ICollection<string> Keys
+        {
+            get { EnsureDictionary(); return inst_object.Keys; }
+        }
+
+        /// <summary>
+        /// Determines whether the json contains an element that has the specified key.
+        /// </summary>
+        /// <param name="key">The key to locate in the json.</param>
+        /// <returns>true if the json contains an element that has the specified key; otherwise, false.</returns>
+        public bool ContainsKey(string key)
+        {
+            EnsureDictionary();
+            return inst_object.Keys.Contains(key);
+        }
+        #endregion
+
+
+        #region ICollection Properties
+        int ICollection.Count
+        {
+            get
+            {
+                return Count;
+            }
+        }
+
+        bool ICollection.IsSynchronized
+        {
+            get
+            {
+                return EnsureCollection().IsSynchronized;
+            }
+        }
+
+        object ICollection.SyncRoot
+        {
+            get
+            {
+                return EnsureCollection().SyncRoot;
+            }
+        }
+        #endregion
+
+
+        #region IDictionary Properties
+        bool IDictionary.IsFixedSize
+        {
+            get
+            {
+                return EnsureDictionary().IsFixedSize;
+            }
+        }
+
+        bool IDictionary.IsReadOnly
+        {
+            get
+            {
+                return EnsureDictionary().IsReadOnly;
+            }
+        }
+
+        ICollection IDictionary.Keys
+        {
+            get
+            {
+                EnsureDictionary();
+                IList<string> keys = new List<string>();
+
+                foreach (KeyValuePair<string, JsonData> entry in
+                         object_list)
+                {
+                    keys.Add(entry.Key);
+                }
+
+                return (ICollection)keys;
+            }
+        }
+
+        ICollection IDictionary.Values
+        {
+            get
+            {
+                EnsureDictionary();
+                IList<JsonData> values = new List<JsonData>();
+
+                foreach (KeyValuePair<string, JsonData> entry in
+                         object_list)
+                {
+                    values.Add(entry.Value);
+                }
+
+                return (ICollection)values;
+            }
+        }
+        #endregion
+
+
+
+        #region IJsonWrapper Properties
+        bool IJsonWrapper.IsArray
+        {
+            get { return IsArray; }
+        }
+
+        bool IJsonWrapper.IsBoolean
+        {
+            get { return IsBoolean; }
+        }
+
+        bool IJsonWrapper.IsDouble
+        {
+            get { return IsDouble; }
+        }
+
+        bool IJsonWrapper.IsInt
+        {
+            get { return IsInt; }
+        }
+
+        bool IJsonWrapper.IsLong
+        {
+            get { return IsLong; }
+        }
+
+        bool IJsonWrapper.IsObject
+        {
+            get { return IsObject; }
+        }
+
+        bool IJsonWrapper.IsString
+        {
+            get { return IsString; }
+        }
+        #endregion
+
+
+        #region IList Properties
+        bool IList.IsFixedSize
+        {
+            get
+            {
+                return EnsureList().IsFixedSize;
+            }
+        }
+
+        bool IList.IsReadOnly
+        {
+            get
+            {
+                return EnsureList().IsReadOnly;
+            }
+        }
+        #endregion
+
+
+        #region IDictionary Indexer
+        object IDictionary.this[object key]
+        {
+            get
+            {
+                return EnsureDictionary()[key];
+            }
+
+            set
+            {
+                if (!(key is string))
+                    throw new ArgumentException(
+                        "The key has to be a string");
+
+                JsonData data = ToJsonData(value);
+
+                this[(string)key] = data;
+            }
+        }
+        #endregion
+
+
+        #region IOrderedDictionary Indexer
+        object IOrderedDictionary.this[int idx]
+        {
+            get
+            {
+                EnsureDictionary();
+                return object_list[idx].Value;
+            }
+
+            set
+            {
+                EnsureDictionary();
+                JsonData data = ToJsonData(value);
+
+                KeyValuePair<string, JsonData> old_entry = object_list[idx];
+
+                inst_object[old_entry.Key] = data;
+
+                KeyValuePair<string, JsonData> entry =
+                    new KeyValuePair<string, JsonData>(old_entry.Key, data);
+
+                object_list[idx] = entry;
+            }
+        }
+        #endregion
+
+
+        #region IList Indexer
+        object IList.this[int index]
+        {
+            get
+            {
+                return EnsureList()[index];
+            }
+
+            set
+            {
+                EnsureList();
+                JsonData data = ToJsonData(value);
+
+                this[index] = data;
+            }
+        }
+        #endregion
+
+
+        #region Public Indexers
+        public JsonData this[string prop_name]
+        {
+            get
+            {
+                EnsureDictionary();
+                return inst_object[prop_name];
+            }
+
+            set
+            {
+                EnsureDictionary();
+
+                KeyValuePair<string, JsonData> entry =
+                    new KeyValuePair<string, JsonData>(prop_name, value);
+
+                if (inst_object.ContainsKey(prop_name))
+                {
+                    for (int i = 0; i < object_list.Count; i++)
+                    {
+                        if (object_list[i].Key == prop_name)
+                        {
+                            object_list[i] = entry;
+                            break;
+                        }
+                    }
+                }
+                else
+                    object_list.Add(entry);
+
+                inst_object[prop_name] = value;
+
+                json = null;
+            }
+        }
+
+        public JsonData this[int index]
+        {
+            get
+            {
+                EnsureCollection();
+
+                if (type == JsonType.Array)
+                    return inst_array[index];
+
+                return object_list[index].Value;
+            }
+
+            set
+            {
+                EnsureCollection();
+
+                if (type == JsonType.Array)
+                    inst_array[index] = value;
+                else
+                {
+                    KeyValuePair<string, JsonData> entry = object_list[index];
+                    KeyValuePair<string, JsonData> new_entry =
+                        new KeyValuePair<string, JsonData>(entry.Key, value);
+
+                    object_list[index] = new_entry;
+                    inst_object[entry.Key] = value;
+                }
+
+                json = null;
+            }
+        }
+        #endregion
+
+
+        #region Constructors
+        public JsonData()
+        {
+        }
+
+        public JsonData(bool boolean)
+        {
+            type = JsonType.Boolean;
+            inst_boolean = boolean;
+        }
+
+        public JsonData(double number)
+        {
+            type = JsonType.Double;
+            inst_double = number;
+        }
+
+        public JsonData(int number)
+        {
+            type = JsonType.Int;
+            inst_int = number;
+        }
+
+        public JsonData(long number)
+        {
+            type = JsonType.Long;
+            inst_long = number;
+        }
+
+        public JsonData(object obj)
+        {
+            if (obj is bool)
+            {
+                type = JsonType.Boolean;
+                inst_boolean = (bool)obj;
+                return;
+            }
+
+            if (obj is double)
+            {
+                type = JsonType.Double;
+                inst_double = (double)obj;
+                return;
+            }
+
+            if (obj is int)
+            {
+                type = JsonType.Int;
+                inst_int = (int)obj;
+                return;
+            }
+
+            if (obj is long)
+            {
+                type = JsonType.Long;
+                inst_long = (long)obj;
+                return;
+            }
+
+            if (obj is string)
+            {
+                type = JsonType.String;
+                inst_string = (string)obj;
+                return;
+            }
+
+            throw new ArgumentException(
+                "Unable to wrap the given object with JsonData");
+        }
+
+        public JsonData(string str)
+        {
+            type = JsonType.String;
+            inst_string = str;
+        }
+        #endregion
+
+
+        #region Implicit Conversions
+        public static implicit operator JsonData(bool data)
+        {
+            return new JsonData(data);
+        }
+
+        public static implicit operator JsonData(double data)
+        {
+            return new JsonData(data);
+        }
+
+        public static implicit operator JsonData(int data)
+        {
+            return new JsonData(data);
+        }
+
+        public static implicit operator JsonData(long data)
+        {
+            return new JsonData(data);
+        }
+
+        public static implicit operator JsonData(string data)
+        {
+            return new JsonData(data);
+        }
+        #endregion
+
+
+        #region Explicit Conversions
+        public static explicit operator bool(JsonData data)
+        {
+            if (data.type != JsonType.Boolean)
+                throw new InvalidCastException(
+                    "Instance of JsonData doesn't hold a double");
+
+            return data.inst_boolean;
+        }
+
+        public static explicit operator double(JsonData data)
+        {
+            if (data.type != JsonType.Double)
+                throw new InvalidCastException(
+                    "Instance of JsonData doesn't hold a double");
+
+            return data.inst_double;
+        }
+
+        public static explicit operator int(JsonData data)
+        {
+            if (data.type != JsonType.Int && data.type != JsonType.Long)
+            {
+                throw new InvalidCastException(
+                    "Instance of JsonData doesn't hold an int");
+            }
+
+            // cast may truncate data... but that's up to the user to consider
+            return data.type == JsonType.Int ? data.inst_int : (int)data.inst_long;
+        }
+
+        public static explicit operator long(JsonData data)
+        {
+            if (data.type != JsonType.Long && data.type != JsonType.Int)
+            {
+                throw new InvalidCastException(
+                    "Instance of JsonData doesn't hold a long");
+            }
+
+            return data.type == JsonType.Long ? data.inst_long : data.inst_int;
+        }
+
+        public static explicit operator string(JsonData data)
+        {
+            if (data.type != JsonType.String)
+                throw new InvalidCastException(
+                    "Instance of JsonData doesn't hold a string");
+
+            return data.inst_string;
+        }
+        #endregion
+
+
+        #region ICollection Methods
+        void ICollection.CopyTo(Array array, int index)
+        {
+            EnsureCollection().CopyTo(array, index);
+        }
+        #endregion
+
+
+        #region IDictionary Methods
+        void IDictionary.Add(object key, object value)
+        {
+            JsonData data = ToJsonData(value);
+
+            EnsureDictionary().Add(key, data);
+
+            KeyValuePair<string, JsonData> entry =
+                new KeyValuePair<string, JsonData>((string)key, data);
+            object_list.Add(entry);
+
+            json = null;
+        }
+
+        void IDictionary.Clear()
+        {
+            EnsureDictionary().Clear();
+            object_list.Clear();
+            json = null;
+        }
+
+        bool IDictionary.Contains(object key)
+        {
+            return EnsureDictionary().Contains(key);
+        }
+
+        IDictionaryEnumerator IDictionary.GetEnumerator()
+        {
+            return ((IOrderedDictionary)this).GetEnumerator();
+        }
+
+        void IDictionary.Remove(object key)
+        {
+            EnsureDictionary().Remove(key);
+
+            for (int i = 0; i < object_list.Count; i++)
+            {
+                if (object_list[i].Key == (string)key)
+                {
+                    object_list.RemoveAt(i);
+                    break;
+                }
+            }
+
+            json = null;
+        }
+        #endregion
+
+
+        #region IEnumerable Methods
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return EnsureCollection().GetEnumerator();
+        }
+        #endregion
+
+
+        #region IJsonWrapper Methods
+        bool IJsonWrapper.GetBoolean()
+        {
+            if (type != JsonType.Boolean)
+                throw new InvalidOperationException(
+                    "JsonData instance doesn't hold a boolean");
+
+            return inst_boolean;
+        }
+
+        double IJsonWrapper.GetDouble()
+        {
+            if (type != JsonType.Double)
+                throw new InvalidOperationException(
+                    "JsonData instance doesn't hold a double");
+
+            return inst_double;
+        }
+
+        int IJsonWrapper.GetInt()
+        {
+            if (type != JsonType.Int)
+                throw new InvalidOperationException(
+                    "JsonData instance doesn't hold an int");
+
+            return inst_int;
+        }
+
+        long IJsonWrapper.GetLong()
+        {
+            if (type != JsonType.Long)
+                throw new InvalidOperationException(
+                    "JsonData instance doesn't hold a long");
+
+            return inst_long;
+        }
+
+        string IJsonWrapper.GetString()
+        {
+            if (type != JsonType.String)
+                throw new InvalidOperationException(
+                    "JsonData instance doesn't hold a string");
+
+            return inst_string;
+        }
+
+        void IJsonWrapper.SetBoolean(bool val)
+        {
+            type = JsonType.Boolean;
+            inst_boolean = val;
+            json = null;
+        }
+
+        void IJsonWrapper.SetDouble(double val)
+        {
+            type = JsonType.Double;
+            inst_double = val;
+            json = null;
+        }
+
+        void IJsonWrapper.SetInt(int val)
+        {
+            type = JsonType.Int;
+            inst_int = val;
+            json = null;
+        }
+
+        void IJsonWrapper.SetLong(long val)
+        {
+            type = JsonType.Long;
+            inst_long = val;
+            json = null;
+        }
+
+        void IJsonWrapper.SetString(string val)
+        {
+            type = JsonType.String;
+            inst_string = val;
+            json = null;
+        }
+
+        string IJsonWrapper.ToJson()
+        {
+            return ToJson();
+        }
+
+        void IJsonWrapper.ToJson(JsonWriter writer)
+        {
+            ToJson(writer);
+        }
+        #endregion
+
+
+        #region IList Methods
+        int IList.Add(object value)
+        {
+            return Add(value);
+        }
+
+        void IList.Clear()
+        {
+            EnsureList().Clear();
+            json = null;
+        }
+
+        bool IList.Contains(object value)
+        {
+            return EnsureList().Contains(value);
+        }
+
+        int IList.IndexOf(object value)
+        {
+            return EnsureList().IndexOf(value);
+        }
+
+        void IList.Insert(int index, object value)
+        {
+            EnsureList().Insert(index, value);
+            json = null;
+        }
+
+        void IList.Remove(object value)
+        {
+            EnsureList().Remove(value);
+            json = null;
+        }
+
+        void IList.RemoveAt(int index)
+        {
+            EnsureList().RemoveAt(index);
+            json = null;
+        }
+        #endregion
+
+
+        #region IOrderedDictionary Methods
+        IDictionaryEnumerator IOrderedDictionary.GetEnumerator()
+        {
+            EnsureDictionary();
+
+            return new OrderedDictionaryEnumerator(
+                object_list.GetEnumerator());
+        }
+
+        void IOrderedDictionary.Insert(int idx, object key, object value)
+        {
+            string property = (string)key;
+            JsonData data = ToJsonData(value);
+
+            this[property] = data;
+
+            KeyValuePair<string, JsonData> entry =
+                new KeyValuePair<string, JsonData>(property, data);
+
+            object_list.Insert(idx, entry);
+        }
+
+        void IOrderedDictionary.RemoveAt(int idx)
+        {
+            EnsureDictionary();
+
+            inst_object.Remove(object_list[idx].Key);
+            object_list.RemoveAt(idx);
+        }
+        #endregion
+
+
+        #region Private Methods
+        private ICollection EnsureCollection()
+        {
+            if (type == JsonType.Array)
+                return (ICollection)inst_array;
+
+            if (type == JsonType.Object)
+                return (ICollection)inst_object;
+
+            throw new InvalidOperationException(
+                "The JsonData instance has to be initialized first");
+        }
+
+        private IDictionary EnsureDictionary()
+        {
+            if (type == JsonType.Object)
+                return (IDictionary)inst_object;
+
+            if (type != JsonType.None)
+                throw new InvalidOperationException(
+                    "Instance of JsonData is not a dictionary");
+
+            type = JsonType.Object;
+            inst_object = new Dictionary<string, JsonData>();
+            object_list = new List<KeyValuePair<string, JsonData>>();
+
+            return (IDictionary)inst_object;
+        }
+
+        private IList EnsureList()
+        {
+            if (type == JsonType.Array)
+                return (IList)inst_array;
+
+            if (type != JsonType.None)
+                throw new InvalidOperationException(
+                    "Instance of JsonData is not a list");
+
+            type = JsonType.Array;
+            inst_array = new List<JsonData>();
+
+            return (IList)inst_array;
+        }
+
+        private JsonData ToJsonData(object obj)
+        {
+            if (obj == null)
+                return null;
+
+            if (obj is JsonData)
+                return (JsonData)obj;
+
+            return new JsonData(obj);
+        }
+
+        private static void WriteJson(IJsonWrapper obj, JsonWriter writer)
+        {
+            if (obj == null)
+            {
+                writer.Write(null);
+                return;
+            }
+
+            if (obj.IsString)
+            {
+                writer.Write(obj.GetString());
+                return;
+            }
+
+            if (obj.IsBoolean)
+            {
+                writer.Write(obj.GetBoolean());
+                return;
+            }
+
+            if (obj.IsDouble)
+            {
+                writer.Write(obj.GetDouble());
+                return;
+            }
+
+            if (obj.IsInt)
+            {
+                writer.Write(obj.GetInt());
+                return;
+            }
+
+            if (obj.IsLong)
+            {
+                writer.Write(obj.GetLong());
+                return;
+            }
+
+            if (obj.IsArray)
+            {
+                writer.WriteArrayStart();
+                foreach (object elem in (IList)obj)
+                    WriteJson((JsonData)elem, writer);
+                writer.WriteArrayEnd();
+
+                return;
+            }
+
+            if (obj.IsObject)
+            {
+                writer.WriteObjectStart();
+
+                foreach (DictionaryEntry entry in (IDictionary)obj)
+                {
+                    writer.WritePropertyName((string)entry.Key);
+                    WriteJson((JsonData)entry.Value, writer);
+                }
+                writer.WriteObjectEnd();
+
+                return;
+            }
+        }
+        #endregion
+
+
+        public int Add(object value)
+        {
+            JsonData data = ToJsonData(value);
+
+            json = null;
+
+            return EnsureList().Add(data);
+        }
+
+        public bool Remove(object obj)
+        {
+            json = null;
+            if (IsObject)
+            {
+                JsonData value = null;
+                if (inst_object.TryGetValue((string)obj, out value))
+                    return inst_object.Remove((string)obj) && object_list.Remove(new KeyValuePair<string, JsonData>((string)obj, value));
+                else
+                    throw new KeyNotFoundException("The specified key was not found in the JsonData object.");
+            }
+            if (IsArray)
+            {
+                return inst_array.Remove(ToJsonData(obj));
+            }
+            throw new InvalidOperationException(
+                    "Instance of JsonData is not an object or a list.");
+        }
+
+        public void Clear()
+        {
+            if (IsObject)
+            {
+                ((IDictionary)this).Clear();
+                return;
+            }
+
+            if (IsArray)
+            {
+                ((IList)this).Clear();
+                return;
+            }
+        }
+
+        public bool Equals(JsonData x)
+        {
+            if (x == null)
+                return false;
+
+            if (x.type != type)
+            {
+                // further check to see if this is a long to int comparison
+                if (x.type != JsonType.Int && x.type != JsonType.Long
+                    || type != JsonType.Int && type != JsonType.Long)
+                {
+                    return false;
+                }
+            }
+
+            switch (type)
+            {
+                case JsonType.None:
+                    return true;
+
+                case JsonType.Object:
+                    return inst_object.Equals(x.inst_object);
+
+                case JsonType.Array:
+                    return inst_array.Equals(x.inst_array);
+
+                case JsonType.String:
+                    return inst_string.Equals(x.inst_string);
+
+                case JsonType.Int:
+                    {
+                        if (x.IsLong)
+                        {
+                            if (x.inst_long < int.MinValue || x.inst_long > int.MaxValue)
+                                return false;
+                            return inst_int.Equals((int)x.inst_long);
+                        }
+                        return inst_int.Equals(x.inst_int);
+                    }
+
+                case JsonType.Long:
+                    {
+                        if (x.IsInt)
+                        {
+                            if (inst_long < int.MinValue || inst_long > int.MaxValue)
+                                return false;
+                            return x.inst_int.Equals((int)inst_long);
+                        }
+                        return inst_long.Equals(x.inst_long);
+                    }
+
+                case JsonType.Double:
+                    return inst_double.Equals(x.inst_double);
+
+                case JsonType.Boolean:
+                    return inst_boolean.Equals(x.inst_boolean);
+            }
+
+            return false;
+        }
+
+        public JsonType GetJsonType()
+        {
+            return type;
+        }
+
+        public void SetJsonType(JsonType type)
+        {
+            if (this.type == type)
+                return;
+
+            switch (type)
+            {
+                case JsonType.None:
+                    break;
+
+                case JsonType.Object:
+                    inst_object = new Dictionary<string, JsonData>();
+                    object_list = new List<KeyValuePair<string, JsonData>>();
+                    break;
+
+                case JsonType.Array:
+                    inst_array = new List<JsonData>();
+                    break;
+
+                case JsonType.String:
+                    inst_string = default;
+                    break;
+
+                case JsonType.Int:
+                    inst_int = default;
+                    break;
+
+                case JsonType.Long:
+                    inst_long = default;
+                    break;
+
+                case JsonType.Double:
+                    inst_double = default;
+                    break;
+
+                case JsonType.Boolean:
+                    inst_boolean = default;
+                    break;
+            }
+
+            this.type = type;
+        }
+
+        public string ToJson()
+        {
+            if (json != null)
+                return json;
+
+            StringWriter sw = new StringWriter();
+            JsonWriter writer = new JsonWriter(sw);
+            writer.Validate = false;
+
+            WriteJson(this, writer);
+            json = sw.ToString();
+
+            return json;
+        }
+
+        public void ToJson(JsonWriter writer)
+        {
+            bool old_validate = writer.Validate;
+
+            writer.Validate = false;
+
+            WriteJson(this, writer);
+
+            writer.Validate = old_validate;
+        }
+
+        public override string ToString()
+        {
+            switch (type)
+            {
+                case JsonType.Array:
+                    return "JsonData array";
+
+                case JsonType.Boolean:
+                    return inst_boolean.ToString();
+
+                case JsonType.Double:
+                    return inst_double.ToString();
+
+                case JsonType.Int:
+                    return inst_int.ToString();
+
+                case JsonType.Long:
+                    return inst_long.ToString();
+
+                case JsonType.Object:
+                    return "JsonData object";
+
+                case JsonType.String:
+                    return inst_string;
+            }
+
+            return "Uninitialized JsonData";
+        }
+    }
+
+
+    internal class OrderedDictionaryEnumerator : IDictionaryEnumerator
+    {
+        IEnumerator<KeyValuePair<string, JsonData>> list_enumerator;
+
+
+        public object Current
+        {
+            get { return Entry; }
+        }
+
+        public DictionaryEntry Entry
+        {
+            get
+            {
+                KeyValuePair<string, JsonData> curr = list_enumerator.Current;
+                return new DictionaryEntry(curr.Key, curr.Value);
+            }
+        }
+
+        public object Key
+        {
+            get { return list_enumerator.Current.Key; }
+        }
+
+        public object Value
+        {
+            get { return list_enumerator.Current.Value; }
+        }
+
+
+        public OrderedDictionaryEnumerator(
+            IEnumerator<KeyValuePair<string, JsonData>> enumerator)
+        {
+            list_enumerator = enumerator;
+        }
+
+
+        public bool MoveNext()
+        {
+            return list_enumerator.MoveNext();
+        }
+
+        public void Reset()
+        {
+            list_enumerator.Reset();
+        }
+    }
+}
diff --git a/O&Z_Obfuscator/LitJson/JsonException.cs b/O&Z_Obfuscator/LitJson/JsonException.cs
new file mode 100644
index 0000000..c8d728a
--- /dev/null
+++ b/O&Z_Obfuscator/LitJson/JsonException.cs
@@ -0,0 +1,65 @@
+#region Header
+/**
+ * JsonException.cs
+ *   Base class throwed by LitJSON when a parsing error occurs.
+ *
+ * The authors disclaim copyright to this source code. For more details, see
+ * the COPYING file included with this distribution.
+ **/
+#endregion
+
+
+using System;
+
+
+namespace O_Z_IL2CPP_Security.LitJson
+{
+    public class JsonException :
+#if NETSTANDARD1_5
+        Exception
+#else
+        ApplicationException
+#endif
+    {
+        public JsonException() : base()
+        {
+        }
+
+        internal JsonException(ParserToken token) :
+            base(string.Format(
+                    "Invalid token '{0}' in input string", token))
+        {
+        }
+
+        internal JsonException(ParserToken token,
+                                Exception inner_exception) :
+            base(string.Format(
+                    "Invalid token '{0}' in input string", token),
+                inner_exception)
+        {
+        }
+
+        internal JsonException(int c) :
+            base(string.Format(
+                    "Invalid character '{0}' in input string", (char)c))
+        {
+        }
+
+        internal JsonException(int c, Exception inner_exception) :
+            base(string.Format(
+                    "Invalid character '{0}' in input string", (char)c),
+                inner_exception)
+        {
+        }
+
+
+        public JsonException(string message) : base(message)
+        {
+        }
+
+        public JsonException(string message, Exception inner_exception) :
+            base(message, inner_exception)
+        {
+        }
+    }
+}
diff --git a/O&Z_Obfuscator/LitJson/JsonMapper.cs b/O&Z_Obfuscator/LitJson/JsonMapper.cs
new file mode 100644
index 0000000..f9622e6
--- /dev/null
+++ b/O&Z_Obfuscator/LitJson/JsonMapper.cs
@@ -0,0 +1,1098 @@
+#region Header
+/**
+ * JsonMapper.cs
+ *   JSON to .Net object and object to JSON conversions.
+ *
+ * The authors disclaim copyright to this source code. For more details, see
+ * the COPYING file included with this distribution.
+ **/
+#endregion
+
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Reflection;
+
+
+namespace O_Z_IL2CPP_Security.LitJson
+{
+    internal struct PropertyMetadata
+    {
+        public MemberInfo Info;
+        public bool IsField;
+        public Type Type;
+    }
+
+
+    internal struct ArrayMetadata
+    {
+        private Type element_type;
+        private bool is_array;
+        private bool is_list;
+
+
+        public Type ElementType
+        {
+            get
+            {
+                if (element_type == null)
+                    return typeof(JsonData);
+
+                return element_type;
+            }
+
+            set { element_type = value; }
+        }
+
+        public bool IsArray
+        {
+            get { return is_array; }
+            set { is_array = value; }
+        }
+
+        public bool IsList
+        {
+            get { return is_list; }
+            set { is_list = value; }
+        }
+    }
+
+
+    internal struct ObjectMetadata
+    {
+        private Type element_type;
+        private bool is_dictionary;
+
+        private IDictionary<string, PropertyMetadata> properties;
+
+
+        public Type ElementType
+        {
+            get
+            {
+                if (element_type == null)
+                    return typeof(JsonData);
+
+                return element_type;
+            }
+
+            set { element_type = value; }
+        }
+
+        public bool IsDictionary
+        {
+            get { return is_dictionary; }
+            set { is_dictionary = value; }
+        }
+
+        public IDictionary<string, PropertyMetadata> Properties
+        {
+            get { return properties; }
+            set { properties = value; }
+        }
+    }
+
+
+    internal delegate void ExporterFunc(object obj, JsonWriter writer);
+    public delegate void ExporterFunc<T>(T obj, JsonWriter writer);
+
+    internal delegate object ImporterFunc(object input);
+    public delegate TValue ImporterFunc<TJson, TValue>(TJson input);
+
+    public delegate IJsonWrapper WrapperFactory();
+
+
+    public class JsonMapper
+    {
+        #region Fields
+        private static readonly int max_nesting_depth;
+
+        private static readonly IFormatProvider datetime_format;
+
+        private static readonly IDictionary<Type, ExporterFunc> base_exporters_table;
+        private static readonly IDictionary<Type, ExporterFunc> custom_exporters_table;
+
+        private static readonly IDictionary<Type,
+                IDictionary<Type, ImporterFunc>> base_importers_table;
+        private static readonly IDictionary<Type,
+                IDictionary<Type, ImporterFunc>> custom_importers_table;
+
+        private static readonly IDictionary<Type, ArrayMetadata> array_metadata;
+        private static readonly object array_metadata_lock = new object();
+
+        private static readonly IDictionary<Type,
+                IDictionary<Type, MethodInfo>> conv_ops;
+        private static readonly object conv_ops_lock = new object();
+
+        private static readonly IDictionary<Type, ObjectMetadata> object_metadata;
+        private static readonly object object_metadata_lock = new object();
+
+        private static readonly IDictionary<Type,
+                IList<PropertyMetadata>> type_properties;
+        private static readonly object type_properties_lock = new object();
+
+        private static readonly JsonWriter static_writer;
+        private static readonly object static_writer_lock = new object();
+        #endregion
+
+
+        #region Constructors
+        static JsonMapper()
+        {
+            max_nesting_depth = 100;
+
+            array_metadata = new Dictionary<Type, ArrayMetadata>();
+            conv_ops = new Dictionary<Type, IDictionary<Type, MethodInfo>>();
+            object_metadata = new Dictionary<Type, ObjectMetadata>();
+            type_properties = new Dictionary<Type,
+                            IList<PropertyMetadata>>();
+
+            static_writer = new JsonWriter();
+
+            datetime_format = DateTimeFormatInfo.InvariantInfo;
+
+            base_exporters_table = new Dictionary<Type, ExporterFunc>();
+            custom_exporters_table = new Dictionary<Type, ExporterFunc>();
+
+            base_importers_table = new Dictionary<Type,
+                                 IDictionary<Type, ImporterFunc>>();
+            custom_importers_table = new Dictionary<Type,
+                                   IDictionary<Type, ImporterFunc>>();
+
+            RegisterBaseExporters();
+            RegisterBaseImporters();
+        }
+        #endregion
+
+
+        #region Private Methods
+        private static void AddArrayMetadata(Type type)
+        {
+            if (array_metadata.ContainsKey(type))
+                return;
+
+            ArrayMetadata data = new ArrayMetadata();
+
+            data.IsArray = type.IsArray;
+
+            if (type.GetInterface("System.Collections.IList") != null)
+                data.IsList = true;
+
+            foreach (PropertyInfo p_info in type.GetProperties())
+            {
+                if (p_info.Name != "Item")
+                    continue;
+
+                ParameterInfo[] parameters = p_info.GetIndexParameters();
+
+                if (parameters.Length != 1)
+                    continue;
+
+                if (parameters[0].ParameterType == typeof(int))
+                    data.ElementType = p_info.PropertyType;
+            }
+
+            lock (array_metadata_lock)
+            {
+                try
+                {
+                    array_metadata.Add(type, data);
+                }
+                catch (ArgumentException)
+                {
+                    return;
+                }
+            }
+        }
+
+        private static void AddObjectMetadata(Type type)
+        {
+            if (object_metadata.ContainsKey(type))
+                return;
+
+            ObjectMetadata data = new ObjectMetadata();
+
+            if (type.GetInterface("System.Collections.IDictionary") != null)
+                data.IsDictionary = true;
+
+            data.Properties = new Dictionary<string, PropertyMetadata>();
+
+            foreach (PropertyInfo p_info in type.GetProperties())
+            {
+                if (p_info.Name == "Item")
+                {
+                    ParameterInfo[] parameters = p_info.GetIndexParameters();
+
+                    if (parameters.Length != 1)
+                        continue;
+
+                    if (parameters[0].ParameterType == typeof(string))
+                        data.ElementType = p_info.PropertyType;
+
+                    continue;
+                }
+
+                PropertyMetadata p_data = new PropertyMetadata();
+                p_data.Info = p_info;
+                p_data.Type = p_info.PropertyType;
+
+                data.Properties.Add(p_info.Name, p_data);
+            }
+
+            foreach (FieldInfo f_info in type.GetFields())
+            {
+                PropertyMetadata p_data = new PropertyMetadata();
+                p_data.Info = f_info;
+                p_data.IsField = true;
+                p_data.Type = f_info.FieldType;
+
+                data.Properties.Add(f_info.Name, p_data);
+            }
+
+            lock (object_metadata_lock)
+            {
+                try
+                {
+                    object_metadata.Add(type, data);
+                }
+                catch (ArgumentException)
+                {
+                    return;
+                }
+            }
+        }
+
+        private static void AddTypeProperties(Type type)
+        {
+            if (type_properties.ContainsKey(type))
+                return;
+
+            IList<PropertyMetadata> props = new List<PropertyMetadata>();
+
+            foreach (PropertyInfo p_info in type.GetProperties())
+            {
+                if (p_info.Name == "Item")
+                    continue;
+
+                PropertyMetadata p_data = new PropertyMetadata();
+                p_data.Info = p_info;
+                p_data.IsField = false;
+                props.Add(p_data);
+            }
+
+            foreach (FieldInfo f_info in type.GetFields())
+            {
+                PropertyMetadata p_data = new PropertyMetadata();
+                p_data.Info = f_info;
+                p_data.IsField = true;
+
+                props.Add(p_data);
+            }
+
+            lock (type_properties_lock)
+            {
+                try
+                {
+                    type_properties.Add(type, props);
+                }
+                catch (ArgumentException)
+                {
+                    return;
+                }
+            }
+        }
+
+        private static MethodInfo GetConvOp(Type t1, Type t2)
+        {
+            lock (conv_ops_lock)
+            {
+                if (!conv_ops.ContainsKey(t1))
+                    conv_ops.Add(t1, new Dictionary<Type, MethodInfo>());
+            }
+
+            if (conv_ops[t1].ContainsKey(t2))
+                return conv_ops[t1][t2];
+
+            MethodInfo op = t1.GetMethod(
+                "op_Implicit", new Type[] { t2 });
+
+            lock (conv_ops_lock)
+            {
+                try
+                {
+                    conv_ops[t1].Add(t2, op);
+                }
+                catch (ArgumentException)
+                {
+                    return conv_ops[t1][t2];
+                }
+            }
+
+            return op;
+        }
+
+        private static object ReadValue(Type inst_type, JsonReader reader)
+        {
+            reader.Read();
+
+            if (reader.Token == JsonToken.ArrayEnd)
+                return null;
+
+            Type underlying_type = Nullable.GetUnderlyingType(inst_type);
+            Type value_type = underlying_type ?? inst_type;
+
+            if (reader.Token == JsonToken.Null)
+            {
+#if NETSTANDARD1_5
+                if (inst_type.IsClass() || underlying_type != null) {
+                    return null;
+                }
+#else
+                if (inst_type.IsClass || underlying_type != null)
+                {
+                    return null;
+                }
+#endif
+
+                throw new JsonException(string.Format(
+                            "Can't assign null to an instance of type {0}",
+                            inst_type));
+            }
+
+            if (reader.Token == JsonToken.Double ||
+                reader.Token == JsonToken.Int ||
+                reader.Token == JsonToken.Long ||
+                reader.Token == JsonToken.String ||
+                reader.Token == JsonToken.Boolean)
+            {
+
+                Type json_type = reader.Value.GetType();
+
+                if (value_type.IsAssignableFrom(json_type))
+                    return reader.Value;
+
+                // If there's a custom importer that fits, use it
+                if (custom_importers_table.ContainsKey(json_type) &&
+                    custom_importers_table[json_type].ContainsKey(
+                        value_type))
+                {
+
+                    ImporterFunc importer =
+                        custom_importers_table[json_type][value_type];
+
+                    return importer(reader.Value);
+                }
+
+                // Maybe there's a base importer that works
+                if (base_importers_table.ContainsKey(json_type) &&
+                    base_importers_table[json_type].ContainsKey(
+                        value_type))
+                {
+
+                    ImporterFunc importer =
+                        base_importers_table[json_type][value_type];
+
+                    return importer(reader.Value);
+                }
+
+                // Maybe it's an enum
+#if NETSTANDARD1_5
+                if (value_type.IsEnum())
+                    return Enum.ToObject (value_type, reader.Value);
+#else
+                if (value_type.IsEnum)
+                    return Enum.ToObject(value_type, reader.Value);
+#endif
+                // Try using an implicit conversion operator
+                MethodInfo conv_op = GetConvOp(value_type, json_type);
+
+                if (conv_op != null)
+                    return conv_op.Invoke(null,
+                                           new object[] { reader.Value });
+
+                // No luck
+                throw new JsonException(string.Format(
+                        "Can't assign value '{0}' (type {1}) to type {2}",
+                        reader.Value, json_type, inst_type));
+            }
+
+            object instance = null;
+
+            if (reader.Token == JsonToken.ArrayStart)
+            {
+
+                AddArrayMetadata(inst_type);
+                ArrayMetadata t_data = array_metadata[inst_type];
+
+                if (!t_data.IsArray && !t_data.IsList)
+                    throw new JsonException(string.Format(
+                            "Type {0} can't act as an array",
+                            inst_type));
+
+                IList list;
+                Type elem_type;
+
+                if (!t_data.IsArray)
+                {
+                    list = (IList)Activator.CreateInstance(inst_type);
+                    elem_type = t_data.ElementType;
+                }
+                else
+                {
+                    list = new ArrayList();
+                    elem_type = inst_type.GetElementType();
+                }
+
+                list.Clear();
+
+                while (true)
+                {
+                    object item = ReadValue(elem_type, reader);
+                    if (item == null && reader.Token == JsonToken.ArrayEnd)
+                        break;
+
+                    list.Add(item);
+                }
+
+                if (t_data.IsArray)
+                {
+                    int n = list.Count;
+                    instance = Array.CreateInstance(elem_type, n);
+
+                    for (int i = 0; i < n; i++)
+                        ((Array)instance).SetValue(list[i], i);
+                }
+                else
+                    instance = list;
+
+            }
+            else if (reader.Token == JsonToken.ObjectStart)
+            {
+                AddObjectMetadata(value_type);
+                ObjectMetadata t_data = object_metadata[value_type];
+
+                instance = Activator.CreateInstance(value_type);
+
+                while (true)
+                {
+                    reader.Read();
+
+                    if (reader.Token == JsonToken.ObjectEnd)
+                        break;
+
+                    string property = (string)reader.Value;
+
+                    if (t_data.Properties.ContainsKey(property))
+                    {
+                        PropertyMetadata prop_data =
+                            t_data.Properties[property];
+
+                        if (prop_data.IsField)
+                        {
+                            ((FieldInfo)prop_data.Info).SetValue(
+                                instance, ReadValue(prop_data.Type, reader));
+                        }
+                        else
+                        {
+                            PropertyInfo p_info =
+                                (PropertyInfo)prop_data.Info;
+
+                            if (p_info.CanWrite)
+                                p_info.SetValue(
+                                    instance,
+                                    ReadValue(prop_data.Type, reader),
+                                    null);
+                            else
+                                ReadValue(prop_data.Type, reader);
+                        }
+
+                    }
+                    else
+                    {
+                        if (!t_data.IsDictionary)
+                        {
+
+                            if (!reader.SkipNonMembers)
+                            {
+                                throw new JsonException(string.Format(
+                                        "The type {0} doesn't have the " +
+                                        "property '{1}'",
+                                        inst_type, property));
+                            }
+                            else
+                            {
+                                ReadSkip(reader);
+                                continue;
+                            }
+                        }
+
+                        ((IDictionary)instance).Add(
+                            property, ReadValue(
+                                t_data.ElementType, reader));
+                    }
+
+                }
+
+            }
+
+            return instance;
+        }
+
+        private static IJsonWrapper ReadValue(WrapperFactory factory,
+                                               JsonReader reader)
+        {
+            reader.Read();
+
+            if (reader.Token == JsonToken.ArrayEnd ||
+                reader.Token == JsonToken.Null)
+                return null;
+
+            IJsonWrapper instance = factory();
+
+            if (reader.Token == JsonToken.String)
+            {
+                instance.SetString((string)reader.Value);
+                return instance;
+            }
+
+            if (reader.Token == JsonToken.Double)
+            {
+                instance.SetDouble((double)reader.Value);
+                return instance;
+            }
+
+            if (reader.Token == JsonToken.Int)
+            {
+                instance.SetInt((int)reader.Value);
+                return instance;
+            }
+
+            if (reader.Token == JsonToken.Long)
+            {
+                instance.SetLong((long)reader.Value);
+                return instance;
+            }
+
+            if (reader.Token == JsonToken.Boolean)
+            {
+                instance.SetBoolean((bool)reader.Value);
+                return instance;
+            }
+
+            if (reader.Token == JsonToken.ArrayStart)
+            {
+                instance.SetJsonType(JsonType.Array);
+
+                while (true)
+                {
+                    IJsonWrapper item = ReadValue(factory, reader);
+                    if (item == null && reader.Token == JsonToken.ArrayEnd)
+                        break;
+
+                    instance.Add(item);
+                }
+            }
+            else if (reader.Token == JsonToken.ObjectStart)
+            {
+                instance.SetJsonType(JsonType.Object);
+
+                while (true)
+                {
+                    reader.Read();
+
+                    if (reader.Token == JsonToken.ObjectEnd)
+                        break;
+
+                    string property = (string)reader.Value;
+
+                    ((IDictionary)instance)[property] = ReadValue(
+                        factory, reader);
+                }
+
+            }
+
+            return instance;
+        }
+
+        private static void ReadSkip(JsonReader reader)
+        {
+            ToWrapper(
+                delegate { return new JsonMockWrapper(); }, reader);
+        }
+
+        private static void RegisterBaseExporters()
+        {
+            base_exporters_table[typeof(byte)] =
+                delegate (object obj, JsonWriter writer)
+                {
+                    writer.Write(Convert.ToInt32((byte)obj));
+                };
+
+            base_exporters_table[typeof(char)] =
+                delegate (object obj, JsonWriter writer)
+                {
+                    writer.Write(Convert.ToString((char)obj));
+                };
+
+            base_exporters_table[typeof(DateTime)] =
+                delegate (object obj, JsonWriter writer)
+                {
+                    writer.Write(Convert.ToString((DateTime)obj,
+                                                    datetime_format));
+                };
+
+            base_exporters_table[typeof(decimal)] =
+                delegate (object obj, JsonWriter writer)
+                {
+                    writer.Write((decimal)obj);
+                };
+
+            base_exporters_table[typeof(sbyte)] =
+                delegate (object obj, JsonWriter writer)
+                {
+                    writer.Write(Convert.ToInt32((sbyte)obj));
+                };
+
+            base_exporters_table[typeof(short)] =
+                delegate (object obj, JsonWriter writer)
+                {
+                    writer.Write(Convert.ToInt32((short)obj));
+                };
+
+            base_exporters_table[typeof(ushort)] =
+                delegate (object obj, JsonWriter writer)
+                {
+                    writer.Write(Convert.ToInt32((ushort)obj));
+                };
+
+            base_exporters_table[typeof(uint)] =
+                delegate (object obj, JsonWriter writer)
+                {
+                    writer.Write(Convert.ToUInt64((uint)obj));
+                };
+
+            base_exporters_table[typeof(ulong)] =
+                delegate (object obj, JsonWriter writer)
+                {
+                    writer.Write((ulong)obj);
+                };
+
+            base_exporters_table[typeof(DateTimeOffset)] =
+                delegate (object obj, JsonWriter writer)
+                {
+                    writer.Write(((DateTimeOffset)obj).ToString("yyyy-MM-ddTHH:mm:ss.fffffffzzz", datetime_format));
+                };
+        }
+
+        private static void RegisterBaseImporters()
+        {
+            ImporterFunc importer;
+
+            importer = delegate (object input)
+            {
+                return Convert.ToByte((int)input);
+            };
+            RegisterImporter(base_importers_table, typeof(int),
+                              typeof(byte), importer);
+
+            importer = delegate (object input)
+            {
+                return Convert.ToUInt64((int)input);
+            };
+            RegisterImporter(base_importers_table, typeof(int),
+                              typeof(ulong), importer);
+
+            importer = delegate (object input)
+            {
+                return Convert.ToInt64((int)input);
+            };
+            RegisterImporter(base_importers_table, typeof(int),
+                              typeof(long), importer);
+
+            importer = delegate (object input)
+            {
+                return Convert.ToSByte((int)input);
+            };
+            RegisterImporter(base_importers_table, typeof(int),
+                              typeof(sbyte), importer);
+
+            importer = delegate (object input)
+            {
+                return Convert.ToInt16((int)input);
+            };
+            RegisterImporter(base_importers_table, typeof(int),
+                              typeof(short), importer);
+
+            importer = delegate (object input)
+            {
+                return Convert.ToUInt16((int)input);
+            };
+            RegisterImporter(base_importers_table, typeof(int),
+                              typeof(ushort), importer);
+
+            importer = delegate (object input)
+            {
+                return Convert.ToUInt32((int)input);
+            };
+            RegisterImporter(base_importers_table, typeof(int),
+                              typeof(uint), importer);
+
+            importer = delegate (object input)
+            {
+                return Convert.ToSingle((int)input);
+            };
+            RegisterImporter(base_importers_table, typeof(int),
+                              typeof(float), importer);
+
+            importer = delegate (object input)
+            {
+                return Convert.ToDouble((int)input);
+            };
+            RegisterImporter(base_importers_table, typeof(int),
+                              typeof(double), importer);
+
+            importer = delegate (object input)
+            {
+                return Convert.ToDecimal((double)input);
+            };
+            RegisterImporter(base_importers_table, typeof(double),
+                              typeof(decimal), importer);
+
+            importer = delegate (object input)
+            {
+                return Convert.ToSingle((double)input);
+            };
+            RegisterImporter(base_importers_table, typeof(double),
+                typeof(float), importer);
+
+            importer = delegate (object input)
+            {
+                return Convert.ToUInt32((long)input);
+            };
+            RegisterImporter(base_importers_table, typeof(long),
+                              typeof(uint), importer);
+
+            importer = delegate (object input)
+            {
+                return Convert.ToChar((string)input);
+            };
+            RegisterImporter(base_importers_table, typeof(string),
+                              typeof(char), importer);
+
+            importer = delegate (object input)
+            {
+                return Convert.ToDateTime((string)input, datetime_format);
+            };
+            RegisterImporter(base_importers_table, typeof(string),
+                              typeof(DateTime), importer);
+
+            importer = delegate (object input)
+            {
+                return DateTimeOffset.Parse((string)input, datetime_format);
+            };
+            RegisterImporter(base_importers_table, typeof(string),
+                typeof(DateTimeOffset), importer);
+        }
+
+        private static void RegisterImporter(
+            IDictionary<Type, IDictionary<Type, ImporterFunc>> table,
+            Type json_type, Type value_type, ImporterFunc importer)
+        {
+            if (!table.ContainsKey(json_type))
+                table.Add(json_type, new Dictionary<Type, ImporterFunc>());
+
+            table[json_type][value_type] = importer;
+        }
+
+        private static void WriteValue(object obj, JsonWriter writer,
+                                        bool writer_is_private,
+                                        int depth)
+        {
+            if (depth > max_nesting_depth)
+                throw new JsonException(
+                    string.Format("Max allowed object depth reached while " +
+                                   "trying to export from type {0}",
+                                   obj.GetType()));
+
+            if (obj == null)
+            {
+                writer.Write(null);
+                return;
+            }
+
+            if (obj is IJsonWrapper)
+            {
+                if (writer_is_private)
+                    writer.TextWriter.Write(((IJsonWrapper)obj).ToJson());
+                else
+                    ((IJsonWrapper)obj).ToJson(writer);
+
+                return;
+            }
+
+            if (obj is string)
+            {
+                writer.Write((string)obj);
+                return;
+            }
+
+            if (obj is double)
+            {
+                writer.Write((double)obj);
+                return;
+            }
+
+            if (obj is float)
+            {
+                writer.Write((float)obj);
+                return;
+            }
+
+            if (obj is int)
+            {
+                writer.Write((int)obj);
+                return;
+            }
+
+            if (obj is bool)
+            {
+                writer.Write((bool)obj);
+                return;
+            }
+
+            if (obj is long)
+            {
+                writer.Write((long)obj);
+                return;
+            }
+
+            if (obj is Array)
+            {
+                writer.WriteArrayStart();
+
+                foreach (object elem in (Array)obj)
+                    WriteValue(elem, writer, writer_is_private, depth + 1);
+
+                writer.WriteArrayEnd();
+
+                return;
+            }
+
+            if (obj is IList)
+            {
+                writer.WriteArrayStart();
+                foreach (object elem in (IList)obj)
+                    WriteValue(elem, writer, writer_is_private, depth + 1);
+                writer.WriteArrayEnd();
+
+                return;
+            }
+
+            if (obj is IDictionary dictionary)
+            {
+                writer.WriteObjectStart();
+                foreach (DictionaryEntry entry in dictionary)
+                {
+                    var propertyName = entry.Key is string key ?
+                        key
+                        : Convert.ToString(entry.Key, CultureInfo.InvariantCulture);
+                    writer.WritePropertyName(propertyName);
+                    WriteValue(entry.Value, writer, writer_is_private,
+                                depth + 1);
+                }
+                writer.WriteObjectEnd();
+
+                return;
+            }
+
+            Type obj_type = obj.GetType();
+
+            // See if there's a custom exporter for the object
+            if (custom_exporters_table.ContainsKey(obj_type))
+            {
+                ExporterFunc exporter = custom_exporters_table[obj_type];
+                exporter(obj, writer);
+
+                return;
+            }
+
+            // If not, maybe there's a base exporter
+            if (base_exporters_table.ContainsKey(obj_type))
+            {
+                ExporterFunc exporter = base_exporters_table[obj_type];
+                exporter(obj, writer);
+
+                return;
+            }
+
+            // Last option, let's see if it's an enum
+            if (obj is Enum)
+            {
+                Type e_type = Enum.GetUnderlyingType(obj_type);
+
+                if (e_type == typeof(long))
+                    writer.Write((long)obj);
+                else if (e_type == typeof(uint))
+                    writer.Write((uint)obj);
+                else if (e_type == typeof(ulong))
+                    writer.Write((ulong)obj);
+                else if (e_type == typeof(ushort))
+                    writer.Write((ushort)obj);
+                else if (e_type == typeof(short))
+                    writer.Write((short)obj);
+                else if (e_type == typeof(byte))
+                    writer.Write((byte)obj);
+                else if (e_type == typeof(sbyte))
+                    writer.Write((sbyte)obj);
+                else
+                    writer.Write((int)obj);
+
+                return;
+            }
+
+            // Okay, so it looks like the input should be exported as an
+            // object
+            AddTypeProperties(obj_type);
+            IList<PropertyMetadata> props = type_properties[obj_type];
+
+            writer.WriteObjectStart();
+            foreach (PropertyMetadata p_data in props)
+            {
+                if (p_data.IsField)
+                {
+                    writer.WritePropertyName(p_data.Info.Name);
+                    WriteValue(((FieldInfo)p_data.Info).GetValue(obj),
+                                writer, writer_is_private, depth + 1);
+                }
+                else
+                {
+                    PropertyInfo p_info = (PropertyInfo)p_data.Info;
+
+                    if (p_info.CanRead)
+                    {
+                        writer.WritePropertyName(p_data.Info.Name);
+                        WriteValue(p_info.GetValue(obj, null),
+                                    writer, writer_is_private, depth + 1);
+                    }
+                }
+            }
+            writer.WriteObjectEnd();
+        }
+        #endregion
+
+
+        public static string ToJson(object obj)
+        {
+            lock (static_writer_lock)
+            {
+                static_writer.Reset();
+
+                WriteValue(obj, static_writer, true, 0);
+
+                return static_writer.ToString();
+            }
+        }
+
+        public static void ToJson(object obj, JsonWriter writer)
+        {
+            WriteValue(obj, writer, false, 0);
+        }
+
+        public static JsonData ToObject(JsonReader reader)
+        {
+            return (JsonData)ToWrapper(
+                delegate { return new JsonData(); }, reader);
+        }
+
+        public static JsonData ToObject(TextReader reader)
+        {
+            JsonReader json_reader = new JsonReader(reader);
+
+            return (JsonData)ToWrapper(
+                delegate { return new JsonData(); }, json_reader);
+        }
+
+        public static JsonData ToObject(string json)
+        {
+            return (JsonData)ToWrapper(
+                delegate { return new JsonData(); }, json);
+        }
+
+        public static T ToObject<T>(JsonReader reader)
+        {
+            return (T)ReadValue(typeof(T), reader);
+        }
+
+        public static T ToObject<T>(TextReader reader)
+        {
+            JsonReader json_reader = new JsonReader(reader);
+
+            return (T)ReadValue(typeof(T), json_reader);
+        }
+
+        public static T ToObject<T>(string json)
+        {
+            JsonReader reader = new JsonReader(json);
+
+            return (T)ReadValue(typeof(T), reader);
+        }
+
+        public static object ToObject(string json, Type ConvertType)
+        {
+            JsonReader reader = new JsonReader(json);
+
+            return ReadValue(ConvertType, reader);
+        }
+
+        public static IJsonWrapper ToWrapper(WrapperFactory factory,
+                                              JsonReader reader)
+        {
+            return ReadValue(factory, reader);
+        }
+
+        public static IJsonWrapper ToWrapper(WrapperFactory factory,
+                                              string json)
+        {
+            JsonReader reader = new JsonReader(json);
+
+            return ReadValue(factory, reader);
+        }
+
+        public static void RegisterExporter<T>(ExporterFunc<T> exporter)
+        {
+            ExporterFunc exporter_wrapper =
+                delegate (object obj, JsonWriter writer)
+                {
+                    exporter((T)obj, writer);
+                };
+
+            custom_exporters_table[typeof(T)] = exporter_wrapper;
+        }
+
+        public static void RegisterImporter<TJson, TValue>(
+            ImporterFunc<TJson, TValue> importer)
+        {
+            ImporterFunc importer_wrapper =
+                delegate (object input)
+                {
+                    return importer((TJson)input);
+                };
+
+            RegisterImporter(custom_importers_table, typeof(TJson),
+                              typeof(TValue), importer_wrapper);
+        }
+
+        public static void UnregisterExporters()
+        {
+            custom_exporters_table.Clear();
+        }
+
+        public static void UnregisterImporters()
+        {
+            custom_importers_table.Clear();
+        }
+    }
+}
diff --git a/O&Z_Obfuscator/LitJson/JsonMockWrapper.cs b/O&Z_Obfuscator/LitJson/JsonMockWrapper.cs
new file mode 100644
index 0000000..1be9fd6
--- /dev/null
+++ b/O&Z_Obfuscator/LitJson/JsonMockWrapper.cs
@@ -0,0 +1,109 @@
+#region Header
+/**
+ * JsonMockWrapper.cs
+ *   Mock object implementing IJsonWrapper, to facilitate actions like
+ *   skipping data more efficiently.
+ *
+ * The authors disclaim copyright to this source code. For more details, see
+ * the COPYING file included with this distribution.
+ **/
+#endregion
+
+
+using System;
+using System.Collections;
+using System.Collections.Specialized;
+
+
+namespace O_Z_IL2CPP_Security.LitJson
+{
+    public class JsonMockWrapper : IJsonWrapper
+    {
+        public bool IsArray { get { return false; } }
+        public bool IsBoolean { get { return false; } }
+        public bool IsDouble { get { return false; } }
+        public bool IsInt { get { return false; } }
+        public bool IsLong { get { return false; } }
+        public bool IsObject { get { return false; } }
+        public bool IsString { get { return false; } }
+
+        public bool GetBoolean() { return false; }
+        public double GetDouble() { return 0.0; }
+        public int GetInt() { return 0; }
+        public JsonType GetJsonType() { return JsonType.None; }
+        public long GetLong() { return 0L; }
+        public string GetString() { return ""; }
+
+        public void SetBoolean(bool val) { }
+        public void SetDouble(double val) { }
+        public void SetInt(int val) { }
+        public void SetJsonType(JsonType type) { }
+        public void SetLong(long val) { }
+        public void SetString(string val) { }
+
+        public string ToJson() { return ""; }
+        public void ToJson(JsonWriter writer) { }
+
+
+        bool IList.IsFixedSize { get { return true; } }
+        bool IList.IsReadOnly { get { return true; } }
+
+        object IList.this[int index]
+        {
+            get { return null; }
+            set { }
+        }
+
+        int IList.Add(object value) { return 0; }
+        void IList.Clear() { }
+        bool IList.Contains(object value) { return false; }
+        int IList.IndexOf(object value) { return -1; }
+        void IList.Insert(int i, object v) { }
+        void IList.Remove(object value) { }
+        void IList.RemoveAt(int index) { }
+
+
+        int ICollection.Count { get { return 0; } }
+        bool ICollection.IsSynchronized { get { return false; } }
+        object ICollection.SyncRoot { get { return null; } }
+
+        void ICollection.CopyTo(Array array, int index) { }
+
+
+        IEnumerator IEnumerable.GetEnumerator() { return null; }
+
+
+        bool IDictionary.IsFixedSize { get { return true; } }
+        bool IDictionary.IsReadOnly { get { return true; } }
+
+        ICollection IDictionary.Keys { get { return null; } }
+        ICollection IDictionary.Values { get { return null; } }
+
+        object IDictionary.this[object key]
+        {
+            get { return null; }
+            set { }
+        }
+
+        void IDictionary.Add(object k, object v) { }
+        void IDictionary.Clear() { }
+        bool IDictionary.Contains(object key) { return false; }
+        void IDictionary.Remove(object key) { }
+
+        IDictionaryEnumerator IDictionary.GetEnumerator() { return null; }
+
+
+        object IOrderedDictionary.this[int idx]
+        {
+            get { return null; }
+            set { }
+        }
+
+        IDictionaryEnumerator IOrderedDictionary.GetEnumerator()
+        {
+            return null;
+        }
+        void IOrderedDictionary.Insert(int i, object k, object v) { }
+        void IOrderedDictionary.RemoveAt(int i) { }
+    }
+}
diff --git a/O&Z_Obfuscator/LitJson/JsonReader.cs b/O&Z_Obfuscator/LitJson/JsonReader.cs
new file mode 100644
index 0000000..7f210bf
--- /dev/null
+++ b/O&Z_Obfuscator/LitJson/JsonReader.cs
@@ -0,0 +1,523 @@
+#region Header
+/**
+ * JsonReader.cs
+ *   Stream-like access to JSON text.
+ *
+ * The authors disclaim copyright to this source code. For more details, see
+ * the COPYING file included with this distribution.
+ **/
+#endregion
+
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text;
+
+
+namespace O_Z_IL2CPP_Security.LitJson
+{
+    public enum JsonToken
+    {
+        None,
+
+        ObjectStart,
+        PropertyName,
+        ObjectEnd,
+
+        ArrayStart,
+        ArrayEnd,
+
+        Int,
+        Long,
+        Double,
+
+        String,
+
+        Boolean,
+        Null
+    }
+
+
+    public class JsonReader
+    {
+        #region Fields
+        private static readonly IDictionary<int, IDictionary<int, int[]>> parse_table;
+
+        private Stack<int> automaton_stack;
+        private int current_input;
+        private int current_symbol;
+        private bool end_of_json;
+        private bool end_of_input;
+        private Lexer lexer;
+        private bool parser_in_string;
+        private bool parser_return;
+        private bool read_started;
+        private TextReader reader;
+        private bool reader_is_owned;
+        private bool skip_non_members;
+        private object token_value;
+        private JsonToken token;
+        #endregion
+
+
+        #region Public Properties
+        public bool AllowComments
+        {
+            get { return lexer.AllowComments; }
+            set { lexer.AllowComments = value; }
+        }
+
+        public bool AllowSingleQuotedStrings
+        {
+            get { return lexer.AllowSingleQuotedStrings; }
+            set { lexer.AllowSingleQuotedStrings = value; }
+        }
+
+        public bool SkipNonMembers
+        {
+            get { return skip_non_members; }
+            set { skip_non_members = value; }
+        }
+
+        public bool EndOfInput
+        {
+            get { return end_of_input; }
+        }
+
+        public bool EndOfJson
+        {
+            get { return end_of_json; }
+        }
+
+        public JsonToken Token
+        {
+            get { return token; }
+        }
+
+        public object Value
+        {
+            get { return token_value; }
+        }
+        #endregion
+
+
+        #region Constructors
+        static JsonReader()
+        {
+            parse_table = PopulateParseTable();
+        }
+
+        public JsonReader(string json_text) :
+            this(new StringReader(json_text), true)
+        {
+        }
+
+        public JsonReader(TextReader reader) :
+            this(reader, false)
+        {
+        }
+
+        private JsonReader(TextReader reader, bool owned)
+        {
+            if (reader == null)
+                throw new ArgumentNullException("reader");
+
+            parser_in_string = false;
+            parser_return = false;
+
+            read_started = false;
+            automaton_stack = new Stack<int>();
+            automaton_stack.Push((int)ParserToken.End);
+            automaton_stack.Push((int)ParserToken.Text);
+
+            lexer = new Lexer(reader);
+
+            end_of_input = false;
+            end_of_json = false;
+
+            skip_non_members = true;
+
+            this.reader = reader;
+            reader_is_owned = owned;
+        }
+        #endregion
+
+
+        #region Static Methods
+        private static IDictionary<int, IDictionary<int, int[]>> PopulateParseTable()
+        {
+            // See section A.2. of the manual for details
+            IDictionary<int, IDictionary<int, int[]>> parse_table = new Dictionary<int, IDictionary<int, int[]>>();
+
+            TableAddRow(parse_table, ParserToken.Array);
+            TableAddCol(parse_table, ParserToken.Array, '[',
+                            '[',
+                            (int)ParserToken.ArrayPrime);
+
+            TableAddRow(parse_table, ParserToken.ArrayPrime);
+            TableAddCol(parse_table, ParserToken.ArrayPrime, '"',
+                            (int)ParserToken.Value,
+
+                            (int)ParserToken.ValueRest,
+                            ']');
+            TableAddCol(parse_table, ParserToken.ArrayPrime, '[',
+                            (int)ParserToken.Value,
+                            (int)ParserToken.ValueRest,
+                            ']');
+            TableAddCol(parse_table, ParserToken.ArrayPrime, ']',
+                            ']');
+            TableAddCol(parse_table, ParserToken.ArrayPrime, '{',
+                            (int)ParserToken.Value,
+                            (int)ParserToken.ValueRest,
+                            ']');
+            TableAddCol(parse_table, ParserToken.ArrayPrime, (int)ParserToken.Number,
+                            (int)ParserToken.Value,
+                            (int)ParserToken.ValueRest,
+                            ']');
+            TableAddCol(parse_table, ParserToken.ArrayPrime, (int)ParserToken.True,
+                            (int)ParserToken.Value,
+                            (int)ParserToken.ValueRest,
+                            ']');
+            TableAddCol(parse_table, ParserToken.ArrayPrime, (int)ParserToken.False,
+                            (int)ParserToken.Value,
+                            (int)ParserToken.ValueRest,
+                            ']');
+            TableAddCol(parse_table, ParserToken.ArrayPrime, (int)ParserToken.Null,
+                            (int)ParserToken.Value,
+                            (int)ParserToken.ValueRest,
+                            ']');
+
+            TableAddRow(parse_table, ParserToken.Object);
+            TableAddCol(parse_table, ParserToken.Object, '{',
+                            '{',
+                            (int)ParserToken.ObjectPrime);
+
+            TableAddRow(parse_table, ParserToken.ObjectPrime);
+            TableAddCol(parse_table, ParserToken.ObjectPrime, '"',
+                            (int)ParserToken.Pair,
+                            (int)ParserToken.PairRest,
+                            '}');
+            TableAddCol(parse_table, ParserToken.ObjectPrime, '}',
+                            '}');
+
+            TableAddRow(parse_table, ParserToken.Pair);
+            TableAddCol(parse_table, ParserToken.Pair, '"',
+                            (int)ParserToken.String,
+                            ':',
+                            (int)ParserToken.Value);
+
+            TableAddRow(parse_table, ParserToken.PairRest);
+            TableAddCol(parse_table, ParserToken.PairRest, ',',
+                            ',',
+                            (int)ParserToken.Pair,
+                            (int)ParserToken.PairRest);
+            TableAddCol(parse_table, ParserToken.PairRest, '}',
+                            (int)ParserToken.Epsilon);
+
+            TableAddRow(parse_table, ParserToken.String);
+            TableAddCol(parse_table, ParserToken.String, '"',
+                            '"',
+                            (int)ParserToken.CharSeq,
+                            '"');
+
+            TableAddRow(parse_table, ParserToken.Text);
+            TableAddCol(parse_table, ParserToken.Text, '[',
+                            (int)ParserToken.Array);
+            TableAddCol(parse_table, ParserToken.Text, '{',
+                            (int)ParserToken.Object);
+
+            TableAddRow(parse_table, ParserToken.Value);
+            TableAddCol(parse_table, ParserToken.Value, '"',
+                            (int)ParserToken.String);
+            TableAddCol(parse_table, ParserToken.Value, '[',
+                            (int)ParserToken.Array);
+            TableAddCol(parse_table, ParserToken.Value, '{',
+                            (int)ParserToken.Object);
+            TableAddCol(parse_table, ParserToken.Value, (int)ParserToken.Number,
+                            (int)ParserToken.Number);
+            TableAddCol(parse_table, ParserToken.Value, (int)ParserToken.True,
+                            (int)ParserToken.True);
+            TableAddCol(parse_table, ParserToken.Value, (int)ParserToken.False,
+                            (int)ParserToken.False);
+            TableAddCol(parse_table, ParserToken.Value, (int)ParserToken.Null,
+                            (int)ParserToken.Null);
+
+            TableAddRow(parse_table, ParserToken.ValueRest);
+            TableAddCol(parse_table, ParserToken.ValueRest, ',',
+                            ',',
+                            (int)ParserToken.Value,
+                            (int)ParserToken.ValueRest);
+            TableAddCol(parse_table, ParserToken.ValueRest, ']',
+                            (int)ParserToken.Epsilon);
+
+            return parse_table;
+        }
+
+        private static void TableAddCol(IDictionary<int, IDictionary<int, int[]>> parse_table, ParserToken row, int col,
+                                         params int[] symbols)
+        {
+            parse_table[(int)row].Add(col, symbols);
+        }
+
+        private static void TableAddRow(IDictionary<int, IDictionary<int, int[]>> parse_table, ParserToken rule)
+        {
+            parse_table.Add((int)rule, new Dictionary<int, int[]>());
+        }
+        #endregion
+
+
+        #region Private Methods
+        private void ProcessNumber(string number)
+        {
+            if (number.IndexOf('.') != -1 ||
+                number.IndexOf('e') != -1 ||
+                number.IndexOf('E') != -1)
+            {
+
+                double n_double;
+                if (double.TryParse(number, NumberStyles.Any, CultureInfo.InvariantCulture, out n_double))
+                {
+                    token = JsonToken.Double;
+                    token_value = n_double;
+
+                    return;
+                }
+            }
+
+            int n_int32;
+            if (int.TryParse(number, NumberStyles.Integer, CultureInfo.InvariantCulture, out n_int32))
+            {
+                token = JsonToken.Int;
+                token_value = n_int32;
+
+                return;
+            }
+
+            long n_int64;
+            if (long.TryParse(number, NumberStyles.Integer, CultureInfo.InvariantCulture, out n_int64))
+            {
+                token = JsonToken.Long;
+                token_value = n_int64;
+
+                return;
+            }
+
+            ulong n_uint64;
+            if (ulong.TryParse(number, NumberStyles.Integer, CultureInfo.InvariantCulture, out n_uint64))
+            {
+                token = JsonToken.Long;
+                token_value = n_uint64;
+
+                return;
+            }
+
+            // Shouldn't happen, but just in case, return something
+            token = JsonToken.Int;
+            token_value = 0;
+        }
+
+        private void ProcessSymbol()
+        {
+            if (current_symbol == '[')
+            {
+                token = JsonToken.ArrayStart;
+                parser_return = true;
+
+            }
+            else if (current_symbol == ']')
+            {
+                token = JsonToken.ArrayEnd;
+                parser_return = true;
+
+            }
+            else if (current_symbol == '{')
+            {
+                token = JsonToken.ObjectStart;
+                parser_return = true;
+
+            }
+            else if (current_symbol == '}')
+            {
+                token = JsonToken.ObjectEnd;
+                parser_return = true;
+
+            }
+            else if (current_symbol == '"')
+            {
+                if (parser_in_string)
+                {
+                    parser_in_string = false;
+
+                    parser_return = true;
+
+                }
+                else
+                {
+                    if (token == JsonToken.None)
+                        token = JsonToken.String;
+
+                    parser_in_string = true;
+                }
+
+            }
+            else if (current_symbol == (int)ParserToken.CharSeq)
+            {
+                token_value = lexer.StringValue;
+
+            }
+            else if (current_symbol == (int)ParserToken.False)
+            {
+                token = JsonToken.Boolean;
+                token_value = false;
+                parser_return = true;
+
+            }
+            else if (current_symbol == (int)ParserToken.Null)
+            {
+                token = JsonToken.Null;
+                parser_return = true;
+
+            }
+            else if (current_symbol == (int)ParserToken.Number)
+            {
+                ProcessNumber(lexer.StringValue);
+
+                parser_return = true;
+
+            }
+            else if (current_symbol == (int)ParserToken.Pair)
+            {
+                token = JsonToken.PropertyName;
+
+            }
+            else if (current_symbol == (int)ParserToken.True)
+            {
+                token = JsonToken.Boolean;
+                token_value = true;
+                parser_return = true;
+
+            }
+        }
+
+        private bool ReadToken()
+        {
+            if (end_of_input)
+                return false;
+
+            lexer.NextToken();
+
+            if (lexer.EndOfInput)
+            {
+                Close();
+
+                return false;
+            }
+
+            current_input = lexer.Token;
+
+            return true;
+        }
+        #endregion
+
+
+        public void Close()
+        {
+            if (end_of_input)
+                return;
+
+            end_of_input = true;
+            end_of_json = true;
+
+            if (reader_is_owned)
+            {
+                using (reader) { }
+            }
+
+            reader = null;
+        }
+
+        public bool Read()
+        {
+            if (end_of_input)
+                return false;
+
+            if (end_of_json)
+            {
+                end_of_json = false;
+                automaton_stack.Clear();
+                automaton_stack.Push((int)ParserToken.End);
+                automaton_stack.Push((int)ParserToken.Text);
+            }
+
+            parser_in_string = false;
+            parser_return = false;
+
+            token = JsonToken.None;
+            token_value = null;
+
+            if (!read_started)
+            {
+                read_started = true;
+
+                if (!ReadToken())
+                    return false;
+            }
+
+
+            int[] entry_symbols;
+
+            while (true)
+            {
+                if (parser_return)
+                {
+                    if (automaton_stack.Peek() == (int)ParserToken.End)
+                        end_of_json = true;
+
+                    return true;
+                }
+
+                current_symbol = automaton_stack.Pop();
+
+                ProcessSymbol();
+
+                if (current_symbol == current_input)
+                {
+                    if (!ReadToken())
+                    {
+                        if (automaton_stack.Peek() != (int)ParserToken.End)
+                            throw new JsonException(
+                                "Input doesn't evaluate to proper JSON text");
+
+                        if (parser_return)
+                            return true;
+
+                        return false;
+                    }
+
+                    continue;
+                }
+
+                try
+                {
+
+                    entry_symbols =
+                        parse_table[current_symbol][current_input];
+
+                }
+                catch (KeyNotFoundException e)
+                {
+                    throw new JsonException((ParserToken)current_input, e);
+                }
+
+                if (entry_symbols[0] == (int)ParserToken.Epsilon)
+                    continue;
+
+                for (int i = entry_symbols.Length - 1; i >= 0; i--)
+                    automaton_stack.Push(entry_symbols[i]);
+            }
+        }
+
+    }
+}
diff --git a/O&Z_Obfuscator/LitJson/JsonWriter.cs b/O&Z_Obfuscator/LitJson/JsonWriter.cs
new file mode 100644
index 0000000..8e27db0
--- /dev/null
+++ b/O&Z_Obfuscator/LitJson/JsonWriter.cs
@@ -0,0 +1,499 @@
+#region Header
+/**
+ * JsonWriter.cs
+ *   Stream-like facility to output JSON text.
+ *
+ * The authors disclaim copyright to this source code. For more details, see
+ * the COPYING file included with this distribution.
+ **/
+#endregion
+
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text;
+
+
+namespace O_Z_IL2CPP_Security.LitJson
+{
+    internal enum Condition
+    {
+        InArray,
+        InObject,
+        NotAProperty,
+        Property,
+        Value
+    }
+
+    internal class WriterContext
+    {
+        public int Count;
+        public bool InArray;
+        public bool InObject;
+        public bool ExpectingValue;
+        public int Padding;
+    }
+
+    public class JsonWriter
+    {
+        #region Fields
+        private static readonly NumberFormatInfo number_format;
+
+        private WriterContext context;
+        private Stack<WriterContext> ctx_stack;
+        private bool has_reached_end;
+        private char[] hex_seq;
+        private int indentation;
+        private int indent_value;
+        private StringBuilder inst_string_builder;
+        private bool pretty_print;
+        private bool validate;
+        private bool lower_case_properties;
+        private TextWriter writer;
+        #endregion
+
+
+        #region Properties
+        public int IndentValue
+        {
+            get { return indent_value; }
+            set
+            {
+                indentation = indentation / indent_value * value;
+                indent_value = value;
+            }
+        }
+
+        public bool PrettyPrint
+        {
+            get { return pretty_print; }
+            set { pretty_print = value; }
+        }
+
+        public TextWriter TextWriter
+        {
+            get { return writer; }
+        }
+
+        public bool Validate
+        {
+            get { return validate; }
+            set { validate = value; }
+        }
+
+        public bool LowerCaseProperties
+        {
+            get { return lower_case_properties; }
+            set { lower_case_properties = value; }
+        }
+        #endregion
+
+
+        #region Constructors
+        static JsonWriter()
+        {
+            number_format = NumberFormatInfo.InvariantInfo;
+        }
+
+        public JsonWriter()
+        {
+            inst_string_builder = new StringBuilder();
+            writer = new StringWriter(inst_string_builder);
+
+            Init();
+        }
+
+        public JsonWriter(StringBuilder sb) :
+            this(new StringWriter(sb))
+        {
+        }
+
+        public JsonWriter(TextWriter writer)
+        {
+            if (writer == null)
+                throw new ArgumentNullException("writer");
+
+            this.writer = writer;
+
+            Init();
+        }
+        #endregion
+
+
+        #region Private Methods
+        private void DoValidation(Condition cond)
+        {
+            if (!context.ExpectingValue)
+                context.Count++;
+
+            if (!validate)
+                return;
+
+            if (has_reached_end)
+                throw new JsonException(
+                    "A complete JSON symbol has already been written");
+
+            switch (cond)
+            {
+                case Condition.InArray:
+                    if (!context.InArray)
+                        throw new JsonException(
+                            "Can't close an array here");
+                    break;
+
+                case Condition.InObject:
+                    if (!context.InObject || context.ExpectingValue)
+                        throw new JsonException(
+                            "Can't close an object here");
+                    break;
+
+                case Condition.NotAProperty:
+                    if (context.InObject && !context.ExpectingValue)
+                        throw new JsonException(
+                            "Expected a property");
+                    break;
+
+                case Condition.Property:
+                    if (!context.InObject || context.ExpectingValue)
+                        throw new JsonException(
+                            "Can't add a property here");
+                    break;
+
+                case Condition.Value:
+                    if (!context.InArray &&
+                        (!context.InObject || !context.ExpectingValue))
+                        throw new JsonException(
+                            "Can't add a value here");
+
+                    break;
+            }
+        }
+
+        private void Init()
+        {
+            has_reached_end = false;
+            hex_seq = new char[4];
+            indentation = 0;
+            indent_value = 4;
+            pretty_print = false;
+            validate = true;
+            lower_case_properties = false;
+
+            ctx_stack = new Stack<WriterContext>();
+            context = new WriterContext();
+            ctx_stack.Push(context);
+        }
+
+        private static void IntToHex(int n, char[] hex)
+        {
+            int num;
+
+            for (int i = 0; i < 4; i++)
+            {
+                num = n % 16;
+
+                if (num < 10)
+                    hex[3 - i] = (char)('0' + num);
+                else
+                    hex[3 - i] = (char)('A' + (num - 10));
+
+                n >>= 4;
+            }
+        }
+
+        private void Indent()
+        {
+            if (pretty_print)
+                indentation += indent_value;
+        }
+
+
+        private void Put(string str)
+        {
+            if (pretty_print && !context.ExpectingValue)
+                for (int i = 0; i < indentation; i++)
+                    writer.Write(' ');
+
+            writer.Write(str);
+        }
+
+        private void PutNewline()
+        {
+            PutNewline(true);
+        }
+
+        private void PutNewline(bool add_comma)
+        {
+            if (add_comma && !context.ExpectingValue &&
+                context.Count > 1)
+                writer.Write(',');
+
+            if (pretty_print && !context.ExpectingValue)
+                writer.Write(Environment.NewLine);
+        }
+
+        private void PutString(string str)
+        {
+            Put(string.Empty);
+
+            writer.Write('"');
+
+            int n = str.Length;
+            for (int i = 0; i < n; i++)
+            {
+                switch (str[i])
+                {
+                    case '\n':
+                        writer.Write("\\n");
+                        continue;
+
+                    case '\r':
+                        writer.Write("\\r");
+                        continue;
+
+                    case '\t':
+                        writer.Write("\\t");
+                        continue;
+
+                    case '"':
+                    case '\\':
+                        writer.Write('\\');
+                        writer.Write(str[i]);
+                        continue;
+
+                    case '\f':
+                        writer.Write("\\f");
+                        continue;
+
+                    case '\b':
+                        writer.Write("\\b");
+                        continue;
+                }
+
+                if (str[i] >= 32 && str[i] <= 126)
+                {
+                    writer.Write(str[i]);
+                    continue;
+                }
+
+                // Default, turn into a \uXXXX sequence
+                IntToHex(str[i], hex_seq);
+                writer.Write("\\u");
+                writer.Write(hex_seq);
+            }
+
+            writer.Write('"');
+        }
+
+        private void Unindent()
+        {
+            if (pretty_print)
+                indentation -= indent_value;
+        }
+        #endregion
+
+
+        public override string ToString()
+        {
+            if (inst_string_builder == null)
+                return string.Empty;
+
+            return inst_string_builder.ToString();
+        }
+
+        public void Reset()
+        {
+            has_reached_end = false;
+
+            ctx_stack.Clear();
+            context = new WriterContext();
+            ctx_stack.Push(context);
+
+            if (inst_string_builder != null)
+                inst_string_builder.Remove(0, inst_string_builder.Length);
+        }
+
+        public void Write(bool boolean)
+        {
+            DoValidation(Condition.Value);
+            PutNewline();
+
+            Put(boolean ? "true" : "false");
+
+            context.ExpectingValue = false;
+        }
+
+        public void Write(decimal number)
+        {
+            DoValidation(Condition.Value);
+            PutNewline();
+
+            Put(Convert.ToString(number, number_format));
+
+            context.ExpectingValue = false;
+        }
+
+        public void Write(double number)
+        {
+            DoValidation(Condition.Value);
+            PutNewline();
+
+            string str = Convert.ToString(number, number_format);
+            Put(str);
+
+            if (str.IndexOf('.') == -1 &&
+                str.IndexOf('E') == -1)
+                writer.Write(".0");
+
+            context.ExpectingValue = false;
+        }
+
+        public void Write(float number)
+        {
+            DoValidation(Condition.Value);
+            PutNewline();
+
+            string str = Convert.ToString(number, number_format);
+            Put(str);
+
+            context.ExpectingValue = false;
+        }
+
+        public void Write(int number)
+        {
+            DoValidation(Condition.Value);
+            PutNewline();
+
+            Put(Convert.ToString(number, number_format));
+
+            context.ExpectingValue = false;
+        }
+
+        public void Write(long number)
+        {
+            DoValidation(Condition.Value);
+            PutNewline();
+
+            Put(Convert.ToString(number, number_format));
+
+            context.ExpectingValue = false;
+        }
+
+        public void Write(string str)
+        {
+            DoValidation(Condition.Value);
+            PutNewline();
+
+            if (str == null)
+                Put("null");
+            else
+                PutString(str);
+
+            context.ExpectingValue = false;
+        }
+
+        [CLSCompliant(false)]
+        public void Write(ulong number)
+        {
+            DoValidation(Condition.Value);
+            PutNewline();
+
+            Put(Convert.ToString(number, number_format));
+
+            context.ExpectingValue = false;
+        }
+
+        public void WriteArrayEnd()
+        {
+            DoValidation(Condition.InArray);
+            PutNewline(false);
+
+            ctx_stack.Pop();
+            if (ctx_stack.Count == 1)
+                has_reached_end = true;
+            else
+            {
+                context = ctx_stack.Peek();
+                context.ExpectingValue = false;
+            }
+
+            Unindent();
+            Put("]");
+        }
+
+        public void WriteArrayStart()
+        {
+            DoValidation(Condition.NotAProperty);
+            PutNewline();
+
+            Put("[");
+
+            context = new WriterContext();
+            context.InArray = true;
+            ctx_stack.Push(context);
+
+            Indent();
+        }
+
+        public void WriteObjectEnd()
+        {
+            DoValidation(Condition.InObject);
+            PutNewline(false);
+
+            ctx_stack.Pop();
+            if (ctx_stack.Count == 1)
+                has_reached_end = true;
+            else
+            {
+                context = ctx_stack.Peek();
+                context.ExpectingValue = false;
+            }
+
+            Unindent();
+            Put("}");
+        }
+
+        public void WriteObjectStart()
+        {
+            DoValidation(Condition.NotAProperty);
+            PutNewline();
+
+            Put("{");
+
+            context = new WriterContext();
+            context.InObject = true;
+            ctx_stack.Push(context);
+
+            Indent();
+        }
+
+        public void WritePropertyName(string property_name)
+        {
+            DoValidation(Condition.Property);
+            PutNewline();
+            string propertyName = property_name == null || !lower_case_properties
+                ? property_name
+                : property_name.ToLowerInvariant();
+
+            PutString(propertyName);
+
+            if (pretty_print)
+            {
+                if (propertyName.Length > context.Padding)
+                    context.Padding = propertyName.Length;
+
+                for (int i = context.Padding - propertyName.Length;
+                     i >= 0; i--)
+                    writer.Write(' ');
+
+                writer.Write(": ");
+            }
+            else
+                writer.Write(':');
+
+            context.ExpectingValue = true;
+        }
+    }
+}
diff --git a/O&Z_Obfuscator/LitJson/Lexer.cs b/O&Z_Obfuscator/LitJson/Lexer.cs
new file mode 100644
index 0000000..f476ede
--- /dev/null
+++ b/O&Z_Obfuscator/LitJson/Lexer.cs
@@ -0,0 +1,971 @@
+#region Header
+/**
+ * Lexer.cs
+ *   JSON lexer implementation based on a finite state machine.
+ *
+ * The authors disclaim copyright to this source code. For more details, see
+ * the COPYING file included with this distribution.
+ **/
+#endregion
+
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+
+namespace O_Z_IL2CPP_Security.LitJson
+{
+    internal class FsmContext
+    {
+        public bool Return;
+        public int NextState;
+        public Lexer L;
+        public int StateStack;
+    }
+
+
+    internal class Lexer
+    {
+        #region Fields
+        private delegate bool StateHandler(FsmContext ctx);
+
+        private static readonly int[] fsm_return_table;
+        private static readonly StateHandler[] fsm_handler_table;
+
+        private bool allow_comments;
+        private bool allow_single_quoted_strings;
+        private bool end_of_input;
+        private FsmContext fsm_context;
+        private int input_buffer;
+        private int input_char;
+        private TextReader reader;
+        private int state;
+        private StringBuilder string_buffer;
+        private string string_value;
+        private int token;
+        private int unichar;
+        #endregion
+
+
+        #region Properties
+        public bool AllowComments
+        {
+            get { return allow_comments; }
+            set { allow_comments = value; }
+        }
+
+        public bool AllowSingleQuotedStrings
+        {
+            get { return allow_single_quoted_strings; }
+            set { allow_single_quoted_strings = value; }
+        }
+
+        public bool EndOfInput
+        {
+            get { return end_of_input; }
+        }
+
+        public int Token
+        {
+            get { return token; }
+        }
+
+        public string StringValue
+        {
+            get { return string_value; }
+        }
+        #endregion
+
+
+        #region Constructors
+        static Lexer()
+        {
+            PopulateFsmTables(out fsm_handler_table, out fsm_return_table);
+        }
+
+        public Lexer(TextReader reader)
+        {
+            allow_comments = true;
+            allow_single_quoted_strings = true;
+
+            input_buffer = 0;
+            string_buffer = new StringBuilder(128);
+            state = 1;
+            end_of_input = false;
+            this.reader = reader;
+
+            fsm_context = new FsmContext();
+            fsm_context.L = this;
+        }
+        #endregion
+
+
+        #region Static Methods
+        private static int HexValue(int digit)
+        {
+            switch (digit)
+            {
+                case 'a':
+                case 'A':
+                    return 10;
+
+                case 'b':
+                case 'B':
+                    return 11;
+
+                case 'c':
+                case 'C':
+                    return 12;
+
+                case 'd':
+                case 'D':
+                    return 13;
+
+                case 'e':
+                case 'E':
+                    return 14;
+
+                case 'f':
+                case 'F':
+                    return 15;
+
+                default:
+                    return digit - '0';
+            }
+        }
+
+        private static void PopulateFsmTables(out StateHandler[] fsm_handler_table, out int[] fsm_return_table)
+        {
+            // See section A.1. of the manual for details of the finite
+            // state machine.
+            fsm_handler_table = new StateHandler[28] {
+                State1,
+                State2,
+                State3,
+                State4,
+                State5,
+                State6,
+                State7,
+                State8,
+                State9,
+                State10,
+                State11,
+                State12,
+                State13,
+                State14,
+                State15,
+                State16,
+                State17,
+                State18,
+                State19,
+                State20,
+                State21,
+                State22,
+                State23,
+                State24,
+                State25,
+                State26,
+                State27,
+                State28
+            };
+
+            fsm_return_table = new int[28] {
+                (int) ParserToken.Char,
+                0,
+                (int) ParserToken.Number,
+                (int) ParserToken.Number,
+                0,
+                (int) ParserToken.Number,
+                0,
+                (int) ParserToken.Number,
+                0,
+                0,
+                (int) ParserToken.True,
+                0,
+                0,
+                0,
+                (int) ParserToken.False,
+                0,
+                0,
+                (int) ParserToken.Null,
+                (int) ParserToken.CharSeq,
+                (int) ParserToken.Char,
+                0,
+                0,
+                (int) ParserToken.CharSeq,
+                (int) ParserToken.Char,
+                0,
+                0,
+                0,
+                0
+            };
+        }
+
+        private static char ProcessEscChar(int esc_char)
+        {
+            switch (esc_char)
+            {
+                case '"':
+                case '\'':
+                case '\\':
+                case '/':
+                    return Convert.ToChar(esc_char);
+
+                case 'n':
+                    return '\n';
+
+                case 't':
+                    return '\t';
+
+                case 'r':
+                    return '\r';
+
+                case 'b':
+                    return '\b';
+
+                case 'f':
+                    return '\f';
+
+                default:
+                    // Unreachable
+                    return '?';
+            }
+        }
+
+        private static bool State1(FsmContext ctx)
+        {
+            while (ctx.L.GetChar())
+            {
+                if (ctx.L.input_char == ' ' ||
+                    ctx.L.input_char >= '\t' && ctx.L.input_char <= '\r')
+                    continue;
+
+                if (ctx.L.input_char >= '1' && ctx.L.input_char <= '9')
+                {
+                    ctx.L.string_buffer.Append((char)ctx.L.input_char);
+                    ctx.NextState = 3;
+                    return true;
+                }
+
+                switch (ctx.L.input_char)
+                {
+                    case '"':
+                        ctx.NextState = 19;
+                        ctx.Return = true;
+                        return true;
+
+                    case ',':
+                    case ':':
+                    case '[':
+                    case ']':
+                    case '{':
+                    case '}':
+                        ctx.NextState = 1;
+                        ctx.Return = true;
+                        return true;
+
+                    case '-':
+                        ctx.L.string_buffer.Append((char)ctx.L.input_char);
+                        ctx.NextState = 2;
+                        return true;
+
+                    case '0':
+                        ctx.L.string_buffer.Append((char)ctx.L.input_char);
+                        ctx.NextState = 4;
+                        return true;
+
+                    case 'f':
+                        ctx.NextState = 12;
+                        return true;
+
+                    case 'n':
+                        ctx.NextState = 16;
+                        return true;
+
+                    case 't':
+                        ctx.NextState = 9;
+                        return true;
+
+                    case '\'':
+                        if (!ctx.L.allow_single_quoted_strings)
+                            return false;
+
+                        ctx.L.input_char = '"';
+                        ctx.NextState = 23;
+                        ctx.Return = true;
+                        return true;
+
+                    case '/':
+                        if (!ctx.L.allow_comments)
+                            return false;
+
+                        ctx.NextState = 25;
+                        return true;
+
+                    default:
+                        return false;
+                }
+            }
+
+            return true;
+        }
+
+        private static bool State2(FsmContext ctx)
+        {
+            ctx.L.GetChar();
+
+            if (ctx.L.input_char >= '1' && ctx.L.input_char <= '9')
+            {
+                ctx.L.string_buffer.Append((char)ctx.L.input_char);
+                ctx.NextState = 3;
+                return true;
+            }
+
+            switch (ctx.L.input_char)
+            {
+                case '0':
+                    ctx.L.string_buffer.Append((char)ctx.L.input_char);
+                    ctx.NextState = 4;
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+
+        private static bool State3(FsmContext ctx)
+        {
+            while (ctx.L.GetChar())
+            {
+                if (ctx.L.input_char >= '0' && ctx.L.input_char <= '9')
+                {
+                    ctx.L.string_buffer.Append((char)ctx.L.input_char);
+                    continue;
+                }
+
+                if (ctx.L.input_char == ' ' ||
+                    ctx.L.input_char >= '\t' && ctx.L.input_char <= '\r')
+                {
+                    ctx.Return = true;
+                    ctx.NextState = 1;
+                    return true;
+                }
+
+                switch (ctx.L.input_char)
+                {
+                    case ',':
+                    case ']':
+                    case '}':
+                        ctx.L.UngetChar();
+                        ctx.Return = true;
+                        ctx.NextState = 1;
+                        return true;
+
+                    case '.':
+                        ctx.L.string_buffer.Append((char)ctx.L.input_char);
+                        ctx.NextState = 5;
+                        return true;
+
+                    case 'e':
+                    case 'E':
+                        ctx.L.string_buffer.Append((char)ctx.L.input_char);
+                        ctx.NextState = 7;
+                        return true;
+
+                    default:
+                        return false;
+                }
+            }
+            return true;
+        }
+
+        private static bool State4(FsmContext ctx)
+        {
+            ctx.L.GetChar();
+
+            if (ctx.L.input_char == ' ' ||
+                ctx.L.input_char >= '\t' && ctx.L.input_char <= '\r')
+            {
+                ctx.Return = true;
+                ctx.NextState = 1;
+                return true;
+            }
+
+            switch (ctx.L.input_char)
+            {
+                case ',':
+                case ']':
+                case '}':
+                    ctx.L.UngetChar();
+                    ctx.Return = true;
+                    ctx.NextState = 1;
+                    return true;
+
+                case '.':
+                    ctx.L.string_buffer.Append((char)ctx.L.input_char);
+                    ctx.NextState = 5;
+                    return true;
+
+                case 'e':
+                case 'E':
+                    ctx.L.string_buffer.Append((char)ctx.L.input_char);
+                    ctx.NextState = 7;
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+
+        private static bool State5(FsmContext ctx)
+        {
+            ctx.L.GetChar();
+
+            if (ctx.L.input_char >= '0' && ctx.L.input_char <= '9')
+            {
+                ctx.L.string_buffer.Append((char)ctx.L.input_char);
+                ctx.NextState = 6;
+                return true;
+            }
+
+            return false;
+        }
+
+        private static bool State6(FsmContext ctx)
+        {
+            while (ctx.L.GetChar())
+            {
+                if (ctx.L.input_char >= '0' && ctx.L.input_char <= '9')
+                {
+                    ctx.L.string_buffer.Append((char)ctx.L.input_char);
+                    continue;
+                }
+
+                if (ctx.L.input_char == ' ' ||
+                    ctx.L.input_char >= '\t' && ctx.L.input_char <= '\r')
+                {
+                    ctx.Return = true;
+                    ctx.NextState = 1;
+                    return true;
+                }
+
+                switch (ctx.L.input_char)
+                {
+                    case ',':
+                    case ']':
+                    case '}':
+                        ctx.L.UngetChar();
+                        ctx.Return = true;
+                        ctx.NextState = 1;
+                        return true;
+
+                    case 'e':
+                    case 'E':
+                        ctx.L.string_buffer.Append((char)ctx.L.input_char);
+                        ctx.NextState = 7;
+                        return true;
+
+                    default:
+                        return false;
+                }
+            }
+
+            return true;
+        }
+
+        private static bool State7(FsmContext ctx)
+        {
+            ctx.L.GetChar();
+
+            if (ctx.L.input_char >= '0' && ctx.L.input_char <= '9')
+            {
+                ctx.L.string_buffer.Append((char)ctx.L.input_char);
+                ctx.NextState = 8;
+                return true;
+            }
+
+            switch (ctx.L.input_char)
+            {
+                case '+':
+                case '-':
+                    ctx.L.string_buffer.Append((char)ctx.L.input_char);
+                    ctx.NextState = 8;
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+
+        private static bool State8(FsmContext ctx)
+        {
+            while (ctx.L.GetChar())
+            {
+                if (ctx.L.input_char >= '0' && ctx.L.input_char <= '9')
+                {
+                    ctx.L.string_buffer.Append((char)ctx.L.input_char);
+                    continue;
+                }
+
+                if (ctx.L.input_char == ' ' ||
+                    ctx.L.input_char >= '\t' && ctx.L.input_char <= '\r')
+                {
+                    ctx.Return = true;
+                    ctx.NextState = 1;
+                    return true;
+                }
+
+                switch (ctx.L.input_char)
+                {
+                    case ',':
+                    case ']':
+                    case '}':
+                        ctx.L.UngetChar();
+                        ctx.Return = true;
+                        ctx.NextState = 1;
+                        return true;
+
+                    default:
+                        return false;
+                }
+            }
+
+            return true;
+        }
+
+        private static bool State9(FsmContext ctx)
+        {
+            ctx.L.GetChar();
+
+            switch (ctx.L.input_char)
+            {
+                case 'r':
+                    ctx.NextState = 10;
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+
+        private static bool State10(FsmContext ctx)
+        {
+            ctx.L.GetChar();
+
+            switch (ctx.L.input_char)
+            {
+                case 'u':
+                    ctx.NextState = 11;
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+
+        private static bool State11(FsmContext ctx)
+        {
+            ctx.L.GetChar();
+
+            switch (ctx.L.input_char)
+            {
+                case 'e':
+                    ctx.Return = true;
+                    ctx.NextState = 1;
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+
+        private static bool State12(FsmContext ctx)
+        {
+            ctx.L.GetChar();
+
+            switch (ctx.L.input_char)
+            {
+                case 'a':
+                    ctx.NextState = 13;
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+
+        private static bool State13(FsmContext ctx)
+        {
+            ctx.L.GetChar();
+
+            switch (ctx.L.input_char)
+            {
+                case 'l':
+                    ctx.NextState = 14;
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+
+        private static bool State14(FsmContext ctx)
+        {
+            ctx.L.GetChar();
+
+            switch (ctx.L.input_char)
+            {
+                case 's':
+                    ctx.NextState = 15;
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+
+        private static bool State15(FsmContext ctx)
+        {
+            ctx.L.GetChar();
+
+            switch (ctx.L.input_char)
+            {
+                case 'e':
+                    ctx.Return = true;
+                    ctx.NextState = 1;
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+
+        private static bool State16(FsmContext ctx)
+        {
+            ctx.L.GetChar();
+
+            switch (ctx.L.input_char)
+            {
+                case 'u':
+                    ctx.NextState = 17;
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+
+        private static bool State17(FsmContext ctx)
+        {
+            ctx.L.GetChar();
+
+            switch (ctx.L.input_char)
+            {
+                case 'l':
+                    ctx.NextState = 18;
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+
+        private static bool State18(FsmContext ctx)
+        {
+            ctx.L.GetChar();
+
+            switch (ctx.L.input_char)
+            {
+                case 'l':
+                    ctx.Return = true;
+                    ctx.NextState = 1;
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+
+        private static bool State19(FsmContext ctx)
+        {
+            while (ctx.L.GetChar())
+            {
+                switch (ctx.L.input_char)
+                {
+                    case '"':
+                        ctx.L.UngetChar();
+                        ctx.Return = true;
+                        ctx.NextState = 20;
+                        return true;
+
+                    case '\\':
+                        ctx.StateStack = 19;
+                        ctx.NextState = 21;
+                        return true;
+
+                    default:
+                        ctx.L.string_buffer.Append((char)ctx.L.input_char);
+                        continue;
+                }
+            }
+
+            return true;
+        }
+
+        private static bool State20(FsmContext ctx)
+        {
+            ctx.L.GetChar();
+
+            switch (ctx.L.input_char)
+            {
+                case '"':
+                    ctx.Return = true;
+                    ctx.NextState = 1;
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+
+        private static bool State21(FsmContext ctx)
+        {
+            ctx.L.GetChar();
+
+            switch (ctx.L.input_char)
+            {
+                case 'u':
+                    ctx.NextState = 22;
+                    return true;
+
+                case '"':
+                case '\'':
+                case '/':
+                case '\\':
+                case 'b':
+                case 'f':
+                case 'n':
+                case 'r':
+                case 't':
+                    ctx.L.string_buffer.Append(
+                        ProcessEscChar(ctx.L.input_char));
+                    ctx.NextState = ctx.StateStack;
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+
+        private static bool State22(FsmContext ctx)
+        {
+            int counter = 0;
+            int mult = 4096;
+
+            ctx.L.unichar = 0;
+
+            while (ctx.L.GetChar())
+            {
+
+                if (ctx.L.input_char >= '0' && ctx.L.input_char <= '9' ||
+                    ctx.L.input_char >= 'A' && ctx.L.input_char <= 'F' ||
+                    ctx.L.input_char >= 'a' && ctx.L.input_char <= 'f')
+                {
+
+                    ctx.L.unichar += HexValue(ctx.L.input_char) * mult;
+
+                    counter++;
+                    mult /= 16;
+
+                    if (counter == 4)
+                    {
+                        ctx.L.string_buffer.Append(
+                            Convert.ToChar(ctx.L.unichar));
+                        ctx.NextState = ctx.StateStack;
+                        return true;
+                    }
+
+                    continue;
+                }
+
+                return false;
+            }
+
+            return true;
+        }
+
+        private static bool State23(FsmContext ctx)
+        {
+            while (ctx.L.GetChar())
+            {
+                switch (ctx.L.input_char)
+                {
+                    case '\'':
+                        ctx.L.UngetChar();
+                        ctx.Return = true;
+                        ctx.NextState = 24;
+                        return true;
+
+                    case '\\':
+                        ctx.StateStack = 23;
+                        ctx.NextState = 21;
+                        return true;
+
+                    default:
+                        ctx.L.string_buffer.Append((char)ctx.L.input_char);
+                        continue;
+                }
+            }
+
+            return true;
+        }
+
+        private static bool State24(FsmContext ctx)
+        {
+            ctx.L.GetChar();
+
+            switch (ctx.L.input_char)
+            {
+                case '\'':
+                    ctx.L.input_char = '"';
+                    ctx.Return = true;
+                    ctx.NextState = 1;
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+
+        private static bool State25(FsmContext ctx)
+        {
+            ctx.L.GetChar();
+
+            switch (ctx.L.input_char)
+            {
+                case '*':
+                    ctx.NextState = 27;
+                    return true;
+
+                case '/':
+                    ctx.NextState = 26;
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+
+        private static bool State26(FsmContext ctx)
+        {
+            while (ctx.L.GetChar())
+            {
+                if (ctx.L.input_char == '\n')
+                {
+                    ctx.NextState = 1;
+                    return true;
+                }
+            }
+
+            return true;
+        }
+
+        private static bool State27(FsmContext ctx)
+        {
+            while (ctx.L.GetChar())
+            {
+                if (ctx.L.input_char == '*')
+                {
+                    ctx.NextState = 28;
+                    return true;
+                }
+            }
+
+            return true;
+        }
+
+        private static bool State28(FsmContext ctx)
+        {
+            while (ctx.L.GetChar())
+            {
+                if (ctx.L.input_char == '*')
+                    continue;
+
+                if (ctx.L.input_char == '/')
+                {
+                    ctx.NextState = 1;
+                    return true;
+                }
+
+                ctx.NextState = 27;
+                return true;
+            }
+
+            return true;
+        }
+        #endregion
+
+
+        private bool GetChar()
+        {
+            if ((input_char = NextChar()) != -1)
+                return true;
+
+            end_of_input = true;
+            return false;
+        }
+
+        private int NextChar()
+        {
+            if (input_buffer != 0)
+            {
+                int tmp = input_buffer;
+                input_buffer = 0;
+
+                return tmp;
+            }
+
+            return reader.Read();
+        }
+
+        public bool NextToken()
+        {
+            StateHandler handler;
+            fsm_context.Return = false;
+
+            while (true)
+            {
+                handler = fsm_handler_table[state - 1];
+
+                if (!handler(fsm_context))
+                    throw new JsonException(input_char);
+
+                if (end_of_input)
+                    return false;
+
+                if (fsm_context.Return)
+                {
+                    string_value = string_buffer.ToString();
+                    string_buffer.Remove(0, string_buffer.Length);
+                    token = fsm_return_table[state - 1];
+
+                    if (token == (int)ParserToken.Char)
+                        token = input_char;
+
+                    state = fsm_context.NextState;
+
+                    return true;
+                }
+
+                state = fsm_context.NextState;
+            }
+        }
+
+        private void UngetChar()
+        {
+            input_buffer = input_char;
+        }
+    }
+}
diff --git a/O&Z_Obfuscator/LitJson/LitJSON.csproj b/O&Z_Obfuscator/LitJson/LitJSON.csproj
new file mode 100644
index 0000000..73a77ff
--- /dev/null
+++ b/O&Z_Obfuscator/LitJson/LitJSON.csproj
@@ -0,0 +1,61 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>netstandard2.1;netstandard2.0;net45;netstandard1.5;net40;net35;net20;net6.0</TargetFrameworks>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <DebugType>embedded</DebugType>
+    <EmbedUntrackedSources>true</EmbedUntrackedSources>
+    <PublishRepositoryUrl>true</PublishRepositoryUrl>
+    <SourceLinkCreate Condition="'$(OS)' == 'Windows_NT'">true</SourceLinkCreate>
+  </PropertyGroup>
+
+  <ItemGroup Condition="'$(OS)' == 'Windows_NT'">
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="All" />
+    <DotNetCliToolReference Include="dotnet-sourcelink-git" Version="2.8.3" />
+    <DotNetCliToolReference Include="dotnet-sourcelink" Version="2.8.3" />
+  </ItemGroup>
+
+  <PropertyGroup>
+    <PackageId>LitJson</PackageId>
+    <Description>A .Net library to handle conversions from and to JSON (JavaScript Object Notation) strings. Written in C#, and it’s intended to be small, fast and easy to use.
+It's quick and lean, without external dependencies.</Description>
+    <Copyright>The authors disclaim copyright to this source code.</Copyright>
+    <Authors>Leonardo Boshell, Mattias Karlsson and contributors</Authors>
+    <Company>Leonardo Boshell, Mattias Karlsson and contributors</Company>
+    <PackageLicenseExpression>Unlicense</PackageLicenseExpression>
+    <PackageIcon>litjson.png</PackageIcon>
+    <RepositoryUrl>https://github.com/LitJSON/litjson</RepositoryUrl>
+    <RepositoryType>git</RepositoryType>
+    <PackageTags>JSON;Serializer</PackageTags>
+    <IncludeSource>true</IncludeSource>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Include="litjson.png" Pack="true" PackagePath="" />
+  </ItemGroup>
+
+  <PropertyGroup Condition="'$(TargetFramework)' == 'net20' ">
+    <DefineConstants>$(DefineConstants);LEGACY</DefineConstants>
+    <FrameworkPathOverride Condition="'$(TargetFramework)' == 'net20' and '$(OS)' == 'Windows_NT'">C:\Windows\Microsoft.NET\Framework\v2.0.50727</FrameworkPathOverride>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(TargetFramework)' == 'net35' ">
+    <DefineConstants>$(DefineConstants);LEGACY</DefineConstants>
+    <FrameworkPathOverride Condition="'$(TargetFramework)' == 'net35' and '$(OS)' == 'Windows_NT'">C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v3.5\Profile\Client</FrameworkPathOverride>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(TargetFramework)' == 'net40' ">
+    <DefineConstants>$(DefineConstants);LEGACY</DefineConstants>
+  </PropertyGroup>
+
+  <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard1.5' ">
+    <PackageReference Include="System.Collections.NonGeneric" Version="4.0.1" />
+    <PackageReference Include="System.Collections.Specialized" Version="4.0.1" />
+    <PackageReference Include="System.Reflection" Version="4.3.0" />
+    <PackageReference Include="System.Reflection.TypeExtensions" Version="4.1.0" />
+  </ItemGroup>
+
+</Project>
diff --git a/O&Z_Obfuscator/LitJson/Netstandard15Polyfill.cs b/O&Z_Obfuscator/LitJson/Netstandard15Polyfill.cs
new file mode 100644
index 0000000..55b02a2
--- /dev/null
+++ b/O&Z_Obfuscator/LitJson/Netstandard15Polyfill.cs
@@ -0,0 +1,24 @@
+#if NETSTANDARD1_5
+using System;
+using System.Reflection;
+namespace LitJson
+{
+    internal static class Netstandard15Polyfill
+    {
+        internal static Type GetInterface(this Type type, string name)
+        {
+            return type.GetTypeInfo().GetInterface(name); 
+        }
+
+        internal static bool IsClass(this Type type)
+        {
+            return type.GetTypeInfo().IsClass;
+        }
+
+        internal static bool IsEnum(this Type type)
+        {
+            return type.GetTypeInfo().IsEnum;
+        }
+    }
+}
+#endif
\ No newline at end of file
diff --git a/O&Z_Obfuscator/LitJson/ParserToken.cs b/O&Z_Obfuscator/LitJson/ParserToken.cs
new file mode 100644
index 0000000..0dabea2
--- /dev/null
+++ b/O&Z_Obfuscator/LitJson/ParserToken.cs
@@ -0,0 +1,45 @@
+#region Header
+
+#endregion
+
+
+/**
+* ParserToken.cs
+*   Internal representation of the tokens used by the lexer and the parser.
+*
+* The authors disclaim copyright to this source code. For more details, see
+* the COPYING file included with this distribution.
+**/
+namespace O_Z_IL2CPP_Security.LitJson
+{
+    internal enum ParserToken
+    {
+        // Lexer tokens (see section A.1.1. of the manual)
+        None = char.MaxValue + 1,
+        Number,
+        True,
+        False,
+        Null,
+        CharSeq,
+        // Single char
+        Char,
+
+        // Parser Rules (see section A.2.1 of the manual)
+        Text,
+        Object,
+        ObjectPrime,
+        Pair,
+        PairRest,
+        Array,
+        ArrayPrime,
+        Value,
+        ValueRest,
+        String,
+
+        // End of input
+        End,
+
+        // The empty rule
+        Epsilon
+    }
+}
diff --git a/O&Z_Obfuscator/LitJson/litjson.png b/O&Z_Obfuscator/LitJson/litjson.png
new file mode 100644
index 0000000000000000000000000000000000000000..a4c15e5bbd11ae56f6707941c9e5dedfad044e95
GIT binary patch
literal 3356
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

literal 0
HcmV?d00001

diff --git a/O&Z_Obfuscator/OZ_Obfuscator.csproj b/O&Z_Obfuscator/OZ_Obfuscator.csproj
index 8e73c3b..ecc4aa6 100644
--- a/O&Z_Obfuscator/OZ_Obfuscator.csproj
+++ b/O&Z_Obfuscator/OZ_Obfuscator.csproj
@@ -71,9 +71,20 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="AssemblyLoader.cs" />
+    <Compile Include="LitJson\IJsonWrapper.cs" />
+    <Compile Include="LitJson\JsonData.cs" />
+    <Compile Include="LitJson\JsonException.cs" />
+    <Compile Include="LitJson\JsonMapper.cs" />
+    <Compile Include="LitJson\JsonMockWrapper.cs" />
+    <Compile Include="LitJson\JsonReader.cs" />
+    <Compile Include="LitJson\JsonWriter.cs" />
+    <Compile Include="LitJson\Lexer.cs" />
+    <Compile Include="LitJson\Netstandard15Polyfill.cs" />
+    <Compile Include="LitJson\ParserToken.cs" />
     <Compile Include="Ofbuscators\ControlFlow.cs" />
     <Compile Include="Ofbuscators\Antide4dot.cs" />
     <Compile Include="Ofbuscators\LocalVariables2Field.cs" />
+    <Compile Include="Ofbuscators\ObfusFunc.cs" />
     <Compile Include="Runtime\Num2Modle.cs" />
     <Compile Include="Ofbuscators\NumObfus.cs" />
     <Compile Include="Program.cs" />
@@ -89,5 +100,12 @@
       <Install>false</Install>
     </BootstrapperPackage>
   </ItemGroup>
+  <ItemGroup>
+    <None Include="LitJson\AssemblyInfo.cs.in" />
+    <None Include="LitJson\LitJSON.csproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="LitJson\litjson.png" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
 </Project>
\ No newline at end of file
diff --git a/O&Z_Obfuscator/Ofbuscators/ObfusFunc.cs b/O&Z_Obfuscator/Ofbuscators/ObfusFunc.cs
new file mode 100644
index 0000000..0442df3
--- /dev/null
+++ b/O&Z_Obfuscator/Ofbuscators/ObfusFunc.cs
@@ -0,0 +1,90 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using O_Z_IL2CPP_Security.LitJson;
+using OZ_Obfus;
+
+namespace OZ_Obfuscator.Ofbuscators
+{
+    public class ObfusFunc
+    {
+        ModuleDefMD module;
+        List<string> ignoreMethod = new List<string>();
+        List<string> ignoreField = new List<string>();
+        List<string> obfusClass = new List<string>();
+        public ObfusFunc(ModuleDefMD module)
+        {
+            this.module = module;
+            if(!File.Exists("keyfunc.json"))
+            {
+                Console.ForegroundColor = ConsoleColor.Red;
+                Console.WriteLine("keyfunc.json not found!");
+                Console.ForegroundColor = ConsoleColor.Yellow;
+                Console.WriteLine("正在重新生成默认keyfunc.json...");
+                Console.WriteLine("如果您不想使用默认keyfunc.json,请重新配置keyfunc.json");
+                Console.ForegroundColor = ConsoleColor.White;
+                File.WriteAllBytes("keyfunc.json", Convert.FromBase64String(ignore.origin));
+            }
+            ignore ig = JsonMapper.ToObject<ignore>(File.ReadAllText("keyfunc.json"));
+            foreach (var item in ig.ignoreMethod)
+                ignoreMethod.Add(item.ToLower());
+            foreach (var item in ig.ignoreField)
+                ignoreField.Add(item.ToLower());
+            foreach(var item in ig.customignoreMethod)
+                ignoreMethod.Add(item.ToLower());
+            foreach (var item in ig.customignoreField)
+                ignoreField.Add(item.ToLower());
+            foreach (var item in ig.customignoreClass)
+                obfusClass.Add(item.ToLower());
+        }
+        public void Excute()
+        {
+            foreach (var type in module.Types.Where(x => !(x.Name.StartsWith("<"))))
+            {
+                foreach (var field in type.Fields.Where(x => !x.IsRuntimeSpecialName && !x.IsSpecialName
+                && !(x.Name.StartsWith("<"))))
+                {
+                    if (ignoreField.FirstOrDefault(x => field.FullName.ToLower().Contains(x)) == null)
+                        NameGenerator.SetObfusName(field, NameGenerator.Mode.FuncName, 3);
+                }
+                foreach (var method in type.Methods.Where(x => !x.IsConstructor && !x.IsVirtual
+                && !x.IsRuntime && !x.IsRuntimeSpecialName && !x.IsAbstract
+                && !((x.GenericParameters != null) && x.GenericParameters.Count > 0) && !(x.Overrides.Count > 0)
+                && !(x.Name.StartsWith("<") || x.Name.ToLower().StartsWith("do"))))
+                {
+                    if (ignoreMethod.FirstOrDefault(x => method.FullName.ToLower().Contains(x)) == null)
+                        NameGenerator.SetObfusName(method, NameGenerator.Mode.FuncName, 5);
+                    if (method.HasParams())
+                    {
+                        foreach (var p in method.Parameters)
+                        {
+                            p.Name = NameGenerator.GetName(NameGenerator.Mode.FuncName, 4);
+                        }
+                    }
+                }
+                foreach (var p in type.Properties.Where(x => !x.IsRuntimeSpecialName && !x.IsSpecialName))
+                    NameGenerator.SetObfusName(p, NameGenerator.Mode.Base64, 5);
+                //NameGenerator.SetObfusName(type, NameGenerator.Mode.FuncName, 6);
+
+                if (obfusClass.FirstOrDefault(x => type.FullName.ToLower().Contains(x)) != null)
+                {
+                    NameGenerator.SetObfusName(type, NameGenerator.Mode.FuncName, 6);
+                }
+            }
+        }
+    }
+    public class ignore
+    {
+        public string[] ignoreMethod;
+        public string[] ignoreField;
+        public string[] customignoreMethod;
+        public string[] customignoreField;
+        public string[] customignoreClass;
+        public static string origin = "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";
+    }
+}
diff --git a/O&Z_Obfuscator/Program.cs b/O&Z_Obfuscator/Program.cs
index 36c7140..1de5e04 100644
--- a/O&Z_Obfuscator/Program.cs
+++ b/O&Z_Obfuscator/Program.cs
@@ -15,6 +15,12 @@ class Program
     {
         static void Main(string[] args)
         {
+            AssemblyLoader loader = new AssemblyLoader("C:\\Users\\22864\\Desktop\\END_AUTO V2\\END_Data\\Managed\\Assembly-CSharp.dll.bak");
+            ObfusFunc obfusFunc = new ObfusFunc(loader.Module);
+            obfusFunc.Excute();
+            loader.Save();
+            Console.ReadKey();
+            /*
             AssemblyLoader loader;
             if (args.Length > 0)
             {
@@ -61,6 +67,7 @@ static void Main(string[] args)
                 Console.WriteLine("Press any key to exit...");
                 Console.ReadKey();
             }
+            */
         }
         void printfinstr(ModuleDefMD Module)
         {
diff --git a/O&Z_Obfuscator/README.md b/O&Z_Obfuscator/README.md
index 414e884..8aebdd5 100644
--- a/O&Z_Obfuscator/README.md
+++ b/O&Z_Obfuscator/README.md
@@ -10,11 +10,7 @@
    O&Z_IL2CPP_Security.exe input MonoObfus
    ~~~
 3. Enjoy Safe! xD
-4. ~~您也可以直接使用命令行来操作加密你的NET程序集(*不仅是Unity Script,而是任何NET程序集!*)~~
-
-   (此功能已删除,目前已经将主程序合并到O&Z_IL2CPP_Security.exe中)
-   
-   ![Usage](img/usage.png)
+4. 如果你想使用ObfusFunc参数来获取更加强大的混淆,请仔细阅 **读加密参数说明-ObfusFunc** 中的条例
 
 ## 加密参数说明
  - ControlFlow(控制流程加密)
@@ -37,4 +33,27 @@
    使用本方法加密您游戏内的字符串常量,每一个字符串都单独对应一个单独和密码和单独的解密函数,使破解难度上升
    ![Stringobfus](img/strobfus.png)
 
-   
+ - ObfusFunc(类&方法&字段混淆)
+
+   使用本方法加密您项目中所有的函数,类,甚至是参数,使程序的不可读性达到最高(我们采用了Unity函数名堆积作为字典,使得这种方法混淆的函数难以被反混淆器识别为Obfuscated或JunkFunc)
+
+   ![ObfusFunc](img/funcobfus.png)
+   ### 使用方法以及注意事项
+   1. 您需要配置 **keyfunc.json**,来完成本程序对于您项目的适配
+   ![KeyFunc](img/keyfunc.png)
+   2. 在配置keyfunc.json中,我们已经预先配置好了Unity中的大部分生命周期函数以及关键回调,这些都将会作为skip的部分跳过混淆
+   3. 我们为您提供了三种可以自定义的部分,用于适配您的程序
+       - 忽略的方法(customignoreMethod): **此项采用白名单的模式**,如果您不需要混淆某个方法或者某个方法不能被混淆(例如使用了反射),可以将方法名称添加到这里
+       - 忽略的字段(customignoreField): **此项采用白名单的模式**,如果您不需要混淆某个字段或者某个字段不能被混淆(例如使用了反射),可以将字段名称添加到这里
+       - 需要混淆的类(customignoreClass): **此项采用白名单的模式**,因为涉及到Unity预制体的影响,类名一般来说不能够轻易混淆(*详细原因见下方*),如果你需要混淆某个类名,可以将类名添加到这里
+   4. **需要注意的事项**
+       - 在Unity中,GameObject或者prefabs初始绑定了脚本,则该脚本的类名不可混淆,方法名和字段名可以混淆
+       - 在Unity中,GameObject或者prefabs初始没有绑定脚本,但是在代码中动态添加了脚本,则该脚本的类名、方法名和字段名都可以混淆 
+       - 如果该脚本中涉及到了UI的事件响应(如Button.OnClick),则该脚本的类名和该方法名都不可混淆,字段名可以混淆
+       - Unity的生命周期方法和回调方法不能混淆,上方的忽略列表包含了大多数常用的生命周期和回调方法,如果有遗漏,可以自行添加
+       - Unity中的Invoke等特殊方法所调用的函数方法不可混淆,同理协程类的方法也不可混淆,请自行添加到自定义忽略列表
+       - 部分涉及反射类的代码不能混淆,如System.Reflection(GetField,GetMethod,Invoke等),请自行添加到自定义忽略列表
+       - Native层里直接调用C#或通过Unity内置API发送事件到C#的类和方法不可混淆(大多数在移动平台中)
+       - 一些特殊插件对应的脚本不可混淆,例如xLua和与之绑定的C#脚本
+       - 你可以将一些关键的方法(例如涉及到*游戏内购,广告的接入,游戏全局管理控制,游戏资源的管理,游戏本地化保存,与服务器云交互*等等)写到一个不涉及Unity预制体或者UI事件等情况的专用的脚本中,并对该脚本的类进行混淆
+    5. 正确的配置好keyfunc,可以最大程度为您的游戏带来安全,谢谢您的使用!如果有任何问题,欢迎联系作者QQ,添加讨论群或者在issue提出
diff --git a/O&Z_Obfuscator/img/config.png b/O&Z_Obfuscator/img/config.png
index 8d272cf9dce6670ed5bdf16d099390cc035e2f10..2b8486dd609561618d1898bac25b453a7a9ebb53 100644
GIT binary patch
literal 38205
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

literal 22462
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
DDtEo#

diff --git a/O&Z_Obfuscator/img/funcobfus.png b/O&Z_Obfuscator/img/funcobfus.png
new file mode 100644
index 0000000000000000000000000000000000000000..b66e39e5a88dfba8f593b9ac35b19739a5f01494
GIT binary patch
literal 68721
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
E116fV)c^nh

literal 0
HcmV?d00001

diff --git a/O&Z_Obfuscator/img/keyfunc.png b/O&Z_Obfuscator/img/keyfunc.png
new file mode 100644
index 0000000000000000000000000000000000000000..1a8f3f47ed46146d8c8e23b885039a902ee91d20
GIT binary patch
literal 110303
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
DM(GSn

literal 0
HcmV?d00001

diff --git a/O&Z_Obfuscator/utils.cs b/O&Z_Obfuscator/utils.cs
index 9a0b886..a8d7ada 100644
--- a/O&Z_Obfuscator/utils.cs
+++ b/O&Z_Obfuscator/utils.cs
@@ -8,7 +8,7 @@
 using System.Security.Cryptography;
 using System.Text;
 using System.Threading.Tasks;
-
+using O_Z_IL2CPP_Security.LitJson;
 namespace OZ_Obfus
 {
     public static class Extensions
@@ -211,7 +211,6 @@ public static string GenertateRandomFuncName()
 {
             return FuncNames[RandomGenerator.Generate(FuncNames.Length)];
         }
-
         public static string[] FuncNames =
         {
             "Awake","Start","Updata","FixedUpdata",
@@ -225,9 +224,11 @@ public static string GenertateRandomFuncName()
             "OnGUI","OnJointBreak","OnLevelWasLoaded","OnMouseDown","OnMouseDrag","OnMouseEnter",
             "OnMouseExit","OnMouseOver","OnMouseUp","OnPostRender","OnPreCull","OnPreRender",
             "OnRenderImage","OnRenderObject","OnSerializeNetworkView","OnServerInitialized",
-            "OnTriggerEnter","OnTriggerExit","OnTriggerStay"
+            "OnTriggerEnter","OnTriggerExit","OnTriggerStay","Reset","OnTransformParentChanged",
+            "OnPreCull","OnJointBreak","OnApplicationQuit","OnDestory","OnDisable","OnAnimatorIK",
+            "OnAnimatorMove","OnApplicationQuit","OnEnable","OnParticleTrigger","OnParticleUpdateJobScheduled",
+            "OnPlayerConnected","OnPostRender","__"
         };
-        
         public const string ERROR = ";̥͓̠̙̠̺̫̱̹̮͈͈͓͍̟̻͆ͧ͒ͩͨ̉ͯ̂̈̉̽̉͑̔̊́͟͜;̢̧͔͓͉̝̆̒ͣͣ̄ͣ̊̈́̎̓͛̇͆ͯͪ̿͟;ͫͭ͒̉̐͑̀҉̭̭͕̟͇̰̺͖͎̗̰̩͉;̸̛̘̬̫̫͔̜͙̣̯̠̯̻͍̰͍̥͓ͦ̎ͯͯ͂ͤ̉̃̊͐̐̽͜;̵̧̂͐̉̆́̚̚҉̜̦̳͇͍;̙͈̞̪̖͚̬͍͙̹ͭ̿͒ͧͧͨ̀;͐̇̋̍̿̎̀͌ͣ͌҉ ̞̙̘̱͟͠_̍̽̋̑͒ͧ̌͐̿͞͡҉̯̣̥̹̗̫̥̩͈̘͟ͅͅ_̈͛̈͊̈́ͥͬ̌ͪ̃̽͑̓͋͛̆̈͋̽҉̸̛̠̝̜͈̮͢_͒͂̋̈́͋̉͒ͦ̊ͯ̐̾̂̐҉҉̧̯̜̣̮̦̱̦̖̗͡_̧̨̹̳̘̯̱͖͙̘̍ͥ͊͌̌ͧͥ̍ͨ̐͡_̵̺̮̞̖̰͔̮̺̳͖̳̳̥͖͖͊͐͛ͥͪ͛͑͠ͅ_ͧ̓ ̴̡̪͎̣̘̳̤̬͔̟̺̳̻̥͇ͧͫ̽͐̄ͤ̎̔_̸̠̪̺͕̩̮̹̦͇̫͙͖̦̻̏̈́̅ͦ͐_̴̸̢͚̤͙͓̱̬̫̝̞̣̥̽͛͊ͥͬ̍͆ͨ͑͋̍͊ͭ͗́ͅ^̵͖̖̹̦͎̦̜͋̉͋͐̈́ͪ̋̊̄́͘͟ ̨͚͙͖̫͚̙̊̏̍̐ͥ̅̏̎͆͗ͧ́̚͞!̧͕͈͕͙̱̟̆ͭ͋ͫ̕͢͞;̛̣̭̖̹̜̘̮̜̭͓̰̫͙͋̏ͯͤ̂ͬ͗ͥ̌ͥ̓ͮͪ͗́͞ͅ;̪̳̼̱̽ͨ͋͛̔ͪͬ̃͌̂̌͐̀ͧͬ̾ͨ̚̚;̛͍̘̗̣͉͓̘͖͙̪͙̦͇̩͈ͩ͋̄̓ͣ́̃ͦͫ͒̑͋̃ͣͥ̋̀;̢͚̰͈͍ͮͤͣ͂̆͋ͨ̀̐̕͞͞ͅ;̨̢̬̹̯̯̤͕͍̺̩̫͈͉̙̪̪̜̻͚̂͋̏̓͛ͣ͟;̥̖̭͕͔̝͇̞̠̰͐̿̆ͣ̈͟͡;̵̸̻̫͔̼͚̤͇̝̞̬̞͚͇̓̐͆̾ͭ̈́ͫ̈́́͜͞;̌ͨ͌̐̉̂̃̅̃̋ͤͤͣͯ҉̧̹̗̺̹͈̙͇̦̣ͅ;̸̫̙͈̫̮̻͎̱͓̗̍&a_̈͛̈͊̈́ͥͬ̌ͪ̃̽͑̓͋͛̆̈͋̽҉̸̛̠̝̜͈̮͢_͒&‮‮‮‮‮‮‮‮‮‮‮";
 
 
diff --git a/README.md b/README.md
index 26cc689..ed4da60 100644
--- a/README.md
+++ b/README.md
@@ -5,25 +5,21 @@ O&Z Protector 是由 **Z1029[QQ:3408708525]** **和[oRangeSumMer](https://space.
 
 ***本程序基于[Net6.0](https://dotnet.microsoft.com/zh-cn/download/dotnet/6.0) & [NETFramework4.8](https://dotnet.microsoft.com/zh-cn/download/dotnet-framework/net48)开发,运行需要[Net6.0](https://dotnet.microsoft.com/zh-cn/download/dotnet/6.0) & [NETFramework4.8](https://dotnet.microsoft.com/zh-cn/download/dotnet-framework/net48)环境,请确保您的PC正确安装了NET Runtime或者NET SDK***
 
-## >>>[O&Z-IL2CPP(Click me!)](/O%26Z_IL2CPP_Security/README.md)<<<
+## >>>[O&Z-IL2CPP(Click me!)](O%26Z_IL2CPP_Security/README.md)<<<
 
-## >>>[O&Z-MonoObfuscator(Click me!)](/O%26Z_Obfuscator/README.md)<<<
+## >>>[O&Z-MonoObfuscator(Click me!)](O%26Z_Obfuscator/README.md)<<<
 
 ## What's New
-1. 我们正式完成了O&Z MonoObfuscator的编写并且在此次更新中release!
-2. **修复了MonoObfuscate 功能使用过程中无法对路径中含有空格的程序集使用**
-
-   目前实现的功能:
-- 字符串加密
-- 常量预设值加密
-- 流程混淆(ControlFlow)
-- 局部变量转为Feild
-- . . . . ([更多](/O%26Z_IL2CPP_Security/README.md))
+1. **修复了MonoObfuscate 功能使用过程中无法对路径中含有空格的程序集使用**
+2. 在MonoObfuscate功能中,我们添加了对类,方法,字段名的混淆是的代码的不可读性和破解难度上升到了最高,而且此方法可以兼容Unity(需要自定义配置keyfunc.json文件)!
+   ![obfusfunc](O%26Z_Obfuscator/img/funcobfus.png)
 
 ## 预告
 1. UI窗口界面即将完成!
 2. 正在测试对于所有unity版本il2cpp的支持,自动生成libil2cpp
-3. 我们正在编写O&ZMonoObfus的函数与方法名称的混淆
+3. ~~我们正在编写O&ZMonoObfus的函数与方法名称的混淆~~
+4. 我们准备重写Mono虚拟机,在底层对Unity Mono的JIT,AOT等进行加密
+5. 我们正在尝试对于IL2CPP生成方式中,在生成IL代码时,插入MonoObfuscate的功能,使得IL2CPP获得最佳保险
 
 ## 未来的规划
 1. 对AssetBundle资源进行加密