using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using FixPluginTypesSerialization.Patchers;
using FixPluginTypesSerialization.UnityPlayer;
using FixPluginTypesSerialization.UnityPlayer.Structs.Default;
using FixPluginTypesSerialization.Util;
using Microsoft.CodeAnalysis;
using Microsoft.Deployment.Compression;
using Microsoft.Deployment.Compression.Cab;
using Mono.Cecil;
using MonoMod.RuntimeDetour;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("FixPluginTypesSerialization")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+18666a053a1d3d5c39ebafa9bb4683203fadb3a7")]
[assembly: AssemblyProduct("FixPluginTypesSerialization")]
[assembly: AssemblyTitle("FixPluginTypesSerialization")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NativeIntegerAttribute : Attribute
	{
		public readonly bool[] TransformFlags;

		public NativeIntegerAttribute()
		{
			TransformFlags = new bool[1] { true };
		}

		public NativeIntegerAttribute(bool[] P_0)
		{
			TransformFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace FixPluginTypesSerialization
{
	internal static class Config
	{
		private static readonly ConfigFile _config = new ConfigFile(Path.Combine(Paths.ConfigPath, "FixPluginTypesSerialization.cfg"), true);

		internal static ConfigEntry<string> UnityVersionOverride = _config.Bind<string>("Cache", "UnityVersionOverride", "", "Unity version is Major.Minor.Patch format i.e. 2017.2.1. If specified, this version will be used instead of auto-detection from executable info. Specify only if the patcher doesn't work otherwise.");

		internal static ConfigEntry<string> LastDownloadedGUID = _config.Bind<string>("Cache", "LastDownloadedGUID", "000000000000000000000000000000000", "The GUID of the last downloaded UnityPlayer pdb file." + Environment.NewLine + "If this GUID matches with the current one," + Environment.NewLine + "the offsets for the functions below will be used" + Environment.NewLine + "instead of generating them at runtime.");

		internal static ConfigEntry<string> MonoManagerAwakeFromLoadOffset = _config.Bind<string>("Cache", "MonoManagerAwakeFromLoadOffset", "00", "The in-memory offset of the MonoManager::AwakeFromLoad function.");

		internal static ConfigEntry<string> MonoManagerIsAssemblyCreatedOffset = _config.Bind<string>("Cache", "MonoManagerIsAssemblyCreatedOffset", "00", "The in-memory offset of the MonoManager::IsAssemblyCreated function.");

		internal static ConfigEntry<string> IsFileCreatedOffset = _config.Bind<string>("Cache", "IsFileCreatedOffset", "00", "The in-memory offset of the IsFileCreated function.");

		internal static ConfigEntry<string> ScriptingManagerDeconstructorOffset = _config.Bind<string>("Cache", "ScriptingManagerDeconstructorOffset", "00", "The in-memory offset of the ScriptingManagerDeconstructor function.");

		internal static ConfigEntry<string> ConvertSeparatorsToPlatformOffset = _config.Bind<string>("Cache", "ConvertSeparatorsToPlatformOffset", "00", "The in-memory offset of the ConvertSeparatorsToPlatform function.");

		internal static ConfigEntry<string> FreeAllocInternalOffset = _config.Bind<string>("Cache", "FreeAllocInternalOffset", "00", "The in-memory offset of the free_alloc_internal function.");

		internal static ConfigEntry<string> MallocInternalOffset = _config.Bind<string>("Cache", "MallocInternalOffset", "00", "The in-memory offset of the malloc_internal function.");

		internal static ConfigEntry<string> ScriptingAssembliesOffset = _config.Bind<string>("Cache", "ScriptingAssembliesOffset", "00", "The in-memory offset of the m_ScriptingAssemblies global field.");
	}
	internal static class FixPluginTypesSerializationPatcher
	{
		public static List<string> PluginPaths = (from f in Directory.GetFiles(Paths.PluginPath, "*.dll", SearchOption.AllDirectories)
			where IsNetAssembly(f)
			select f).ToList();

		public static List<string> PluginNames = PluginPaths.Select((string p) => Path.GetFileName(p)).ToList();

		public static IEnumerable<string> TargetDLLs { get; } = new string[0];


		public static bool IsNetAssembly(string fileName)
		{
			try
			{
				AssemblyName.GetAssemblyName(fileName);
			}
			catch (BadImageFormatException)
			{
				return false;
			}
			return true;
		}

		public static void Patch(AssemblyDefinition ass)
		{
		}

		public static void Initialize()
		{
			Log.Init();
			try
			{
				InitializeInternal();
			}
			catch (Exception ex)
			{
				Log.Error($"Failed to initialize plugin types serialization fix: ({ex.GetType()}) {ex.Message}. Some plugins may not work properly.");
				Log.Error(ex);
			}
		}

		private static void InitializeInternal()
		{
			DetourUnityPlayer();
		}

		private static void DetourUnityPlayer()
		{
			string text = Path.Combine(Paths.GameRootPath, "UnityPlayer.dll");
			if (!File.Exists(text))
			{
				text = Paths.ExecutablePath;
			}
			MiniPdbReader pdbReader = new MiniPdbReader(text);
			ProcessModule processModule = Process.GetCurrentProcess().Modules.Cast<ProcessModule>().FirstOrDefault(IsUnityPlayer) ?? Process.GetCurrentProcess().MainModule;
			CommonUnityFunctions.Init(processModule.BaseAddress, processModule.ModuleMemorySize, pdbReader);
			AwakeFromLoad awakeFromLoad = new AwakeFromLoad();
			IsAssemblyCreated isAssemblyCreated = new IsAssemblyCreated();
			IsFileCreated isFileCreated = new IsFileCreated();
			ScriptingManagerDeconstructor scriptingManagerDeconstructor = new ScriptingManagerDeconstructor();
			ConvertSeparatorsToPlatform convertSeparatorsToPlatform = new ConvertSeparatorsToPlatform();
			awakeFromLoad.Patch(processModule.BaseAddress, processModule.ModuleMemorySize, pdbReader, Config.MonoManagerAwakeFromLoadOffset);
			isAssemblyCreated.Patch(processModule.BaseAddress, processModule.ModuleMemorySize, pdbReader, Config.MonoManagerIsAssemblyCreatedOffset);
			if (!IsAssemblyCreated.IsApplied)
			{
				isFileCreated.Patch(processModule.BaseAddress, processModule.ModuleMemorySize, pdbReader, Config.IsFileCreatedOffset);
			}
			convertSeparatorsToPlatform.Patch(processModule.BaseAddress, processModule.ModuleMemorySize, pdbReader, Config.ConvertSeparatorsToPlatformOffset);
			scriptingManagerDeconstructor.Patch(processModule.BaseAddress, processModule.ModuleMemorySize, pdbReader, Config.ScriptingManagerDeconstructorOffset);
			static bool IsUnityPlayer(ProcessModule p)
			{
				return p.ModuleName.ToLowerInvariant().Contains("unityplayer");
			}
		}
	}
	internal static class Log
	{
		internal static ManualLogSource _logSource;

		internal static void Init()
		{
			_logSource = Logger.CreateLogSource("FixPluginTypesSerialization");
		}

		internal static void Debug(object data)
		{
			_logSource.LogDebug(data);
		}

		internal static void Error(object data)
		{
			_logSource.LogError(data);
		}

		internal static void Fatal(object data)
		{
			_logSource.LogFatal(data);
		}

		internal static void Info(object data)
		{
			_logSource.LogInfo(data);
		}

		internal static void Message(object data)
		{
			_logSource.LogMessage(data);
		}

		internal static void Warning(object data)
		{
			_logSource.LogWarning(data);
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "FixPluginTypesSerialization";

		public const string PLUGIN_NAME = "FixPluginTypesSerialization";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace FixPluginTypesSerialization.Util
{
	internal class BytePattern
	{
		private readonly byte?[] pattern;

		private int[] jumpTable;

		public int Length => pattern.Length;

		public bool IsE8 => pattern[0] == 232;

		public BytePattern(string bytes)
		{
			pattern = bytes.ParseHexBytes();
			CreateJumpTable();
		}

		public BytePattern(byte[] bytes)
		{
			pattern = bytes.Cast<byte?>().ToArray();
			CreateJumpTable();
		}

		public static implicit operator BytePattern(string pattern)
		{
			return new BytePattern(pattern);
		}

		public static implicit operator BytePattern(byte[] pattern)
		{
			return new BytePattern(pattern);
		}

		private void CreateJumpTable()
		{
			jumpTable = new int[pattern.Length];
			int num = 0;
			jumpTable[0] = -1;
			int num2 = 1;
			while (num2 < pattern.Length)
			{
				if (pattern[num2] == pattern[num])
				{
					jumpTable[num2] = jumpTable[num];
				}
				else
				{
					jumpTable[num2] = num;
					while (num >= 0 && pattern[num2] != pattern[num])
					{
						num = jumpTable[num];
					}
				}
				num2++;
				num++;
			}
		}

		public unsafe long Match(IntPtr start, long maxSize)
		{
			byte* ptr = (byte*)start.ToPointer();
			long num = 0L;
			long num2 = 0L;
			while (num < maxSize)
			{
				if (!pattern[num2].HasValue || ptr[num] == pattern[num2])
				{
					num++;
					num2++;
					if (num2 == pattern.Length)
					{
						return num - num2;
					}
				}
				else
				{
					num2 = jumpTable[num2];
					if (num2 < 0)
					{
						num++;
						num2++;
					}
				}
			}
			return 0L;
		}
	}
	internal class CommonUnityFunctions
	{
		public enum AllocateOptions
		{
			None,
			NullIfOutOfMemory
		}

		private delegate IntPtr MallocInternalFunc(ulong size, ulong allign, int label, AllocateOptions allocateOptions, IntPtr file, int line);

		private delegate void FreeAllocInternalV1Func(IntPtr ptr, int label);

		private delegate void FreeAllocInternalV2Func(IntPtr ptr, int label, IntPtr file, int line);

		private static MallocInternalFunc mallocInternal;

		private static FreeAllocInternalV1Func freeAllocInternalV1;

		private static FreeAllocInternalV2Func freeAllocInternalV2;

		public static IntPtr ScriptingAssemblies { get; private set; }

		public static void Init(IntPtr unityModule, int moduleSize, MiniPdbReader pdbReader)
		{
			IntPtr intPtr = PatternDiscover.Discover(unityModule, moduleSize, pdbReader, Config.MallocInternalOffset, new BytePattern[1] { Encoding.ASCII.GetBytes("malloc_internal") }, Array.Empty<BytePattern>());
			if (intPtr != IntPtr.Zero)
			{
				mallocInternal = (MallocInternalFunc)Marshal.GetDelegateForFunctionPointer(intPtr, typeof(MallocInternalFunc));
			}
			IntPtr intPtr2 = PatternDiscover.Discover(unityModule, moduleSize, pdbReader, Config.FreeAllocInternalOffset, new BytePattern[1] { Encoding.ASCII.GetBytes("free_alloc_internal") }, Array.Empty<BytePattern>());
			if (intPtr2 != IntPtr.Zero)
			{
				if (UseRightStructs.UnityVersion >= new Version(2019, 3))
				{
					freeAllocInternalV2 = (FreeAllocInternalV2Func)Marshal.GetDelegateForFunctionPointer(intPtr2, typeof(FreeAllocInternalV2Func));
				}
				else
				{
					freeAllocInternalV1 = (FreeAllocInternalV1Func)Marshal.GetDelegateForFunctionPointer(intPtr2, typeof(FreeAllocInternalV1Func));
				}
			}
			IntPtr intPtr3 = PatternDiscover.Discover(unityModule, moduleSize, pdbReader, Config.ScriptingAssembliesOffset, new BytePattern[1] { Encoding.ASCII.GetBytes("m_ScriptingAssemblies@") }, Array.Empty<BytePattern>());
			if (intPtr3 != IntPtr.Zero)
			{
				ScriptingAssemblies = intPtr3;
			}
		}

		public unsafe static IntPtr MallocString(string str, int label, out ulong length)
		{
			IntPtr intPtr = Marshal.StringToHGlobalAnsi(str);
			length = (ulong)str.Length;
			byte* ptr = (byte*)(void*)intPtr + length;
			while (*ptr != 0)
			{
				ptr++;
				length++;
			}
			IntPtr intPtr2 = mallocInternal(length + 1, 16uL, label, AllocateOptions.NullIfOutOfMemory, IntPtr.Zero, 0);
			for (ulong num = 0uL; num <= length; num++)
			{
				((byte*)(void*)intPtr2)[num] = ((byte*)(void*)intPtr)[num];
			}
			Marshal.FreeHGlobal(intPtr);
			return intPtr2;
		}

		public static IntPtr MallocInternal(ulong size, ulong allign, int label)
		{
			return mallocInternal(size, allign, label, AllocateOptions.NullIfOutOfMemory, IntPtr.Zero, 0);
		}

		public static void FreeAllocInternal(IntPtr ptr, int label)
		{
			if (UseRightStructs.UnityVersion >= new Version(2019, 3))
			{
				freeAllocInternalV2(ptr, label, IntPtr.Zero, 0);
			}
			else
			{
				freeAllocInternalV1(ptr, label);
			}
		}
	}
	internal static class DictionaryExtensions
	{
		public static void Deconstruct<T1, T2>(this KeyValuePair<T1, T2> tuple, out T1 key, out T2 value)
		{
			key = tuple.Key;
			value = tuple.Value;
		}

		public static void Deconstruct(this VersionedHandler versionedHandler, out Version version, out object handler)
		{
			version = versionedHandler.version;
			handler = versionedHandler.handler;
		}
	}
	internal class MiniPdbReader
	{
		private static readonly HttpClient _httpClient = new HttpClient
		{
			Timeout = TimeSpan.FromMinutes(5.0)
		};

		private readonly PeReader _peReader;

		private byte[] _pdbFile;

		internal bool IsPdbAvailable;

		internal bool UseCache;

		private static byte[] DownloadFromWeb(string url)
		{
			Log.Info("Downloading : " + url + "\nThis pdb file is needed for the plugin to work properly. This may take a while, relax, modding is coming.");
			try
			{
				HttpResponseMessage result = _httpClient.GetAsync(url).GetAwaiter().GetResult();
				Log.Info("Status Code : " + result.StatusCode);
				if (result.StatusCode != HttpStatusCode.OK)
				{
					return null;
				}
				return result.Content.ReadAsByteArrayAsync().GetAwaiter().GetResult();
			}
			catch (TaskCanceledException)
			{
				Log.Info("Could not download pdb. Plugin may not work correctly.");
				return null;
			}
		}

		internal MiniPdbReader(string targetFilePath)
		{
			_peReader = new PeReader(targetFilePath);
			if (_peReader.RsdsPdbFileName == null)
			{
				Log.Info("No pdb path found in the pe file. Falling back to sig matching");
				return;
			}
			UseCache = Config.LastDownloadedGUID.Value == _peReader.PdbGuid;
			Log.Message((UseCache ? "U" : "Not u") + "sing the config cache");
			if (!UseCache)
			{
				if (DownloadUnityPdb(_peReader))
				{
					Config.LastDownloadedGUID.Value = _peReader.PdbGuid;
					IsPdbAvailable = true;
				}
				else
				{
					Log.Info("Failed to find the linked pdb in the unity symbol server. Falling back to sig matching");
				}
			}
			else
			{
				IsPdbAvailable = true;
			}
		}

		private bool DownloadUnityPdb(PeReader peReader)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			string path = peReader.RsdsPdbFileName.TrimEnd('b') + "_";
			byte[] array = DownloadFromWeb(Path.Combine("http://symbolserver.unity3d.com/", peReader.RsdsPdbFileName, peReader.PdbGuid, path));
			if (array != null)
			{
				string tempPath = Path.GetTempPath();
				string text = Path.Combine(tempPath, "pdb.cab");
				try
				{
					File.Delete(text);
				}
				catch (Exception)
				{
				}
				Log.Info("Writing the compressed pdb to " + text);
				File.WriteAllBytes(text, array);
				CabInfo val = new CabInfo(text);
				Log.Info("Unpacking the compressed pdb");
				((ArchiveInfo)val).Unpack(tempPath);
				string path2 = Path.Combine(tempPath, peReader.RsdsPdbFileName);
				_pdbFile = File.ReadAllBytes(path2);
				File.Delete(text);
				File.Delete(path2);
			}
			return _pdbFile != null;
		}

		internal unsafe IntPtr FindFunctionOffset(BytePattern[] bytePatterns)
		{
			fixed (byte* ptr = &_pdbFile[0])
			{
				IntPtr pdbStartAddress = (IntPtr)ptr;
				long sizeOfPdb = _pdbFile.Length;
				var anon = bytePatterns.Select((BytePattern p) => new
				{
					p = p,
					res = p.Match(pdbStartAddress, sizeOfPdb)
				}).FirstOrDefault(m => m.res > 0);
				if (anon == null)
				{
					Log.Error("No function offset found, cannot hook ! Please report it to the r2api devs !");
					return IntPtr.Zero;
				}
				Log.Info($"Found at {anon.res:X} ({pdbStartAddress.ToInt64() + anon.res:X})");
				uint* ptr2 = (uint*)(pdbStartAddress.ToInt64() + anon.res - 7);
				uint num = *ptr2;
				ushort* ptr3 = (ushort*)(pdbStartAddress.ToInt64() + anon.res - 3);
				int num2 = *ptr3 - 1;
				num += _peReader.ImageSectionHeaders[num2].VirtualAddress;
				Log.Info("Function offset : " + num.ToString("X") + " | PE section : " + num2);
				return new IntPtr(num);
			}
		}
	}
	internal static class MonoManagerCommon
	{
		public unsafe static void CopyNativeAssemblyListToManagedV1(List<StringStorageDefaultV1> managedAssemblyList, Vector<StringStorageDefaultV1> assemblyNames)
		{
			managedAssemblyList.Clear();
			for (StringStorageDefaultV1* ptr = assemblyNames.first; ptr != assemblyNames.last; ptr++)
			{
				managedAssemblyList.Add(*ptr);
			}
		}

		public unsafe static void AddAssembliesToManagedListV1(List<StringStorageDefaultV1> managedAssemblyList, List<string> pluginAssemblyPaths)
		{
			foreach (string pluginAssemblyPath in pluginAssemblyPaths)
			{
				string? fileName = Path.GetFileName(pluginAssemblyPath);
				ulong num = (ulong)fileName.Length;
				IntPtr intPtr = Marshal.StringToHGlobalAnsi(fileName);
				byte* ptr = (byte*)(void*)intPtr + num;
				while (*ptr != 0)
				{
					ptr++;
					num++;
				}
				StringStorageDefaultV1 stringStorageDefaultV = default(StringStorageDefaultV1);
				stringStorageDefaultV.label = UseRightStructs.LabelMemStringId;
				stringStorageDefaultV.data = intPtr;
				stringStorageDefaultV.capacity = num;
				stringStorageDefaultV.size = num;
				StringStorageDefaultV1 item = stringStorageDefaultV;
				managedAssemblyList.Add(item);
			}
		}

		public unsafe static void AllocNativeAssemblyListFromManagedV1(List<StringStorageDefaultV1> managedAssemblyList, Vector<StringStorageDefaultV1>* assemblyNames)
		{
			StringStorageDefaultV1* ptr = (StringStorageDefaultV1*)(void*)Marshal.AllocHGlobal(Marshal.SizeOf(typeof(StringStorageDefaultV1)) * managedAssemblyList.Count);
			int i = 0;
			StringStorageDefaultV1* ptr2 = ptr;
			for (; i < managedAssemblyList.Count; i++)
			{
				*ptr2 = managedAssemblyList[i];
				ptr2++;
			}
			assemblyNames->first = ptr;
			assemblyNames->last = ptr + managedAssemblyList.Count;
			assemblyNames->end = assemblyNames->last;
		}

		public unsafe static void PrintAssembliesV1(Vector<StringStorageDefaultV1> assemblyNames)
		{
			for (StringStorageDefaultV1* ptr = assemblyNames.first; ptr != assemblyNames.last; ptr++)
			{
				nint ptr2 = ptr->data;
				if (ptr->data == 0)
				{
					ptr2 = (nint)((byte*)ptr + 8);
				}
				Log.Warning($"Ass: {Marshal.PtrToStringAnsi(ptr2, (int)ptr->size)} | label : {ptr->label:X}");
			}
		}

		public unsafe static void CopyNativeAssemblyListToManagedV2(List<StringStorageDefaultV1> managedAssemblyList, DynamicArrayData assemblyNames)
		{
			managedAssemblyList.Clear();
			ulong num = 0uL;
			StringStorageDefaultV1* ptr = (StringStorageDefaultV1*)assemblyNames.ptr;
			for (; num < assemblyNames.size; num++)
			{
				managedAssemblyList.Add(*ptr);
				ptr++;
			}
		}

		public unsafe static void AllocNativeAssemblyListFromManagedV2(List<StringStorageDefaultV1> managedAssemblyList, DynamicArrayData* assemblyNames)
		{
			StringStorageDefaultV1* ptr = (StringStorageDefaultV1*)(void*)Marshal.AllocHGlobal(Marshal.SizeOf(typeof(StringStorageDefaultV1)) * managedAssemblyList.Count);
			int i = 0;
			StringStorageDefaultV1* ptr2 = ptr;
			for (; i < managedAssemblyList.Count; i++)
			{
				*ptr2 = managedAssemblyList[i];
				ptr2++;
			}
			assemblyNames->ptr = (nint)ptr;
			assemblyNames->size = (ulong)managedAssemblyList.Count;
			assemblyNames->capacity = assemblyNames->size;
		}

		public unsafe static void PrintAssembliesV2(DynamicArrayData assemblyNames)
		{
			ulong num = 0uL;
			StringStorageDefaultV1* ptr = (StringStorageDefaultV1*)assemblyNames.ptr;
			for (; num < assemblyNames.size; num++)
			{
				nint ptr2 = ptr->data;
				if (ptr->data == 0)
				{
					ptr2 = (nint)((byte*)ptr + 8);
				}
				Log.Warning($"Ass: {Marshal.PtrToStringAnsi(ptr2, (int)ptr->size)} | label : {ptr->label:X}");
				ptr++;
			}
		}

		public unsafe static void CopyNativeAssemblyListToManagedV3(List<StringStorageDefaultV2> managedAssemblyList, DynamicArrayData assemblyNames)
		{
			managedAssemblyList.Clear();
			ulong num = 0uL;
			StringStorageDefaultV2* ptr = (StringStorageDefaultV2*)assemblyNames.ptr;
			for (; num < assemblyNames.size; num++)
			{
				managedAssemblyList.Add(*ptr);
				ptr++;
			}
		}

		public unsafe static void AddAssembliesToManagedListV3(List<StringStorageDefaultV2> managedAssemblyList, List<string> pluginAssemblyPaths)
		{
			foreach (string pluginAssemblyPath in pluginAssemblyPaths)
			{
				string? fileName = Path.GetFileName(pluginAssemblyPath);
				ulong num = (ulong)fileName.Length;
				IntPtr intPtr = Marshal.StringToHGlobalAnsi(fileName);
				byte* ptr = (byte*)(void*)intPtr + num;
				while (*ptr != 0)
				{
					ptr++;
					num++;
				}
				StringStorageDefaultV2 stringStorageDefaultV = default(StringStorageDefaultV2);
				stringStorageDefaultV.union = new StringStorageDefaultV2Union
				{
					heap = new HeapAllocatedRepresentationV2
					{
						data = intPtr,
						capacity = num,
						size = num
					}
				};
				stringStorageDefaultV.data_repr = StringRepresentation.Heap;
				stringStorageDefaultV.label = UseRightStructs.LabelMemStringId;
				StringStorageDefaultV2 item = stringStorageDefaultV;
				managedAssemblyList.Add(item);
			}
		}

		public unsafe static void AllocNativeAssemblyListFromManagedV3(List<StringStorageDefaultV2> managedAssemblyList, DynamicArrayData* assemblyNames)
		{
			StringStorageDefaultV2* ptr = (StringStorageDefaultV2*)(void*)Marshal.AllocHGlobal(Marshal.SizeOf(typeof(StringStorageDefaultV2)) * managedAssemblyList.Count);
			int i = 0;
			StringStorageDefaultV2* ptr2 = ptr;
			for (; i < managedAssemblyList.Count; i++)
			{
				*ptr2 = managedAssemblyList[i];
				ptr2++;
			}
			assemblyNames->ptr = (nint)ptr;
			assemblyNames->size = (ulong)managedAssemblyList.Count;
			assemblyNames->capacity = assemblyNames->size;
		}

		public unsafe static void PrintAssembliesV3(DynamicArrayData assemblyNames)
		{
			ulong num = 0uL;
			StringStorageDefaultV2* ptr = (StringStorageDefaultV2*)assemblyNames.ptr;
			for (; num < assemblyNames.size; num++)
			{
				if (ptr->data_repr == StringRepresentation.Embedded)
				{
					Log.Warning($"Ass: {Marshal.PtrToStringAnsi((IntPtr)ptr->union.embedded.data)} | label : {ptr->label:X}");
				}
				else
				{
					Log.Warning($"Ass: {Marshal.PtrToStringAnsi(ptr->union.heap.data, (int)ptr->union.heap.size)} | label : {ptr->label:X}");
				}
				ptr++;
			}
		}

		public unsafe static void CopyNativeAssemblyListToManagedV4(List<StringStorageDefaultV3> managedAssemblyList, DynamicArrayData assemblyNames)
		{
			managedAssemblyList.Clear();
			ulong num = 0uL;
			StringStorageDefaultV3* ptr = (StringStorageDefaultV3*)assemblyNames.ptr;
			for (; num < assemblyNames.size; num++)
			{
				managedAssemblyList.Add(*ptr);
				ptr++;
			}
		}

		public unsafe static void AddAssembliesToManagedListV4(List<StringStorageDefaultV3> managedAssemblyList, List<string> pluginAssemblyPaths)
		{
			foreach (string pluginAssemblyPath in pluginAssemblyPaths)
			{
				string? fileName = Path.GetFileName(pluginAssemblyPath);
				ulong num = (ulong)fileName.Length;
				IntPtr intPtr = Marshal.StringToHGlobalAnsi(fileName);
				byte* ptr = (byte*)(void*)intPtr + num;
				while (*ptr != 0)
				{
					ptr++;
					num++;
				}
				StringStorageDefaultV3 stringStorageDefaultV = default(StringStorageDefaultV3);
				stringStorageDefaultV.union = new StringStorageDefaultV3Union
				{
					heap = new HeapAllocatedRepresentationV3
					{
						data = intPtr,
						capacity = num,
						size = num,
						flags = new StringStorageDefaultV3Flags
						{
							IsHeap = true
						}
					}
				};
				stringStorageDefaultV.label = UseRightStructs.LabelMemStringId;
				StringStorageDefaultV3 item = stringStorageDefaultV;
				managedAssemblyList.Add(item);
			}
		}

		public unsafe static void AllocNativeAssemblyListFromManagedV4(List<StringStorageDefaultV3> managedAssemblyList, DynamicArrayData* assemblyNames)
		{
			StringStorageDefaultV3* ptr = (StringStorageDefaultV3*)(void*)Marshal.AllocHGlobal(Marshal.SizeOf(typeof(StringStorageDefaultV3)) * managedAssemblyList.Count);
			int i = 0;
			StringStorageDefaultV3* ptr2 = ptr;
			for (; i < managedAssemblyList.Count; i++)
			{
				*ptr2 = managedAssemblyList[i];
				ptr2++;
			}
			assemblyNames->ptr = (nint)ptr;
			assemblyNames->size = (ulong)managedAssemblyList.Count;
			assemblyNames->capacity = assemblyNames->size;
		}

		public unsafe static void PrintAssembliesV4(DynamicArrayData assemblyNames)
		{
			ulong num = 0uL;
			StringStorageDefaultV3* ptr = (StringStorageDefaultV3*)assemblyNames.ptr;
			for (; num < assemblyNames.size; num++)
			{
				if (ptr->union.embedded.flags.IsEmbedded)
				{
					Log.Warning($"Ass: {Marshal.PtrToStringAnsi((IntPtr)ptr->union.embedded.data)} | label : {ptr->label:X}");
				}
				else
				{
					Log.Warning($"Ass: {Marshal.PtrToStringAnsi(ptr->union.heap.data, (int)ptr->union.heap.size)} | label : {ptr->label:X}");
				}
				ptr++;
			}
		}
	}
	internal static class NativeLibraryHelper
	{
		[AttributeUsage(AttributeTargets.Field, AllowMultiple = false)]
		public class DynamicDllImportAttribute : Attribute
		{
			public string DLL;

			public string[] EntryPoints;

			public DynamicDllImportAttribute(string dll, params string[] entryPoints)
			{
				DLL = dll;
				EntryPoints = entryPoints;
			}
		}

		private static readonly IntPtr NULL = IntPtr.Zero;

		public static Dictionary<string, string> DllMap = new Dictionary<string, string>();

		private static IntPtr _EntryPoint = NULL;

		public static IntPtr EntryPoint
		{
			get
			{
				if (_EntryPoint != NULL)
				{
					return _EntryPoint;
				}
				return _EntryPoint = OpenLibrary(null);
			}
		}

		public static ulong CurrentThreadId
		{
			get
			{
				if (Environment.OSVersion.Platform == PlatformID.Win32NT)
				{
					return GetCurrentThreadId();
				}
				return 0uL;
			}
		}

		[DllImport("kernel32")]
		private static extern IntPtr GetModuleHandle(string lpModuleName);

		[DllImport("kernel32")]
		private static extern IntPtr LoadLibrary(string lpFileName);

		[DllImport("kernel32", CharSet = CharSet.Ansi, ExactSpelling = true, SetLastError = true)]
		private static extern IntPtr GetProcAddress(IntPtr hModule, string procName);

		public static IntPtr OpenLibrary(string name)
		{
			if (DllMap.TryGetValue(name, out var value))
			{
				name = value;
			}
			if (Environment.OSVersion.Platform == PlatformID.Win32NT)
			{
				IntPtr intPtr = GetModuleHandle(name);
				if (intPtr == NULL)
				{
					intPtr = LoadLibrary(name);
				}
				return intPtr;
			}
			return NULL;
		}

		public static IntPtr GetFunction(this IntPtr lib, string name)
		{
			if (lib == NULL)
			{
				return NULL;
			}
			if (Environment.OSVersion.Platform == PlatformID.Win32NT)
			{
				return GetProcAddress(lib, name);
			}
			return NULL;
		}

		public static T GetDelegate<T>(this IntPtr lib, string name) where T : class
		{
			if (lib == NULL)
			{
				return null;
			}
			IntPtr function = lib.GetFunction(name);
			if (function == NULL)
			{
				return null;
			}
			return function.AsDelegate<T>();
		}

		public static T GetDelegateAtRVA<T>(this IntPtr basea, long rva) where T : class
		{
			return new IntPtr(basea.ToInt64() + rva).AsDelegate<T>();
		}

		public static T AsDelegate<T>(this IntPtr s) where T : class
		{
			return Marshal.GetDelegateForFunctionPointer(s, typeof(T)) as T;
		}

		[DllImport("kernel32")]
		private static extern uint GetCurrentThreadId();

		public static void ResolveDynamicDllImports(this Type type)
		{
			FieldInfo[] fields = type.GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (FieldInfo fieldInfo in fields)
			{
				bool flag = true;
				object[] customAttributes = fieldInfo.GetCustomAttributes(typeof(DynamicDllImportAttribute), inherit: true);
				for (int j = 0; j < customAttributes.Length; j++)
				{
					DynamicDllImportAttribute dynamicDllImportAttribute = (DynamicDllImportAttribute)customAttributes[j];
					flag = false;
					IntPtr intPtr = OpenLibrary(dynamicDllImportAttribute.DLL);
					if (intPtr == NULL)
					{
						continue;
					}
					string[] entryPoints = dynamicDllImportAttribute.EntryPoints;
					foreach (string name in entryPoints)
					{
						IntPtr function = intPtr.GetFunction(name);
						if (!(function == NULL))
						{
							fieldInfo.SetValue(null, Marshal.GetDelegateForFunctionPointer(function, fieldInfo.FieldType));
							flag = true;
							break;
						}
					}
					if (flag)
					{
						break;
					}
				}
				if (!flag)
				{
					throw new EntryPointNotFoundException("No matching entry point found for " + fieldInfo.Name + " in " + fieldInfo.DeclaringType.FullName);
				}
			}
		}
	}
	public struct OriginalPathData
	{
		public IntPtr thisRef;

		public IntPtr thisDataRef;

		public ulong size;

		public OriginalPathData(IntPtr thisRef, IntPtr thisDataRef, ulong size)
		{
			this.thisRef = thisRef;
			this.thisDataRef = thisDataRef;
			this.size = size;
		}
	}
	internal class PatternDiscover
	{
		public static IntPtr Discover(IntPtr unityModule, int moduleSize, MiniPdbReader pdbReader, ConfigEntry<string> functionOffsetCache, BytePattern[] pdbPatterns, BytePattern[] sigPatterns)
		{
			if (pdbReader.IsPdbAvailable)
			{
				return DiscoverWithPdb(unityModule, pdbReader, functionOffsetCache, pdbPatterns);
			}
			return DiscoverWithSig(unityModule, moduleSize, sigPatterns);
		}

		public static IntPtr DiscoverWithPdb(IntPtr unityModule, MiniPdbReader pdbReader, ConfigEntry<string> functionOffsetCache, BytePattern[] pdbPatterns)
		{
			IntPtr intPtr;
			if (pdbReader.UseCache)
			{
				intPtr = new IntPtr(Convert.ToInt64(functionOffsetCache.Value, 16));
				if (intPtr == IntPtr.Zero)
				{
					return intPtr;
				}
			}
			else
			{
				intPtr = pdbReader.FindFunctionOffset(pdbPatterns);
				if (intPtr == IntPtr.Zero)
				{
					functionOffsetCache.Value = "00";
					return intPtr;
				}
				functionOffsetCache.Value = intPtr.ToString("X");
			}
			return (IntPtr)(unityModule.ToInt64() + intPtr.ToInt64());
		}

		public unsafe static IntPtr DiscoverWithSig(IntPtr unityModule, int moduleSize, BytePattern[] sigPatterns)
		{
			var anon = sigPatterns.Select((BytePattern p) => new
			{
				p = p,
				res = p.Match(unityModule, moduleSize)
			}).FirstOrDefault(m => m.res > 0);
			if (anon == null)
			{
				return IntPtr.Zero;
			}
			byte* ptr = (byte*)unityModule.ToPointer();
			Log.Info($"Found at {anon.res:X} ({unityModule.ToInt64() + anon.res:X})");
			long num = unityModule.ToInt64() + anon.res;
			if (anon.p.IsE8)
			{
				int num2 = *(int*)(unityModule.ToInt64() + anon.res + 1);
				Log.Info($"Parsed e8_offset: {num2:X}");
				num = num + 5 + num2;
			}
			Log.Info($"memory address: {num:X} (image base: {unityModule.ToInt64():X})");
			return new IntPtr(num);
		}
	}
	internal class PeReader
	{
		public struct IMAGE_DOS_HEADER
		{
			public ushort e_magic;

			public ushort e_cblp;

			public ushort e_cp;

			public ushort e_crlc;

			public ushort e_cparhdr;

			public ushort e_minalloc;

			public ushort e_maxalloc;

			public ushort e_ss;

			public ushort e_sp;

			public ushort e_csum;

			public ushort e_ip;

			public ushort e_cs;

			public ushort e_lfarlc;

			public ushort e_ovno;

			public ushort e_res_0;

			public ushort e_res_1;

			public ushort e_res_2;

			public ushort e_res_3;

			public ushort e_oemid;

			public ushort e_oeminfo;

			public ushort e_res2_0;

			public ushort e_res2_1;

			public ushort e_res2_2;

			public ushort e_res2_3;

			public ushort e_res2_4;

			public ushort e_res2_5;

			public ushort e_res2_6;

			public ushort e_res2_7;

			public ushort e_res2_8;

			public ushort e_res2_9;

			public uint e_lfanew;
		}

		public struct IMAGE_DATA_DIRECTORY
		{
			public uint VirtualAddress;

			public uint Size;
		}

		[StructLayout(LayoutKind.Sequential, Pack = 1)]
		public struct IMAGE_OPTIONAL_HEADER32
		{
			public ushort Magic;

			public byte MajorLinkerVersion;

			public byte MinorLinkerVersion;

			public uint SizeOfCode;

			public uint SizeOfInitializedData;

			public uint SizeOfUninitializedData;

			public uint AddressOfEntryPoint;

			public uint BaseOfCode;

			public uint BaseOfData;

			public uint ImageBase;

			public uint SectionAlignment;

			public uint FileAlignment;

			public ushort MajorOperatingSystemVersion;

			public ushort MinorOperatingSystemVersion;

			public ushort MajorImageVersion;

			public ushort MinorImageVersion;

			public ushort MajorSubsystemVersion;

			public ushort MinorSubsystemVersion;

			public uint Win32VersionValue;

			public uint SizeOfImage;

			public uint SizeOfHeaders;

			public uint CheckSum;

			public ushort Subsystem;

			public ushort DllCharacteristics;

			public uint SizeOfStackReserve;

			public uint SizeOfStackCommit;

			public uint SizeOfHeapReserve;

			public uint SizeOfHeapCommit;

			public uint LoaderFlags;

			public uint NumberOfRvaAndSizes;

			public IMAGE_DATA_DIRECTORY ExportTable;

			public IMAGE_DATA_DIRECTORY ImportTable;

			public IMAGE_DATA_DIRECTORY ResourceTable;

			public IMAGE_DATA_DIRECTORY ExceptionTable;

			public IMAGE_DATA_DIRECTORY CertificateTable;

			public IMAGE_DATA_DIRECTORY BaseRelocationTable;

			public IMAGE_DATA_DIRECTORY Debug;

			public IMAGE_DATA_DIRECTORY Architecture;

			public IMAGE_DATA_DIRECTORY GlobalPtr;

			public IMAGE_DATA_DIRECTORY TLSTable;

			public IMAGE_DATA_DIRECTORY LoadConfigTable;

			public IMAGE_DATA_DIRECTORY BoundImport;

			public IMAGE_DATA_DIRECTORY IAT;

			public IMAGE_DATA_DIRECTORY DelayImportDescriptor;

			public IMAGE_DATA_DIRECTORY CLRRuntimeHeader;

			public IMAGE_DATA_DIRECTORY Reserved;
		}

		[StructLayout(LayoutKind.Sequential, Pack = 1)]
		public struct IMAGE_OPTIONAL_HEADER64
		{
			public ushort Magic;

			public byte MajorLinkerVersion;

			public byte MinorLinkerVersion;

			public uint SizeOfCode;

			public uint SizeOfInitializedData;

			public uint SizeOfUninitializedData;

			public uint AddressOfEntryPoint;

			public uint BaseOfCode;

			public ulong ImageBase;

			public uint SectionAlignment;

			public uint FileAlignment;

			public ushort MajorOperatingSystemVersion;

			public ushort MinorOperatingSystemVersion;

			public ushort MajorImageVersion;

			public ushort MinorImageVersion;

			public ushort MajorSubsystemVersion;

			public ushort MinorSubsystemVersion;

			public uint Win32VersionValue;

			public uint SizeOfImage;

			public uint SizeOfHeaders;

			public uint CheckSum;

			public ushort Subsystem;

			public ushort DllCharacteristics;

			public ulong SizeOfStackReserve;

			public ulong SizeOfStackCommit;

			public ulong SizeOfHeapReserve;

			public ulong SizeOfHeapCommit;

			public uint LoaderFlags;

			public uint NumberOfRvaAndSizes;

			public IMAGE_DATA_DIRECTORY ExportTable;

			public IMAGE_DATA_DIRECTORY ImportTable;

			public IMAGE_DATA_DIRECTORY ResourceTable;

			public IMAGE_DATA_DIRECTORY ExceptionTable;

			public IMAGE_DATA_DIRECTORY CertificateTable;

			public IMAGE_DATA_DIRECTORY BaseRelocationTable;

			public IMAGE_DATA_DIRECTORY Debug;

			public IMAGE_DATA_DIRECTORY Architecture;

			public IMAGE_DATA_DIRECTORY GlobalPtr;

			public IMAGE_DATA_DIRECTORY TLSTable;

			public IMAGE_DATA_DIRECTORY LoadConfigTable;

			public IMAGE_DATA_DIRECTORY BoundImport;

			public IMAGE_DATA_DIRECTORY IAT;

			public IMAGE_DATA_DIRECTORY DelayImportDescriptor;

			public IMAGE_DATA_DIRECTORY CLRRuntimeHeader;

			public IMAGE_DATA_DIRECTORY Reserved;
		}

		[StructLayout(LayoutKind.Sequential, Pack = 1)]
		public struct IMAGE_FILE_HEADER
		{
			public ushort Machine;

			public ushort NumberOfSections;

			public uint TimeDateStamp;

			public uint PointerToSymbolTable;

			public uint NumberOfSymbols;

			public ushort SizeOfOptionalHeader;

			public ushort Characteristics;
		}

		[StructLayout(LayoutKind.Explicit)]
		public struct IMAGE_SECTION_HEADER
		{
			[FieldOffset(0)]
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
			public string Name;

			[FieldOffset(8)]
			public uint VirtualSize;

			[FieldOffset(12)]
			public uint VirtualAddress;

			[FieldOffset(16)]
			public uint SizeOfRawData;

			[FieldOffset(20)]
			public uint PointerToRawData;

			[FieldOffset(24)]
			public uint PointerToRelocations;

			[FieldOffset(28)]
			public uint PointerToLinenumbers;

			[FieldOffset(32)]
			public ushort NumberOfRelocations;

			[FieldOffset(34)]
			public ushort NumberOfLinenumbers;

			[FieldOffset(36)]
			public DataSectionFlags Characteristics;
		}

		[Flags]
		public enum DataSectionFlags : uint
		{
			TypeReg = 0u,
			TypeDsect = 1u,
			TypeNoLoad = 2u,
			TypeGroup = 4u,
			TypeNoPadded = 8u,
			TypeCopy = 0x10u,
			ContentCode = 0x20u,
			ContentInitializedData = 0x40u,
			ContentUninitializedData = 0x80u,
			LinkOther = 0x100u,
			LinkInfo = 0x200u,
			TypeOver = 0x400u,
			LinkRemove = 0x800u,
			LinkComDat = 0x1000u,
			NoDeferSpecExceptions = 0x4000u,
			RelativeGP = 0x8000u,
			MemPurgeable = 0x20000u,
			Memory16Bit = 0x20000u,
			MemoryLocked = 0x40000u,
			MemoryPreload = 0x80000u,
			Align1Bytes = 0x100000u,
			Align2Bytes = 0x200000u,
			Align4Bytes = 0x300000u,
			Align8Bytes = 0x400000u,
			Align16Bytes = 0x500000u,
			Align32Bytes = 0x600000u,
			Align64Bytes = 0x700000u,
			Align128Bytes = 0x800000u,
			Align256Bytes = 0x900000u,
			Align512Bytes = 0xA00000u,
			Align1024Bytes = 0xB00000u,
			Align2048Bytes = 0xC00000u,
			Align4096Bytes = 0xD00000u,
			Align8192Bytes = 0xE00000u,
			LinkExtendedRelocationOverflow = 0x1000000u,
			MemoryDiscardable = 0x2000000u,
			MemoryNotCached = 0x4000000u,
			MemoryNotPaged = 0x8000000u,
			MemoryShared = 0x10000000u,
			MemoryExecute = 0x20000000u,
			MemoryRead = 0x40000000u,
			MemoryWrite = 0x80000000u
		}

		public struct IMAGE_DEBUG_DIRECTORY
		{
			public enum _Type : uint
			{
				IMAGE_DEBUG_TYPE_UNKNOWN,
				IMAGE_DEBUG_TYPE_COFF,
				IMAGE_DEBUG_TYPE_CODEVIEW,
				IMAGE_DEBUG_TYPE_FPO,
				IMAGE_DEBUG_TYPE_MISC,
				IMAGE_DEBUG_TYPE_EXCEPTION,
				IMAGE_DEBUG_TYPE_FIXUP,
				IMAGE_DEBUG_TYPE_OMAP_TO_SRC,
				IMAGE_DEBUG_TYPE_OMAP_FROM_SRC,
				IMAGE_DEBUG_TYPE_BORLAND,
				IMAGE_DEBUG_TYPE_RESERVED10,
				IMAGE_DEBUG_TYPE_CLSID,
				IMAGE_DEBUG_TYPE_VC_FEATURE,
				IMAGE_DEBUG_TYPE_POGO,
				IMAGE_DEBUG_TYPE_ILTCG,
				IMAGE_DEBUG_TYPE_MPX,
				IMAGE_DEBUG_TYPE_REPRO
			}

			public uint Characteristics;

			public uint TimeDateStamp;

			public ushort MajorVersion;

			public ushort MinorVersion;

			public _Type Type;

			public uint SizeOfData;

			public uint AddressOfRawData;

			public uint PointerToRawData;
		}

		public struct RSDS
		{
			internal const int Magic = 1396986706;

			[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
			internal byte[] Guid;

			internal uint Age;
		}

		private IMAGE_DOS_HEADER dosHeader;

		private IMAGE_FILE_HEADER fileHeader;

		private IMAGE_OPTIONAL_HEADER32 optionalHeader32;

		private IMAGE_OPTIONAL_HEADER64 optionalHeader64;

		private IMAGE_DEBUG_DIRECTORY? imageDebugDirectory;

		private string rsdsPdbFileName;

		private string pdbGuid;

		private readonly IMAGE_SECTION_HEADER[] imageSectionHeaders;

		public bool Is32BitHeader
		{
			get
			{
				ushort num = 256;
				return (num & FileHeader.Characteristics) == num;
			}
		}

		public IMAGE_FILE_HEADER FileHeader => fileHeader;

		public IMAGE_OPTIONAL_HEADER32 OptionalHeader32 => optionalHeader32;

		public IMAGE_OPTIONAL_HEADER64 OptionalHeader64 => optionalHeader64;

		public IMAGE_DEBUG_DIRECTORY? ImageDebugDirectory => imageDebugDirectory;

		public IMAGE_SECTION_HEADER[] ImageSectionHeaders => imageSectionHeaders;

		public string RsdsPdbFileName => rsdsPdbFileName;

		public string PdbGuid => pdbGuid;

		public DateTime TimeStamp
		{
			get
			{
				DateTime dateTime = new DateTime(1970, 1, 1, 0, 0, 0).AddSeconds(fileHeader.TimeDateStamp);
				return dateTime + TimeZone.CurrentTimeZone.GetUtcOffset(dateTime);
			}
		}

		public PeReader(string filePath)
		{
			using FileStream fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
			BinaryReader binaryReader = new BinaryReader(fileStream);
			dosHeader = FromBinaryReader<IMAGE_DOS_HEADER>(binaryReader);
			fileStream.Seek(dosHeader.e_lfanew, SeekOrigin.Begin);
			binaryReader.ReadUInt32();
			fileHeader = FromBinaryReader<IMAGE_FILE_HEADER>(binaryReader);
			uint virtualAddress;
			if (Is32BitHeader)
			{
				optionalHeader32 = FromBinaryReader<IMAGE_OPTIONAL_HEADER32>(binaryReader);
				virtualAddress = optionalHeader32.Debug.VirtualAddress;
			}
			else
			{
				optionalHeader64 = FromBinaryReader<IMAGE_OPTIONAL_HEADER64>(binaryReader);
				virtualAddress = optionalHeader64.Debug.VirtualAddress;
			}
			imageSectionHeaders = new IMAGE_SECTION_HEADER[fileHeader.NumberOfSections];
			for (int i = 0; i < imageSectionHeaders.Length; i++)
			{
				IMAGE_SECTION_HEADER imageSectionHeader = FromBinaryReader<IMAGE_SECTION_HEADER>(binaryReader);
				imageSectionHeaders[i] = imageSectionHeader;
				if (!imageDebugDirectory.HasValue)
				{
					imageDebugDirectory = TryGetDebugDirectory(binaryReader, virtualAddress, ref imageSectionHeader);
				}
			}
			if (imageDebugDirectory.HasValue)
			{
				TryGetRSDS(binaryReader);
			}
		}

		private IMAGE_DEBUG_DIRECTORY? TryGetDebugDirectory(BinaryReader reader, uint debugRva, ref IMAGE_SECTION_HEADER imageSectionHeader)
		{
			uint num = ((imageSectionHeader.VirtualSize != 0) ? imageSectionHeader.VirtualSize : imageSectionHeader.SizeOfRawData);
			if (debugRva >= imageSectionHeader.VirtualAddress && debugRva < imageSectionHeader.VirtualAddress + num)
			{
				long position = reader.BaseStream.Position;
				uint num2 = debugRva - imageSectionHeader.VirtualAddress + imageSectionHeader.PointerToRawData;
				reader.BaseStream.Position = num2;
				IMAGE_DEBUG_DIRECTORY value = FromBinaryReader<IMAGE_DEBUG_DIRECTORY>(reader);
				reader.BaseStream.Position = position;
				return value;
			}
			return null;
		}

		private void TryGetRSDS(BinaryReader reader)
		{
			var anon = new
			{
				RSDSFileOffset = ImageDebugDirectory.Value.PointerToRawData,
				Size = ImageDebugDirectory.Value.SizeOfData
			};
			reader.BaseStream.Position = anon.RSDSFileOffset;
			long num = anon.RSDSFileOffset + anon.Size;
			while (reader.BaseStream.Position != num)
			{
				if (reader.ReadInt32() != 1396986706)
				{
					continue;
				}
				GCHandle gCHandle = GCHandle.Alloc(reader.ReadBytes(Marshal.SizeOf<RSDS>()), GCHandleType.Pinned);
				try
				{
					RSDS rSDS = Marshal.PtrToStructure<RSDS>(gCHandle.AddrOfPinnedObject());
					pdbGuid = new Guid(rSDS.Guid).ToString("N").ToUpperInvariant() + rSDS.Age;
					List<byte> list = new List<byte>();
					bool flag = true;
					while (flag)
					{
						byte b = reader.ReadByte();
						if (b != 0)
						{
							list.Add(b);
						}
						else
						{
							flag = false;
						}
					}
					rsdsPdbFileName = Path.GetFileName(Encoding.Default.GetString(list.ToArray()));
					break;
				}
				finally
				{
					gCHandle.Free();
				}
			}
		}

		public static PeReader GetCallingAssemblyHeader()
		{
			return new PeReader(Assembly.GetCallingAssembly().Location);
		}

		public static PeReader GetAssemblyHeader()
		{
			return new PeReader(Assembly.GetAssembly(typeof(PeReader)).Location);
		}

		public static T FromBinaryReader<T>(BinaryReader reader)
		{
			GCHandle gCHandle = GCHandle.Alloc(reader.ReadBytes(Marshal.SizeOf(typeof(T))), GCHandleType.Pinned);
			T result = (T)Marshal.PtrToStructure(gCHandle.AddrOfPinnedObject(), typeof(T));
			gCHandle.Free();
			return result;
		}
	}
	internal static class Polyfills
	{
		public static bool StringIsNullOrWhiteSpace(string value)
		{
			return string.IsNullOrWhiteSpace(value);
		}

		public static Version VersionParse(string input)
		{
			return Version.Parse(input);
		}
	}
	internal static class StringExtensions
	{
		public static string Format(this string fmt, Dictionary<string, Func<string>> vars)
		{
			return vars.Aggregate(fmt, (string str, KeyValuePair<string, Func<string>> kv) => str.Replace("{" + kv.Key + "}", kv.Value()));
		}

		public static byte?[] ParseHexBytes(this string str)
		{
			List<byte?> list = new List<byte?>();
			StringReader stringReader = new StringReader(str);
			while (stringReader.Peek() > 0)
			{
				char c = char.ToLower((char)stringReader.Read());
				if (char.IsWhiteSpace(c))
				{
					continue;
				}
				switch (c)
				{
				case ';':
					stringReader.ReadLine();
					continue;
				case '?':
					list.Add(null);
					stringReader.Read();
					continue;
				}
				if (IsHexChar(c) && stringReader.Peek() > 0)
				{
					char c2 = char.ToLower((char)stringReader.Peek());
					if (IsHexChar(c2))
					{
						stringReader.Read();
						list.Add(byte.Parse($"{c}{c2}", NumberStyles.HexNumber));
					}
				}
			}
			return list.ToArray();
			static bool IsHexChar(char lowerC)
			{
				if ('0' > lowerC || lowerC > '9')
				{
					if ('a' <= lowerC)
					{
						return lowerC <= 'f';
					}
					return false;
				}
				return true;
			}
		}
	}
	public struct VersionedHandler
	{
		public Version version;

		public object handler;

		public VersionedHandler(Version version, object handler)
		{
			this.version = version;
			this.handler = handler;
		}
	}
}
namespace FixPluginTypesSerialization.UnityPlayer
{
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = false)]
	internal class ApplicableToUnityVersionsSinceAttribute : Attribute
	{
		public string StartVersion { get; }

		public ApplicableToUnityVersionsSinceAttribute(string startVersion)
		{
			StartVersion = startVersion;
		}
	}
	public static class UseRightStructs
	{
		private static readonly Type[] InterfacesOfInterest;

		private static readonly Dictionary<Type, List<VersionedHandler>> VersionedHandlers;

		private static readonly Dictionary<Type, object> CurrentHandlers;

		private static Version _unityVersion;

		public static Version UnityVersion
		{
			get
			{
				if (_unityVersion == null)
				{
					InitializeUnityVersion();
				}
				return _unityVersion;
			}
		}

		public static int LabelMemStringId { get; private set; }

		private static void InitializeUnityVersion()
		{
			if (!Polyfills.StringIsNullOrWhiteSpace(Config.UnityVersionOverride.Value))
			{
				if (TryInitializeUnityVersion(Config.UnityVersionOverride.Value))
				{
					Log.Debug("Unity version obtained from config file");
					return;
				}
				Log.Error("Unity version " + Config.UnityVersionOverride.Value + " has incorrect format.");
			}
			if (TryInitializeUnityVersion(Process.GetCurrentProcess().MainModule.FileVersionInfo.FileVersion))
			{
				Log.Debug("Unity version obtained from main application module.");
			}
			else
			{
				Log.Error("Running under default Unity version. UnityVersionHandler is not initialized.");
			}
		}

		private static bool TryInitializeUnityVersion(string version)
		{
			try
			{
				if (Polyfills.StringIsNullOrWhiteSpace(version))
				{
					return false;
				}
				string[] array = version.Split('.');
				int result = 0;
				int result2 = 0;
				int result3 = 0;
				bool flag = int.TryParse(array[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out result);
				if (flag && array.Length > 1)
				{
					flag = int.TryParse(array[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out result2);
				}
				if (flag && array.Length > 2)
				{
					flag = int.TryParse(array[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out result3);
				}
				if (!flag)
				{
					Log.Error("Failed to parse Unity version: " + version);
					return false;
				}
				_unityVersion = new Version(result, result2, result3);
				Log.Info($"Running under Unity v{UnityVersion}");
				return true;
			}
			catch (Exception arg)
			{
				Log.Error($"Failed to parse Unity version: {arg}");
				return false;
			}
		}

		static UseRightStructs()
		{
			VersionedHandlers = new Dictionary<Type, List<VersionedHandler>>();
			CurrentHandlers = new Dictionary<Type, object>();
			Type[] allTypesSafe = GetAllTypesSafe();
			InterfacesOfInterest = allTypesSafe.Where((Type t) => t.IsInterface && typeof(INativeStruct).IsAssignableFrom(t) && t != typeof(INativeStruct)).ToArray();
			Type[] interfacesOfInterest = InterfacesOfInterest;
			foreach (Type key in interfacesOfInterest)
			{
				VersionedHandlers[key] = new List<VersionedHandler>();
			}
			foreach (Type item in allTypesSafe.Where((Type t) => !t.IsAbstract && InterfacesOfInterest.Any((Type i) => i.IsAssignableFrom(t))))
			{
				foreach (ApplicableToUnityVersionsSinceAttribute customAttribute in item.GetCustomAttributes<ApplicableToUnityVersionsSinceAttribute>())
				{
					object handler = Activator.CreateInstance(item);
					interfacesOfInterest = item.GetInterfaces();
					foreach (Type type in interfacesOfInterest)
					{
						if (InterfacesOfInterest.Contains(type))
						{
							VersionedHandlers[type].Add(new VersionedHandler(Polyfills.VersionParse(customAttribute.StartVersion), handler));
						}
					}
				}
			}
			foreach (List<VersionedHandler> value in VersionedHandlers.Values)
			{
				value.Sort((VersionedHandler a, VersionedHandler b) => -a.version.CompareTo(b.version));
			}
			GatherUnityVersionSpecificHandlers();
			SetUnityVersionSpecificMemStringId();
		}

		private static void GatherUnityVersionSpecificHandlers()
		{
			CurrentHandlers.Clear();
			Type[] interfacesOfInterest = InterfacesOfInterest;
			foreach (Type key in interfacesOfInterest)
			{
				foreach (var (version2, value) in VersionedHandlers[key])
				{
					if (!(version2 > UnityVersion))
					{
						CurrentHandlers[key] = value;
						break;
					}
				}
			}
		}

		private static T GetHandler<T>()
		{
			if (CurrentHandlers.TryGetValue(typeof(T), out var value))
			{
				return (T)value;
			}
			Log.Error($"No direct for {typeof(T).FullName} found for Unity {UnityVersion}; this likely indicates a severe error somewhere");
			throw new ApplicationException("No handler");
		}

		private static Type[] GetAllTypesSafe()
		{
			try
			{
				return typeof(UseRightStructs).Assembly.GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				return ex.Types.Where((Type t) => t != null).ToArray();
			}
		}

		internal static T GetStruct<T>(IntPtr ptr) where T : INativeStruct
		{
			if (ptr == IntPtr.Zero)
			{
				throw new ArgumentNullException("ptr");
			}
			T handler = GetHandler<T>();
			handler.Pointer = ptr;
			return handler;
		}

		private static void SetUnityVersionSpecificMemStringId()
		{
			if (UnityVersion >= new Version(2023, 1))
			{
				LabelMemStringId = 9;
			}
			else if (UnityVersion >= new Version(2021, 1))
			{
				LabelMemStringId = 73;
			}
			else if (UnityVersion >= new Version(2020, 2))
			{
				LabelMemStringId = 43;
			}
			else if (UnityVersion >= new Version(2020, 1))
			{
				LabelMemStringId = 42;
			}
			else if (UnityVersion >= new Version(2019, 4))
			{
				LabelMemStringId = 43;
			}
			else if (UnityVersion >= new Version(2019, 3))
			{
				LabelMemStringId = 42;
			}
			else if (UnityVersion >= new Version(2019, 1))
			{
				LabelMemStringId = 43;
			}
			else if (UnityVersion >= new Version(2018, 3))
			{
				LabelMemStringId = 69;
			}
			else if (UnityVersion >= new Version(2017, 2))
			{
				LabelMemStringId = 68;
			}
			else
			{
				LabelMemStringId = 66;
			}
		}
	}
}
namespace FixPluginTypesSerialization.UnityPlayer.Structs.v2023.v1
{
	[ApplicableToUnityVersionsSince("2023.1.0")]
	public class MonoManager : IMonoManager, INativeStruct
	{
		private ScriptingAssemblies _originalScriptingAssemblies;

		public List<StringStorageDefaultV3> ManagedAssemblyList = new List<StringStorageDefaultV3>();

		public IntPtr Pointer
		{
			get
			{
				return CommonUnityFunctions.ScriptingAssemblies;
			}
			set
			{
			}
		}

		private unsafe RuntimeStatic<ScriptingAssemblies>* _this => (RuntimeStatic<ScriptingAssemblies>*)(void*)Pointer;

		public int AssemblyCount => ManagedAssemblyList.Count;

		public MonoManager()
		{
		}

		public MonoManager(IntPtr pointer)
		{
		}

		public unsafe void CopyNativeAssemblyListToManaged()
		{
			MonoManagerCommon.CopyNativeAssemblyListToManagedV4(ManagedAssemblyList, _this->value->names);
		}

		public void AddAssembliesToManagedList(List<string> pluginAssemblyPaths)
		{
			MonoManagerCommon.AddAssembliesToManagedListV4(ManagedAssemblyList, pluginAssemblyPaths);
		}

		public unsafe void AllocNativeAssemblyListFromManaged()
		{
			MonoManagerCommon.AllocNativeAssemblyListFromManagedV4(ManagedAssemblyList, &_this->value->names);
		}

		public unsafe void PrintAssemblies()
		{
			MonoManagerCommon.PrintAssembliesV4(_this->value->names);
		}

		public unsafe void RestoreOriginalAssemblyNamesArrayPtr()
		{
			*_this->value = _originalScriptingAssemblies;
		}
	}
	[ApplicableToUnityVersionsSince("2023.1.0")]
	public class RelativePathString : IRelativePathString, INativeStruct
	{
		public IntPtr Pointer { get; set; }

		private unsafe StringStorageDefaultV3* _this => (StringStorageDefaultV3*)(void*)Pointer;

		public RelativePathString()
		{
		}

		public RelativePathString(IntPtr pointer)
		{
			Pointer = pointer;
		}

		public unsafe void FixAbsolutePath()
		{
			if (!_this->union.embedded.flags.IsEmbedded && (_this->union.heap.data == 0 || _this->union.heap.size == 0L))
			{
				return;
			}
			string fileName = Path.GetFileName(_this->union.embedded.flags.IsEmbedded ? Marshal.PtrToStringAnsi((IntPtr)_this->union.embedded.data) : Marshal.PtrToStringAnsi(_this->union.heap.data, (int)_this->union.heap.size));
			int num = FixPluginTypesSerializationPatcher.PluginNames.IndexOf(fileName);
			if (num != -1)
			{
				ulong length;
				IntPtr data = CommonUnityFunctions.MallocString(FixPluginTypesSerializationPatcher.PluginPaths[num], UseRightStructs.LabelMemStringId, out length);
				if (!_this->union.embedded.flags.IsEmbedded)
				{
					CommonUnityFunctions.FreeAllocInternal(_this->union.heap.data, _this->label);
				}
				StringStorageDefaultV3* @this = _this;
				@this->union = new StringStorageDefaultV3Union
				{
					heap = new HeapAllocatedRepresentationV3
					{
						data = data,
						capacity = length,
						size = length,
						flags = new StringStorageDefaultV3Flags
						{
							IsHeap = true
						}
					}
				};
				@this->label = UseRightStructs.LabelMemStringId;
			}
		}

		public unsafe string ToStringAnsi()
		{
			if (!_this->union.embedded.flags.IsEmbedded && (_this->union.heap.data == 0 || _this->union.heap.size == 0L))
			{
				return null;
			}
			if (_this->union.embedded.flags.IsEmbedded)
			{
				return Marshal.PtrToStringAnsi((IntPtr)_this->union.embedded.data);
			}
			return Marshal.PtrToStringAnsi(_this->union.heap.data, (int)_this->union.heap.size);
		}
	}
}
namespace FixPluginTypesSerialization.UnityPlayer.Structs.v2021.v1
{
	[ApplicableToUnityVersionsSince("2021.1.0")]
	public class MonoManager : IMonoManager, INativeStruct
	{
		private ScriptingAssemblies _originalScriptingAssemblies;

		public List<StringStorageDefaultV2> ManagedAssemblyList = new List<StringStorageDefaultV2>();

		public IntPtr Pointer
		{
			get
			{
				return CommonUnityFunctions.ScriptingAssemblies;
			}
			set
			{
			}
		}

		private unsafe RuntimeStatic<ScriptingAssemblies>* _this => (RuntimeStatic<ScriptingAssemblies>*)(void*)Pointer;

		public int AssemblyCount => ManagedAssemblyList.Count;

		public MonoManager()
		{
		}

		public MonoManager(IntPtr pointer)
		{
		}

		public unsafe void CopyNativeAssemblyListToManaged()
		{
			MonoManagerCommon.CopyNativeAssemblyListToManagedV3(ManagedAssemblyList, _this->value->names);
		}

		public void AddAssembliesToManagedList(List<string> pluginAssemblyPaths)
		{
			MonoManagerCommon.AddAssembliesToManagedListV3(ManagedAssemblyList, pluginAssemblyPaths);
		}

		public unsafe void AllocNativeAssemblyListFromManaged()
		{
			MonoManagerCommon.AllocNativeAssemblyListFromManagedV3(ManagedAssemblyList, &_this->value->names);
		}

		public unsafe void PrintAssemblies()
		{
			MonoManagerCommon.PrintAssembliesV3(_this->value->names);
		}

		public unsafe void RestoreOriginalAssemblyNamesArrayPtr()
		{
			*_this->value = _originalScriptingAssemblies;
		}
	}
	[ApplicableToUnityVersionsSince("2021.1.0")]
	public class RelativePathString : IRelativePathString, INativeStruct
	{
		public IntPtr Pointer { get; set; }

		private unsafe StringStorageDefaultV2* _this => (StringStorageDefaultV2*)(void*)Pointer;

		public RelativePathString()
		{
		}

		public RelativePathString(IntPtr pointer)
		{
			Pointer = pointer;
		}

		public unsafe void FixAbsolutePath()
		{
			if (_this->data_repr != StringRepresentation.Embedded && (_this->union.heap.data == 0 || _this->union.heap.size == 0L))
			{
				return;
			}
			string path = ((_this->data_repr != StringRepresentation.Embedded) ? Marshal.PtrToStringAnsi(_this->union.heap.data, (int)_this->union.heap.size) : Marshal.PtrToStringAnsi((IntPtr)_this->union.embedded.data));
			string fileName = Path.GetFileName(path);
			int num = FixPluginTypesSerializationPatcher.PluginNames.IndexOf(fileName);
			if (num != -1)
			{
				ulong length;
				IntPtr data = CommonUnityFunctions.MallocString(FixPluginTypesSerializationPatcher.PluginPaths[num], UseRightStructs.LabelMemStringId, out length);
				if (_this->data_repr != StringRepresentation.Embedded)
				{
					CommonUnityFunctions.FreeAllocInternal(_this->union.heap.data, _this->label);
				}
				StringStorageDefaultV2* @this = _this;
				@this->union = new StringStorageDefaultV2Union
				{
					heap = new HeapAllocatedRepresentationV2
					{
						data = data,
						capacity = length,
						size = length
					}
				};
				@this->data_repr = StringRepresentation.Heap;
				@this->label = UseRightStructs.LabelMemStringId;
			}
		}

		public unsafe string ToStringAnsi()
		{
			if (_this->data_repr != StringRepresentation.Embedded && (_this->union.heap.data == 0 || _this->union.heap.size == 0L))
			{
				return null;
			}
			if (_this->data_repr == StringRepresentation.Embedded)
			{
				return Marshal.PtrToStringAnsi((IntPtr)_this->union.embedded.data);
			}
			return Marshal.PtrToStringAnsi(_this->union.heap.data, (int)_this->union.heap.size);
		}
	}
}
namespace FixPluginTypesSerialization.UnityPlayer.Structs.v2020.v2
{
	[ApplicableToUnityVersionsSince("2020.2.0")]
	public class MonoManager : IMonoManager, INativeStruct
	{
		private ScriptingAssemblies _originalScriptingAssemblies;

		public List<StringStorageDefaultV1> ManagedAssemblyList = new List<StringStorageDefaultV1>();

		public IntPtr Pointer
		{
			get
			{
				return CommonUnityFunctions.ScriptingAssemblies;
			}
			set
			{
			}
		}

		private unsafe RuntimeStatic<ScriptingAssemblies>* _this => (RuntimeStatic<ScriptingAssemblies>*)(void*)Pointer;

		public int AssemblyCount => ManagedAssemblyList.Count;

		public MonoManager()
		{
		}

		public MonoManager(IntPtr pointer)
		{
		}

		public unsafe void CopyNativeAssemblyListToManaged()
		{
			MonoManagerCommon.CopyNativeAssemblyListToManagedV2(ManagedAssemblyList, _this->value->names);
		}

		public void AddAssembliesToManagedList(List<string> pluginAssemblyPaths)
		{
			MonoManagerCommon.AddAssembliesToManagedListV1(ManagedAssemblyList, pluginAssemblyPaths);
		}

		public unsafe void AllocNativeAssemblyListFromManaged()
		{
			MonoManagerCommon.AllocNativeAssemblyListFromManagedV2(ManagedAssemblyList, &_this->value->names);
		}

		public unsafe void PrintAssemblies()
		{
			MonoManagerCommon.PrintAssembliesV2(_this->value->names);
		}

		public unsafe void RestoreOriginalAssemblyNamesArrayPtr()
		{
			*_this->value = _originalScriptingAssemblies;
		}
	}
}
namespace FixPluginTypesSerialization.UnityPlayer.Structs.v2020.v1
{
	[StructLayout(LayoutKind.Explicit)]
	public struct MonoManagerStruct
	{
		[FieldOffset(448)]
		public DynamicArrayData m_AssemblyNames;
	}
	[ApplicableToUnityVersionsSince("2020.1.0")]
	public class MonoManager : IMonoManager, INativeStruct
	{
		private DynamicArrayData _originalAssemblyNames;

		public List<StringStorageDefaultV1> ManagedAssemblyList = new List<StringStorageDefaultV1>();

		public IntPtr Pointer { get; set; }

		private unsafe MonoManagerStruct* _this => (MonoManagerStruct*)(void*)Pointer;

		public int AssemblyCount => ManagedAssemblyList.Count;

		public MonoManager()
		{
		}

		public MonoManager(IntPtr pointer)
		{
			Pointer = pointer;
		}

		public unsafe void CopyNativeAssemblyListToManaged()
		{
			MonoManagerCommon.CopyNativeAssemblyListToManagedV2(ManagedAssemblyList, _this->m_AssemblyNames);
		}

		public void AddAssembliesToManagedList(List<string> pluginAssemblyPaths)
		{
			MonoManagerCommon.AddAssembliesToManagedListV1(ManagedAssemblyList, pluginAssemblyPaths);
		}

		public unsafe void AllocNativeAssemblyListFromManaged()
		{
			_originalAssemblyNames = _this->m_AssemblyNames;
			MonoManagerCommon.AllocNativeAssemblyListFromManagedV2(ManagedAssemblyList, &_this->m_AssemblyNames);
		}

		public unsafe void PrintAssemblies()
		{
			MonoManagerCommon.PrintAssembliesV2(_this->m_AssemblyNames);
		}

		public unsafe void RestoreOriginalAssemblyNamesArrayPtr()
		{
			_this->m_AssemblyNames = _originalAssemblyNames;
		}
	}
}
namespace FixPluginTypesSerialization.UnityPlayer.Structs.v2019
{
	public struct AssemblyList
	{
		public nint ptr;

		public int label;

		public ulong size;

		public ulong capacity;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	public struct AssemblyStringStruct
	{
		public const int ValidStringLabel = 42;

		public nint data;

		public ulong capacity;

		public ulong extra;

		public ulong size;

		public int label;

		public bool IsValid()
		{
			if (data != 0)
			{
				return label == 42;
			}
			return false;
		}
	}
	[ApplicableToUnityVersionsSince("2019.3.0")]
	public class AssemblyString : IAssemblyString, INativeStruct
	{
		public IntPtr Pointer { get; set; }

		private unsafe AssemblyStringStruct* _this => (AssemblyStringStruct*)(void*)Pointer;

		public AssemblyString()
		{
		}

		public AssemblyString(IntPtr pointer)
		{
			Pointer = pointer;
		}

		public unsafe void FixAbsolutePath()
		{
			if (_this->data != 0)
			{
				string pathNameStr = Marshal.PtrToStringAnsi(_this->data, (int)_this->size);
				string text = FixPluginTypesSerializationPatcher.PluginPaths.FirstOrDefault((string p) => Path.GetFileName(p) == Path.GetFileName(pathNameStr));
				if (!string.IsNullOrEmpty(text))
				{
					ulong num = (ulong)text.Length;
					IntPtr intPtr = Marshal.StringToHGlobalAnsi(text);
					(IntPtr, IntPtr, ulong) value = ((IntPtr)_this, _this->data, _this->size);
					ReadStringFromFile.ModifiedPathsToOriginalPaths.Add(intPtr, value);
					_this->data = intPtr;
					_this->capacity = num;
					_this->size = num;
				}
			}
		}

		public unsafe void RestoreOriginalString(IntPtr constCharPtr)
		{
			if (ReadStringFromFile.ModifiedPathsToOriginalPaths.TryGetValue(constCharPtr, out var value))
			{
				AssemblyStringStruct* ptr = (AssemblyStringStruct*)(void*)value.Item1;
				ptr->data = value.Item2;
				ptr->size = value.Item3;
				ptr->capacity = value.Item3;
			}
		}
	}
	[StructLayout(LayoutKind.Explicit)]
	public struct MonoManagerStruct
	{
		[FieldOffset(432)]
		public AssemblyList m_AssemblyNames;
	}
	[ApplicableToUnityVersionsSince("2019.3.0")]
	public class MonoManager : IMonoManager, INativeStruct
	{
		private AssemblyList _originalAssemblyNames;

		public List<AssemblyStringStruct> ManagedAssemblyList = new List<AssemblyStringStruct>();

		public IntPtr Pointer { get; set; }

		private unsafe MonoManagerStruct* _this => (MonoManagerStruct*)(void*)Pointer;

		public int AssemblyCount => ManagedAssemblyList.Count;

		public MonoManager()
		{
		}

		public MonoManager(IntPtr pointer)
		{
			Pointer = pointer;
		}

		public unsafe void CopyNativeAssemblyListToManaged()
		{
			ManagedAssemblyList.Clear();
			ulong num = 0uL;
			AssemblyStringStruct* ptr = (AssemblyStringStruct*)_this->m_AssemblyNames.ptr;
			for (; num < _this->m_AssemblyNames.size; num++)
			{
				AssemblyStringStruct assemblyStringStruct = default(AssemblyStringStruct);
				assemblyStringStruct.capacity = ptr->capacity;
				assemblyStringStruct.extra = ptr->extra;
				assemblyStringStruct.label = ptr->label;
				assemblyStringStruct.size = ptr->size;
				assemblyStringStruct.data = ptr->data;
				AssemblyStringStruct item = assemblyStringStruct;
				ManagedAssemblyList.Add(item);
				ptr++;
			}
		}

		public void AddAssembliesToManagedList(List<string> pluginAssemblyPaths)
		{
			foreach (string pluginAssemblyPath in pluginAssemblyPaths)
			{
				string fileName = Path.GetFileName(pluginAssemblyPath);
				ulong num = (ulong)fileName.Length;
				AssemblyStringStruct assemblyStringStruct = default(AssemblyStringStruct);
				assemblyStringStruct.label = 42;
				assemblyStringStruct.data = Marshal.StringToHGlobalAnsi(fileName);
				assemblyStringStruct.capacity = num;
				assemblyStringStruct.size = num;
				AssemblyStringStruct item = assemblyStringStruct;
				ManagedAssemblyList.Add(item);
			}
		}

		public unsafe void AllocNativeAssemblyListFromManaged()
		{
			AssemblyStringStruct* ptr = (AssemblyStringStruct*)(void*)Marshal.AllocHGlobal(Marshal.SizeOf<AssemblyStringStruct>() * ManagedAssemblyList.Count);
			int i = 0;
			AssemblyStringStruct* ptr2 = ptr;
			for (; i < ManagedAssemblyList.Count; i++)
			{
				ptr2->label = ManagedAssemblyList[i].label;
				ptr2->size = ManagedAssemblyList[i].size;
				ptr2->capacity = ManagedAssemblyList[i].capacity;
				ptr2->extra = ManagedAssemblyList[i].extra;
				ptr2->data = ManagedAssemblyList[i].data;
				ptr2++;
			}
			_originalAssemblyNames = _this->m_AssemblyNames;
			_this->m_AssemblyNames.ptr = (nint)ptr;
			_this->m_AssemblyNames.size = (ulong)ManagedAssemblyList.Count;
			_this->m_AssemblyNames.capacity = _this->m_AssemblyNames.size;
		}

		public unsafe void PrintAssemblies()
		{
			ulong num = 0uL;
			AssemblyStringStruct* ptr = (AssemblyStringStruct*)_this->m_AssemblyNames.ptr;
			for (; num < _this->m_AssemblyNames.size; num++)
			{
				if (ptr->IsValid())
				{
					Log.Warning($"Ass: {Marshal.PtrToStringAnsi(ptr->data, (int)ptr->size)} | label : {ptr->label:X}");
				}
				ptr++;
			}
		}

		public unsafe void RestoreOriginalAssemblyNamesArrayPtr()
		{
			_this->m_AssemblyNames = _originalAssemblyNames;
		}
	}
}
namespace FixPluginTypesSerialization.UnityPlayer.Structs.v2019.v1
{
	[StructLayout(LayoutKind.Explicit)]
	public struct MonoManagerStruct
	{
		[FieldOffset(432)]
		public DynamicArrayData m_AssemblyNames;
	}
	[ApplicableToUnityVersionsSince("2019.1.0")]
	public class MonoManager : IMonoManager, INativeStruct
	{
		private DynamicArrayData _originalAssemblyNames;

		public List<StringStorageDefaultV1> ManagedAssemblyList = new List<StringStorageDefaultV1>();

		public IntPtr Pointer { get; set; }

		private unsafe MonoManagerStruct* _this => (MonoManagerStruct*)(void*)Pointer;

		public int AssemblyCount => ManagedAssemblyList.Count;

		public MonoManager()
		{
		}

		public MonoManager(IntPtr pointer)
		{
			Pointer = pointer;
		}

		public unsafe void CopyNativeAssemblyListToManaged()
		{
			MonoManagerCommon.CopyNativeAssemblyListToManagedV2(ManagedAssemblyList, _this->m_AssemblyNames);
		}

		public void AddAssembliesToManagedList(List<string> pluginAssemblyPaths)
		{
			MonoManagerCommon.AddAssembliesToManagedListV1(ManagedAssemblyList, pluginAssemblyPaths);
		}

		public unsafe void AllocNativeAssemblyListFromManaged()
		{
			_originalAssemblyNames = _this->m_AssemblyNames;
			MonoManagerCommon.AllocNativeAssemblyListFromManagedV2(ManagedAssemblyList, &_this->m_AssemblyNames);
		}

		public unsafe void PrintAssemblies()
		{
			MonoManagerCommon.PrintAssembliesV2(_this->m_AssemblyNames);
		}

		public unsafe void RestoreOriginalAssemblyNamesArrayPtr()
		{
			_this->m_AssemblyNames = _originalAssemblyNames;
		}
	}
}
namespace FixPluginTypesSerialization.UnityPlayer.Structs.v2018
{
	public struct AssemblyList
	{
		public unsafe AssemblyStringStruct* first;

		public unsafe AssemblyStringStruct* last;

		public unsafe AssemblyStringStruct* end;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	public struct AssemblyStringStruct
	{
		public const int ValidStringLabel = 69;

		public nint data;

		public ulong capacity;

		public ulong extra;

		public ulong size;

		public int label;

		public bool IsValid()
		{
			if (data != 0)
			{
				return label == 69;
			}
			return false;
		}
	}
	[ApplicableToUnityVersionsSince("5.3.0")]
	public class AssemblyString : IAssemblyString, INativeStruct
	{
		public IntPtr Pointer { get; set; }

		private unsafe AssemblyStringStruct* _this => (AssemblyStringStruct*)(void*)Pointer;

		public AssemblyString()
		{
		}

		public AssemblyString(IntPtr pointer)
		{
			Pointer = pointer;
		}

		public unsafe void FixAbsolutePath()
		{
			if (_this->data != 0)
			{
				string pathNameStr = Marshal.PtrToStringAnsi(_this->data, (int)_this->size);
				string text = FixPluginTypesSerializationPatcher.PluginPaths.FirstOrDefault((string p) => Path.GetFileName(p) == Path.GetFileName(pathNameStr));
				if (!string.IsNullOrEmpty(text))
				{
					ulong num = (ulong)text.Length;
					IntPtr intPtr = Marshal.StringToHGlobalAnsi(text);
					(IntPtr, IntPtr, ulong) value = ((IntPtr)_this, _this->data, _this->size);
					ReadStringFromFile.ModifiedPathsToOriginalPaths.Add(intPtr, value);
					_this->data = intPtr;
					_this->capacity = num;
					_this->size = num;
				}
			}
		}

		public unsafe void RestoreOriginalString(IntPtr constCharPtr)
		{
			if (ReadStringFromFile.ModifiedPathsToOriginalPaths.TryGetValue(constCharPtr, out var value))
			{
				AssemblyStringStruct* ptr = (AssemblyStringStruct*)(void*)value.Item1;
				ptr->data = value.Item2;
				ptr->size = value.Item3;
				ptr->capacity = value.Item3;
			}
		}
	}
	[StructLayout(LayoutKind.Explicit)]
	public struct MonoManagerStruct
	{
		[FieldOffset(408)]
		public AssemblyList m_AssemblyNames;
	}
	[ApplicableToUnityVersionsSince("5.0.0")]
	public class MonoManager : IMonoManager, INativeStruct
	{
		private AssemblyList _originalAssemblyNames;

		public List<AssemblyStringStruct> ManagedAssemblyList = new List<AssemblyStringStruct>();

		public IntPtr Pointer { get; set; }

		private unsafe MonoManagerStruct* _this => (MonoManagerStruct*)(void*)Pointer;

		public int AssemblyCount => ManagedAssemblyList.Count;

		public MonoManager()
		{
		}

		public MonoManager(IntPtr pointer)
		{
			Pointer = pointer;
		}

		public unsafe void CopyNativeAssemblyListToManaged()
		{
			ManagedAssemblyList.Clear();
			for (AssemblyStringStruct* ptr = _this->m_AssemblyNames.first; ptr != _this->m_AssemblyNames.last; ptr++)
			{
				AssemblyStringStruct assemblyStringStruct = default(AssemblyStringStruct);
				assemblyStringStruct.capacity = ptr->capacity;
				assemblyStringStruct.extra = ptr->extra;
				assemblyStringStruct.label = ptr->label;
				assemblyStringStruct.size = ptr->size;
				assemblyStringStruct.data = ptr->data;
				AssemblyStringStruct item = assemblyStringStruct;
				ManagedAssemblyList.Add(item);
			}
		}

		public void AddAssembliesToManagedList(List<string> pluginAssemblyPaths)
		{
			foreach (string pluginAssemblyPath in pluginAssemblyPaths)
			{
				string fileName = Path.GetFileName(pluginAssemblyPath);
				ulong num = (ulong)fileName.Length;
				AssemblyStringStruct assemblyStringStruct = default(AssemblyStringStruct);
				assemblyStringStruct.label = 69;
				assemblyStringStruct.data = Marshal.StringToHGlobalAnsi(fileName);
				assemblyStringStruct.capacity = num;
				assemblyStringStruct.size = num;
				AssemblyStringStruct item = assemblyStringStruct;
				ManagedAssemblyList.Add(item);
			}
		}

		public unsafe void AllocNativeAssemblyListFromManaged()
		{
			AssemblyStringStruct* ptr = (AssemblyStringStruct*)(void*)Marshal.AllocHGlobal(Marshal.SizeOf<AssemblyStringStruct>() * ManagedAssemblyList.Count);
			int i = 0;
			AssemblyStringStruct* ptr2 = ptr;
			for (; i < ManagedAssemblyList.Count; i++)
			{
				ptr2->label = ManagedAssemblyList[i].label;
				ptr2->size = ManagedAssemblyList[i].size;
				ptr2->capacity = ManagedAssemblyList[i].capacity;
				ptr2->extra = ManagedAssemblyList[i].extra;
				ptr2->data = ManagedAssemblyList[i].data;
				ptr2++;
			}
			_originalAssemblyNames = _this->m_AssemblyNames;
			_this->m_AssemblyNames.first = ptr;
			_this->m_AssemblyNames.last = ptr + ManagedAssemblyList.Count;
			_this->m_AssemblyNames.end = _this->m_AssemblyNames.last;
		}

		public unsafe void PrintAssemblies()
		{
			for (AssemblyStringStruct* ptr = _this->m_AssemblyNames.first; ptr != _this->m_AssemblyNames.last; ptr++)
			{
				if (ptr->IsValid())
				{
					Log.Warning("Ass: " + Marshal.PtrToStringAnsi(ptr->data, (int)ptr->size));
				}
			}
		}

		public unsafe void RestoreOriginalAssemblyNamesArrayPtr()
		{
			_this->m_AssemblyNames = _originalAssemblyNames;
		}
	}
}
namespace FixPluginTypesSerialization.UnityPlayer.Structs.v2017.v3
{
	[StructLayout(LayoutKind.Explicit)]
	public struct MonoManagerStruct
	{
		[FieldOffset(408)]
		public Vector<StringStorageDefaultV1> m_AssemblyNames;
	}
	[ApplicableToUnityVersionsSince("2017.3.0")]
	public class MonoManager : IMonoManager, INativeStruct
	{
		private Vector<StringStorageDefaultV1> _originalAssemblyNames;

		public List<StringStorageDefaultV1> ManagedAssemblyList = new List<StringStorageDefaultV1>();

		public IntPtr Pointer { get; set; }

		private unsafe MonoManagerStruct* _this => (MonoManagerStruct*)(void*)Pointer;

		public int AssemblyCount => ManagedAssemblyList.Count;

		public MonoManager()
		{
		}

		public MonoManager(IntPtr pointer)
		{
			Pointer = pointer;
		}

		public unsafe void CopyNativeAssemblyListToManaged()
		{
			MonoManagerCommon.CopyNativeAssemblyListToManagedV1(ManagedAssemblyList, _this->m_AssemblyNames);
		}

		public void AddAssembliesToManagedList(List<string> pluginAssemblyPaths)
		{
			MonoManagerCommon.AddAssembliesToManagedListV1(ManagedAssemblyList, pluginAssemblyPaths);
		}

		public unsafe void AllocNativeAssemblyListFromManaged()
		{
			_originalAssemblyNames = _this->m_AssemblyNames;
			MonoManagerCommon.AllocNativeAssemblyListFromManagedV1(ManagedAssemblyList, &_this->m_AssemblyNames);
		}

		public unsafe void PrintAssemblies()
		{
			MonoManagerCommon.PrintAssembliesV1(_this->m_AssemblyNames);
		}

		public unsafe void RestoreOriginalAssemblyNamesArrayPtr()
		{
			_this->m_AssemblyNames = _originalAssemblyNames;
		}
	}
}
namespace FixPluginTypesSerialization.UnityPlayer.Structs.v2017.v2
{
	[StructLayout(LayoutKind.Explicit)]
	public struct MonoManagerStruct
	{
		[FieldOffset(448)]
		public Vector<StringStorageDefaultV1> m_AssemblyNames;
	}
	[ApplicableToUnityVersionsSince("2017.2.0")]
	public class MonoManager : IMonoManager, INativeStruct
	{
		private Vector<StringStorageDefaultV1> _originalAssemblyNames;

		public List<StringStorageDefaultV1> ManagedAssemblyList = new List<StringStorageDefaultV1>();

		public IntPtr Pointer { get; set; }

		private unsafe MonoManagerStruct* _this => (MonoManagerStruct*)(void*)Pointer;

		public int AssemblyCount => ManagedAssemblyList.Count;

		public MonoManager()
		{
		}

		public MonoManager(IntPtr pointer)
		{
			Pointer = pointer;
		}

		public unsafe void CopyNativeAssemblyListToManaged()
		{
			MonoManagerCommon.CopyNativeAssemblyListToManagedV1(ManagedAssemblyList, _this->m_AssemblyNames);
		}

		public void AddAssembliesToManagedList(List<string> pluginAssemblyPaths)
		{
			MonoManagerCommon.AddAssembliesToManagedListV1(ManagedAssemblyList, pluginAssemblyPaths);
		}

		public unsafe void AllocNativeAssemblyListFromManaged()
		{
			_originalAssemblyNames = _this->m_AssemblyNames;
			MonoManagerCommon.AllocNativeAssemblyListFromManagedV1(ManagedAssemblyList, &_this->m_AssemblyNames);
		}

		public unsafe void PrintAssemblies()
		{
			MonoManagerCommon.PrintAssembliesV1(_this->m_AssemblyNames);
		}

		public unsafe void RestoreOriginalAssemblyNamesArrayPtr()
		{
			_this->m_AssemblyNames = _originalAssemblyNames;
		}
	}
}
namespace FixPluginTypesSerialization.UnityPlayer.Structs.v2017.v1
{
	[StructLayout(LayoutKind.Explicit)]
	public struct MonoManagerStruct
	{
		[FieldOffset(504)]
		public Vector<StringStorageDefaultV1> m_AssemblyNames;
	}
	[ApplicableToUnityVersionsSince("2017.1.0")]
	public class MonoManager : IMonoManager, INativeStruct
	{
		private Vector<StringStorageDefaultV1> _originalAssemblyNames;

		public List<StringStorageDefaultV1> ManagedAssemblyList = new List<StringStorageDefaultV1>();

		public IntPtr Pointer { get; set; }

		private unsafe MonoManagerStruct* _this => (MonoManagerStruct*)(void*)Pointer;

		public int AssemblyCount => ManagedAssemblyList.Count;

		public MonoManager()
		{
		}

		public MonoManager(IntPtr pointer)
		{
			Pointer = pointer;
		}

		public unsafe void CopyNativeAssemblyListToManaged()
		{
			MonoManagerCommon.CopyNativeAssemblyListToManagedV1(ManagedAssemblyList, _this->m_AssemblyNames);
		}

		public void AddAssembliesToManagedList(List<string> pluginAssemblyPaths)
		{
			MonoManagerCommon.AddAssembliesToManagedListV1(ManagedAssemblyList, pluginAssemblyPaths);
		}

		public unsafe void AllocNativeAssemblyListFromManaged()
		{
			_originalAssemblyNames = _this->m_AssemblyNames;
			MonoManagerCommon.AllocNativeAssemblyListFromManagedV1(ManagedAssemblyList, &_this->m_AssemblyNames);
		}

		public unsafe void PrintAssemblies()
		{
			MonoManagerCommon.PrintAssembliesV1(_this->m_AssemblyNames);
		}

		public unsafe void RestoreOriginalAssemblyNamesArrayPtr()
		{
			_this->m_AssemblyNames = _originalAssemblyNames;
		}
	}
	[ApplicableToUnityVersionsSince("2017.1.0")]
	public class RelativePathString : IRelativePathString, INativeStruct
	{
		public IntPtr Pointer { get; set; }

		private unsafe StringStorageDefaultV1* _this => (StringStorageDefaultV1*)(void*)Pointer;

		public RelativePathString()
		{
		}

		public RelativePathString(IntPtr pointer)
		{
			Pointer = pointer;
		}

		public unsafe void FixAbsolutePath()
		{
			if (_this->size == 0L)
			{
				return;
			}
			nint num = _this->data;
			if (num == 0)
			{
				num = (IntPtr)(Pointer.ToInt64() + 8);
			}
			string fileName = Path.GetFileName(Marshal.PtrToStringAnsi(num, (int)_this->size));
			int num2 = FixPluginTypesSerializationPatcher.PluginNames.IndexOf(fileName);
			if (num2 != -1)
			{
				ulong length;
				IntPtr data = CommonUnityFunctions.MallocString(FixPluginTypesSerializationPatcher.PluginPaths[num2], UseRightStructs.LabelMemStringId, out length);
				if (_this->data != 0)
				{
					CommonUnityFunctions.FreeAllocInternal(_this->data, _this->label);
				}
				StringStorageDefaultV1* @this = _this;
				@this->data = data;
				@this->capacity = length;
				@this->extra = 0uL;
				@this->size = length;
				@this->label = UseRightStructs.LabelMemStringId;
			}
		}

		public unsafe string ToStringAnsi()
		{
			if (_this->size == 0L)
			{
				return null;
			}
			nint num = _this->data;
			if (num == 0)
			{
				num = (nint)((byte*)_this + 8);
			}
			return Marshal.PtrToStringAnsi(num, (int)_this->size);
		}
	}
}
namespace FixPluginTypesSerialization.UnityPlayer.Structs.Default
{
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	public struct DynamicArrayData
	{
		public nint ptr;

		public int label;

		public ulong size;

		public ulong capacity;
	}
	public interface IAssemblyString : INativeStruct
	{
		void FixAbsolutePath();

		void RestoreOriginalString(IntPtr constCharPtr);
	}
	public interface IMonoManager : INativeStruct
	{
		int AssemblyCount { get; }

		void CopyNativeAssemblyListToManaged();

		void AddAssembliesToManagedList(List<string> pluginAssemblyPaths);

		void AllocNativeAssemblyListFromManaged();

		void PrintAssemblies();

		void RestoreOriginalAssemblyNamesArrayPtr();
	}
	public interface IRelativePathString : INativeStruct
	{
		void FixAbsolutePath();

		string ToStringAnsi();
	}
	public struct RuntimeStatic<T> where T : struct
	{
		public unsafe T* value;

		public int label;

		public int unknown1;

		public ulong memAlign;

		public unsafe fixed byte memAreaName[32];

		public unsafe fixed byte memObjectName[32];

		public RegisterRuntimeInitializeAndCleanup registerCallbacks;

		public ulong unknown2;

		public ulong unknown3;

		public ulong unknown4;

		public ulong unknown5;

		public ulong unknown6;

		public ulong unknown7;

		public ReadWriteSpinLock @lock;
	}
	public struct RegisterRuntimeInitializeAndCleanup
	{
		public int order;

		public IntPtr userData;

		public IntPtr init;

		public IntPtr cleanup;

		public bool initCalled;

		public unsafe RegisterRuntimeInitializeAndCleanup* m_Next;

		public unsafe RegisterRuntimeInitializeAndCleanup* m_Prev;
	}
	public struct ReadWriteSpinLock
	{
		public long m_Counter;

		public ulong unknown1;

		public ulong unknown2;

		public ulong unknown3;

		public ulong unknown4;

		public ulong unknown5;

		public ulong unknown6;

		public ulong unknown7;
	}
	public struct ScriptingAssemblies
	{
		public DynamicArrayData names;

		public DynamicArrayData types;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	public struct StringStorageDefaultV1
	{
		public nint data;

		public ulong capacity;

		public ulong extra;

		public ulong size;

		public int label;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	public struct StringStorageDefaultV2
	{
		public StringStorageDefaultV2Union union;

		public StringRepresentation data_repr;

		public int label;
	}
	[StructLayout(LayoutKind.Explicit, Pack = 8)]
	public struct StringStorageDefaultV2Union
	{
		[FieldOffset(0)]
		public StackAllocatedRepresentationV2 embedded;

		[FieldOffset(0)]
		public HeapAllocatedRepresentationV2 heap;
	}
	public struct StackAllocatedRepresentationV2
	{
		public unsafe fixed byte data[25];
	}
	public struct HeapAllocatedRepresentationV2
	{
		public nint data;

		public ulong capacity;

		public ulong size;
	}
	public enum StringRepresentation
	{
		Heap,
		Embedded,
		External
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	public struct StringStorageDefaultV3
	{
		public StringStorageDefaultV3Union union;

		public int label;
	}
	[StructLayout(LayoutKind.Explicit, Pack = 8)]
	public struct StringStorageDefaultV3Union
	{
		[FieldOffset(0)]
		public StackAllocatedRepresentationV3 embedded;

		[FieldOffset(0)]
		public HeapAllocatedRepresentationV3 heap;
	}
	public struct StackAllocatedRepresentationV3
	{
		public unsafe fixed byte data[31];

		public StringStorageDefaultV3Flags flags;
	}
	public struct StringStorageDefaultV3Flags
	{
		public byte flags;

		public bool IsHeap
		{
			get
			{
				return (flags & 0x40) > 0;
			}
			set
			{
				if (value)
				{
					flags = 95;
				}
				else
				{
					flags = 0;
				}
			}
		}

		public bool IsExternal
		{
			get
			{
				return (flags & 0x80) > 0;
			}
			set
			{
				if (value)
				{
					flags = byte.MaxValue;
				}
				else
				{
					flags = 0;
				}
			}
		}

		public bool IsEmbedded
		{
			get
			{
				return flags < 64;
			}
			set
			{
				IsHeap = !value;
			}
		}

		public static implicit operator int(StringStorageDefaultV3Flags f)
		{
			return f.flags;
		}

		public static implicit operator byte(StringStorageDefaultV3Flags f)
		{
			return f.flags;
		}
	}
	[StructLayout(LayoutKind.Explicit)]
	public struct HeapAllocatedRepresentationV3
	{
		[FieldOffset(0)]
		public nint data;

		[FieldOffset(8)]
		public ulong capacity;

		[FieldOffset(16)]
		public ulong size;

		[FieldOffset(31)]
		public StringStorageDefaultV3Flags flags;
	}
	public struct Vector<T> where T : struct
	{
		public unsafe T* first;

		public unsafe T* last;

		public unsafe T* end;
	}
	public interface INativeStruct
	{
		IntPtr Pointer { get; set; }
	}
}
namespace FixPluginTypesSerialization.Patchers
{
	internal class AwakeFromLoad : Patcher
	{
		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		private delegate void AwakeFromLoadDelegate(IntPtr _monoManager, int awakeMode);

		private static AwakeFromLoadDelegate original;

		private static NativeDetour _detour;

		internal static IMonoManager CurrentMonoManager;

		internal static bool IsApplied { get; private set; }

		protected override BytePattern[] PdbPatterns { get; } = new BytePattern[2]
		{
			Encoding.ASCII.GetBytes("MonoManager::AwakeFromLoad"),
			Encoding.ASCII.GetBytes("AwakeFromLoad@MonoManager")
		};


		protected override BytePattern[] SigPatterns { get; } = new BytePattern[1] { "40 53 48 81 EC ? ? ? ? 33 C0 C7 44 24 ? ? ? ? ? 0F 57 C0" };


		protected override void Apply(IntPtr from)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			IntPtr functionPointerForDelegate = Marshal.GetFunctionPointerForDelegate<AwakeFromLoadDelegate>(OnAwakeFromLoad);
			_detour = new NativeDetour(from, functionPointerForDelegate, new NativeDetourConfig
			{
				ManualApply = true
			});
			original = _detour.GenerateTrampoline<AwakeFromLoadDelegate>();
			_detour.Apply();
			IsApplied = true;
		}

		internal static void Dispose()
		{
			NativeDetour detour = _detour;
			if (detour != null)
			{
				detour.Dispose();
			}
			IsApplied = false;
		}

		private static void OnAwakeFromLoad(IntPtr _monoManager, int awakeMode)
		{
			CurrentMonoManager = UseRightStructs.GetStruct<IMonoManager>(_monoManager);
			CurrentMonoManager.CopyNativeAssemblyListToManaged();
			IsAssemblyCreated.VanillaAssemblyCount = CurrentMonoManager.AssemblyCount;
			CurrentMonoManager.AddAssembliesToManagedList(FixPluginTypesSerializationPatcher.PluginPaths);
			CurrentMonoManager.AllocNativeAssemblyListFromManaged();
			original(_monoManager, awakeMode);
			IsFileCreated.Dispose();
			ConvertSeparatorsToPlatform.Dispose();
			IsAssemblyCreated.Dispose();
		}
	}
	internal class ConvertSeparatorsToPlatform : Patcher
	{
		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		private delegate void ConvertSeparatorsToPlatformDelegate(IntPtr assemblyStringPathName);

		private static NativeDetour _detourConvertSeparatorsToPlatform;

		private static ConvertSeparatorsToPlatformDelegate originalConvertSeparatorsToPlatform;

		internal static bool IsApplied { get; private set; }

		protected override BytePattern[] PdbPatterns { get; } = new BytePattern[1] { Encoding.ASCII.GetBytes("ConvertSeparatorsToPlatform") };


		protected override BytePattern[] SigPatterns { get; } = new BytePattern[0];


		protected override void Apply(IntPtr from)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			IntPtr functionPointerForDelegate = Marshal.GetFunctionPointerForDelegate<ConvertSeparatorsToPlatformDelegate>(OnConvertSeparatorsToPlatformV1);
			_detourConvertSeparatorsToPlatform = new NativeDetour(from, functionPointerForDelegate, new NativeDetourConfig
			{
				ManualApply = true
			});
			originalConvertSeparatorsToPlatform = _detourConvertSeparatorsToPlatform.GenerateTrampoline<ConvertSeparatorsToPlatformDelegate>();
			_detourConvertSeparatorsToPlatform.Apply();
			IsApplied = true;
		}

		internal static void Dispose()
		{
			if (_detourConvertSeparatorsToPlatform != null && _detourConvertSeparatorsToPlatform.IsApplied)
			{
				_detourConvertSeparatorsToPlatform.Dispose();
			}
			IsApplied = false;
		}

		private static void OnConvertSeparatorsToPlatformV1(IntPtr assemblyStringPathName)
		{
			UseRightStructs.GetStruct<IRelativePathString>(assemblyStringPathName).FixAbsolutePath();
			originalConvertSeparatorsToPlatform(assemblyStringPathName);
		}
	}
	internal class IsAssemblyCreated : Patcher
	{
		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		private delegate bool IsAssemblyCreatedDelegate(IntPtr _monoManager, int index);

		private static IsAssemblyCreatedDelegate original;

		private static NativeDetour _detour;

		internal static int VanillaAssemblyCount;

		internal static bool IsApplied { get; private set; }

		protected override BytePattern[] PdbPatterns { get; } = new BytePattern[2]
		{
			Encoding.ASCII.GetBytes("MonoManager::IsAssemblyCreated"),
			Encoding.ASCII.GetBytes("IsAssemblyCreated@MonoManager")
		};


		protected override BytePattern[] SigPatterns { get; } = new BytePattern[2] { "E8 ? ? ? ? 84 C0 74 43 45 84 FF", "E8 ? ? ? ? 84 C0 74 41 45 84 FF" };


		protected override void Apply(IntPtr from)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			IntPtr functionPointerForDelegate = Marshal.GetFunctionPointerForDelegate<IsAssemblyCreatedDelegate>(OnIsAssemblyCreated);
			_detour = new NativeDetour(from, functionPointerForDelegate, new NativeDetourConfig
			{
				ManualApply = true
			});
			original = _detour.GenerateTrampoline<IsAssemblyCreatedDelegate>();
			NativeDetour detour = _detour;
			if (detour != null)
			{
				detour.Apply();
			}
			IsApplied = true;
		}

		internal static void Dispose()
		{
			NativeDetour detour = _detour;
			if (detour != null)
			{
				detour.Dispose();
			}
			IsApplied = false;
		}

		private static bool OnIsAssemblyCreated(IntPtr _monoManager, int index)
		{
			if (index >= VanillaAssemblyCount)
			{
				return true;
			}
			return original(_monoManager, index);
		}
	}
	internal class IsFileCreated : Patcher
	{
		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		private delegate bool IsFileCreatedDelegate(IntPtr str);

		private static IsFileCreatedDelegate original;

		private static NativeDetour _detour;

		internal static bool IsApplied { get; private set; }

		protected override BytePattern[] PdbPatterns { get; } = new BytePattern[1] { Encoding.ASCII.GetBytes("IsFileCreated") };


		protected override BytePattern[] SigPatterns { get; } = new BytePattern[0];


		protected override void Apply(IntPtr from)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			IntPtr functionPointerForDelegate = Marshal.GetFunctionPointerForDelegate<IsFileCreatedDelegate>(OnIsFileCreated);
			_detour = new NativeDetour(from, functionPointerForDelegate, new NativeDetourConfig
			{
				ManualApply = true
			});
			original = _detour.GenerateTrampoline<IsFileCreatedDelegate>();
			_detour.Apply();
			IsApplied = true;
		}

		internal static void Dispose()
		{
			NativeDetour detour = _detour;
			if (detour != null)
			{
				detour.Dispose();
			}
			IsApplied = false;
		}

		private static bool OnIsFileCreated(IntPtr str)
		{
			string text = UseRightStructs.GetStruct<IRelativePathString>(str).ToStringAnsi();
			if (text != null && FixPluginTypesSerializationPatcher.PluginNames.Any(text.EndsWith))
			{
				return true;
			}
			return original(str);
		}
	}
	internal abstract class Patcher
	{
		protected abstract BytePattern[] PdbPatterns { get; }

		protected abstract BytePattern[] SigPatterns { get; }

		public void Patch(IntPtr unityModule, int moduleSize, MiniPdbReader pdbReader, ConfigEntry<string> functionOffsetCache)
		{
			IntPtr intPtr = PatternDiscover.Discover(unityModule, moduleSize, pdbReader, functionOffsetCache, PdbPatterns, SigPatterns);
			if (intPtr != IntPtr.Zero)
			{
				Apply(intPtr);
			}
		}

		protected abstract void Apply(IntPtr from);
	}
	internal class ReadStringFromFile : Patcher
	{
		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		private delegate bool ReadStringFromFileDelegate(IntPtr outData, IntPtr assemblyStringPathName);

		private delegate IntPtr mono_assembly_load_from_full_delegate(IntPtr image, IntPtr constCharFName, IntPtr status, IntPtr refonly);

		private static NativeDetour _detourReadStringFromFile;

		private static ReadStringFromFileDelegate originalReadStringFromFile;

		private static readonly IntPtr Mono = NativeLibraryHelper.OpenLibrary("mono-2.0-bdwgc.dll");

		private static readonly IntPtr mono_assembly_load_from_full_fn = Mono.GetFunction("mono_assembly_load_from_full");

		private static NativeDetour _monoDetour;

		private static mono_assembly_load_from_full_delegate originalMonoAssemblyLoadFromFull;

		internal static readonly Dictionary<IntPtr, (IntPtr, IntPtr, ulong)> ModifiedPathsToOriginalPaths = new Dictionary<IntPtr, (IntPtr, IntPtr, ulong)>();

		protected override BytePattern[] PdbPatterns { get; } = new BytePattern[1] { Encoding.ASCII.GetBytes("ReadStringFromFile") };


		protected override BytePattern[] SigPatterns { get; } = new BytePattern[3] { "E8 ? ? ? ? 4C 8D 45 EF 48 8D 4D 17 84 C0", "E8 ? ? ? ? 48 8B 4D B7 0F B6 F0", "E8 ? ? ? ? 48 8D 4D 8F 0F B6 D8" };


		protected override void Apply(IntPtr from)
		{
			ApplyReadStringFromFileDetour(from);
			ApplyMonoDetour();
		}

		private void ApplyReadStringFromFileDetour(IntPtr from)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			IntPtr functionPointerForDelegate = Marshal.GetFunctionPointerForDelegate<ReadStringFromFileDelegate>(OnReadStringFromFile);
			_detourReadStringFromFile = new NativeDetour(from, functionPointerForDelegate, new NativeDetourConfig
			{
				ManualApply = true
			});
			originalReadStringFromFile = _detourReadStringFromFile.GenerateTrampoline<ReadStringFromFileDelegate>();
			_detourReadStringFromFile.Apply();
		}

		private void ApplyMonoDetour()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			IntPtr functionPointerForDelegate = Marshal.GetFunctionPointerForDelegate<mono_assembly_load_from_full_delegate>(OnMonoAssemblyLoadFromFull);
			_monoDetour = new NativeDetour(mono_assembly_load_from_full_fn, functionPointerForDelegate, new NativeDetourConfig
			{
				ManualApply = true
			});
			originalMonoAssemblyLoadFromFull = _monoDetour.GenerateTrampoline<mono_assembly_load_from_full_delegate>();
			_monoDetour.Apply();
		}

		internal static void Dispose()
		{
			DisposeDetours();
		}

		private static void DisposeDetours()
		{
			if (_detourReadStringFromFile != null && _detourReadStringFromFile.IsApplied)
			{
				_detourReadStringFromFile.Dispose();
			}
			if (_monoDetour != null && _monoDetour.IsApplied)
			{
				_monoDetour.Dispose();
			}
			foreach (KeyValuePair<IntPtr, (IntPtr, IntPtr, ulong)> modifiedPathsToOriginalPath in ModifiedPathsToOriginalPaths)
			{
				modifiedPathsToOriginalPath.Deconstruct(out var key, out var _);
				Marshal.FreeHGlobal(key);
			}
		}

		private static bool OnReadStringFromFile(IntPtr outData, IntPtr assemblyStringPathName)
		{
			UseRightStructs.GetStruct<IAssemblyString>(assemblyStringPathName).FixAbsolutePath();
			return originalReadStringFromFile(outData, assemblyStringPathName);
		}

		private static IntPtr OnMonoAssemblyLoadFromFull(IntPtr image, IntPtr constCharFNamePtr, IntPtr status, IntPtr refonly)
		{
			IntPtr result = originalMonoAssemblyLoadFromFull(image, constCharFNamePtr, status, refonly);
			UseRightStructs.GetStruct<IAssemblyString>(constCharFNamePtr).RestoreOriginalString(constCharFNamePtr);
			return result;
		}
	}
	internal class ScriptingManagerDeconstructor : Patcher
	{
		[UnmanagedFunctionPointer(CallingConvention.FastCall)]
		private delegate void ScriptingManagerDeconstructorDelegate(IntPtr scriptingManagerPtr);

		private static NativeDetour _detour;

		private static ScriptingManagerDeconstructorDelegate orig;

		internal static bool IsApplied { get; private set; }

		protected override BytePattern[] PdbPatterns { get; } = new BytePattern[2]
		{
			Encoding.ASCII.GetBytes("ScriptingManager::~ScriptingManager"),
			Encoding.ASCII.GetBytes("?1ScriptingManager@")
		};


		protected override BytePattern[] SigPatterns { get; } = new BytePattern[1] { "48 89 5C 24 ? 57 48 83 EC 20 48 8D 05 ? ? ? ? 48 8B D9 48 89 01 48 81 C1 ? ? ? ? E8 ? ? ? ? 48 8D 8B ? ? ? ? E8 ? ? ? ? 48 8D 8B" };


		protected override void Apply(IntPtr from)
		{
			ApplyDetour(from);
			IsApplied = true;
		}

		private void ApplyDetour(IntPtr from)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			IntPtr functionPointerForDelegate = Marshal.GetFunctionPointerForDelegate<ScriptingManagerDeconstructorDelegate>(OnDeconstructor);
			_detour = new NativeDetour(from, functionPointerForDelegate, new NativeDetourConfig
			{
				ManualApply = true
			});
			orig = _detour.GenerateTrampoline<ScriptingManagerDeconstructorDelegate>();
			_detour.Apply();
		}

		internal static void Dispose()
		{
			DisposeDetours();
			IsApplied = false;
		}

		private static void DisposeDetours()
		{
			if (_detour != null && _detour.IsApplied)
			{
				_detour.Dispose();
			}
		}

		private static void OnDeconstructor(IntPtr scriptingManagerPtr)
		{
			AwakeFromLoad.CurrentMonoManager.RestoreOriginalAssemblyNamesArrayPtr();
			Log.Info("Restored original AssemblyNames list");
			orig(scriptingManagerPtr);
		}
	}
}