Evaisa-FixPluginTypesSerialization Source

Communities

Lethal CompanyFixPluginTypesSerialization

Install

Last Updated

First Uploaded

Downloads

6.8M

Likes

Size

111KB

Dependency string

Evaisa-FixPluginTypesSerialization-1.1.4

Dependants

3726 other mods

Tools Libraries Misc BepInEx

Download

Details Required (0)Wiki Changelog Versions Analysis

The result has been truncated due to the large size, download it to view the full contents!

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
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 BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using FixPluginTypesSerialization.Patchers;
using FixPluginTypesSerialization.UnityPlayer;
using FixPluginTypesSerialization.UnityPlayer.Structs.Default;
using FixPluginTypesSerialization.Util;
using FixPluginTypesSerialization.Util.Platform;
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.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("FixPluginTypesSerialization")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+cee13878e76b7575aaae028d3da3d4ff040d8322")]
[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>("Overrides", "UnityVersionOverride", "", "Unity version is Major.Minor.Patch format i.e. 2017.2.1." + Environment.NewLine + "If specified, this version will be used instead of auto-detection" + Environment.NewLine + "from executable info. Specify only if the patcher doesn't work otherwise.");

		internal static ConfigEntry<FunctionOffsetLookup> FunctionOffsetLookupType = _config.Bind<FunctionOffsetLookup>("Overrides", "FunctionOffsetLookupType", FunctionOffsetLookup.PreferSupportedVersions, "PreferSupportedVersions - using values for supported versions, if a version is not supported trying to use pdb." + Environment.NewLine + "PreferPdb - using pdb, it will be downloaded from  Unity symbols server,if there is no pdb or download failed trying to use values for supported versions." + Environment.NewLine + "Manual - using offsets from [Cache] section of the config, which you need to specify yourself as hex values.");

		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;
			}
			PatternDiscoverer patternDiscoverer = new PatternDiscoverer((Process.GetCurrentProcess().Modules.Cast<ProcessModule>().FirstOrDefault(IsUnityPlayer) ?? Process.GetCurrentProcess().MainModule).BaseAddress, text);
			CommonUnityFunctions.Init(patternDiscoverer);
			AwakeFromLoad awakeFromLoad = new AwakeFromLoad();
			IsAssemblyCreated isAssemblyCreated = new IsAssemblyCreated();
			IsFileCreated isFileCreated = new IsFileCreated();
			ScriptingManagerDeconstructor scriptingManagerDeconstructor = new ScriptingManagerDeconstructor();
			ConvertSeparatorsToPlatform convertSeparatorsToPlatform = new ConvertSeparatorsToPlatform();
			awakeFromLoad.Patch(patternDiscoverer, Config.MonoManagerAwakeFromLoadOffset);
			isAssemblyCreated.Patch(patternDiscoverer, Config.MonoManagerIsAssemblyCreatedOffset);
			if (!IsAssemblyCreated.IsApplied)
			{
				isFileCreated.Patch(patternDiscoverer, Config.IsFileCreatedOffset);
			}
			convertSeparatorsToPlatform.Patch(patternDiscoverer, Config.ConvertSeparatorsToPlatformOffset);
			scriptingManagerDeconstructor.Patch(patternDiscoverer, 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);
		}
	}
}
namespace FixPluginTypesSerialization.Util
{
	internal class BytePattern
	{
		private readonly byte?[] pattern;

		private int[] jumpTable;

		public int Length => pattern.Length;

		public bool IsE8 => ((int?)pattern[0]).GetValueOrDefault() == 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(PatternDiscoverer patternDiscoverer)
		{
			IntPtr intPtr = patternDiscoverer.Discover(Config.MallocInternalOffset, new BytePattern[1] { Encoding.ASCII.GetBytes("malloc_internal") });
			if (intPtr != IntPtr.Zero)
			{
				mallocInternal = (MallocInternalFunc)Marshal.GetDelegateForFunctionPointer(intPtr, typeof(MallocInternalFunc));
			}
			IntPtr intPtr2 = patternDiscoverer.Discover(Config.FreeAllocInternalOffset, new BytePattern[1] { Encoding.ASCII.GetBytes("free_alloc_internal") });
			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 = patternDiscoverer.Discover(Config.ScriptingAssembliesOffset, new BytePattern[1] { Encoding.ASCII.GetBytes("m_ScriptingAssemblies@") });
			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;
		}
	}
	public enum FunctionOffsetLookup
	{
		PreferSupportedVersions,
		PreferPdb,
		Manual
	}
	public static class FunctionOffsets
	{
		public static bool TryGet(Version unityVersion, out Dictionary<string, long> offsets)
		{
			offsets = ((IntPtr.Size == 4) ? Get32(unityVersion) : Get64(unityVersion));
			return offsets != null;
		}

		private static Dictionary<string, long> Get32(Version unityVersion)
		{
			return null;
		}

		private static Dictionary<string, long> Get64(Version unityVersion)
		{
			switch (unityVersion.Major)
			{
			case 5:
				switch (unityVersion.Minor)
				{
				case 0:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(1519584L, 0L, 2772736L, 1572448L, 2795760L, 11808L, 9536L, 0L);
					case 1:
						return CreateOffsets(1526224L, 0L, 2776448L, 1578976L, 2799424L, 11808L, 9536L, 0L);
					case 2:
						return CreateOffsets(1526512L, 0L, 2780208L, 1578704L, 2803280L, 11984L, 9712L, 0L);
					case 3:
						return CreateOffsets(1532016L, 0L, 2788720L, 1584288L, 2811408L, 11984L, 9712L, 0L);
					case 4:
						return CreateOffsets(1532352L, 0L, 2787216L, 1585264L, 2810400L, 11824L, 9552L, 0L);
					}
					break;
				case 1:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(1539536L, 0L, 2895136L, 1591456L, 2914064L, 11792L, 9520L, 0L);
					case 1:
						return CreateOffsets(1532352L, 0L, 2889568L, 1584848L, 2909008L, 11776L, 9504L, 0L);
					case 2:
						return CreateOffsets(1536608L, 0L, 2895968L, 1588528L, 2914816L, 11968L, 9696L, 0L);
					case 3:
						return CreateOffsets(1534064L, 0L, 2893280L, 1586352L, 2912464L, 11792L, 9520L, 0L);
					case 4:
						return CreateOffsets(1534560L, 0L, 2897920L, 1586960L, 2917712L, 11776L, 9504L, 0L);
					case 5:
						return CreateOffsets(1536544L, 0L, 2895200L, 1589008L, 2914736L, 11776L, 9504L, 0L);
					}
					break;
				case 2:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(1601024L, 0L, 2917232L, 1653200L, 2938816L, 11936L, 9664L, 0L);
					case 1:
						return CreateOffsets(1604832L, 0L, 2921792L, 1657232L, 2942912L, 11776L, 9504L, 0L);
					case 2:
						return CreateOffsets(1608448L, 0L, 2921632L, 1660080L, 2943344L, 11952L, 9680L, 0L);
					case 3:
						return CreateOffsets(1609760L, 0L, 2918432L, 1661824L, 2940192L, 11824L, 9552L, 0L);
					case 4:
						return CreateOffsets(1610208L, 0L, 2923312L, 1661584L, 2945072L, 11760L, 9488L, 0L);
					case 5:
						return CreateOffsets(1603040L, 0L, 2920608L, 1655584L, 2942368L, 11760L, 9488L, 0L);
					}
					break;
				case 3:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(2058016L, 0L, 3148928L, 2107216L, 3172256L, 1179552L, 1176448L, 0L);
					case 1:
						return CreateOffsets(2054016L, 0L, 3149200L, 2102688L, 3173328L, 1171392L, 1168288L, 0L);
					case 2:
						return CreateOffsets(2054240L, 0L, 3147872L, 2103040L, 3172048L, 1176608L, 1173504L, 0L);
					case 3:
						return CreateOffsets(2055600L, 0L, 3152432L, 2104288L, 3175856L, 1174752L, 1171648L, 0L);
					case 4:
						return CreateOffsets(1996128L, 0L, 3090368L, 2045792L, 3114800L, 1133136L, 1129424L, 0L);
					case 5:
						return CreateOffsets(2003360L, 0L, 3112208L, 2052592L, 3136096L, 1137840L, 1133504L, 0L);
					case 6:
						return CreateOffsets(2018064L, 0L, 3116768L, 2067408L, 3140608L, 1147680L, 1143344L, 0L);
					case 7:
						return CreateOffsets(2025424L, 0L, 3130592L, 2074400L, 3154544L, 1152864L, 1148528L, 0L);
					case 8:
						return CreateOffsets(2026160L, 0L, 3131296L, 2075056L, 3155232L, 1158080L, 1153744L, 0L);
					}
					break;
				case 4:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(2151120L, 0L, 3326704L, 2192800L, 3343888L, 1307984L, 1304112L, 0L);
					case 1:
						return CreateOffsets(2164448L, 0L, 3345952L, 2206416L, 3362960L, 1322688L, 1318816L, 0L);
					case 2:
						return CreateOffsets(2167920L, 0L, 3344976L, 2210608L, 3362080L, 1323072L, 1319200L, 0L);
					case 3:
						return CreateOffsets(2157424L, 0L, 3344160L, 2199552L, 3361968L, 1314432L, 1310560L, 0L);
					case 4:
						return CreateOffsets(2167120L, 0L, 3346880L, 2209696L, 3363392L, 1325200L, 1321328L, 0L);
					case 5:
						return CreateOffsets(2164688L, 0L, 3352400L, 2206656L, 3369104L, 1320624L, 1316752L, 0L);
					case 6:
						return CreateOffsets(2167600L, 0L, 3355312L, 2209344L, 3372816L, 1324048L, 1320176L, 0L);
					}
					break;
				case 5:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(3187616L, 0L, 2666208L, 3236944L, 2678768L, 80864L, 77712L, 0L);
					case 1:
						return CreateOffsets(3193200L, 0L, 2670816L, 3241920L, 2683376L, 81456L, 78288L, 0L);
					case 2:
						return CreateOffsets(3205712L, 0L, 2683728L, 3254592L, 2696288L, 81280L, 78112L, 0L);
					case 3:
						return CreateOffsets(3203472L, 0L, 2684544L, 3252048L, 2695808L, 81088L, 77920L, 0L);
					case 4:
						return CreateOffsets(3204368L, 0L, 2682752L, 3254256L, 2695376L, 81344L, 78176L, 0L);
					case 5:
						return CreateOffsets(3205552L, 0L, 2679536L, 3255328L, 2691840L, 80896L, 77728L, 0L);
					case 6:
						return CreateOffsets(3212144L, 0L, 2689424L, 3261824L, 2701120L, 81168L, 78000L, 0L);
					}
					break;
				case 6:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(8607808L, 0L, 7398368L, 6477584L, 7397984L, 8475808L, 8475984L, 0L);
					case 1:
						return CreateOffsets(8613168L, 0L, 7402064L, 6478288L, 7401680L, 8481280L, 8481456L, 0L);
					case 2:
						return CreateOffsets(8634192L, 0L, 7413264L, 6491008L, 7412880L, 8502496L, 8502672L, 0L);
					case 3:
						return CreateOffsets(8641584L, 0L, 7421536L, 6501520L, 7421152L, 8508976L, 8509152L, 0L);
					case 4:
						return CreateOffsets(8645968L, 0L, 7425024L, 6502240L, 7424640L, 8515008L, 8515184L, 0L);
					case 5:
						return CreateOffsets(8650080L, 0L, 7426080L, 6502768L, 7425696L, 8517088L, 8517264L, 0L);
					case 6:
						return CreateOffsets(8644208L, 0L, 7420704L, 6497312L, 7420320L, 8511584L, 8511760L, 0L);
					case 7:
						return CreateOffsets(8644208L, 0L, 7420704L, 6497312L, 7420320L, 8511584L, 8511760L, 0L);
					}
					break;
				}
				break;
			case 2017:
				switch (unityVersion.Minor)
				{
				case 1:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(5689904L, 0L, 8344128L, 7269760L, 8357424L, 9310656L, 9306960L, 0L);
					case 1:
						return CreateOffsets(5693664L, 0L, 8350688L, 7274656L, 8364608L, 9318256L, 9314560L, 0L);
					case 2:
						return CreateOffsets(5698352L, 0L, 8350896L, 7277376L, 8364816L, 9322400L, 9318704L, 0L);
					case 3:
						return CreateOffsets(5703968L, 0L, 8363488L, 7285696L, 8377360L, 9338048L, 9334352L, 0L);
					case 4:
						return CreateOffsets(5713616L, 0L, 8372080L, 7296256L, 8385872L, 9345600L, 9341904L, 0L);
					case 5:
						return CreateOffsets(5710224L, 0L, 8372640L, 7292560L, 8386560L, 9345104L, 9341408L, 0L);
					}
					break;
				case 2:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(4525712L, 0L, 3978000L, 4598144L, 3993984L, 1163072L, 1159376L, 0L);
					case 1:
						return CreateOffsets(4527072L, 0L, 3981312L, 4599904L, 3997552L, 1159344L, 1155648L, 0L);
					case 2:
						return CreateOffsets(4527520L, 0L, 3979856L, 4600704L, 3995840L, 1161024L, 1157328L, 0L);
					case 3:
						return CreateOffsets(4535296L, 0L, 3987264L, 4608480L, 4003456L, 1160272L, 1156576L, 0L);
					case 4:
						return CreateOffsets(4531840L, 0L, 3980800L, 4605552L, 3997264L, 1161952L, 1158256L, 0L);
					case 5:
						return CreateOffsets(4531568L, 0L, 3989296L, 4604384L, 4005408L, 1159136L, 1155440L, 0L);
					}
					break;
				case 3:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(6098128L, 6114480L, 0L, 6201264L, 5566256L, 2970112L, 2969968L, 0L);
					case 1:
						return CreateOffsets(6092560L, 6108592L, 0L, 6195360L, 5561584L, 2968608L, 2968464L, 0L);
					}
					break;
				case 4:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(6099152L, 6115168L, 0L, 6200912L, 5570992L, 2962832L, 2962688L, 0L);
					case 1:
						return CreateOffsets(6090224L, 6106352L, 0L, 6192160L, 5563088L, 2966992L, 2966848L, 0L);
					case 2:
						return CreateOffsets(6089152L, 6105184L, 0L, 6191344L, 5558704L, 2966256L, 2966112L, 0L);
					case 3:
						return CreateOffsets(6098288L, 6114416L, 0L, 6200832L, 5569856L, 2976272L, 2976128L, 0L);
					case 4:
						return CreateOffsets(6093440L, 6109568L, 0L, 6195728L, 5562016L, 2968944L, 2968800L, 0L);
					case 5:
						return CreateOffsets(6105040L, 6121072L, 0L, 6207424L, 5575792L, 2969376L, 2969232L, 0L);
					case 6:
						return CreateOffsets(6088256L, 6104304L, 0L, 6190176L, 5555632L, 2970272L, 2970128L, 0L);
					case 7:
						return CreateOffsets(6102032L, 6118064L, 0L, 6203936L, 5573216L, 2967184L, 2967040L, 0L);
					case 8:
						return CreateOffsets(6105072L, 6121200L, 0L, 6207488L, 5576496L, 2979936L, 2979792L, 0L);
					case 9:
						return CreateOffsets(6099504L, 6115632L, 0L, 6202080L, 5567344L, 2969632L, 2969488L, 0L);
					case 10:
						return CreateOffsets(6109760L, 6125808L, 0L, 6212096L, 5574160L, 2970560L, 2970416L, 0L);
					case 11:
						return CreateOffsets(6109840L, 6125872L, 0L, 6211920L, 5575440L, 2968192L, 2968048L, 0L);
					case 12:
						return CreateOffsets(6119152L, 6135168L, 0L, 6221536L, 5589472L, 2973952L, 2973808L, 0L);
					case 13:
						return CreateOffsets(6114544L, 6130672L, 0L, 6217040L, 5579888L, 2980080L, 2979936L, 0L);
					case 14:
						return CreateOffsets(6117312L, 6133440L, 0L, 6220256L, 5580752L, 2985280L, 2985136L, 0L);
					case 15:
						return CreateOffsets(6117904L, 6133936L, 0L, 6221280L, 5581568L, 2981136L, 2980992L, 0L);
					case 16:
						return CreateOffsets(6118368L, 6134400L, 0L, 6221312L, 5587808L, 2969936L, 2969792L, 0L);
					case 17:
						return CreateOffsets(6121104L, 6137136L, 0L, 6224032L, 5590048L, 2973232L, 2973088L, 0L);
					case 18:
						return CreateOffsets(6123024L, 6139152L, 0L, 6226080L, 5591712L, 2970976L, 2970832L, 0L);
					case 19:
						return CreateOffsets(6121200L, 6137216L, 0L, 6223728L, 5585680L, 2974192L, 2974048L, 0L);
					case 20:
						return CreateOffsets(6116240L, 6132272L, 0L, 6219808L, 5580752L, 2969056L, 2968912L, 0L);
					case 21:
						return CreateOffsets(6122640L, 6138688L, 0L, 6225712L, 5589936L, 2980784L, 2980640L, 0L);
					case 22:
						return CreateOffsets(6122640L, 6138688L, 0L, 6225712L, 5589936L, 2980784L, 2980640L, 0L);
					case 23:
						return CreateOffsets(6123424L, 6139456L, 0L, 6226704L, 5591328L, 2969376L, 2969232L, 0L);
					case 24:
						return CreateOffsets(6116784L, 6132800L, 0L, 6219984L, 5585888L, 2982864L, 2982720L, 0L);
					case 25:
						return CreateOffsets(6116208L, 6132432L, 0L, 6219616L, 5582304L, 2982720L, 2982576L, 0L);
					case 26:
						return CreateOffsets(6120352L, 6136576L, 0L, 6223792L, 5586720L, 2970096L, 2969952L, 0L);
					case 27:
						return CreateOffsets(6124624L, 6140848L, 0L, 6228048L, 5592176L, 2980256L, 2980112L, 0L);
					case 28:
						return CreateOffsets(6107520L, 6123856L, 0L, 6211152L, 5571904L, 2974000L, 2973856L, 0L);
					case 29:
						return CreateOffsets(6107520L, 6123856L, 0L, 6211152L, 5571904L, 2974000L, 2973856L, 0L);
					case 30:
						return CreateOffsets(6125328L, 6141680L, 0L, 6228896L, 5586656L, 2982912L, 2982768L, 0L);
					case 31:
						return CreateOffsets(6120704L, 6136944L, 0L, 6223984L, 5587728L, 2976064L, 2975920L, 0L);
					case 32:
						return CreateOffsets(6108816L, 6125056L, 0L, 6212208L, 5573056L, 2968016L, 2967872L, 0L);
					case 33:
						return CreateOffsets(6122272L, 6138624L, 0L, 6225696L, 5585472L, 2984416L, 2984272L, 0L);
					case 34:
						return CreateOffsets(6122512L, 6138848L, 0L, 6226176L, 5586752L, 2983696L, 2983552L, 0L);
					case 35:
						return CreateOffsets(6122752L, 6138976L, 0L, 6225952L, 5590960L, 2972096L, 2971952L, 0L);
					case 36:
						return CreateOffsets(6126272L, 6142496L, 0L, 6229648L, 5592816L, 2986848L, 2986704L, 0L);
					case 37:
						return CreateOffsets(6121616L, 6137856L, 0L, 6225232L, 5585360L, 2971200L, 2971056L, 0L);
					case 38:
						return CreateOffsets(6121424L, 6137664L, 0L, 6225056L, 5587040L, 2978944L, 2978800L, 0L);
					case 39:
						return CreateOffsets(6122736L, 6138976L, 0L, 6226288L, 5591712L, 2985440L, 2985296L, 0L);
					case 40:
						return CreateOffsets(6117872L, 6134096L, 0L, 6221616L, 5582608L, 2982928L, 2982784L, 0L);
					}
					break;
				}
				break;
			case 2018:
				switch (unityVersion.Minor)
				{
				case 1:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(5841104L, 5860640L, 0L, 5923328L, 5335888L, 2849008L, 2848960L, 0L);
					case 1:
						return CreateOffsets(5834512L, 5854048L, 0L, 5916592L, 5330832L, 2848048L, 2837376L, 0L);
					case 2:
						return CreateOffsets(5839264L, 5858800L, 0L, 5921712L, 5335696L, 2850784L, 2840256L, 0L);
					case 3:
						return CreateOffsets(5835600L, 5855136L, 0L, 5918256L, 5331712L, 2847920L, 2847872L, 0L);
					case 4:
						return CreateOffsets(5841024L, 5860560L, 0L, 5923008L, 5335648L, 2846960L, 2846912L, 0L);
					case 5:
						return CreateOffsets(5839920L, 5859456L, 0L, 5922656L, 5333936L, 2848240L, 2837568L, 0L);
					case 6:
						return CreateOffsets(5839104L, 5858640L, 0L, 5921408L, 5334368L, 2848368L, 2837744L, 0L);
					case 7:
						return CreateOffsets(5839888L, 5859424L, 0L, 5922480L, 5336160L, 2853216L, 2842784L, 0L);
					case 8:
						return CreateOffsets(5840960L, 5860512L, 0L, 5923280L, 5334480L, 2845504L, 2845456L, 0L);
					case 9:
						return CreateOffsets(5838832L, 5858368L, 0L, 5921024L, 5336560L, 2851392L, 2840816L, 0L);
					}
					break;
				case 2:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(6134752L, 6152240L, 0L, 6214400L, 5567824L, 3004448L, 3004400L, 0L);
					case 1:
						return CreateOffsets(6136480L, 6154000L, 0L, 6216368L, 5573280L, 3004016L, 3003968L, 0L);
					case 2:
						return CreateOffsets(6136784L, 6154272L, 0L, 6216768L, 5572768L, 3003648L, 3003600L, 0L);
					case 3:
						return CreateOffsets(6134160L, 6151664L, 0L, 6214032L, 5569712L, 3005856L, 2995456L, 0L);
					case 4:
						return CreateOffsets(6137600L, 6155104L, 0L, 6217568L, 5573328L, 3000704L, 2990400L, 0L);
					case 5:
						return CreateOffsets(6135904L, 6153408L, 0L, 6217008L, 5572336L, 3002448L, 3002400L, 0L);
					case 6:
						return CreateOffsets(6140624L, 6158128L, 0L, 6220336L, 5576304L, 3005888L, 3005840L, 0L);
					case 7:
						return CreateOffsets(6141280L, 6158768L, 0L, 6221712L, 5574560L, 3007168L, 3007120L, 0L);
					case 8:
						return CreateOffsets(6141072L, 6158560L, 0L, 6220944L, 5574192L, 3006624L, 3006576L, 0L);
					case 9:
						return CreateOffsets(6142976L, 6160496L, 0L, 6223184L, 5577760L, 3006608L, 2996400L, 0L);
					case 10:
						return CreateOffsets(6144720L, 6162240L, 0L, 6224928L, 5580864L, 3006832L, 2996528L, 0L);
					case 11:
						return CreateOffsets(6140448L, 6157936L, 0L, 6220560L, 5574288L, 3005024L, 3004976L, 0L);
					case 12:
						return CreateOffsets(6144960L, 6162448L, 0L, 6224608L, 5578288L, 3007536L, 2997088L, 0L);
					case 13:
						return CreateOffsets(6144784L, 6162288L, 0L, 6224528L, 5579264L, 3007344L, 2997040L, 0L);
					case 14:
						return CreateOffsets(6148432L, 6165920L, 0L, 6228176L, 5582640L, 3008544L, 2998192L, 0L);
					case 15:
						return CreateOffsets(6146896L, 6164416L, 0L, 6226704L, 5582336L, 3008848L, 3008800L, 0L);
					case 16:
						return CreateOffsets(6147104L, 6164624L, 0L, 6226800L, 5585456L, 3009728L, 3009680L, 0L);
					case 17:
						return CreateOffsets(6147104L, 6164624L, 0L, 6226800L, 5585456L, 3009728L, 3009680L, 0L);
					case 18:
						return CreateOffsets(6141616L, 6159120L, 0L, 6221296L, 5578512L, 3007008L, 3006960L, 0L);
					case 19:
						return CreateOffsets(6145424L, 6162928L, 0L, 6225184L, 5580576L, 3008768L, 3008720L, 0L);
					case 20:
						return CreateOffsets(6147296L, 6164800L, 0L, 6227184L, 5583056L, 3007440L, 2997184L, 0L);
					case 21:
						return CreateOffsets(6147296L, 6164800L, 0L, 6227184L, 5583056L, 3007440L, 2997184L, 0L);
					}
					break;
				case 3:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(9297584L, 9308880L, 0L, 9330880L, 8839872L, 6427856L, 6427808L, 0L);
					case 1:
						return CreateOffsets(9298944L, 9310240L, 0L, 9332240L, 8841232L, 6428736L, 6428688L, 0L);
					case 2:
						return CreateOffsets(9298880L, 9310176L, 0L, 9332176L, 8841168L, 6428720L, 6428672L, 0L);
					case 3:
						return CreateOffsets(9300864L, 9312160L, 0L, 9334160L, 8843152L, 6430848L, 6430800L, 0L);
					case 4:
						return CreateOffsets(9301808L, 9313104L, 0L, 9335104L, 8844096L, 6431776L, 6431728L, 0L);
					case 5:
						return CreateOffsets(9303232L, 9314528L, 0L, 9336528L, 8845360L, 6432080L, 6432032L, 0L);
					case 6:
						return CreateOffsets(9310592L, 9321872L, 0L, 9343872L, 8852688L, 6439856L, 6439808L, 0L);
					case 7:
						return CreateOffsets(9313440L, 9324720L, 0L, 9346720L, 8855536L, 6441168L, 6441120L, 0L);
					case 8:
						return CreateOffsets(9316512L, 9327792L, 0L, 9349792L, 8842976L, 6443808L, 6443760L, 0L);
					case 9:
						return CreateOffsets(9316768L, 9328048L, 0L, 9350048L, 8843232L, 6444048L, 6444000L, 0L);
					case 10:
						return CreateOffsets(9318192L, 9329472L, 0L, 9351472L, 8844400L, 6444848L, 6444800L, 0L);
					case 11:
						return CreateOffsets(9318256L, 9329536L, 0L, 9351536L, 8844464L, 6444784L, 6444736L, 0L);
					case 12:
						return CreateOffsets(9318160L, 9329440L, 0L, 9351440L, 8844336L, 6446272L, 6446224L, 0L);
					case 13:
						return CreateOffsets(9319200L, 9330480L, 0L, 9352480L, 8845168L, 6447104L, 6447056L, 0L);
					case 14:
						return CreateOffsets(9317152L, 9328432L, 0L, 9350432L, 8843168L, 6447504L, 6447456L, 0L);
					}
					break;
				case 4:
					switch (unityVersion.Build)
					{
					case 1:
						return CreateOffsets(9318256L, 9329536L, 0L, 9351536L, 8844272L, 6448576L, 6448528L, 0L);
					case 2:
						return CreateOffsets(9320864L, 9332144L, 0L, 9354144L, 8846880L, 6450800L, 6450752L, 0L);
					case 3:
						return CreateOffsets(9320768L, 9332048L, 0L, 9354048L, 8846784L, 6450560L, 6450512L, 0L);
					case 4:
						return CreateOffsets(9320640L, 9331920L, 0L, 9353920L, 8846640L, 6450688L, 6450640L, 0L);
					case 5:
						return CreateOffsets(9321040L, 9332320L, 0L, 9354320L, 8847008L, 6451552L, 6451504L, 0L);
					case 6:
						return CreateOffsets(9321952L, 9333232L, 0L, 9355232L, 8847920L, 6451568L, 6451520L, 0L);
					case 7:
						return CreateOffsets(9321952L, 9333232L, 0L, 9355232L, 8847920L, 6451568L, 6451520L, 0L);
					case 8:
						return CreateOffsets(9320432L, 9331712L, 0L, 9353712L, 8846352L, 6449696L, 6449648L, 0L);
					case 9:
						return CreateOffsets(9326096L, 9337376L, 0L, 9359376L, 8851888L, 6453808L, 6453760L, 0L);
					case 10:
						return CreateOffsets(9336368L, 9347648L, 0L, 9369648L, 8862128L, 6460048L, 6460000L, 0L);
					case 11:
						return CreateOffsets(9336816L, 9348096L, 0L, 9370096L, 8862576L, 6460544L, 6460496L, 0L);
					case 12:
						return CreateOffsets(9337168L, 9348448L, 0L, 9370448L, 8862928L, 6460896L, 6460848L, 0L);
					case 13:
						return CreateOffsets(9339296L, 9350576L, 0L, 9372576L, 8864832L, 6460512L, 6460464L, 0L);
					case 14:
						return CreateOffsets(9343008L, 9354288L, 0L, 9376048L, 8868544L, 6462976L, 6462928L, 0L);
					case 15:
						return CreateOffsets(9346320L, 9357600L, 0L, 9379360L, 8871840L, 6465216L, 6465168L, 0L);
					case 16:
						return CreateOffsets(9348000L, 9359280L, 0L, 9381040L, 8873504L, 6466592L, 6466544L, 0L);
					case 17:
						return CreateOffsets(9349424L, 9360704L, 0L, 9382464L, 8874928L, 6467872L, 6467824L, 0L);
					case 18:
						return CreateOffsets(9351392L, 9362672L, 0L, 9384432L, 8875168L, 6468128L, 6468080L, 0L);
					case 19:
						return CreateOffsets(9353920L, 9365200L, 0L, 9386960L, 8877696L, 6468832L, 6468784L, 0L);
					case 20:
						return CreateOffsets(9354640L, 9365920L, 0L, 9387680L, 8878352L, 6469520L, 6469472L, 0L);
					case 21:
						return CreateOffsets(9354608L, 9365888L, 0L, 9387648L, 8878288L, 6469488L, 6469440L, 0L);
					case 22:
						return CreateOffsets(9355392L, 9366672L, 0L, 9388432L, 8879072L, 6469920L, 6469872L, 0L);
					case 23:
						return CreateOffsets(9349008L, 9360288L, 0L, 9382048L, 8872688L, 6469296L, 6469248L, 0L);
					case 24:
						return CreateOffsets(9354976L, 9366256L, 0L, 9388016L, 8878656L, 6474432L, 6474384L, 0L);
					case 25:
						return CreateOffsets(9358448L, 9369728L, 0L, 9391488L, 8882128L, 6477616L, 6477568L, 0L);
					case 26:
						return CreateOffsets(9360176L, 9371456L, 0L, 9393216L, 8883840L, 6478464L, 6478416L, 0L);
					case 27:
						return CreateOffsets(9362704L, 9373984L, 0L, 9395744L, 8885872L, 6478688L, 6478640L, 0L);
					case 28:
						return CreateOffsets(9361728L, 9373008L, 0L, 9394768L, 8884896L, 6477680L, 6477632L, 0L);
					case 29:
						return CreateOffsets(9363568L, 9374848L, 0L, 9396608L, 8886736L, 6478832L, 6478784L, 0L);
					case 30:
						return CreateOffsets(9365728L, 9377008L, 0L, 9398816L, 8888896L, 6479888L, 6479840L, 0L);
					case 31:
						return CreateOffsets(9365968L, 9377248L, 0L, 9399056L, 8889136L, 6479904L, 6479856L, 0L);
					case 32:
						return CreateOffsets(9366304L, 9377584L, 0L, 9399392L, 8889472L, 6480000L, 6479952L, 0L);
					case 33:
						return CreateOffsets(9366320L, 9377600L, 0L, 9399408L, 8889488L, 6480000L, 6479952L, 0L);
					case 34:
						return CreateOffsets(9369360L, 9380640L, 0L, 9402448L, 8892528L, 6480000L, 6479952L, 0L);
					case 35:
						return CreateOffsets(9369712L, 9380992L, 0L, 9402800L, 8892880L, 6480352L, 6480304L, 0L);
					case 36:
						return CreateOffsets(9370320L, 9381600L, 0L, 9403408L, 8893280L, 6480688L, 6480640L, 0L);
					}
					break;
				}
				break;
			case 2019:
				switch (unityVersion.Minor)
				{
				case 1:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(9142272L, 9166192L, 0L, 9200784L, 8543344L, 6065712L, 6065664L, 0L);
					case 1:
						return CreateOffsets(9143856L, 9167776L, 0L, 9202368L, 8544928L, 6067216L, 6067168L, 0L);
					case 2:
						return CreateOffsets(9145552L, 9169472L, 0L, 9204064L, 8546624L, 6067984L, 6067936L, 0L);
					case 3:
						return CreateOffsets(9146416L, 9170336L, 0L, 9204928L, 8529248L, 6068992L, 6068944L, 0L);
					case 4:
						return CreateOffsets(9138256L, 9162176L, 0L, 9196768L, 8521088L, 6060064L, 6060016L, 0L);
					case 5:
						return CreateOffsets(9138256L, 9162176L, 0L, 9196768L, 8521088L, 6060064L, 6060016L, 0L);
					case 6:
						return CreateOffsets(9137808L, 9161728L, 0L, 9196320L, 8520512L, 6058848L, 6058800L, 0L);
					case 7:
						return CreateOffsets(9138304L, 9162224L, 0L, 9196816L, 8521008L, 6059136L, 6059088L, 0L);
					case 8:
						return CreateOffsets(9138224L, 9162144L, 0L, 9196736L, 8520928L, 6058912L, 6058864L, 0L);
					case 9:
						return CreateOffsets(9139280L, 9163200L, 0L, 9197792L, 8521984L, 6059792L, 6059744L, 0L);
					case 10:
						return CreateOffsets(9138688L, 9162624L, 0L, 9197216L, 8521392L, 6059968L, 6059920L, 0L);
					case 11:
						return CreateOffsets(9138720L, 9162656L, 0L, 9197248L, 8521424L, 6059968L, 6059920L, 0L);
					case 12:
						return CreateOffsets(9138720L, 9162656L, 0L, 9197248L, 8521424L, 6059968L, 6059920L, 0L);
					case 13:
						return CreateOffsets(9139200L, 9163136L, 0L, 9197728L, 8521904L, 6059776L, 6059728L, 0L);
					case 14:
						return CreateOffsets(9140224L, 9164160L, 0L, 9198880L, 8522928L, 6060784L, 6060736L, 0L);
					}
					break;
				case 2:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(8830144L, 8854096L, 0L, 8888896L, 8195296L, 5738272L, 5738224L, 0L);
					case 1:
						return CreateOffsets(8830880L, 8854832L, 0L, 8889632L, 8196048L, 5738352L, 5738304L, 0L);
					case 2:
						return CreateOffsets(8832304L, 8856256L, 0L, 8891056L, 8197472L, 5738448L, 5738400L, 0L);
					case 3:
						return CreateOffsets(8833472L, 8857424L, 0L, 8892224L, 8198640L, 5739584L, 5739536L, 0L);
					case 4:
						return CreateOffsets(8836032L, 8859984L, 0L, 8894784L, 8201200L, 5741568L, 5741520L, 0L);
					case 5:
						return CreateOffsets(8836160L, 8860112L, 0L, 8894912L, 8201264L, 5740976L, 5740928L, 0L);
					case 6:
						return CreateOffsets(8835888L, 8859840L, 0L, 8894640L, 8200992L, 5740496L, 5740448L, 0L);
					case 7:
						return CreateOffsets(8837152L, 8861104L, 0L, 8895664L, 8202256L, 5740416L, 5740368L, 0L);
					case 8:
						return CreateOffsets(8837488L, 8861456L, 0L, 8896016L, 8202512L, 5740656L, 5740608L, 0L);
					case 9:
						return CreateOffsets(8838368L, 8862336L, 0L, 8896896L, 8203392L, 5741088L, 5741040L, 0L);
					case 10:
						return CreateOffsets(8839008L, 8862976L, 0L, 8897536L, 8203888L, 5741600L, 5741552L, 0L);
					case 11:
						return CreateOffsets(8839552L, 8863520L, 0L, 8898080L, 8204432L, 5742048L, 5742000L, 0L);
					case 12:
						return CreateOffsets(8839696L, 8863664L, 0L, 8898224L, 8204576L, 5742080L, 5742032L, 0L);
					case 13:
						return CreateOffsets(8840752L, 8864720L, 0L, 8899280L, 8205632L, 5742160L, 5742112L, 0L);
					case 14:
						return CreateOffsets(8842256L, 8866224L, 0L, 8900784L, 8207120L, 5742704L, 5742656L, 0L);
					case 15:
						return CreateOffsets(8842736L, 8866704L, 0L, 8901264L, 8207600L, 5743184L, 5743136L, 0L);
					case 16:
						return CreateOffsets(8843440L, 8867408L, 0L, 8901968L, 8208272L, 5743728L, 5743680L, 0L);
					case 17:
						return CreateOffsets(8845744L, 8869712L, 0L, 8904272L, 8210576L, 5745920L, 5745872L, 0L);
					case 18:
						return CreateOffsets(8845136L, 8869104L, 0L, 8903664L, 8209968L, 5744992L, 5744944L, 0L);
					case 19:
						return CreateOffsets(8840176L, 8864144L, 0L, 8898704L, 8205008L, 5740032L, 5739984L, 0L);
					case 20:
						return CreateOffsets(8840400L, 8864368L, 0L, 8898928L, 8205200L, 5740224L, 5740176L, 0L);
					case 21:
						return CreateOffsets(8840400L, 8864368L, 0L, 8898928L, 8205200L, 5740224L, 5740176L, 0L);
					}
					break;
				case 3:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(9002592L, 9014576L, 0L, 9035568L, 8329232L, 5734800L, 5734704L, 0L);
					case 1:
						return CreateOffsets(9004928L, 9016912L, 0L, 9037904L, 8331648L, 5735296L, 5735200L, 0L);
					case 2:
						return CreateOffsets(9006448L, 9018432L, 0L, 9039424L, 8333168L, 5738096L, 5738000L, 0L);
					case 3:
						return CreateOffsets(9006592L, 9018576L, 0L, 9039568L, 8333312L, 5738112L, 5738016L, 0L);
					case 4:
						return CreateOffsets(9012320L, 9024304L, 0L, 9045296L, 8339040L, 5740016L, 5739920L, 0L);
					case 5:
						return CreateOffsets(9014880L, 9026864L, 0L, 9047856L, 8341600L, 5741152L, 5741056L, 0L);
					case 6:
						return CreateOffsets(9021328L, 9033312L, 0L, 9054368L, 8347568L, 5745680L, 5745584L, 0L);
					case 7:
						return CreateOffsets(9024528L, 9036512L, 0L, 9057568L, 8350736L, 5747968L, 5747872L, 0L);
					case 8:
						return CreateOffsets(9033456L, 9045440L, 0L, 9066496L, 8359664L, 5748608L, 5748512L, 0L);
					case 9:
						return CreateOffsets(9034000L, 9045984L, 0L, 9067040L, 8360208L, 5747904L, 5747808L, 0L);
					case 10:
						return CreateOffsets(9034928L, 9046912L, 0L, 9067968L, 8360784L, 5748128L, 5748032L, 0L);
					case 11:
						return CreateOffsets(9041712L, 9053696L, 0L, 9074752L, 8367376L, 5753664L, 5753568L, 0L);
					case 12:
						return CreateOffsets(9042576L, 9054560L, 0L, 9075616L, 8367808L, 5754080L, 5753984L, 0L);
					case 13:
						return CreateOffsets(9043520L, 9055504L, 0L, 9076560L, 8368720L, 5754912L, 5754816L, 0L);
					case 14:
						return CreateOffsets(9045920L, 9057904L, 0L, 9078960L, 8371104L, 5757152L, 5757056L, 0L);
					case 15:
						return CreateOffsets(9057024L, 9069008L, 0L, 9090064L, 8382144L, 5765296L, 5765200L, 0L);
					}
					break;
				case 4:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(9058752L, 9070736L, 0L, 9091792L, 8383872L, 5765664L, 5765568L, 0L);
					case 1:
						return CreateOffsets(9058816L, 9070768L, 0L, 9091856L, 8383936L, 5765664L, 5765568L, 0L);
					case 2:
						return CreateOffsets(9060704L, 9072656L, 0L, 9093744L, 8385824L, 5766816L, 5766720L, 0L);
					case 3:
						return CreateOffsets(9067440L, 9079392L, 0L, 9100480L, 8392560L, 5771232L, 5771136L, 0L);
					case 4:
						return CreateOffsets(9067552L, 9079504L, 0L, 9100592L, 8392672L, 5771232L, 5771136L, 0L);
					case 5:
						return CreateOffsets(9068288L, 9080240L, 0L, 9101328L, 8393392L, 5771584L, 5771488L, 0L);
					case 6:
						return CreateOffsets(9069664L, 9081616L, 0L, 9102704L, 8394752L, 5772672L, 5772576L, 0L);
					case 7:
						return CreateOffsets(9073056L, 9085008L, 0L, 9106096L, 8398112L, 5775648L, 5775552L, 0L);
					case 8:
						return CreateOffsets(9073008L, 9084960L, 0L, 9106048L, 8398064L, 5775184L, 5775088L, 0L);
					case 9:
						return CreateOffsets(9081712L, 9093664L, 0L, 9114752L, 8406224L, 5776832L, 5776736L, 0L);
					case 10:
						return CreateOffsets(9087568L, 9099520L, 0L, 9120608L, 8412080L, 5782096L, 5782000L, 0L);
					case 11:
						return CreateOffsets(9089136L, 9101088L, 0L, 9122176L, 8413760L, 5782416L, 5782320L, 0L);
					case 12:
						return CreateOffsets(9091056L, 9103008L, 0L, 9124096L, 8415344L, 5785168L, 5785072L, 0L);
					case 13:
						return CreateOffsets(9091792L, 9103744L, 0L, 9124832L, 8416080L, 5785440L, 5785344L, 0L);
					case 14:
						return CreateOffsets(9092352L, 9104304L, 0L, 9125392L, 8416640L, 5785776L, 5785680L, 0L);
					case 15:
						return CreateOffsets(9092848L, 9104800L, 0L, 9125888L, 8416976L, 5786064L, 5785968L, 0L);
					case 16:
						return CreateOffsets(9098160L, 9110112L, 0L, 9131232L, 8422144L, 5789232L, 5789136L, 0L);
					case 17:
						return CreateOffsets(9101728L, 9113680L, 0L, 9134800L, 8425008L, 5791824L, 5791728L, 0L);
					case 18:
						return CreateOffsets(9107216L, 9119168L, 0L, 9140288L, 8430512L, 5795952L, 5795856L, 0L);
					case 19:
						return CreateOffsets(9110464L, 9122416L, 0L, 9143536L, 8433616L, 5796864L, 5796768L, 0L);
					case 20:
						return CreateOffsets(9115296L, 9127248L, 0L, 9148368L, 8437840L, 5800832L, 5800736L, 0L);
					case 21:
						return CreateOffsets(9110672L, 9122688L, 0L, 9143808L, 8433184L, 5795968L, 5795872L, 0L);
					case 22:
						return CreateOffsets(9115872L, 9127888L, 0L, 9149008L, 8438336L, 5798352L, 5798256L, 0L);
					case 23:
						return CreateOffsets(9138784L, 9150800L, 0L, 9170672L, 8459856L, 5818064L, 5817968L, 0L);
					case 24:
						return CreateOffsets(9144336L, 9156320L, 0L, 9176112L, 8465104L, 5825632L, 5825536L, 0L);
					case 25:
						return CreateOffsets(9144416L, 9156400L, 0L, 9176192L, 8465248L, 5825712L, 5825616L, 0L);
					case 26:
						return CreateOffsets(9146160L, 9158144L, 0L, 9177936L, 8466288L, 5825760L, 5825664L, 0L);
					case 27:
						return CreateOffsets(9148608L, 9160592L, 0L, 9180272L, 8468752L, 5827792L, 5827696L, 0L);
					case 28:
						return CreateOffsets(9149168L, 9161152L, 0L, 9180832L, 8469280L, 5827984L, 5827888L, 0L);
					case 29:
						return CreateOffsets(9154368L, 9166368L, 0L, 9186048L, 8474480L, 5829488L, 5829392L, 0L);
					case 30:
						return CreateOffsets(9158224L, 9170224L, 0L, 9189904L, 8478336L, 5832976L, 5832880L, 0L);
					case 31:
						return CreateOffsets(9169952L, 9181936L, 0L, 9201616L, 8490064L, 5841152L, 5841056L, 0L);
					case 32:
						return CreateOffsets(9171328L, 9183312L, 0L, 9202992L, 8490320L, 5841600L, 5841504L, 0L);
					case 33:
						return CreateOffsets(9174592L, 9186576L, 0L, 9206256L, 8493584L, 5842464L, 5842368L, 0L);
					case 34:
						return CreateOffsets(9174576L, 9186560L, 0L, 9206240L, 8493568L, 5842416L, 5842320L, 0L);
					case 35:
						return CreateOffsets(9177728L, 9189712L, 0L, 9209392L, 8496720L, 5845248L, 5845152L, 0L);
					case 36:
						return CreateOffsets(9178992L, 9190976L, 0L, 9210656L, 8497968L, 5846416L, 5846320L, 0L);
					case 37:
						return CreateOffsets(9185360L, 9197344L, 0L, 9217008L, 8499712L, 5846544L, 5846448L, 0L);
					case 38:
						return CreateOffsets(9186160L, 9198144L, 0L, 9217808L, 8500480L, 5847360L, 5847264L, 0L);
					case 39:
						return CreateOffsets(9190464L, 9202448L, 0L, 9222112L, 8504784L, 5851648L, 5851552L, 0L);
					case 40:
						return CreateOffsets(9191424L, 9203408L, 0L, 9223072L, 8505728L, 5852480L, 5852384L, 0L);
					}
					break;
				}
				break;
			case 2020:
				switch (unityVersion.Minor)
				{
				case 1:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(8542848L, 8555104L, 0L, 8573920L, 7836576L, 5291184L, 5291088L, 0L);
					case 1:
						return CreateOffsets(8554816L, 8567072L, 0L, 8585888L, 7839760L, 5293008L, 5292912L, 0L);
					case 2:
						return CreateOffsets(8555040L, 8567296L, 0L, 8586112L, 7839984L, 5293232L, 5293136L, 0L);
					case 3:
						return CreateOffsets(8555136L, 8567392L, 0L, 8586208L, 7839888L, 5292896L, 5292800L, 0L);
					case 4:
						return CreateOffsets(8558144L, 8570400L, 0L, 8589216L, 7842480L, 5294512L, 5294416L, 0L);
					case 5:
						return CreateOffsets(8559504L, 8571728L, 0L, 8590576L, 7843552L, 5294336L, 5294240L, 0L);
					case 6:
						return CreateOffsets(8560112L, 8572336L, 0L, 8591184L, 7844160L, 5294912L, 5294816L, 0L);
					case 7:
						return CreateOffsets(8564240L, 8576464L, 0L, 8595312L, 7847888L, 5297120L, 5297024L, 0L);
					case 8:
						return CreateOffsets(8564064L, 8576288L, 0L, 8595136L, 7847712L, 5296976L, 5296880L, 0L);
					case 9:
						return CreateOffsets(8564496L, 8576720L, 0L, 8595568L, 7848144L, 5296720L, 5296624L, 0L);
					case 10:
						return CreateOffsets(8564688L, 8576912L, 0L, 8595760L, 7848336L, 5296992L, 5296896L, 0L);
					case 11:
						return CreateOffsets(8566320L, 8578544L, 0L, 8597392L, 7849968L, 5298736L, 5298640L, 0L);
					case 12:
						return CreateOffsets(8566672L, 8578896L, 0L, 8597744L, 7850320L, 5298864L, 5298768L, 0L);
					case 13:
						return CreateOffsets(8572176L, 8584400L, 0L, 8603248L, 7855856L, 5304352L, 5304256L, 0L);
					case 14:
						return CreateOffsets(8577376L, 8589616L, 0L, 8608368L, 7861024L, 5307440L, 5307344L, 0L);
					case 15:
						return CreateOffsets(8580352L, 8592592L, 0L, 8611376L, 7863840L, 5309536L, 5309440L, 0L);
					case 16:
						return CreateOffsets(8585936L, 8598176L, 0L, 8616960L, 7869040L, 5312880L, 5312784L, 0L);
					case 17:
						return CreateOffsets(8586304L, 8598544L, 0L, 8617328L, 7869408L, 5313072L, 5312976L, 0L);
					}
					break;
				case 2:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(9087040L, 9101408L, 0L, 9122512L, 8355392L, 5680336L, 5680240L, 26666624L);
					case 1:
						return CreateOffsets(9087040L, 9101408L, 0L, 9122512L, 8355392L, 5680336L, 5680240L, 26666624L);
					case 2:
						return CreateOffsets(9090976L, 9105344L, 0L, 9126448L, 8358752L, 5682848L, 5682752L, 26670784L);
					case 3:
						return CreateOffsets(9100640L, 9115008L, 0L, 9136112L, 8368192L, 5685776L, 5685680L, 26687232L);
					case 4:
						return CreateOffsets(9101840L, 9116208L, 0L, 9137344L, 8369392L, 5686848L, 5686752L, 26695488L);
					case 5:
						return CreateOffsets(9103824L, 9118192L, 0L, 9139328L, 8371376L, 5688016L, 5687920L, 26699712L);
					case 6:
						return CreateOffsets(9099936L, 9114304L, 0L, 9135440L, 8367488L, 5683312L, 5683216L, 26703744L);
					case 7:
						return CreateOffsets(9101744L, 9116112L, 0L, 9137248L, 8369296L, 5684752L, 5684656L, 26708096L);
					}
					break;
				case 3:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(9102800L, 9117168L, 0L, 9138304L, 8370352L, 5684832L, 5684736L, 26708096L);
					case 1:
						return CreateOffsets(9135888L, 9150256L, 0L, 9171392L, 8402912L, 5718320L, 5718224L, 26753152L);
					case 2:
						return CreateOffsets(9137280L, 9151648L, 0L, 9172784L, 8404144L, 5718288L, 5718192L, 26757248L);
					case 3:
						return CreateOffsets(9139248L, 9153616L, 0L, 9174752L, 8406048L, 5719504L, 5719408L, 26757248L);
					case 4:
						return CreateOffsets(9139568L, 9153936L, 0L, 9175072L, 8406368L, 5719520L, 5719424L, 26757248L);
					case 5:
						return CreateOffsets(9147488L, 9161856L, 0L, 9182992L, 8413136L, 5724112L, 5724016L, 26773696L);
					case 6:
						return CreateOffsets(9146384L, 9160752L, 0L, 9181888L, 8412032L, 5724160L, 5724064L, 26769600L);
					case 7:
						return CreateOffsets(9147248L, 9161616L, 0L, 9182752L, 8412528L, 5724576L, 5724480L, 26777792L);
					case 8:
						return CreateOffsets(9147952L, 9162320L, 0L, 9183456L, 8412240L, 5724080L, 5723984L, 26474688L);
					case 9:
						return CreateOffsets(9148192L, 9162560L, 0L, 9183696L, 8412400L, 5724272L, 5724176L, 26538752L);
					case 10:
						return CreateOffsets(9156768L, 9171136L, 0L, 9192272L, 8420640L, 5724928L, 5724832L, 26547008L);
					case 11:
						return CreateOffsets(9160864L, 9175232L, 0L, 9196368L, 8424768L, 5728624L, 5728528L, 26551232L);
					case 12:
						return CreateOffsets(9161808L, 9176176L, 0L, 9197312L, 8425696L, 5729328L, 5729232L, 26543040L);
					case 13:
						return CreateOffsets(9163456L, 9177824L, 0L, 9198960L, 8427216L, 5730144L, 5730048L, 26547136L);
					case 14:
						return CreateOffsets(9165152L, 9179600L, 0L, 9200736L, 8428912L, 5731824L, 5731728L, 26563520L);
					case 15:
						return CreateOffsets(9165120L, 9179568L, 0L, 9200704L, 8428896L, 5731824L, 5731728L, 26563520L);
					case 16:
						return CreateOffsets(9168512L, 9182944L, 0L, 9203904L, 8432208L, 5734288L, 5734192L, 26571712L);
					case 17:
						return CreateOffsets(9173248L, 9187680L, 0L, 9208640L, 8436928L, 5738592L, 5738496L, 26584256L);
					case 18:
						return CreateOffsets(9191056L, 9205488L, 0L, 9226448L, 8454496L, 5755536L, 5755440L, 26600640L);
					case 19:
						return CreateOffsets(9191200L, 9205632L, 0L, 9226592L, 8454928L, 5755040L, 5754944L, 26600576L);
					case 20:
						return CreateOffsets(9191680L, 9206112L, 0L, 9227072L, 8455296L, 5755216L, 5755120L, 26600576L);
					case 21:
						return CreateOffsets(9192784L, 9207216L, 0L, 9228176L, 8455472L, 5755168L, 5755072L, 26625152L);
					case 22:
						return CreateOffsets(9196320L, 9210752L, 0L, 9231712L, 8458960L, 5756528L, 5756432L, 26629248L);
					case 23:
						return CreateOffsets(9193808L, 9208240L, 0L, 9229200L, 8458000L, 5757024L, 5756928L, 26625344L);
					case 24:
						return CreateOffsets(9195328L, 9209760L, 0L, 9230720L, 8459424L, 5758448L, 5758352L, 26695168L);
					case 25:
						return CreateOffsets(9202192L, 9216624L, 0L, 9237584L, 8466400L, 5765376L, 5765280L, 26703360L);
					case 26:
						return CreateOffsets(9202848L, 9217280L, 0L, 9238240L, 8467040L, 5766048L, 5765952L, 26703360L);
					case 27:
						return CreateOffsets(9207264L, 9221696L, 0L, 9242656L, 8470784L, 5769712L, 5769616L, 26707520L);
					case 28:
						return CreateOffsets(9209568L, 9224000L, 0L, 9244960L, 8473024L, 5771328L, 5771232L, 26711616L);
					case 29:
						return CreateOffsets(9211408L, 9225840L, 0L, 9246800L, 8474864L, 5771968L, 5771872L, 26703552L);
					case 30:
						return CreateOffsets(9212528L, 9226960L, 0L, 9247920L, 8475984L, 5772784L, 5772688L, 26703552L);
					case 31:
						return CreateOffsets(9244416L, 9259040L, 0L, 9280736L, 8497744L, 5787920L, 5787824L, 26744576L);
					case 32:
						return CreateOffsets(9245184L, 9259808L, 0L, 9281504L, 8498496L, 5788320L, 5788224L, 26748672L);
					case 33:
						return CreateOffsets(9244608L, 9259232L, 0L, 9280928L, 8497856L, 5787920L, 5787824L, 26748672L);
					case 34:
						return CreateOffsets(9244960L, 9259584L, 0L, 9281280L, 8497920L, 5787904L, 5787808L, 26752768L);
					case 35:
						return CreateOffsets(9247424L, 9262048L, 0L, 9283744L, 8500256L, 5788576L, 5788480L, 26752768L);
					case 36:
						return CreateOffsets(9247872L, 9262496L, 0L, 9284192L, 8500704L, 5788832L, 5788736L, 26760960L);
					case 37:
						return CreateOffsets(9251104L, 9265728L, 0L, 9287424L, 8503936L, 5789952L, 5789856L, 26777344L);
					case 38:
						return CreateOffsets(9260896L, 9275552L, 0L, 9297248L, 8513648L, 5791632L, 5791536L, 26777472L);
					case 39:
						return CreateOffsets(9261504L, 9276160L, 0L, 9297856L, 8512864L, 5791952L, 5791856L, 26818368L);
					case 40:
						return CreateOffsets(9262560L, 9277216L, 0L, 9298912L, 8513920L, 5791984L, 5791888L, 26953536L);
					case 41:
						return CreateOffsets(9266896L, 9281552L, 0L, 9303248L, 8517680L, 5794032L, 5793936L, 26961920L);
					case 42:
						return CreateOffsets(9277136L, 9291792L, 0L, 9313488L, 8527648L, 5803488L, 5803392L, 26974208L);
					case 43:
						return CreateOffsets(9280848L, 9295504L, 0L, 9317200L, 8531360L, 5804160L, 5804064L, 26978304L);
					case 44:
						return CreateOffsets(9274672L, 9289280L, 0L, 9309952L, 8525120L, 5800848L, 5800752L, 26961856L);
					case 45:
						return CreateOffsets(8980480L, 8995088L, 0L, 9015760L, 8230560L, 5502768L, 5502672L, 26986432L);
					case 46:
						return CreateOffsets(8981712L, 8996320L, 0L, 9016992L, 8231792L, 5503600L, 5503504L, 26986496L);
					case 47:
						return CreateOffsets(8982128L, 8996736L, 0L, 9017408L, 8232208L, 5504064L, 5503968L, 26990592L);
					case 48:
						return CreateOffsets(8985392L, 9000000L, 0L, 9020672L, 8235664L, 5506688L, 5506592L, 26990592L);
					}
					break;
				}
				break;
			case 2021:
				switch (unityVersion.Minor)
				{
				case 1:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(9107152L, 9120176L, 0L, 9140112L, 8377760L, 5711216L, 5711120L, 26714752L);
					case 1:
						return CreateOffsets(9110304L, 9123328L, 0L, 9143264L, 8380848L, 5712688L, 5712592L, 26722944L);
					case 2:
						return CreateOffsets(9113344L, 9126368L, 0L, 9146304L, 8383744L, 5715584L, 5715488L, 26727040L);
					case 3:
						return CreateOffsets(9114656L, 9127680L, 0L, 9147616L, 8384640L, 5715888L, 5715792L, 26788480L);
					case 4:
						return CreateOffsets(9115632L, 9128656L, 0L, 9148592L, 8384608L, 5715568L, 5715472L, 26792576L);
					case 5:
						return CreateOffsets(9114752L, 9127776L, 0L, 9147696L, 8383792L, 5715440L, 5715344L, 26489472L);
					case 6:
						return CreateOffsets(9116704L, 9129728L, 0L, 9149648L, 8385456L, 5717264L, 5717168L, 26493568L);
					case 7:
						return CreateOffsets(9116688L, 9129712L, 0L, 9149632L, 8385440L, 5717168L, 5717072L, 26493568L);
					case 9:
						return CreateOffsets(9119360L, 9132464L, 0L, 9152384L, 8387840L, 5718240L, 5718144L, 26485440L);
					case 10:
						return CreateOffsets(9122064L, 9135168L, 0L, 9155088L, 8390288L, 5720304L, 5720208L, 26489536L);
					case 11:
						return CreateOffsets(9122064L, 9135168L, 0L, 9155088L, 8390288L, 5720304L, 5720208L, 26489536L);
					case 12:
						return CreateOffsets(9122128L, 9135232L, 0L, 9155152L, 8390336L, 5720352L, 5720256L, 26489536L);
					case 13:
						return CreateOffsets(9122272L, 9135376L, 0L, 9155296L, 8390480L, 5720496L, 5720400L, 26489536L);
					case 14:
						return CreateOffsets(9123696L, 9136800L, 0L, 9156720L, 8391904L, 5721936L, 5721840L, 26493632L);
					case 15:
						return CreateOffsets(9124368L, 9137488L, 0L, 9157328L, 8392640L, 5722672L, 5722576L, 26505920L);
					case 16:
						return CreateOffsets(9001600L, 9014720L, 0L, 9034560L, 8269728L, 5600688L, 5600592L, 26516224L);
					case 17:
						return CreateOffsets(9004032L, 9017152L, 0L, 9036992L, 8272096L, 5602304L, 5602208L, 26520320L);
					case 18:
						return CreateOffsets(9020048L, 9033168L, 0L, 9053008L, 8288016L, 5618256L, 5618160L, 26537024L);
					case 19:
						return CreateOffsets(9021216L, 9034336L, 0L, 9054176L, 8289184L, 5619216L, 5619120L, 26537024L);
					case 20:
						return CreateOffsets(9022272L, 9035392L, 0L, 9055232L, 8290240L, 5620112L, 5620016L, 26541120L);
					case 21:
						return CreateOffsets(9022752L, 9035872L, 0L, 9055712L, 8290672L, 5620336L, 5620240L, 26541120L);
					case 22:
						return CreateOffsets(9023920L, 9037040L, 0L, 9056880L, 8292032L, 5620320L, 5620224L, 26541120L);
					case 23:
						return CreateOffsets(9023392L, 9036512L, 0L, 9056352L, 8291504L, 5620032L, 5619936L, 26541120L);
					case 24:
						return CreateOffsets(9022208L, 9035328L, 0L, 9055168L, 8290352L, 5618944L, 5618848L, 26561600L);
					case 25:
						return CreateOffsets(9026880L, 9040000L, 0L, 9059840L, 8294112L, 5620704L, 5620608L, 26569792L);
					case 26:
						return CreateOffsets(9027472L, 9040592L, 0L, 9060432L, 8294688L, 5621152L, 5621056L, 26569792L);
					case 27:
						return CreateOffsets(9026768L, 9039888L, 0L, 9059728L, 8293984L, 5620224L, 5620128L, 26569792L);
					case 28:
						return CreateOffsets(9026528L, 9039648L, 0L, 9059488L, 8293680L, 5619808L, 5619712L, 26569792L);
					}
					break;
				case 2:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(6652704L, 6667376L, 0L, 6692368L, 5807344L, 2872928L, 2872848L, 27258624L);
					case 1:
						return CreateOffsets(6652976L, 6667648L, 0L, 6692640L, 5807568L, 2872928L, 2872848L, 27258624L);
					case 2:
						return CreateOffsets(6655264L, 6669936L, 0L, 6694928L, 5809856L, 2874560L, 2874480L, 27266880L);
					case 3:
						return CreateOffsets(6656032L, 6670704L, 0L, 6695696L, 5810656L, 2874464L, 2874384L, 27271040L);
					case 4:
						return CreateOffsets(6655456L, 6670128L, 0L, 6695120L, 5810080L, 2874688L, 2874608L, 27271232L);
					case 5:
						return CreateOffsets(6656720L, 6671392L, 0L, 6696384L, 5811344L, 2875344L, 2875264L, 27275200L);
					case 6:
						return CreateOffsets(6657024L, 6671696L, 0L, 6696688L, 5811648L, 2875344L, 2875264L, 27275264L);
					case 7:
						return CreateOffsets(6657344L, 6672016L, 0L, 6697008L, 5811968L, 2875664L, 2875584L, 27279360L);
					case 8:
						return CreateOffsets(6658624L, 6673296L, 0L, 6698288L, 5813216L, 2876048L, 2875968L, 27287616L);
					case 9:
						return CreateOffsets(6659744L, 6674416L, 0L, 6699408L, 5814192L, 2876384L, 2876304L, 27291776L);
					case 10:
						return CreateOffsets(6660320L, 6674992L, 0L, 6699984L, 5814064L, 2876384L, 2876304L, 27295872L);
					case 11:
						return CreateOffsets(6660240L, 6674912L, 0L, 6699904L, 5813984L, 2876272L, 2876192L, 27295872L);
					case 12:
						return CreateOffsets(6661344L, 6676016L, 0L, 6701008L, 5815104L, 2876528L, 2876448L, 27300096L);
					case 13:
						return CreateOffsets(6661360L, 6676032L, 0L, 6701024L, 5815104L, 2876528L, 2876448L, 27300096L);
					case 14:
						return CreateOffsets(6661744L, 6676416L, 0L, 6701408L, 5815488L, 2876528L, 2876448L, 27300096L);
					case 15:
						return CreateOffsets(6661744L, 6676416L, 0L, 6701408L, 5815488L, 2876528L, 2876448L, 27304192L);
					case 16:
						return CreateOffsets(6661744L, 6676416L, 0L, 6701408L, 5815488L, 2876528L, 2876448L, 27312384L);
					case 17:
						return CreateOffsets(6663264L, 6677952L, 0L, 6702672L, 5815616L, 2876528L, 2876448L, 27320576L);
					case 18:
						return CreateOffsets(6666800L, 6681488L, 0L, 6706208L, 5819664L, 2877440L, 2877360L, 27324672L);
					case 19:
						return CreateOffsets(6666928L, 6681616L, 0L, 6706336L, 5819792L, 2877744L, 2877664L, 27324672L);
					}
					break;
				case 3:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(6666928L, 6681616L, 0L, 6706336L, 5819792L, 2877744L, 2877664L, 27324672L);
					case 1:
						return CreateOffsets(6668880L, 6683568L, 0L, 6708288L, 5821696L, 2877744L, 2877664L, 27328768L);
					case 2:
						return CreateOffsets(6669776L, 6684464L, 0L, 6709184L, 5822160L, 2877744L, 2877664L, 27332864L);
					case 3:
						return CreateOffsets(6669856L, 6684544L, 0L, 6709264L, 5822240L, 2877840L, 2877760L, 27337024L);
					case 4:
						return CreateOffsets(6672928L, 6687616L, 0L, 6712336L, 5825312L, 2878608L, 2878528L, 27345152L);
					case 5:
						return CreateOffsets(6674656L, 6689344L, 0L, 6714064L, 5826928L, 2878640L, 2878560L, 27345216L);
					case 6:
						return CreateOffsets(6376752L, 6391440L, 0L, 6416160L, 5529024L, 2580704L, 2580624L, 27369792L);
					case 7:
						return CreateOffsets(6380896L, 6395584L, 0L, 6420304L, 5533168L, 2583872L, 2583792L, 27373888L);
					case 8:
						return CreateOffsets(6381040L, 6395728L, 0L, 6452416L, 5533312L, 2583936L, 2583856L, 27374208L);
					case 9:
						return CreateOffsets(6386512L, 6401152L, 0L, 6457664L, 5538928L, 2583632L, 2583552L, 27370112L);
					case 10:
						return CreateOffsets(6393664L, 6408304L, 0L, 6464816L, 5546064L, 2584256L, 2584176L, 27386560L);
					case 11:
						return CreateOffsets(6395648L, 6410288L, 0L, 6466800L, 5547456L, 2584576L, 2584496L, 27517632L);
					case 12:
						return CreateOffsets(6410224L, 6424864L, 0L, 6481392L, 5559296L, 2586112L, 2586032L, 27543424L);
					case 13:
						return CreateOffsets(6411888L, 6426528L, 0L, 6483056L, 5560272L, 2586288L, 2586208L, 27551616L);
					case 14:
						return CreateOffsets(6413456L, 6428096L, 0L, 6484624L, 5561808L, 2586528L, 2586448L, 27563968L);
					case 15:
						return CreateOffsets(6416896L, 6431536L, 0L, 6488064L, 5565216L, 2586608L, 2586528L, 27564032L);
					case 16:
						return CreateOffsets(6443840L, 6458480L, 0L, 6515008L, 5591552L, 2611616L, 2611536L, 27736704L);
					case 17:
						return CreateOffsets(6445008L, 6459648L, 0L, 6516176L, 5592960L, 2614560L, 2614480L, 27749120L);
					case 18:
						return CreateOffsets(6447856L, 6462496L, 0L, 6519040L, 5595792L, 2614864L, 2614784L, 27753344L);
					case 19:
						return CreateOffsets(6448480L, 6463120L, 0L, 6519664L, 5596128L, 2615088L, 2615008L, 27769728L);
					case 20:
						return CreateOffsets(6449712L, 6464352L, 0L, 6520896L, 5597360L, 2615744L, 2615664L, 27769792L);
					case 21:
						return CreateOffsets(6451840L, 6466480L, 0L, 6523024L, 5599184L, 2616480L, 2616400L, 27839424L);
					case 22:
						return CreateOffsets(6452016L, 6466656L, 0L, 6523200L, 5599360L, 2616480L, 2616400L, 27839424L);
					case 23:
						return CreateOffsets(6452656L, 6467296L, 0L, 6523840L, 5600192L, 2617376L, 2617296L, 27847680L);
					case 24:
						return CreateOffsets(6452688L, 6467328L, 0L, 6523872L, 5600176L, 2617376L, 2617296L, 27847680L);
					case 25:
						return CreateOffsets(6453056L, 6467696L, 0L, 6524240L, 5601376L, 2617424L, 2617344L, 27843584L);
					case 26:
						return CreateOffsets(6454560L, 6469200L, 0L, 6525744L, 5602864L, 2617472L, 2617392L, 27847680L);
					case 27:
						return CreateOffsets(6454800L, 6469440L, 0L, 6525984L, 5602880L, 2617472L, 2617392L, 27847680L);
					case 28:
						return CreateOffsets(6457680L, 6472320L, 0L, 6528864L, 5605600L, 2617744L, 2617664L, 27855872L);
					case 29:
						return CreateOffsets(6441072L, 6455712L, 0L, 6512256L, 5589024L, 2593760L, 2593680L, 27855936L);
					case 30:
						return CreateOffsets(6444464L, 6459104L, 0L, 6515648L, 5593776L, 2594128L, 2594048L, 27864128L);
					case 31:
						return CreateOffsets(6446528L, 6461168L, 0L, 6517712L, 5594896L, 2595088L, 2595008L, 27921472L);
					case 32:
						return CreateOffsets(6448704L, 6463344L, 0L, 6519888L, 5597008L, 2596272L, 2596192L, 27925568L);
					case 33:
						return CreateOffsets(6446528L, 6461168L, 0L, 6517712L, 5594304L, 2593680L, 2593600L, 27913152L);
					case 34:
						return CreateOffsets(6452272L, 6466912L, 0L, 6524096L, 5599184L, 2594336L, 2594256L, 27925504L);
					case 35:
						return CreateOffsets(6452992L, 6467632L, 0L, 6524816L, 5599904L, 2594464L, 2594384L, 27933696L);
					case 36:
						return CreateOffsets(6452832L, 6467472L, 0L, 6524656L, 5600048L, 2594528L, 2594448L, 27933696L);
					case 37:
						return CreateOffsets(6453200L, 6467840L, 0L, 6525024L, 5599552L, 2593536L, 2593456L, 27937792L);
					case 38:
						return CreateOffsets(6453920L, 6468560L, 0L, 6525744L, 5600272L, 2593536L, 2593456L, 27937792L);
					case 39:
						return CreateOffsets(6454176L, 6468816L, 0L, 6526048L, 5600528L, 2593248L, 2593168L, 27945984L);
					case 40:
						return CreateOffsets(6454912L, 6469552L, 0L, 6526784L, 5601200L, 2593504L, 2593424L, 27954176L);
					case 41:
						return CreateOffsets(6460032L, 6474672L, 0L, 6531904L, 5606800L, 2593840L, 2593760L, 27954176L);
					case 42:
						return CreateOffsets(6460256L, 6474896L, 0L, 6532128L, 5607024L, 2593840L, 2593760L, 27954176L);
					case 43:
						return CreateOffsets(6460304L, 6474944L, 0L, 6532176L, 5607072L, 2593840L, 2593760L, 27884544L);
					case 44:
						return CreateOffsets(6477024L, 6491664L, 0L, 6548896L, 5612048L, 2598800L, 2598720L, 27900928L);
					case 45:
						return CreateOffsets(6477072L, 6491712L, 0L, 6548944L, 5612096L, 2598800L, 2598720L, 27905024L);
					case 46:
						return CreateOffsets(6477072L, 6491712L, 0L, 6548944L, 5612096L, 2598800L, 2598720L, 28011520L);
					case 47:
						return CreateOffsets(6477072L, 6491712L, 0L, 6548944L, 5612096L, 2598800L, 2598720L, 28011520L);
					case 48:
						return CreateOffsets(6477072L, 6491712L, 0L, 6548944L, 5612096L, 2598800L, 2598720L, 28015616L);
					case 49:
						return CreateOffsets(6477072L, 6491712L, 0L, 6548944L, 5612096L, 2598800L, 2598720L, 28015616L);
					case 50:
						return CreateOffsets(6477072L, 6491712L, 0L, 6548944L, 5612096L, 2598800L, 2598720L, 28015616L);
					}
					break;
				}
				break;
			case 2022:
				switch (unityVersion.Minor)
				{
				case 1:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(6777184L, 6791680L, 0L, 6816768L, 5906960L, 2901088L, 2901008L, 27528640L);
					case 1:
						return CreateOffsets(6778016L, 6792528L, 0L, 6817616L, 5907392L, 2901232L, 2901152L, 27528640L);
					case 2:
						return CreateOffsets(6780976L, 6795488L, 0L, 6820576L, 5910352L, 2901600L, 2901520L, 27532672L);
					case 3:
						return CreateOffsets(6780976L, 6795488L, 0L, 6820576L, 5910352L, 2901600L, 2901520L, 27532672L);
					case 4:
						return CreateOffsets(6780608L, 6795120L, 0L, 6820208L, 5909984L, 2901600L, 2901520L, 27532672L);
					case 5:
						return CreateOffsets(6780608L, 6795120L, 0L, 6820208L, 5909984L, 2901600L, 2901520L, 27532672L);
					case 6:
						return CreateOffsets(6780528L, 6795040L, 0L, 6820128L, 5909600L, 2901600L, 2901520L, 27532672L);
					case 7:
						return CreateOffsets(6780528L, 6795040L, 0L, 6820128L, 5909600L, 2901600L, 2901520L, 27536768L);
					case 8:
						return CreateOffsets(6780848L, 6795360L, 0L, 6820448L, 5909920L, 2901600L, 2901520L, 27536768L);
					case 9:
						return CreateOffsets(6784272L, 6798784L, 0L, 6823872L, 5913344L, 2901888L, 2901808L, 27684224L);
					case 10:
						return CreateOffsets(6784272L, 6798784L, 0L, 6856288L, 5913344L, 2901888L, 2901808L, 27684480L);
					case 11:
						return CreateOffsets(6784272L, 6798784L, 0L, 6856288L, 5913344L, 2901888L, 2901808L, 27684480L);
					case 12:
						return CreateOffsets(6785312L, 6799824L, 0L, 6857344L, 5914368L, 2902112L, 2902032L, 27684544L);
					case 13:
						return CreateOffsets(6797280L, 6811792L, 0L, 6869312L, 5926352L, 2902112L, 2902032L, 27696832L);
					case 14:
						return CreateOffsets(6797104L, 6811616L, 0L, 6869136L, 5926176L, 2901952L, 2901872L, 27729600L);
					case 15:
						return CreateOffsets(6797104L, 6811616L, 0L, 6869136L, 5926176L, 2901952L, 2901872L, 27737792L);
					case 16:
						return CreateOffsets(6797360L, 6811872L, 0L, 6869392L, 5926176L, 2901952L, 2901872L, 27737792L);
					case 17:
						return CreateOffsets(6798208L, 6812720L, 0L, 6870240L, 5927024L, 2901936L, 2901856L, 27733696L);
					case 18:
						return CreateOffsets(6800912L, 6815424L, 0L, 6872944L, 5929184L, 2902288L, 2902208L, 27737920L);
					case 19:
						return CreateOffsets(6801392L, 6815904L, 0L, 6873424L, 5929664L, 2902608L, 2902528L, 27737920L);
					case 20:
						return CreateOffsets(6801376L, 6815888L, 0L, 6873408L, 5929648L, 2902592L, 2902512L, 27737920L);
					case 21:
						return CreateOffsets(6807376L, 6821888L, 0L, 6879408L, 5935264L, 2902992L, 2902912L, 27746176L);
					case 22:
						return CreateOffsets(6807568L, 6822080L, 0L, 6879600L, 5935456L, 2902992L, 2902912L, 27746176L);
					case 23:
						return CreateOffsets(6807968L, 6822480L, 0L, 6880000L, 5935744L, 2903152L, 2903072L, 27754368L);
					case 24:
						return CreateOffsets(6809360L, 6823872L, 0L, 6881392L, 5937024L, 2903152L, 2903072L, 27746176L);
					}
					break;
				case 2:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(7635360L, 7634128L, 0L, 7719360L, 6690192L, 3458912L, 6453920L, 28917696L);
					case 1:
						return CreateOffsets(7637952L, 7636720L, 0L, 7721952L, 6692784L, 3457664L, 6456512L, 28917760L);
					case 2:
						return CreateOffsets(7643824L, 7642592L, 0L, 7727824L, 6698096L, 3457296L, 6461824L, 28934144L);
					case 3:
						return CreateOffsets(7647840L, 7646608L, 0L, 7731840L, 6702048L, 3460656L, 6461728L, 28933120L);
					case 4:
						return CreateOffsets(7666592L, 7665360L, 0L, 7750896L, 6717104L, 3472224L, 6476864L, 28963136L);
					case 5:
						return CreateOffsets(7668512L, 7667280L, 0L, 7752832L, 6719024L, 3473280L, 6478784L, 28967168L);
					case 6:
						return CreateOffsets(7669008L, 7667776L, 0L, 7753328L, 6719184L, 3473216L, 6478944L, 28967232L);
					case 7:
						return CreateOffsets(7681936L, 7680704L, 0L, 7766256L, 6732192L, 3478656L, 6492608L, 28979520L);
					case 8:
						return CreateOffsets(7683840L, 7682608L, 0L, 7768160L, 6733888L, 3480368L, 6494320L, 28983616L);
					case 9:
						return CreateOffsets(7683616L, 7682384L, 0L, 7767936L, 6735184L, 3481280L, 6495616L, 28991808L);
					case 10:
						return CreateOffsets(7685120L, 7683888L, 0L, 7769440L, 6737008L, 3482176L, 6497424L, 28983616L);
					case 11:
						return CreateOffsets(7687392L, 7686160L, 0L, 7771712L, 6739120L, 3481888L, 6498848L, 28987776L);
					case 12:
						return CreateOffsets(7688928L, 7687696L, 0L, 7773248L, 6740656L, 3480112L, 6500384L, 28995968L);
					case 13:
						return CreateOffsets(7686160L, 7684928L, 0L, 7770480L, 6738016L, 3478880L, 6497744L, 28991872L);
					case 14:
						return CreateOffsets(7690688L, 7689456L, 0L, 7775008L, 6742544L, 3481072L, 6502272L, 29004224L);
					case 15:
						return CreateOffsets(7696432L, 7695200L, 0L, 7780784L, 6748528L, 3482784L, 6508256L, 29012416L);
					case 16:
						return CreateOffsets(7698016L, 7696784L, 0L, 7782368L, 6750352L, 3482544L, 6510080L, 29012288L);
					case 17:
						return CreateOffsets(7698752L, 7697520L, 0L, 7783104L, 6750816L, 3482528L, 6510528L, 29008128L);
					case 18:
						return CreateOffsets(7712128L, 7710896L, 0L, 7796480L, 6764032L, 3482960L, 6523504L, 29032896L);
					case 19:
						return CreateOffsets(7713040L, 7711808L, 0L, 7797392L, 6764944L, 3482992L, 6524416L, 29118976L);
					case 20:
						return CreateOffsets(7843536L, 7842304L, 0L, 7928272L, 6889552L, 3570320L, 6649504L, 29295232L);
					case 21:
						return CreateOffsets(7846064L, 7844832L, 0L, 7930800L, 6892224L, 3570592L, 6652176L, 29295296L);
					}
					break;
				case 3:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(7847584L, 7846352L, 0L, 7932528L, 6892992L, 3570704L, 6652400L, 29299392L);
					case 1:
						return CreateOffsets(7845168L, 7843936L, 0L, 7930080L, 6891360L, 3570512L, 6650848L, 29299456L);
					case 2:
						return CreateOffsets(7845584L, 7844352L, 0L, 7930496L, 6891600L, 3570656L, 6651088L, 29299456L);
					case 3:
						return CreateOffsets(7844976L, 7843744L, 0L, 7929888L, 6891504L, 3570768L, 6651024L, 29303552L);
					case 4:
						return CreateOffsets(7845360L, 7844128L, 0L, 7930272L, 6891872L, 3571136L, 6651392L, 29303552L);
					case 5:
						return CreateOffsets(7770736L, 7769504L, 0L, 7855648L, 6816912L, 3496112L, 6575392L, 29305024L);
					case 6:
						return CreateOffsets(7770304L, 7769072L, 0L, 7855216L, 6816176L, 3494512L, 6574496L, 29313280L);
					case 7:
						return CreateOffsets(7777520L, 7776288L, 0L, 7863936L, 6823312L, 3494432L, 6581392L, 29329856L);
					case 8:
						return CreateOffsets(7781552L, 7780320L, 0L, 7868240L, 6827904L, 3495520L, 6585968L, 29338048L);
					case 9:
						return CreateOffsets(7782592L, 7781360L, 0L, 7869280L, 6828848L, 3495632L, 6586912L, 29342272L);
					case 10:
						return CreateOffsets(7781968L, 7780736L, 0L, 7868656L, 6827888L, 3496800L, 6586336L, 29342208L);
					case 11:
						return CreateOffsets(7790496L, 7789264L, 0L, 7877248L, 6833280L, 3499872L, 6593040L, 29341760L);
					case 12:
						return CreateOffsets(7791136L, 7789904L, 0L, 7877920L, 6833904L, 3501472L, 6583520L, 29345984L);
					case 13:
						return CreateOffsets(7791744L, 7790512L, 0L, 7878528L, 6834000L, 3501568L, 6583616L, 29362368L);
					case 14:
						return CreateOffsets(7814944L, 7814464L, 0L, 7904272L, 6854512L, 3502448L, 6601600L, 29481152L);
					case 15:
						return CreateOffsets(7815904L, 7815424L, 0L, 7905408L, 6855280L, 3502128L, 6602368L, 29489344L);
					case 16:
						return CreateOffsets(7826928L, 7826448L, 0L, 7916400L, 6865920L, 3503072L, 6612752L, 29513984L);
					case 17:
						return CreateOffsets(7824736L, 7824256L, 0L, 7914208L, 6864000L, 3503088L, 6610832L, 29509824L);
					case 18:
						return CreateOffsets(7824704L, 7824224L, 0L, 7914176L, 6863968L, 3502960L, 6610800L, 29509824L);
					case 19:
						return CreateOffsets(7843760L, 7843280L, 0L, 7933232L, 6882768L, 3504816L, 6630560L, 29526336L);
					case 20:
						return CreateOffsets(7875552L, 7875072L, 0L, 7965056L, 6914528L, 3508912L, 6662224L, 29559104L);
					case 21:
						return CreateOffsets(7862512L, 7862032L, 0L, 7952016L, 6869728L, 3509376L, 6649920L, 29559104L);
					case 22:
						return CreateOffsets(7865344L, 7864864L, 0L, 7954848L, 6871856L, 3511008L, 6652048L, 29563200L);
					case 23:
						return CreateOffsets(7863952L, 7863472L, 0L, 7953456L, 6870464L, 3510576L, 6650656L, 29567296L);
					case 24:
						return CreateOffsets(7862496L, 7862016L, 0L, 7952000L, 6868048L, 3508096L, 6648240L, 29567296L);
					case 25:
						return CreateOffsets(7856480L, 7856000L, 0L, 7944384L, 6853104L, 3505952L, 6633520L, 29563200L);
					case 26:
						return CreateOffsets(7858592L, 7858112L, 0L, 7946496L, 6852256L, 3505904L, 6632656L, 29563456L);
					case 27:
						return CreateOffsets(7858800L, 7858320L, 0L, 7946704L, 6852464L, 3504288L, 6632864L, 29563520L);
					case 28:
						return CreateOffsets(7858368L, 7857888L, 0L, 7946272L, 6852032L, 3503968L, 6632432L, 29563520L);
					case 29:
						return CreateOffsets(7858448L, 7857968L, 0L, 7946352L, 6852112L, 3504048L, 6632512L, 29563520L);
					case 30:
						return CreateOffsets(7861344L, 7860864L, 0L, 7949168L, 6855008L, 3506688L, 6635408L, 29567552L);
					case 31:
						return CreateOffsets(7862352L, 7861872L, 0L, 7950176L, 6855824L, 3506848L, 6636224L, 29571648L);
					case 32:
						return CreateOffsets(7862496L, 7862016L, 0L, 7950320L, 6855968L, 3506848L, 6636368L, 29571648L);
					case 33:
						return CreateOffsets(7863168L, 7862688L, 0L, 7950992L, 6856352L, 3507248L, 6636256L, 29579840L);
					case 34:
						return CreateOffsets(7863552L, 7863072L, 0L, 7951376L, 6856752L, 3507440L, 6636656L, 29579904L);
					case 35:
						return CreateOffsets(7864592L, 7864112L, 0L, 7952416L, 6857792L, 3507456L, 6637552L, 29579840L);
					case 36:
						return CreateOffsets(7857456L, 7856976L, 0L, 7943120L, 6855472L, 3509600L, 6636608L, 29555264L);
					case 37:
						return CreateOffsets(7858496L, 7858016L, 0L, 7944160L, 6856512L, 3509504L, 6637696L, 29555264L);
					case 38:
						return CreateOffsets(7858352L, 7857872L, 0L, 7944016L, 6856368L, 3509456L, 6637552L, 29559424L);
					case 39:
						return CreateOffsets(7863408L, 7862928L, 0L, 7948624L, 6861408L, 3509024L, 6641200L, 29563456L);
					case 40:
						return CreateOffsets(7862784L, 7862304L, 0L, 7948000L, 6860784L, 3509216L, 6640592L, 29567552L);
					case 41:
						return CreateOffsets(7863360L, 7862880L, 0L, 7948576L, 6861040L, 3509216L, 6640848L, 29563456L);
					case 42:
						return CreateOffsets(7868624L, 7868144L, 0L, 7953840L, 6866304L, 3514400L, 6646032L, 29403776L);
					case 43:
						return CreateOffsets(7869152L, 7868672L, 0L, 7954432L, 6866832L, 3514560L, 6646560L, 29403712L);
					case 44:
						return CreateOffsets(7870288L, 7869808L, 0L, 7955568L, 6866944L, 3514416L, 6646672L, 29407808L);
					case 45:
						return CreateOffsets(7870880L, 7870400L, 0L, 7956160L, 6867536L, 3514432L, 6647264L, 29411968L);
					case 46:
						return CreateOffsets(7870752L, 7870272L, 0L, 7956032L, 6867408L, 3513872L, 6647136L, 29411968L);
					case 47:
						return CreateOffsets(7870944L, 7870464L, 0L, 7956224L, 6867600L, 3514016L, 6647328L, 29411904L);
					case 48:
						return CreateOffsets(7870912L, 7870432L, 0L, 7956192L, 6867568L, 3513968L, 6647296L, 29416000L);
					case 49:
						return CreateOffsets(7871568L, 7871088L, 0L, 7956848L, 6868224L, 3514624L, 6647952L, 29420096L);
					case 50:
						return CreateOffsets(7871440L, 7870960L, 0L, 7956720L, 6868096L, 3514576L, 6647744L, 29420096L);
					case 51:
						return CreateOffsets(7872928L, 7872448L, 0L, 7958208L, 6869584L, 3515472L, 6648640L, 29424192L);
					case 52:
						return CreateOffsets(7869776L, 7869296L, 0L, 7955056L, 6866432L, 3515584L, 6646816L, 29629312L);
					case 53:
						return CreateOffsets(7867584L, 7867104L, 0L, 7952864L, 6864880L, 3516576L, 6645568L, 29621120L);
					case 54:
						return CreateOffsets(7867392L, 7866912L, 0L, 7953120L, 6864688L, 3516400L, 6645328L, 29629376L);
					case 55:
						return CreateOffsets(7867856L, 7867376L, 0L, 7953584L, 6865136L, 3517040L, 6645776L, 29625408L);
					case 56:
						return CreateOffsets(7872736L, 7872256L, 0L, 7958464L, 6869920L, 3517872L, 6650336L, 29629504L);
					case 57:
						return CreateOffsets(7872976L, 7872496L, 0L, 7958704L, 6870128L, 3517808L, 6650288L, 29629504L);
					case 58:
						return CreateOffsets(7881888L, 7881408L, 0L, 7967616L, 6878304L, 3517008L, 6658576L, 29645888L);
					case 59:
						return CreateOffsets(7881376L, 7880896L, 0L, 7967104L, 6877840L, 3516384L, 6658112L, 29645824L);
					case 60:
						return CreateOffsets(7881392L, 7880912L, 0L, 7967120L, 6878496L, 3517168L, 6658768L, 29666368L);
					case 61:
						return CreateOffsets(7882048L, 7881568L, 0L, 7967776L, 6879040L, 3516880L, 6659184L, 29678656L);
					case 62:
						return CreateOffsets(7881008L, 0L, 6889888L, 7965760L, 6876448L, 3517936L, 6655536L, 29674624L);
					}
					break;
				}
				break;
			case 2023:
				switch (unityVersion.Minor)
				{
				case 1:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(6824560L, 6824016L, 0L, 6914080L, 5866960L, 2476800L, 5489344L, 28587648L);
					case 1:
						return CreateOffsets(6826352L, 6825808L, 0L, 6915872L, 5868752L, 2476976L, 5491168L, 28595840L);
					case 2:
						return CreateOffsets(6827456L, 6826912L, 0L, 6916976L, 5870496L, 2477888L, 5492912L, 28595840L);
					case 3:
						return CreateOffsets(6816704L, 6816160L, 0L, 6906224L, 5859744L, 2467136L, 5482208L, 28587648L);
					case 4:
						return CreateOffsets(6816736L, 6816192L, 0L, 6906256L, 5859776L, 2466688L, 5482192L, 28609600L);
					case 5:
						return CreateOffsets(6815968L, 6815424L, 0L, 6905488L, 5858960L, 2467248L, 5481376L, 28609600L);
					case 6:
						return CreateOffsets(6816400L, 6815856L, 0L, 6905920L, 5859392L, 2467328L, 5481648L, 28609600L);
					case 7:
						return CreateOffsets(6815216L, 6814672L, 0L, 6904736L, 5857920L, 2465872L, 5480176L, 28613696L);
					case 8:
						return CreateOffsets(6820336L, 6819792L, 0L, 6909856L, 5863088L, 2465664L, 5485104L, 28617728L);
					case 9:
						return CreateOffsets(6822976L, 6822432L, 0L, 6912768L, 5866416L, 2465712L, 5488416L, 28630080L);
					case 10:
						return CreateOffsets(6823552L, 6823008L, 0L, 6913344L, 5866944L, 2466208L, 5488944L, 28638272L);
					case 11:
						return CreateOffsets(6826448L, 6825904L, 0L, 6916240L, 5867984L, 2466320L, 5489984L, 28638272L);
					case 12:
						return CreateOffsets(6828720L, 6828176L, 0L, 6918512L, 5869888L, 2467312L, 5492480L, 28642496L);
					case 13:
						return CreateOffsets(6828992L, 6828448L, 0L, 6918784L, 5869984L, 2467872L, 5492560L, 28646592L);
					case 14:
						return CreateOffsets(6829424L, 6828880L, 0L, 6919216L, 5870368L, 2467888L, 5492944L, 28646656L);
					case 15:
						return CreateOffsets(6828320L, 6827776L, 0L, 6918112L, 5869312L, 2467792L, 5491776L, 28646656L);
					case 16:
						return CreateOffsets(6829280L, 6828736L, 0L, 6919072L, 5870272L, 2468448L, 5492352L, 28654848L);
					case 17:
						return CreateOffsets(6831440L, 6830896L, 0L, 6921152L, 5872336L, 2470672L, 5495888L, 28679488L);
					case 18:
						return CreateOffsets(6831792L, 6831248L, 0L, 6921552L, 5872672L, 2470912L, 5496224L, 28683584L);
					case 19:
						return CreateOffsets(6829024L, 6828480L, 0L, 6918784L, 5869904L, 2470928L, 5495696L, 28679488L);
					case 20:
						return CreateOffsets(6827824L, 6827280L, 0L, 6917296L, 5871216L, 2475888L, 5497056L, 28695872L);
					}
					break;
				case 2:
					switch (unityVersion.Build)
					{
					case 0:
						return CreateOffsets(7015696L, 7015120L, 0L, 7091776L, 6050128L, 2586768L, 2586960L, 29192896L);
					case 1:
						return CreateOffsets(7016576L, 7016000L, 0L, 7092672L, 6050928L, 2586416L, 2586608L, 29192896L);
					case 2:
						return CreateOffsets(7018288L, 7017712L, 0L, 7094384L, 6052832L, 2587200L, 2587392L, 29192896L);
					case 3:
						return CreateOffsets(7018224L, 7017648L, 0L, 7094320L, 6052768L, 2587216L, 2587408L, 29209280L);
					case 4:
						return CreateOffsets(7025840L, 7025264L, 0L, 7101952L, 6059616L, 2588864L, 2589056L, 29225664L);
					case 5:
						return CreateOffsets(7026144L, 7025568L, 0L, 7102256L, 6059888L, 2588880L, 2589072L, 29229760L);
					case 6:
						return CreateOffsets(7026192L, 7025616L, 0L, 7102304L, 6059936L, 2588928L, 2589120L, 29225664L);
					case 7:
						return CreateOffsets(7026224L, 7025648L, 0L, 7102336L, 6059968L, 2588928L, 2589120L, 29221568L);
					case 8:
						return CreateOffsets(7040464L, 7039888L, 0L, 7116576L, 6073936L, 2589024L, 2589216L, 29225792L);
					case 9:
						return CreateOffsets(7040496L, 7039920L, 0L, 7116608L, 6073968L, 2589040L, 2589232L, 29229888L);
					case 10:
						return CreateOffsets(7042400L, 7041824L, 0L, 7118512L, 6075856L, 2588944L, 2589136L, 29266816L);
					case 11:
						return CreateOffsets(7043184L, 7042608L, 0L, 7119296L, 6076592L, 2589648L, 2589840L, 29270848L);
					case 12:
						return CreateOffsets(7043584L, 7043008L, 0L, 7119696L, 6076752L, 2589808L, 2590000L, 29270848L);
					case 13:
						return CreateOffsets(7038816L, 7038240L, 0L, 7114928L, 6071552L, 2589904L, 2590096L, 29274944L);
					case 14:
						return CreateOffsets(7038928L, 7038352L, 0L, 7115040L, 6071568L, 2589904L, 2590096L, 29274944L);
					case 15:
						return CreateOffsets(7038832L, 7038256L, 0L, 7114944L, 6071568L, 2589904L, 2590096L, 29274944L);
					case 16:
						return CreateOffsets(7037424L, 7036848L, 0L, 7113536L, 6071664L, 2590000L, 2590192L, 29279040L);
					case 17:
						return CreateOffsets(7062768L, 7062192L, 0L, 7137456L, 6086256L, 2593776L, 2593968L, 29365056L);
					case 18:
						return CreateOffsets(7058160L, 7057584L, 0L, 7132848L, 6081824L, 2592432L, 2592624L, 29352768L);
					case 19:
						return CreateOffsets(7058160L, 7057584L, 0L, 7132848L, 6081824L, 2592432L, 2592624L, 29352768L);
					case 20:
						return CreateOffsets(7056848L, 7056272L, 0L, 7131536L, 6080496L, 2592640L, 2592832L, 29360960L);
					}
					break;
				}
				break;
			}
			return null;
		}

		private static Dictionary<string, long> CreateOffsets(long monoManagerAwakeFromLoadOffset, long monoManagerIsAssemblyCreatedOffset, long isFileCreatedOffset, long scriptingManagerDeconstructorOffset, long convertSeparatorsToPlatformOffset, long mallocInternalOffset, long freeAllocInternalOffset, long scriptingAssembliesOffset)
		{
			return new Dictionary<string, long>
			{
				["MonoManagerAwakeFromLoadOffset"] = monoManagerAwakeFromLoadOffset,
				["MonoManagerIsAssemblyCreatedOffset"] = monoManagerIsAssemblyCreatedOffset,
				["IsFileCreatedOffset"] = isFileCreatedOffset,
				["ScriptingManagerDeconstructorOffset"] = scriptingManagerDeconstructorOffset,
				["ConvertSeparatorsToPlatformOffset"] = convertSeparatorsToPlatformOffset,
				["MallocInternalOffset"] = mallocInternalOffset,
				["FreeAllocInternalOffset"] = freeAllocInternalOffset,
				["ScriptingAssembliesOffset"] = scriptingAssembliesOffset
			};
		}
	}
	internal class MiniPdbReader
	{
		private readonly PeReader _peReader;

		private byte[] _pdbFile;

		internal bool IsPdbAvailable;

		internal bool UseCache;

		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 supported versions");
				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 supported versions");
				}
			}
			else
			{
				IsPdbAvailable = true;
			}
		}

		private bool DownloadUnityPdb(PeReader peReader)
		{
			if (DownloadUnityPdbCab(peReader))
			{
				return true;
			}
			string url = peReader.RsdsPdbFileName + "/" + peReader.PdbGuid + "/" + peReader.RsdsPdbFileName;
			string text = Path.Combine(Path.GetTempPath(), "UnityEngine.pdb");
			if (!Win32.DownloadUnitySymbolFile(url, text))
			{
				return false;
			}
			_pdbFile = File.ReadAllBytes(text);
			File.Delete(text);
			return true;
		}

		private bool DownloadUnityPdbCab(PeReader peReader)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				string text = peReader.RsdsPdbFileName.TrimEnd(new char[1] { 'b' }) + "_";
				string url = peReader.RsdsPdbFileName + "/" + peReader.PdbGuid + "/" + text;
				string tempPath = Path.GetTempPath();
				string text2 = Path.Combine(tempPath, "pdb.cab");
				if (!Win32.DownloadUnitySymbolFile(url, text2))
				{
					return false;
				}
				CabInfo val = new CabInfo(text2);
				Log.Info("Unpacking the compressed pdb");
				((ArchiveInfo)val).Unpack(tempPath);
				string path = Path.Combine(tempPath, "pdb.cab");
				_pdbFile = File.ReadAllBytes(text2);
				File.Delete(text2);
				File.Delete(path);
				return true;
			}
			catch
			{
				return false;
			}
		}

		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)
				{
					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 CopyNativeAssemblyListToManagedV0(List<StringStorageDefaultV0> managedAssemblyList, Vector<StringStorageDefaultV0> assemblyNames)
		{
			managedAssemblyList.Clear();
			for (StringStorageDefaultV0* ptr = assemblyNames.first; ptr != assemblyNames.last; ptr++)
			{
				managedAssemblyList.Add(*ptr);
			}
		}

		public unsafe static void AddAssembliesToManagedListV0(List<StringStorageDefaultV0> 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++;
				}
				StringStorageDefaultV0 stringStorageDefaultV = default(StringStorageDefaultV0);
				stringStorageDefaultV.data = intPtr;
				stringStorageDefaultV.extra1 = num;
				stringStorageDefaultV.size = num;
				stringStorageDefaultV.flags = 31uL;
				stringStorageDefaultV.extra2 = 0uL;
				StringStorageDefaultV0 item = stringStorageDefaultV;
				managedAssemblyList.Add(item);
			}
		}

		public unsafe static void AllocNativeAssemblyListFromManagedV0(List<StringStorageDefaultV0> managedAssemblyList, Vector<StringStorageDefaultV0>* assemblyNames)
		{
			StringStorageDefaultV0* ptr = (StringStorageDefaultV0*)(void*)Marshal.AllocHGlobal(Marshal.SizeOf(typeof(StringStorageDefaultV0)) * managedAssemblyList.Count);
			int i = 0;
			StringStorageDefaultV0* 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 PrintAssembliesV0(Vector<StringStorageDefaultV0> assemblyNames)
		{
			for (StringStorageDefaultV0* ptr = assemblyNames.first; ptr != assemblyNames.last; ptr++)
			{
				if (ptr->flags < 16)
				{
					Log.Warning("Ass: " + Marshal.PtrToStringAnsi((IntPtr)ptr));
				}
				else
				{
					Log.Warning("Ass: " + Marshal.PtrToStringAnsi(ptr->data, (int)ptr->size));
				}
			}
		}

		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 class PatternDiscoverer
	{
		private readonly IntPtr unityModule;

		private readonly MiniPdbReader pdbReader;

		private readonly bool usePdb;

		private readonly Dictionary<string, long> functionOffsets;

		public PatternDiscoverer(IntPtr unityModule, string unityPlayerPath)
		{
			this.unityModule = unityModule;
			switch (Config.FunctionOffsetLookupType.Value)
			{
			case FunctionOffsetLookup.Manual:
				break;
			case FunctionOffsetLookup.PreferPdb:
				pdbReader = new MiniPdbReader(unityPlayerPath);
				usePdb = pdbReader.IsPdbAvailable;
				if (!usePdb)
				{
					if (!FunctionOffsets.TryGet(UseRightStructs.UnityVersion, out functionOffsets))
					{
						throw new NotSupportedException($"Pdb not found and {UseRightStructs.UnityVersion} is not a supported version");
					}
					Log.Info("Found offsets for current version, using them.");
				}
				break;
			case FunctionOffsetLookup.PreferSupportedVersions:
				if (!FunctionOffsets.TryGet(UseRightStructs.UnityVersion, out functionOffsets))
				{
					pdbReader = new MiniPdbReader(unityPlayerPath);
					usePdb = pdbReader.IsPdbAvailable;
					if (!usePdb)
					{
						throw new NotSupportedException($"{UseRightStructs.UnityVersion} is not a supported version and pdb not found");
					}
				}
				else
				{
					Log.Info("Found offsets for current version, using them.");
				}
				break;
			default:
				throw new ArgumentException("FunctionOffsetLookupType");
			}
		}

		public IntPtr Discover(ConfigEntry<string> functionOffsetCache, BytePattern[] pdbPatterns)
		{
			if (usePdb)
			{
				return DiscoverWithPdb(functionOffsetCache, pdbPatterns);
			}
			long num;
			if (f

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Security;
using System.Security.Permissions;
using System.Text;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyDescription("Managed libraries for cabinet archive packing and unpacking")]
[assembly: CLSCompliant(true)]
[assembly: ComVisible(false)]
[assembly: AllowPartiallyTrustedCallers]
[assembly: AssemblyFileVersion("3.10.1.2213")]
[assembly: AssemblyCompany("Outercurve Foundation")]
[assembly: AssemblyCopyright("Copyright (c) Outercurve Foundation. All rights reserved.")]
[assembly: AssemblyProduct("Windows Installer XML Toolset")]
[assembly: AssemblyConfiguration("")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, Assertion = true, UnmanagedCode = true)]
[assembly: AssemblyVersion("3.0.0.0")]
namespace Microsoft.Tools.WindowsInstallerXml
{
	internal static class WixDistribution
	{
		public static string NewsUrl = "http://wixtoolset.org/news/";

		public static string ShortProduct = "WiX Toolset";

		public static string SupportUrl = "http://wixtoolset.org/";

		public static string TelemetryUrlFormat = "http://wixtoolset.org/telemetry/v{0}/?r={1}";

		public static string ReplacePlaceholders(string original, Assembly assembly)
		{
			if ((object)assembly != null)
			{
				FileVersionInfo versionInfo = FileVersionInfo.GetVersionInfo(assembly.Location);
				original = original.Replace("[FileComments]", versionInfo.Comments);
				original = original.Replace("[FileCopyright]", versionInfo.LegalCopyright);
				original = original.Replace("[FileProductName]", versionInfo.ProductName);
				original = original.Replace("[FileVersion]", versionInfo.FileVersion);
				if (original.Contains("[FileVersionMajorMinor]"))
				{
					Version version = new Version(versionInfo.FileVersion);
					original = original.Replace("[FileVersionMajorMinor]", version.Major + "." + version.Minor);
				}
				if (TryGetAttribute<AssemblyCompanyAttribute>(assembly, out var attribute))
				{
					original = original.Replace("[AssemblyCompany]", attribute.Company);
				}
				if (TryGetAttribute<AssemblyCopyrightAttribute>(assembly, out var attribute2))
				{
					original = original.Replace("[AssemblyCopyright]", attribute2.Copyright);
				}
				if (TryGetAttribute<AssemblyDescriptionAttribute>(assembly, out var attribute3))
				{
					original = original.Replace("[AssemblyDescription]", attribute3.Description);
				}
				if (TryGetAttribute<AssemblyProductAttribute>(assembly, out var attribute4))
				{
					original = original.Replace("[AssemblyProduct]", attribute4.Product);
				}
				if (TryGetAttribute<AssemblyTitleAttribute>(assembly, out var attribute5))
				{
					original = original.Replace("[AssemblyTitle]", attribute5.Title);
				}
			}
			original = original.Replace("[NewsUrl]", NewsUrl);
			original = original.Replace("[ShortProduct]", ShortProduct);
			original = original.Replace("[SupportUrl]", SupportUrl);
			return original;
		}

		private static bool TryGetAttribute<T>(Assembly assembly, out T attribute) where T : Attribute
		{
			attribute = null;
			object[] customAttributes = assembly.GetCustomAttributes(typeof(T), inherit: false);
			if (customAttributes != null && customAttributes.Length != 0)
			{
				attribute = customAttributes[0] as T;
			}
			return attribute != null;
		}
	}
}
namespace Microsoft.Deployment.Compression.Cab
{
	internal class CabPacker : CabWorker
	{
		private const string TempStreamName = "%%TEMP%%";

		private NativeMethods.FCI.Handle fciHandle;

		private NativeMethods.FCI.PFNALLOC fciAllocMemHandler;

		private NativeMethods.FCI.PFNFREE fciFreeMemHandler;

		private NativeMethods.FCI.PFNOPEN fciOpenStreamHandler;

		private NativeMethods.FCI.PFNREAD fciReadStreamHandler;

		private NativeMethods.FCI.PFNWRITE fciWriteStreamHandler;

		private NativeMethods.FCI.PFNCLOSE fciCloseStreamHandler;

		private NativeMethods.FCI.PFNSEEK fciSeekStreamHandler;

		private NativeMethods.FCI.PFNFILEPLACED fciFilePlacedHandler;

		private NativeMethods.FCI.PFNDELETE fciDeleteFileHandler;

		private NativeMethods.FCI.PFNGETTEMPFILE fciGetTempFileHandler;

		private NativeMethods.FCI.PFNGETNEXTCABINET fciGetNextCabinet;

		private NativeMethods.FCI.PFNSTATUS fciCreateStatus;

		private NativeMethods.FCI.PFNGETOPENINFO fciGetOpenInfo;

		private IPackStreamContext context;

		private FileAttributes fileAttributes;

		private DateTime fileLastWriteTime;

		private int maxCabBytes;

		private long totalFolderBytesProcessedInCurrentCab;

		private CompressionLevel compressionLevel;

		private bool dontUseTempFiles;

		private IList<Stream> tempStreams;

		public bool UseTempFiles
		{
			get
			{
				return !dontUseTempFiles;
			}
			set
			{
				dontUseTempFiles = !value;
			}
		}

		public CompressionLevel CompressionLevel
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return compressionLevel;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				compressionLevel = value;
			}
		}

		public CabPacker(CabEngine cabEngine)
			: base(cabEngine)
		{
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			fciAllocMemHandler = base.CabAllocMem;
			fciFreeMemHandler = base.CabFreeMem;
			fciOpenStreamHandler = CabOpenStreamEx;
			fciReadStreamHandler = CabReadStreamEx;
			fciWriteStreamHandler = CabWriteStreamEx;
			fciCloseStreamHandler = CabCloseStreamEx;
			fciSeekStreamHandler = CabSeekStreamEx;
			fciFilePlacedHandler = CabFilePlaced;
			fciDeleteFileHandler = CabDeleteFile;
			fciGetTempFileHandler = CabGetTempFile;
			fciGetNextCabinet = CabGetNextCabinet;
			fciCreateStatus = CabCreateStatus;
			fciGetOpenInfo = CabGetOpenInfo;
			tempStreams = new List<Stream>();
			compressionLevel = (CompressionLevel)6;
		}

		private void CreateFci(long maxArchiveSize)
		{
			NativeMethods.FCI.CCAB cCAB = new NativeMethods.FCI.CCAB();
			checked
			{
				if (maxArchiveSize > 0 && maxArchiveSize < cCAB.cb)
				{
					cCAB.cb = Math.Max(32768, (int)maxArchiveSize);
				}
				object option = context.GetOption("maxFolderSize", (object[])null);
				if (option != null)
				{
					long num = Convert.ToInt64(option, CultureInfo.InvariantCulture);
					if (num > 0 && num < cCAB.cbFolderThresh)
					{
						cCAB.cbFolderThresh = (int)num;
					}
				}
				maxCabBytes = cCAB.cb;
				cCAB.szCab = context.GetArchiveName(0);
				if (cCAB.szCab == null)
				{
					throw new FileNotFoundException("Cabinet name not provided by stream context.");
				}
				cCAB.setID = (short)new Random().Next(-32768, 32768);
				base.CabNumbers[cCAB.szCab] = 0;
				currentArchiveName = cCAB.szCab;
				totalArchives = 1;
				base.CabStream = null;
				base.Erf.Clear();
				fciHandle = NativeMethods.FCI.Create(base.ErfHandle.AddrOfPinnedObject(), fciFilePlacedHandler, fciAllocMemHandler, fciFreeMemHandler, fciOpenStreamHandler, fciReadStreamHandler, fciWriteStreamHandler, fciCloseStreamHandler, fciSeekStreamHandler, fciDeleteFileHandler, fciGetTempFileHandler, cCAB, IntPtr.Zero);
				CheckError(extracting: false);
			}
		}

		[SecurityPermission(SecurityAction.Assert, UnmanagedCode = true)]
		public void Pack(IPackStreamContext streamContext, IEnumerable<string> files, long maxArchiveSize)
		{
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			if (streamContext == null)
			{
				throw new ArgumentNullException("streamContext");
			}
			if (files == null)
			{
				throw new ArgumentNullException("files");
			}
			lock (this)
			{
				try
				{
					context = streamContext;
					ResetProgressData();
					CreateFci(maxArchiveSize);
					checked
					{
						FileAttributes fileAttributes = default(FileAttributes);
						DateTime dateTime = default(DateTime);
						foreach (string file in files)
						{
							Stream stream = context.OpenFileReadStream(file, ref fileAttributes, ref dateTime);
							if (stream != null)
							{
								totalFileBytes += stream.Length;
								totalFiles++;
								context.CloseFileReadStream(file, stream);
							}
						}
						long num = 0L;
						currentFileNumber = -1;
						FileAttributes attributes = default(FileAttributes);
						DateTime lastWriteTime = default(DateTime);
						foreach (string file2 in files)
						{
							Stream stream2 = context.OpenFileReadStream(file2, ref attributes, ref lastWriteTime);
							if (stream2 == null)
							{
								continue;
							}
							if (stream2.Length >= 2147450880)
							{
								throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, "File {0} exceeds maximum file size for cabinet format.", new object[1] { file2 }));
							}
							if (num > 0)
							{
								bool flag = num + stream2.Length >= 2147450880;
								if (!flag)
								{
									flag = Convert.ToBoolean(streamContext.GetOption("nextFolder", new object[2] { file2, currentFolderNumber }), CultureInfo.InvariantCulture);
								}
								if (flag)
								{
									FlushFolder();
									num = 0L;
								}
							}
							if (currentFolderTotalBytes > 0)
							{
								currentFolderTotalBytes = 0L;
								currentFolderNumber++;
								num = 0L;
							}
							currentFileName = file2;
							currentFileNumber++;
							currentFileTotalBytes = stream2.Length;
							currentFileBytesProcessed = 0L;
							OnProgress((ArchiveProgressType)0);
							num += stream2.Length;
							AddFile(file2, stream2, attributes, lastWriteTime, execute: false, CompressionLevel);
						}
						FlushFolder();
						FlushCabinet();
					}
				}
				finally
				{
					if (base.CabStream != null)
					{
						context.CloseArchiveWriteStream((int)currentArchiveNumber, currentArchiveName, base.CabStream);
						base.CabStream = null;
					}
					if (base.FileStream != null)
					{
						context.CloseFileReadStream(currentFileName, base.FileStream);
						base.FileStream = null;
					}
					context = null;
					if (fciHandle != null)
					{
						fciHandle.Dispose();
						fciHandle = null;
					}
				}
			}
		}

		internal override int CabOpenStreamEx(string path, int openFlags, int shareMode, out int err, IntPtr pv)
		{
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			if (base.CabNumbers.ContainsKey(path))
			{
				Stream stream = base.CabStream;
				if (stream == null)
				{
					short num = base.CabNumbers[path];
					currentFolderTotalBytes = 0L;
					stream = context.OpenArchiveWriteStream((int)num, path, true, (CompressionEngine)(object)base.CabEngine);
					if (stream == null)
					{
						throw new FileNotFoundException(string.Format(CultureInfo.InvariantCulture, "Cabinet {0} not provided.", new object[1] { num }));
					}
					currentArchiveName = path;
					currentArchiveTotalBytes = Math.Min(totalFolderBytesProcessedInCurrentCab, maxCabBytes);
					currentArchiveBytesProcessed = 0L;
					OnProgress((ArchiveProgressType)3);
					base.CabStream = stream;
				}
				path = "%%CAB%%";
			}
			else
			{
				if (path == "%%TEMP%%")
				{
					Stream stream2 = new MemoryStream();
					tempStreams.Add(stream2);
					int result = base.StreamHandles.AllocHandle(stream2);
					err = 0;
					return result;
				}
				if (path != "%%CAB%%")
				{
					path = Path.Combine(Path.GetTempPath(), path);
					Stream stream3 = new FileStream(path, FileMode.Open, FileAccess.ReadWrite);
					tempStreams.Add(stream3);
					stream3 = (Stream)new DuplicateStream(stream3);
					int result2 = base.StreamHandles.AllocHandle(stream3);
					err = 0;
					return result2;
				}
			}
			return base.CabOpenStreamEx(path, openFlags, shareMode, out err, pv);
		}

		internal override int CabWriteStreamEx(int streamHandle, IntPtr memory, int cb, out int err, IntPtr pv)
		{
			int num = base.CabWriteStreamEx(streamHandle, memory, cb, out err, pv);
			checked
			{
				if (num > 0 && err == 0 && DuplicateStream.OriginalStream(base.StreamHandles[streamHandle]) == DuplicateStream.OriginalStream(base.CabStream))
				{
					currentArchiveBytesProcessed += cb;
					if (currentArchiveBytesProcessed > currentArchiveTotalBytes)
					{
						currentArchiveBytesProcessed = currentArchiveTotalBytes;
					}
				}
				return num;
			}
		}

		internal override int CabCloseStreamEx(int streamHandle, out int err, IntPtr pv)
		{
			Stream stream = DuplicateStream.OriginalStream(base.StreamHandles[streamHandle]);
			checked
			{
				if (stream == DuplicateStream.OriginalStream(base.FileStream))
				{
					context.CloseFileReadStream(currentFileName, stream);
					base.FileStream = null;
					long num = currentFileTotalBytes - currentFileBytesProcessed;
					currentFileBytesProcessed += num;
					fileBytesProcessed += num;
					OnProgress((ArchiveProgressType)2);
					currentFileTotalBytes = 0L;
					currentFileBytesProcessed = 0L;
					currentFileName = null;
				}
				else if (stream == DuplicateStream.OriginalStream(base.CabStream))
				{
					if (stream.CanWrite)
					{
						stream.Flush();
					}
					currentArchiveBytesProcessed = currentArchiveTotalBytes;
					OnProgress((ArchiveProgressType)5);
					currentArchiveNumber++;
					totalArchives++;
					context.CloseArchiveWriteStream(unchecked((int)currentArchiveNumber), currentArchiveName, stream);
					currentArchiveName = base.NextCabinetName;
					currentArchiveBytesProcessed = (currentArchiveTotalBytes = 0L);
					totalFolderBytesProcessedInCurrentCab = 0L;
					base.CabStream = null;
				}
				else
				{
					stream.Close();
					tempStreams.Remove(stream);
				}
				return base.CabCloseStreamEx(streamHandle, out err, pv);
			}
		}

		protected override void Dispose(bool disposing)
		{
			try
			{
				if (disposing && fciHandle != null)
				{
					fciHandle.Dispose();
					fciHandle = null;
				}
			}
			finally
			{
				base.Dispose(disposing);
			}
		}

		private static NativeMethods.FCI.TCOMP GetCompressionType(CompressionLevel compLevel)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected I4, but got Unknown
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if ((int)compLevel < 1)
			{
				return NativeMethods.FCI.TCOMP.TYPE_NONE;
			}
			if ((int)compLevel > 10)
			{
				compLevel = (CompressionLevel)10;
			}
			int num = checked(6 * (compLevel - 1)) / 9;
			return (NativeMethods.FCI.TCOMP)checked((ushort)(3 | (3840 + (num << 8))));
		}

		private void AddFile(string name, Stream stream, FileAttributes attributes, DateTime lastWriteTime, bool execute, CompressionLevel compLevel)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			base.FileStream = stream;
			fileAttributes = attributes & (FileAttributes.ReadOnly | FileAttributes.Hidden | FileAttributes.System | FileAttributes.Archive);
			fileLastWriteTime = lastWriteTime;
			currentFileName = name;
			NativeMethods.FCI.TCOMP compressionType = GetCompressionType(compLevel);
			IntPtr intPtr = IntPtr.Zero;
			try
			{
				Encoding encoding = Encoding.ASCII;
				if (Encoding.UTF8.GetByteCount(name) > name.Length)
				{
					encoding = Encoding.UTF8;
					fileAttributes |= FileAttributes.Normal;
				}
				byte[] bytes = encoding.GetBytes(name);
				intPtr = Marshal.AllocHGlobal(checked(bytes.Length + 1));
				Marshal.Copy(bytes, 0, intPtr, bytes.Length);
				Marshal.WriteByte(intPtr, bytes.Length, 0);
				base.Erf.Clear();
				NativeMethods.FCI.AddFile(fciHandle, string.Empty, intPtr, execute, fciGetNextCabinet, fciCreateStatus, fciGetOpenInfo, compressionType);
			}
			finally
			{
				if (intPtr != IntPtr.Zero)
				{
					Marshal.FreeHGlobal(intPtr);
				}
			}
			CheckError(extracting: false);
			base.FileStream = null;
			currentFileName = null;
		}

		private void FlushFolder()
		{
			base.Erf.Clear();
			NativeMethods.FCI.FlushFolder(fciHandle, fciGetNextCabinet, fciCreateStatus);
			CheckError(extracting: false);
		}

		private void FlushCabinet()
		{
			base.Erf.Clear();
			NativeMethods.FCI.FlushCabinet(fciHandle, fGetNextCab: false, fciGetNextCabinet, fciCreateStatus);
			CheckError(extracting: false);
		}

		private int CabGetOpenInfo(string path, out short date, out short time, out short attribs, out int err, IntPtr pv)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			CompressionEngine.DateTimeToDosDateAndTime(fileLastWriteTime, ref date, ref time);
			attribs = checked((short)fileAttributes);
			Stream stream = base.FileStream;
			base.FileStream = (Stream)new DuplicateStream(stream);
			int result = base.StreamHandles.AllocHandle(stream);
			err = 0;
			return result;
		}

		private int CabFilePlaced(IntPtr pccab, string filePath, long fileSize, int continuation, IntPtr pv)
		{
			return 0;
		}

		private int CabGetNextCabinet(IntPtr pccab, uint prevCabSize, IntPtr pv)
		{
			NativeMethods.FCI.CCAB cCAB = new NativeMethods.FCI.CCAB();
			Marshal.PtrToStructure(pccab, (object)cCAB);
			cCAB.szDisk = string.Empty;
			cCAB.szCab = context.GetArchiveName(cCAB.iCab);
			base.CabNumbers[cCAB.szCab] = checked((short)cCAB.iCab);
			base.NextCabinetName = cCAB.szCab;
			Marshal.StructureToPtr((object)cCAB, pccab, fDeleteOld: false);
			return 1;
		}

		private int CabCreateStatus(NativeMethods.FCI.STATUS typeStatus, uint cb1, uint cb2, IntPtr pv)
		{
			checked
			{
				switch (typeStatus)
				{
				case NativeMethods.FCI.STATUS.FILE:
					if (cb2 != 0 && currentFileBytesProcessed < currentFileTotalBytes)
					{
						if (currentFileBytesProcessed + cb2 > currentFileTotalBytes)
						{
							cb2 = (uint)currentFileTotalBytes - (uint)currentFileBytesProcessed;
						}
						currentFileBytesProcessed += cb2;
						fileBytesProcessed += cb2;
						OnProgress((ArchiveProgressType)1);
					}
					break;
				case NativeMethods.FCI.STATUS.FOLDER:
					if (cb1 == 0)
					{
						currentFolderTotalBytes = cb2 - totalFolderBytesProcessedInCurrentCab;
						totalFolderBytesProcessedInCurrentCab = cb2;
					}
					else if (currentFolderTotalBytes == 0L)
					{
						OnProgress((ArchiveProgressType)4);
					}
					break;
				}
				return 0;
			}
		}

		private int CabGetTempFile(IntPtr tempNamePtr, int tempNameSize, IntPtr pv)
		{
			string s = ((!UseTempFiles) ? "%%TEMP%%" : Path.GetFileName(Path.GetTempFileName()));
			byte[] bytes = Encoding.ASCII.GetBytes(s);
			if (bytes.Length >= tempNameSize)
			{
				return -1;
			}
			Marshal.Copy(bytes, 0, tempNamePtr, bytes.Length);
			Marshal.WriteByte(tempNamePtr, bytes.Length, 0);
			return 1;
		}

		private int CabDeleteFile(string path, out int err, IntPtr pv)
		{
			try
			{
				if (path != "%%TEMP%%")
				{
					path = Path.Combine(Path.GetTempPath(), path);
					File.Delete(path);
				}
			}
			catch (IOException)
			{
			}
			err = 0;
			return 1;
		}
	}
	public class CabEngine : CompressionEngine
	{
		private CabPacker packer;

		private CabUnpacker unpacker;

		private CabPacker Packer
		{
			get
			{
				if (packer == null)
				{
					packer = new CabPacker(this);
				}
				return packer;
			}
		}

		private CabUnpacker Unpacker
		{
			get
			{
				if (unpacker == null)
				{
					unpacker = new CabUnpacker(this);
				}
				return unpacker;
			}
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				if (packer != null)
				{
					packer.Dispose();
					packer = null;
				}
				if (unpacker != null)
				{
					unpacker.Dispose();
					unpacker = null;
				}
			}
			((CompressionEngine)this).Dispose(disposing);
		}

		public override void Pack(IPackStreamContext streamContext, IEnumerable<string> files, long maxArchiveSize)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			Packer.CompressionLevel = ((CompressionEngine)this).CompressionLevel;
			Packer.UseTempFiles = ((CompressionEngine)this).UseTempFiles;
			Packer.Pack(streamContext, files, maxArchiveSize);
		}

		public override bool IsArchive(Stream stream)
		{
			return Unpacker.IsArchive(stream);
		}

		public override IList<ArchiveFileInfo> GetFileInfo(IUnpackStreamContext streamContext, Predicate<string> fileFilter)
		{
			return Unpacker.GetFileInfo(streamContext, fileFilter);
		}

		public override void Unpack(IUnpackStreamContext streamContext, Predicate<string> fileFilter)
		{
			Unpacker.Unpack(streamContext, fileFilter);
		}

		internal void ReportProgress(ArchiveProgressEventArgs e)
		{
			((CompressionEngine)this).OnProgress(e);
		}
	}
	internal abstract class CabWorker : IDisposable
	{
		internal const string CabStreamName = "%%CAB%%";

		private CabEngine cabEngine;

		private HandleManager<Stream> streamHandles;

		private Stream cabStream;

		private Stream fileStream;

		private NativeMethods.ERF erf;

		private GCHandle erfHandle;

		private IDictionary<string, short> cabNumbers;

		private string nextCabinetName;

		private bool suppressProgressEvents;

		private byte[] buf;

		protected string currentFileName;

		protected int currentFileNumber;

		protected int totalFiles;

		protected long currentFileBytesProcessed;

		protected long currentFileTotalBytes;

		protected short currentFolderNumber;

		protected long currentFolderTotalBytes;

		protected string currentArchiveName;

		protected short currentArchiveNumber;

		protected short totalArchives;

		protected long currentArchiveBytesProcessed;

		protected long currentArchiveTotalBytes;

		protected long fileBytesProcessed;

		protected long totalFileBytes;

		public CabEngine CabEngine => cabEngine;

		internal NativeMethods.ERF Erf => erf;

		internal GCHandle ErfHandle => erfHandle;

		internal HandleManager<Stream> StreamHandles => streamHandles;

		internal bool SuppressProgressEvents
		{
			get
			{
				return suppressProgressEvents;
			}
			set
			{
				suppressProgressEvents = value;
			}
		}

		internal IDictionary<string, short> CabNumbers => cabNumbers;

		internal string NextCabinetName
		{
			get
			{
				return nextCabinetName;
			}
			set
			{
				nextCabinetName = value;
			}
		}

		internal Stream CabStream
		{
			get
			{
				return cabStream;
			}
			set
			{
				cabStream = value;
			}
		}

		internal Stream FileStream
		{
			get
			{
				return fileStream;
			}
			set
			{
				fileStream = value;
			}
		}

		protected CabWorker(CabEngine cabEngine)
		{
			this.cabEngine = cabEngine;
			streamHandles = new HandleManager<Stream>();
			erf = new NativeMethods.ERF();
			erfHandle = GCHandle.Alloc(erf, GCHandleType.Pinned);
			cabNumbers = new Dictionary<string, short>(1);
			buf = new byte[32768];
		}

		~CabWorker()
		{
			Dispose(disposing: false);
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected void ResetProgressData()
		{
			currentFileName = null;
			currentFileNumber = 0;
			totalFiles = 0;
			currentFileBytesProcessed = 0L;
			currentFileTotalBytes = 0L;
			currentFolderNumber = 0;
			currentFolderTotalBytes = 0L;
			currentArchiveName = null;
			currentArchiveNumber = 0;
			totalArchives = 0;
			currentArchiveBytesProcessed = 0L;
			currentArchiveTotalBytes = 0L;
			fileBytesProcessed = 0L;
			totalFileBytes = 0L;
		}

		protected void OnProgress(ArchiveProgressType progressType)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			if (!suppressProgressEvents)
			{
				ArchiveProgressEventArgs e = new ArchiveProgressEventArgs(progressType, currentFileName, (currentFileNumber >= 0) ? currentFileNumber : 0, totalFiles, currentFileBytesProcessed, currentFileTotalBytes, currentArchiveName, (int)currentArchiveNumber, (int)totalArchives, currentArchiveBytesProcessed, currentArchiveTotalBytes, fileBytesProcessed, totalFileBytes);
				CabEngine.ReportProgress(e);
			}
		}

		internal IntPtr CabAllocMem(int byteCount)
		{
			return Marshal.AllocHGlobal((IntPtr)byteCount);
		}

		internal void CabFreeMem(IntPtr memPointer)
		{
			Marshal.FreeHGlobal(memPointer);
		}

		internal int CabOpenStream(string path, int openFlags, int shareMode)
		{
			int err;
			return CabOpenStreamEx(path, openFlags, shareMode, out err, IntPtr.Zero);
		}

		internal virtual int CabOpenStreamEx(string path, int openFlags, int shareMode, out int err, IntPtr pv)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			path = path.Trim();
			Stream stream = cabStream;
			cabStream = (Stream)new DuplicateStream(stream);
			int result = streamHandles.AllocHandle(stream);
			err = 0;
			return result;
		}

		internal int CabReadStream(int streamHandle, IntPtr memory, int cb)
		{
			int err;
			return CabReadStreamEx(streamHandle, memory, cb, out err, IntPtr.Zero);
		}

		internal virtual int CabReadStreamEx(int streamHandle, IntPtr memory, int cb, out int err, IntPtr pv)
		{
			Stream stream = streamHandles[streamHandle];
			int num = cb;
			if (num > buf.Length)
			{
				buf = new byte[num];
			}
			num = stream.Read(buf, 0, num);
			Marshal.Copy(buf, 0, memory, num);
			err = 0;
			return num;
		}

		internal int CabWriteStream(int streamHandle, IntPtr memory, int cb)
		{
			int err;
			return CabWriteStreamEx(streamHandle, memory, cb, out err, IntPtr.Zero);
		}

		internal virtual int CabWriteStreamEx(int streamHandle, IntPtr memory, int cb, out int err, IntPtr pv)
		{
			Stream stream = streamHandles[streamHandle];
			if (cb > buf.Length)
			{
				buf = new byte[cb];
			}
			Marshal.Copy(memory, buf, 0, cb);
			stream.Write(buf, 0, cb);
			err = 0;
			return cb;
		}

		internal int CabCloseStream(int streamHandle)
		{
			int err;
			return CabCloseStreamEx(streamHandle, out err, IntPtr.Zero);
		}

		internal virtual int CabCloseStreamEx(int streamHandle, out int err, IntPtr pv)
		{
			streamHandles.FreeHandle(streamHandle);
			err = 0;
			return 0;
		}

		internal int CabSeekStream(int streamHandle, int offset, int seekOrigin)
		{
			int err;
			return CabSeekStreamEx(streamHandle, offset, seekOrigin, out err, IntPtr.Zero);
		}

		internal virtual int CabSeekStreamEx(int streamHandle, int offset, int seekOrigin, out int err, IntPtr pv)
		{
			checked
			{
				offset = (int)streamHandles[streamHandle].Seek(offset, unchecked((SeekOrigin)seekOrigin));
				err = 0;
				return offset;
			}
		}

		protected virtual void Dispose(bool disposing)
		{
			if (disposing)
			{
				if (cabStream != null)
				{
					cabStream.Close();
					cabStream = null;
				}
				if (fileStream != null)
				{
					fileStream.Close();
					fileStream = null;
				}
			}
			if (erfHandle.IsAllocated)
			{
				erfHandle.Free();
			}
		}

		protected void CheckError(bool extracting)
		{
			if (Erf.Error)
			{
				throw new CabException(Erf.Oper, Erf.Type, CabException.GetErrorMessage(Erf.Oper, Erf.Type, extracting));
			}
		}
	}
	[Serializable]
	public class CabException : ArchiveException
	{
		private static ResourceManager errorResources;

		private int error;

		private int errorCode;

		public int Error => error;

		public int ErrorCode => errorCode;

		internal static ResourceManager ErrorResources
		{
			get
			{
				if (errorResources == null)
				{
					errorResources = new ResourceManager(typeof(CabException).Namespace + ".Errors", typeof(CabException).Assembly);
				}
				return errorResources;
			}
		}

		public CabException(string message, Exception innerException)
			: this(0, 0, message, innerException)
		{
		}

		public CabException(string message)
			: this(0, 0, message, null)
		{
		}

		public CabException()
			: this(0, 0, null, null)
		{
		}

		internal CabException(int error, int errorCode, string message, Exception innerException)
			: base(message, innerException)
		{
			this.error = error;
			this.errorCode = errorCode;
		}

		internal CabException(int error, int errorCode, string message)
			: this(error, errorCode, message, null)
		{
		}

		protected CabException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			error = info.GetInt32("cabError");
			errorCode = info.GetInt32("cabErrorCode");
		}

		[SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			info.AddValue("cabError", error);
			info.AddValue("cabErrorCode", errorCode);
			((Exception)this).GetObjectData(info, context);
		}

		internal static string GetErrorMessage(int error, int errorCode, bool extracting)
		{
			int num = (extracting ? 2000 : 1000);
			string text = ErrorResources.GetString(checked(num + error).ToString(CultureInfo.InvariantCulture.NumberFormat), CultureInfo.CurrentCulture);
			if (text == null)
			{
				text = ErrorResources.GetString(num.ToString(CultureInfo.InvariantCulture.NumberFormat), CultureInfo.CurrentCulture);
			}
			if (errorCode != 0)
			{
				string @string = ErrorResources.GetString("1", CultureInfo.CurrentCulture);
				text = string.Format(CultureInfo.InvariantCulture, "{0} " + @string, new object[2] { text, errorCode });
			}
			return text;
		}
	}
	internal class CabUnpacker : CabWorker
	{
		private NativeMethods.FDI.Handle fdiHandle;

		private NativeMethods.FDI.PFNALLOC fdiAllocMemHandler;

		private NativeMethods.FDI.PFNFREE fdiFreeMemHandler;

		private NativeMethods.FDI.PFNOPEN fdiOpenStreamHandler;

		private NativeMethods.FDI.PFNREAD fdiReadStreamHandler;

		private NativeMethods.FDI.PFNWRITE fdiWriteStreamHandler;

		private NativeMethods.FDI.PFNCLOSE fdiCloseStreamHandler;

		private NativeMethods.FDI.PFNSEEK fdiSeekStreamHandler;

		private IUnpackStreamContext context;

		private List<ArchiveFileInfo> fileList;

		private int folderId;

		private Predicate<string> filter;

		[SecurityPermission(SecurityAction.Assert, UnmanagedCode = true)]
		public CabUnpacker(CabEngine cabEngine)
			: base(cabEngine)
		{
			fdiAllocMemHandler = base.CabAllocMem;
			fdiFreeMemHandler = base.CabFreeMem;
			fdiOpenStreamHandler = base.CabOpenStream;
			fdiReadStreamHandler = base.CabReadStream;
			fdiWriteStreamHandler = base.CabWriteStream;
			fdiCloseStreamHandler = base.CabCloseStream;
			fdiSeekStreamHandler = base.CabSeekStream;
			fdiHandle = NativeMethods.FDI.Create(fdiAllocMemHandler, fdiFreeMemHandler, fdiOpenStreamHandler, fdiReadStreamHandler, fdiWriteStreamHandler, fdiCloseStreamHandler, fdiSeekStreamHandler, 1, base.ErfHandle.AddrOfPinnedObject());
			if (base.Erf.Error)
			{
				int oper = base.Erf.Oper;
				int type = base.Erf.Type;
				base.ErfHandle.Free();
				throw new CabException(oper, type, CabException.GetErrorMessage(oper, type, extracting: true));
			}
		}

		[SecurityPermission(SecurityAction.Assert, UnmanagedCode = true)]
		public bool IsArchive(Stream stream)
		{
			if (stream == null)
			{
				throw new ArgumentNullException("stream");
			}
			lock (this)
			{
				short id;
				int cabFolderCount;
				int fileCount;
				return IsCabinet(stream, out id, out cabFolderCount, out fileCount);
			}
		}

		[SecurityPermission(SecurityAction.Assert, UnmanagedCode = true)]
		public IList<ArchiveFileInfo> GetFileInfo(IUnpackStreamContext streamContext, Predicate<string> fileFilter)
		{
			if (streamContext == null)
			{
				throw new ArgumentNullException("streamContext");
			}
			lock (this)
			{
				context = streamContext;
				filter = fileFilter;
				base.NextCabinetName = string.Empty;
				fileList = new List<ArchiveFileInfo>();
				bool flag = base.SuppressProgressEvents;
				base.SuppressProgressEvents = true;
				try
				{
					short num = 0;
					while (base.NextCabinetName != null)
					{
						base.Erf.Clear();
						base.CabNumbers[base.NextCabinetName] = num;
						NativeMethods.FDI.Copy(fdiHandle, base.NextCabinetName, string.Empty, 0, CabListNotify, IntPtr.Zero, IntPtr.Zero);
						CheckError(extracting: true);
						num = checked((short)(num + 1));
					}
					List<ArchiveFileInfo> list = fileList;
					fileList = null;
					return list.AsReadOnly();
				}
				finally
				{
					base.SuppressProgressEvents = flag;
					if (base.CabStream != null)
					{
						context.CloseArchiveReadStream((int)currentArchiveNumber, currentArchiveName, base.CabStream);
						base.CabStream = null;
					}
					context = null;
				}
			}
		}

		[SecurityPermission(SecurityAction.Assert, UnmanagedCode = true)]
		public void Unpack(IUnpackStreamContext streamContext, Predicate<string> fileFilter)
		{
			checked
			{
				lock (this)
				{
					IList<ArchiveFileInfo> fileInfo = GetFileInfo(streamContext, fileFilter);
					ResetProgressData();
					if (fileInfo != null)
					{
						totalFiles = fileInfo.Count;
						for (int i = 0; i < fileInfo.Count; i++)
						{
							totalFileBytes += fileInfo[i].Length;
							if (fileInfo[i].ArchiveNumber >= totalArchives)
							{
								int num = fileInfo[i].ArchiveNumber + 1;
								totalArchives = (short)num;
							}
						}
					}
					context = streamContext;
					fileList = null;
					base.NextCabinetName = string.Empty;
					folderId = -1;
					currentFileNumber = -1;
					try
					{
						short num2 = 0;
						while (base.NextCabinetName != null)
						{
							base.Erf.Clear();
							base.CabNumbers[base.NextCabinetName] = num2;
							NativeMethods.FDI.Copy(fdiHandle, base.NextCabinetName, string.Empty, 0, CabExtractNotify, IntPtr.Zero, IntPtr.Zero);
							CheckError(extracting: true);
							num2++;
						}
					}
					finally
					{
						if (base.CabStream != null)
						{
							context.CloseArchiveReadStream(unchecked((int)currentArchiveNumber), currentArchiveName, base.CabStream);
							base.CabStream = null;
						}
						if (base.FileStream != null)
						{
							context.CloseFileWriteStream(currentFileName, base.FileStream, FileAttributes.Normal, DateTime.Now);
							base.FileStream = null;
						}
						context = null;
					}
				}
			}
		}

		internal override int CabOpenStreamEx(string path, int openFlags, int shareMode, out int err, IntPtr pv)
		{
			if (base.CabNumbers.ContainsKey(path))
			{
				Stream stream = base.CabStream;
				if (stream == null)
				{
					short num = base.CabNumbers[path];
					stream = context.OpenArchiveReadStream((int)num, path, (CompressionEngine)(object)base.CabEngine);
					if (stream == null)
					{
						throw new FileNotFoundException(string.Format(CultureInfo.InvariantCulture, "Cabinet {0} not provided.", new object[1] { num }));
					}
					currentArchiveName = path;
					currentArchiveNumber = num;
					checked
					{
						if (totalArchives <= currentArchiveNumber)
						{
							int num2 = currentArchiveNumber + 1;
							totalArchives = (short)num2;
						}
						currentArchiveTotalBytes = stream.Length;
						currentArchiveBytesProcessed = 0L;
						if (folderId != -3)
						{
							OnProgress((ArchiveProgressType)3);
						}
						base.CabStream = stream;
					}
				}
				path = "%%CAB%%";
			}
			return base.CabOpenStreamEx(path, openFlags, shareMode, out err, pv);
		}

		internal override int CabReadStreamEx(int streamHandle, IntPtr memory, int cb, out int err, IntPtr pv)
		{
			int result = base.CabReadStreamEx(streamHandle, memory, cb, out err, pv);
			checked
			{
				if (err == 0 && base.CabStream != null && fileList == null && DuplicateStream.OriginalStream(base.StreamHandles[streamHandle]) == DuplicateStream.OriginalStream(base.CabStream))
				{
					currentArchiveBytesProcessed += cb;
					if (currentArchiveBytesProcessed > currentArchiveTotalBytes)
					{
						currentArchiveBytesProcessed = currentArchiveTotalBytes;
					}
				}
				return result;
			}
		}

		internal override int CabWriteStreamEx(int streamHandle, IntPtr memory, int cb, out int err, IntPtr pv)
		{
			int num = base.CabWriteStreamEx(streamHandle, memory, cb, out err, pv);
			checked
			{
				if (num > 0 && err == 0)
				{
					currentFileBytesProcessed += cb;
					fileBytesProcessed += cb;
					OnProgress((ArchiveProgressType)1);
				}
				return num;
			}
		}

		internal override int CabCloseStreamEx(int streamHandle, out int err, IntPtr pv)
		{
			Stream stream = DuplicateStream.OriginalStream(base.StreamHandles[streamHandle]);
			if (stream == DuplicateStream.OriginalStream(base.CabStream))
			{
				if (folderId != -3)
				{
					OnProgress((ArchiveProgressType)5);
				}
				context.CloseArchiveReadStream((int)currentArchiveNumber, currentArchiveName, stream);
				currentArchiveName = base.NextCabinetName;
				currentArchiveBytesProcessed = (currentArchiveTotalBytes = 0L);
				base.CabStream = null;
			}
			return base.CabCloseStreamEx(streamHandle, out err, pv);
		}

		protected override void Dispose(bool disposing)
		{
			try
			{
				if (disposing && fdiHandle != null)
				{
					fdiHandle.Dispose();
					fdiHandle = null;
				}
			}
			finally
			{
				base.Dispose(disposing);
			}
		}

		private static string GetFileName(NativeMethods.FDI.NOTIFICATION notification)
		{
			Encoding encoding = ((((uint)notification.attribs & 0x80u) != 0) ? Encoding.UTF8 : Encoding.Default);
			int i;
			for (i = 0; Marshal.ReadByte(notification.psz1, i) != 0; i = checked(i + 1))
			{
			}
			byte[] array = new byte[i];
			Marshal.Copy(notification.psz1, array, 0, i);
			string text = encoding.GetString(array);
			if (Path.IsPathRooted(text))
			{
				text = text.Replace(Path.VolumeSeparatorChar.ToString() ?? "", "");
			}
			return text;
		}

		private bool IsCabinet(Stream cabStream, out short id, out int cabFolderCount, out int fileCount)
		{
			int num = base.StreamHandles.AllocHandle(cabStream);
			try
			{
				base.Erf.Clear();
				NativeMethods.FDI.CABINFO pfdici;
				bool result = NativeMethods.FDI.IsCabinet(fdiHandle, num, out pfdici) != 0;
				if (base.Erf.Error)
				{
					if (base.Erf.Oper != 3)
					{
						throw new CabException(base.Erf.Oper, base.Erf.Type, CabException.GetErrorMessage(base.Erf.Oper, base.Erf.Type, extracting: true));
					}
					result = false;
				}
				id = pfdici.setID;
				cabFolderCount = pfdici.cFolders;
				fileCount = pfdici.cFiles;
				return result;
			}
			finally
			{
				base.StreamHandles.FreeHandle(num);
			}
		}

		private int CabListNotify(NativeMethods.FDI.NOTIFICATIONTYPE notificationType, NativeMethods.FDI.NOTIFICATION notification)
		{
			checked
			{
				switch (notificationType)
				{
				case NativeMethods.FDI.NOTIFICATIONTYPE.CABINET_INFO:
				{
					string text = Marshal.PtrToStringAnsi(notification.psz1);
					base.NextCabinetName = ((text.Length != 0) ? text : null);
					return 0;
				}
				case NativeMethods.FDI.NOTIFICATIONTYPE.PARTIAL_FILE:
					return 0;
				case NativeMethods.FDI.NOTIFICATIONTYPE.COPY_FILE:
				{
					string fileName = GetFileName(notification);
					if ((filter == null || filter(fileName)) && fileList != null)
					{
						FileAttributes fileAttributes = unchecked((FileAttributes)(notification.attribs & 0x27));
						if (fileAttributes == (FileAttributes)0)
						{
							fileAttributes = FileAttributes.Normal;
						}
						DateTime lastWriteTime = default(DateTime);
						CompressionEngine.DosDateAndTimeToDateTime(notification.date, notification.time, ref lastWriteTime);
						long length = notification.cb;
						CabFileInfo item = new CabFileInfo(fileName, notification.iFolder, notification.iCabinet, fileAttributes, lastWriteTime, length);
						fileList.Add((ArchiveFileInfo)(object)item);
						currentFileNumber = fileList.Count - 1;
						fileBytesProcessed += notification.cb;
					}
					totalFiles++;
					totalFileBytes += notification.cb;
					return 0;
				}
				default:
					return 0;
				}
			}
		}

		private int CabExtractNotify(NativeMethods.FDI.NOTIFICATIONTYPE notificationType, NativeMethods.FDI.NOTIFICATION notification)
		{
			switch (notificationType)
			{
			case NativeMethods.FDI.NOTIFICATIONTYPE.CABINET_INFO:
				if (base.NextCabinetName != null && base.NextCabinetName.StartsWith("?", StringComparison.Ordinal))
				{
					base.NextCabinetName = base.NextCabinetName.Substring(1);
				}
				else
				{
					string text = Marshal.PtrToStringAnsi(notification.psz1);
					base.NextCabinetName = ((text.Length != 0) ? text : null);
				}
				return 0;
			case NativeMethods.FDI.NOTIFICATIONTYPE.NEXT_CABINET:
			{
				string key = Marshal.PtrToStringAnsi(notification.psz1);
				base.CabNumbers[key] = notification.iCabinet;
				base.NextCabinetName = "?" + base.NextCabinetName;
				return 0;
			}
			case NativeMethods.FDI.NOTIFICATIONTYPE.COPY_FILE:
				return CabExtractCopyFile(notification);
			case NativeMethods.FDI.NOTIFICATIONTYPE.CLOSE_FILE_INFO:
				return CabExtractCloseFile(notification);
			default:
				return 0;
			}
		}

		private int CabExtractCopyFile(NativeMethods.FDI.NOTIFICATION notification)
		{
			checked
			{
				if (notification.iFolder != folderId)
				{
					if (notification.iFolder != -3 && folderId != -1)
					{
						currentFolderNumber++;
					}
					folderId = notification.iFolder;
				}
				string fileName = GetFileName(notification);
				if (filter == null || filter(fileName))
				{
					currentFileNumber++;
					currentFileName = fileName;
					currentFileBytesProcessed = 0L;
					currentFileTotalBytes = notification.cb;
					OnProgress((ArchiveProgressType)0);
					DateTime dateTime = default(DateTime);
					CompressionEngine.DosDateAndTimeToDateTime(notification.date, notification.time, ref dateTime);
					Stream stream = context.OpenFileWriteStream(fileName, unchecked((long)notification.cb), dateTime);
					if (stream != null)
					{
						base.FileStream = stream;
						return base.StreamHandles.AllocHandle(stream);
					}
					fileBytesProcessed += notification.cb;
					OnProgress((ArchiveProgressType)2);
					currentFileName = null;
				}
				return 0;
			}
		}

		private int CabExtractCloseFile(NativeMethods.FDI.NOTIFICATION notification)
		{
			Stream stream = base.StreamHandles[notification.hf];
			base.StreamHandles.FreeHandle(notification.hf);
			string fileName = GetFileName(notification);
			FileAttributes fileAttributes = (FileAttributes)(notification.attribs & 0x27);
			if (fileAttributes == (FileAttributes)0)
			{
				fileAttributes = FileAttributes.Normal;
			}
			DateTime dateTime = default(DateTime);
			CompressionEngine.DosDateAndTimeToDateTime(notification.date, notification.time, ref dateTime);
			stream.Flush();
			context.CloseFileWriteStream(fileName, stream, fileAttributes, dateTime);
			base.FileStream = null;
			checked
			{
				long num = currentFileTotalBytes - currentFileBytesProcessed;
				currentFileBytesProcessed += num;
				fileBytesProcessed += num;
				OnProgress((ArchiveProgressType)2);
				currentFileName = null;
				return 1;
			}
		}
	}
	[Serializable]
	public class CabFileInfo : ArchiveFileInfo
	{
		private int cabFolder;

		public CabInfo Cabinet => (CabInfo)(object)((ArchiveFileInfo)this).Archive;

		public string CabinetName => ((ArchiveFileInfo)this).ArchiveName;

		public int CabinetFolderNumber
		{
			get
			{
				if (cabFolder < 0)
				{
					((ArchiveFileInfo)this).Refresh();
				}
				return cabFolder;
			}
		}

		public CabFileInfo(CabInfo cabinetInfo, string filePath)
			: base((ArchiveInfo)(object)cabinetInfo, filePath)
		{
			if (cabinetInfo == null)
			{
				throw new ArgumentNullException("cabinetInfo");
			}
			cabFolder = -1;
		}

		internal CabFileInfo(string filePath, int cabFolder, int cabNumber, FileAttributes attributes, DateTime lastWriteTime, long length)
			: base(filePath, cabNumber, attributes, lastWriteTime, length)
		{
			this.cabFolder = cabFolder;
		}

		protected CabFileInfo(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			cabFolder = info.GetInt32("cabFolder");
		}

		[SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			((ArchiveFileInfo)this).GetObjectData(info, context);
			info.AddValue("cabFolder", cabFolder);
		}

		protected override void Refresh(ArchiveFileInfo newFileInfo)
		{
			((ArchiveFileInfo)this).Refresh(newFileInfo);
			cabFolder = ((CabFileInfo)(object)newFileInfo).cabFolder;
		}
	}
	[Serializable]
	public class CabInfo : ArchiveInfo
	{
		public CabInfo(string path)
			: base(path)
		{
		}

		protected CabInfo(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}

		protected override CompressionEngine CreateCompressionEngine()
		{
			return (CompressionEngine)(object)new CabEngine();
		}

		public IList<CabFileInfo> GetFiles()
		{
			IList<ArchiveFileInfo> files = ((ArchiveInfo)this).GetFiles();
			List<CabFileInfo> list = new List<CabFileInfo>(files.Count);
			foreach (CabFileInfo item in files)
			{
				list.Add(item);
			}
			return list.AsReadOnly();
		}

		public IList<CabFileInfo> GetFiles(string searchPattern)
		{
			IList<ArchiveFileInfo> files = ((ArchiveInfo)this).GetFiles(searchPattern);
			List<CabFileInfo> list = new List<CabFileInfo>(files.Count);
			foreach (CabFileInfo item in files)
			{
				list.Add(item);
			}
			return list.AsReadOnly();
		}
	}
	internal sealed class HandleManager<T> where T : class
	{
		private List<T> handles;

		public T this[int handle]
		{
			get
			{
				if (handle > 0 && handle <= handles.Count)
				{
					return handles[checked(handle - 1)];
				}
				return null;
			}
		}

		public HandleManager()
		{
			handles = new List<T>();
		}

		public int AllocHandle(T obj)
		{
			handles.Add(obj);
			return handles.Count;
		}

		public void FreeHandle(int handle)
		{
			if (handle > 0 && handle <= handles.Count)
			{
				handles[checked(handle - 1)] = null;
			}
		}
	}
	internal static class NativeMethods
	{
		internal static class FCI
		{
			[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
			internal delegate IntPtr PFNALLOC(int cb);

			[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
			internal delegate void PFNFREE(IntPtr pv);

			[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
			internal delegate int PFNOPEN(string path, int oflag, int pmode, out int err, IntPtr pv);

			[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
			internal delegate int PFNREAD(int fileHandle, IntPtr memory, int cb, out int err, IntPtr pv);

			[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
			internal delegate int PFNWRITE(int fileHandle, IntPtr memory, int cb, out int err, IntPtr pv);

			[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
			internal delegate int PFNCLOSE(int fileHandle, out int err, IntPtr pv);

			[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
			internal delegate int PFNSEEK(int fileHandle, int dist, int seekType, out int err, IntPtr pv);

			[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
			internal delegate int PFNDELETE(string path, out int err, IntPtr pv);

			[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
			internal delegate int PFNGETNEXTCABINET(IntPtr pccab, uint cbPrevCab, IntPtr pv);

			[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
			internal delegate int PFNFILEPLACED(IntPtr pccab, string path, long fileSize, int continuation, IntPtr pv);

			[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
			internal delegate int PFNGETOPENINFO(string path, out short date, out short time, out short pattribs, out int err, IntPtr pv);

			[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
			internal delegate int PFNSTATUS(STATUS typeStatus, uint cb1, uint cb2, IntPtr pv);

			[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
			internal delegate int PFNGETTEMPFILE(IntPtr tempNamePtr, int tempNameSize, IntPtr pv);

			internal enum ERROR
			{
				NONE,
				OPEN_SRC,
				READ_SRC,
				ALLOC_FAIL,
				TEMP_FILE,
				BAD_COMPR_TYPE,
				CAB_FILE,
				USER_ABORT,
				MCI_FAIL
			}

			internal enum TCOMP : ushort
			{
				MASK_TYPE = 15,
				TYPE_NONE = 0,
				TYPE_MSZIP = 1,
				TYPE_QUANTUM = 2,
				TYPE_LZX = 3,
				BAD = 15,
				MASK_LZX_WINDOW = 7936,
				LZX_WINDOW_LO = 3840,
				LZX_WINDOW_HI = 5376,
				SHIFT_LZX_WINDOW = 8,
				MASK_QUANTUM_LEVEL = 240,
				QUANTUM_LEVEL_LO = 16,
				QUANTUM_LEVEL_HI = 112,
				SHIFT_QUANTUM_LEVEL = 4,
				MASK_QUANTUM_MEM = 7936,
				QUANTUM_MEM_LO = 2560,
				QUANTUM_MEM_HI = 5376,
				SHIFT_QUANTUM_MEM = 8,
				MASK_RESERVED = 57344
			}

			internal enum STATUS : uint
			{
				FILE,
				FOLDER,
				CABINET
			}

			[StructLayout(LayoutKind.Sequential)]
			internal class CCAB
			{
				internal int cb = int.MaxValue;

				internal int cbFolderThresh = 2147450880;

				internal int cbReserveCFHeader;

				internal int cbReserveCFFolder;

				internal int cbReserveCFData;

				internal int iCab;

				internal int iDisk;

				internal int fFailOnIncompressible;

				internal short setID;

				[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
				internal string szDisk = string.Empty;

				[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
				internal string szCab = string.Empty;

				[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
				internal string szCabPath = string.Empty;
			}

			internal class Handle : SafeHandle
			{
				public override bool IsInvalid => handle == IntPtr.Zero;

				internal Handle()
					: base(IntPtr.Zero, ownsHandle: true)
				{
				}

				[SecurityPermission(SecurityAction.Assert, UnmanagedCode = true)]
				protected override bool ReleaseHandle()
				{
					return Destroy(handle);
				}
			}

			internal const int MIN_DISK = 32768;

			internal const int MAX_DISK = int.MaxValue;

			internal const int MAX_FOLDER = 2147450880;

			internal const int MAX_FILENAME = 256;

			internal const int MAX_CABINET_NAME = 256;

			internal const int MAX_CAB_PATH = 256;

			internal const int MAX_DISK_NAME = 256;

			internal const int CPU_80386 = 1;

			[DllImport("cabinet.dll", BestFitMapping = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, EntryPoint = "FCICreate", ThrowOnUnmappableChar = true)]
			internal static extern Handle Create(IntPtr perf, PFNFILEPLACED pfnfcifp, PFNALLOC pfna, PFNFREE pfnf, PFNOPEN pfnopen, PFNREAD pfnread, PFNWRITE pfnwrite, PFNCLOSE pfnclose, PFNSEEK pfnseek, PFNDELETE pfndelete, PFNGETTEMPFILE pfnfcigtf, [MarshalAs(UnmanagedType.LPStruct)] CCAB pccab, IntPtr pv);

			[DllImport("cabinet.dll", BestFitMapping = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, EntryPoint = "FCIAddFile", ThrowOnUnmappableChar = true)]
			internal static extern int AddFile(Handle hfci, string pszSourceFile, IntPtr pszFileName, [MarshalAs(UnmanagedType.Bool)] bool fExecute, PFNGETNEXTCABINET pfnfcignc, PFNSTATUS pfnfcis, PFNGETOPENINFO pfnfcigoi, TCOMP typeCompress);

			[DllImport("cabinet.dll", BestFitMapping = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, EntryPoint = "FCIFlushCabinet", ThrowOnUnmappableChar = true)]
			internal static extern int FlushCabinet(Handle hfci, [MarshalAs(UnmanagedType.Bool)] bool fGetNextCab, PFNGETNEXTCABINET pfnfcignc, PFNSTATUS pfnfcis);

			[DllImport("cabinet.dll", BestFitMapping = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, EntryPoint = "FCIFlushFolder", ThrowOnUnmappableChar = true)]
			internal static extern int FlushFolder(Handle hfci, PFNGETNEXTCABINET pfnfcignc, PFNSTATUS pfnfcis);

			[DllImport("cabinet.dll", BestFitMapping = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, EntryPoint = "FCIDestroy", ThrowOnUnmappableChar = true)]
			[SuppressUnmanagedCodeSecurity]
			[return: MarshalAs(UnmanagedType.Bool)]
			internal static extern bool Destroy(IntPtr hfci);
		}

		internal static class FDI
		{
			[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
			internal delegate IntPtr PFNALLOC(int cb);

			[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
			internal delegate void PFNFREE(IntPtr pv);

			[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
			internal delegate int PFNOPEN(string path, int oflag, int pmode);

			[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
			internal delegate int PFNREAD(int hf, IntPtr pv, int cb);

			[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
			internal delegate int PFNWRITE(int hf, IntPtr pv, int cb);

			[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
			internal delegate int PFNCLOSE(int hf);

			[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
			internal delegate int PFNSEEK(int hf, int dist, int seektype);

			[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
			internal delegate int PFNNOTIFY(NOTIFICATIONTYPE fdint, NOTIFICATION fdin);

			internal enum ERROR
			{
				NONE,
				CABINET_NOT_FOUND,
				NOT_A_CABINET,
				UNKNOWN_CABINET_VERSION,
				CORRUPT_CABINET,
				ALLOC_FAIL,
				BAD_COMPR_TYPE,
				MDI_FAIL,
				TARGET_FILE,
				RESERVE_MISMATCH,
				WRONG_CABINET,
				USER_ABORT
			}

			internal enum NOTIFICATIONTYPE
			{
				CABINET_INFO,
				PARTIAL_FILE,
				COPY_FILE,
				CLOSE_FILE_INFO,
				NEXT_CABINET,
				ENUMERATE
			}

			internal struct CABINFO
			{
				internal int cbCabinet;

				internal short cFolders;

				internal short cFiles;

				internal short setID;

				internal short iCabinet;

				internal int fReserve;

				internal int hasprev;

				internal int hasnext;
			}

			[StructLayout(LayoutKind.Sequential)]
			internal class NOTIFICATION
			{
				internal int cb;

				internal IntPtr psz1;

				internal IntPtr psz2;

				internal IntPtr psz3;

				internal IntPtr pv;

				internal IntPtr hf_ptr;

				internal short date;

				internal short time;

				internal short attribs;

				internal short setID;

				internal short iCabinet;

				internal short iFolder;

				internal int fdie;

				internal int hf => (int)hf_ptr;
			}

			internal class Handle : SafeHandle
			{
				public override bool IsInvalid => handle == IntPtr.Zero;

				internal Handle()
					: base(IntPtr.Zero, ownsHandle: true)
				{
				}

				protected override bool ReleaseHandle()
				{
					return Destroy(handle);
				}
			}

			internal const int MAX_DISK = int.MaxValue;

			internal const int MAX_FILENAME = 256;

			internal const int MAX_CABINET_NAME = 256;

			internal const int MAX_CAB_PATH = 256;

			internal const int MAX_DISK_NAME = 256;

			internal const int CPU_80386 = 1;

			[DllImport("cabinet.dll", BestFitMapping = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, EntryPoint = "FDICreate", ThrowOnUnmappableChar = true)]
			internal static extern Handle Create([MarshalAs(UnmanagedType.FunctionPtr)] PFNALLOC pfnalloc, [MarshalAs(UnmanagedType.FunctionPtr)] PFNFREE pfnfree, PFNOPEN pfnopen, PFNREAD pfnread, PFNWRITE pfnwrite, PFNCLOSE pfnclose, PFNSEEK pfnseek, int cpuType, IntPtr perf);

			[DllImport("cabinet.dll", BestFitMapping = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, EntryPoint = "FDICopy", ThrowOnUnmappableChar = true)]
			internal static extern int Copy(Handle hfdi, string pszCabinet, string pszCabPath, int flags, PFNNOTIFY pfnfdin, IntPtr pfnfdid, IntPtr pvUser);

			[DllImport("cabinet.dll", BestFitMapping = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, EntryPoint = "FDIDestroy", ThrowOnUnmappableChar = true)]
			[SuppressUnmanagedCodeSecurity]
			[return: MarshalAs(UnmanagedType.Bool)]
			internal static extern bool Destroy(IntPtr hfdi);

			[DllImport("cabinet.dll", BestFitMapping = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, EntryPoint = "FDIIsCabinet", ThrowOnUnmappableChar = true)]
			internal static extern int IsCabinet(Handle hfdi, int hf, out CABINFO pfdici);
		}

		[StructLayout(LayoutKind.Sequential)]
		internal class ERF
		{
			private int erfOper;

			private int erfType;

			private int fError;

			internal int Oper
			{
				get
				{
					return erfOper;
				}
				set
				{
					erfOper = value;
				}
			}

			internal int Type
			{
				get
				{
					return erfType;
				}
				set
				{
					erfType = value;
				}
			}

			internal bool Error
			{
				get
				{
					return fError != 0;
				}
				set
				{
					fError = (value ? 1 : 0);
				}
			}

			internal void Clear()
			{
				Oper = 0;
				Type = 0;
				Error = false;
			}
		}
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyDescription("Abstract base libraries for archive packing and unpacking")]
[assembly: CLSCompliant(true)]
[assembly: ComVisible(false)]
[assembly: AllowPartiallyTrustedCallers]
[assembly: AssemblyFileVersion("3.10.1.2213")]
[assembly: AssemblyCompany("Outercurve Foundation")]
[assembly: AssemblyCopyright("Copyright (c) Outercurve Foundation. All rights reserved.")]
[assembly: AssemblyProduct("Windows Installer XML Toolset")]
[assembly: AssemblyConfiguration("")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, Unrestricted = true)]
[assembly: AssemblyVersion("3.0.0.0")]
namespace Microsoft.Tools.WindowsInstallerXml
{
	internal static class WixDistribution
	{
		public static string NewsUrl = "http://wixtoolset.org/news/";

		public static string ShortProduct = "WiX Toolset";

		public static string SupportUrl = "http://wixtoolset.org/";

		public static string TelemetryUrlFormat = "http://wixtoolset.org/telemetry/v{0}/?r={1}";

		public static string ReplacePlaceholders(string original, Assembly assembly)
		{
			if ((object)assembly != null)
			{
				FileVersionInfo versionInfo = FileVersionInfo.GetVersionInfo(assembly.Location);
				original = original.Replace("[FileComments]", versionInfo.Comments);
				original = original.Replace("[FileCopyright]", versionInfo.LegalCopyright);
				original = original.Replace("[FileProductName]", versionInfo.ProductName);
				original = original.Replace("[FileVersion]", versionInfo.FileVersion);
				if (original.Contains("[FileVersionMajorMinor]"))
				{
					Version version = new Version(versionInfo.FileVersion);
					original = original.Replace("[FileVersionMajorMinor]", version.Major + "." + version.Minor);
				}
				if (TryGetAttribute<AssemblyCompanyAttribute>(assembly, out var attribute))
				{
					original = original.Replace("[AssemblyCompany]", attribute.Company);
				}
				if (TryGetAttribute<AssemblyCopyrightAttribute>(assembly, out var attribute2))
				{
					original = original.Replace("[AssemblyCopyright]", attribute2.Copyright);
				}
				if (TryGetAttribute<AssemblyDescriptionAttribute>(assembly, out var attribute3))
				{
					original = original.Replace("[AssemblyDescription]", attribute3.Description);
				}
				if (TryGetAttribute<AssemblyProductAttribute>(assembly, out var attribute4))
				{
					original = original.Replace("[AssemblyProduct]", attribute4.Product);
				}
				if (TryGetAttribute<AssemblyTitleAttribute>(assembly, out var attribute5))
				{
					original = original.Replace("[AssemblyTitle]", attribute5.Title);
				}
			}
			original = original.Replace("[NewsUrl]", NewsUrl);
			original = original.Replace("[ShortProduct]", ShortProduct);
			original = original.Replace("[SupportUrl]", SupportUrl);
			return original;
		}

		private static bool TryGetAttribute<T>(Assembly assembly, out T attribute) where T : Attribute
		{
			attribute = null;
			object[] customAttributes = assembly.GetCustomAttributes(typeof(T), inherit: false);
			if (customAttributes != null && customAttributes.Length != 0)
			{
				attribute = customAttributes[0] as T;
			}
			return attribute != null;
		}
	}
}
namespace Microsoft.Deployment.Compression
{
	[Serializable]
	public class ArchiveException : IOException
	{
		public ArchiveException(string message, Exception innerException)
			: base(message, innerException)
		{
		}

		public ArchiveException(string message)
			: this(message, null)
		{
		}

		public ArchiveException()
			: this(null, null)
		{
		}

		protected ArchiveException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	public abstract class ArchiveFileInfo : FileSystemInfo
	{
		private ArchiveInfo archiveInfo;

		private string name;

		private string path;

		private bool initialized;

		private bool exists;

		private int archiveNumber;

		private FileAttributes attributes;

		private DateTime lastWriteTime;

		private long length;

		public override string Name => name;

		public string Path => path;

		public override string FullName
		{
			get
			{
				string text = System.IO.Path.Combine(Path, Name);
				if (Archive != null)
				{
					text = System.IO.Path.Combine(ArchiveName, text);
				}
				return text;
			}
		}

		public ArchiveInfo Archive
		{
			get
			{
				return archiveInfo;
			}
			internal set
			{
				archiveInfo = value;
				OriginalPath = value?.FullName;
				FullPath = OriginalPath;
			}
		}

		public string ArchiveName
		{
			get
			{
				if (Archive == null)
				{
					return null;
				}
				return Archive.FullName;
			}
		}

		public int ArchiveNumber => archiveNumber;

		public override bool Exists
		{
			get
			{
				if (!initialized)
				{
					Refresh();
				}
				return exists;
			}
		}

		public long Length
		{
			get
			{
				if (!initialized)
				{
					Refresh();
				}
				return length;
			}
		}

		public new FileAttributes Attributes
		{
			get
			{
				if (!initialized)
				{
					Refresh();
				}
				return attributes;
			}
		}

		public new DateTime LastWriteTime
		{
			get
			{
				if (!initialized)
				{
					Refresh();
				}
				return lastWriteTime;
			}
		}

		protected ArchiveFileInfo(ArchiveInfo archiveInfo, string filePath)
		{
			if (filePath == null)
			{
				throw new ArgumentNullException("filePath");
			}
			Archive = archiveInfo;
			name = System.IO.Path.GetFileName(filePath);
			path = System.IO.Path.GetDirectoryName(filePath);
			attributes = FileAttributes.Normal;
			lastWriteTime = DateTime.MinValue;
		}

		protected ArchiveFileInfo(string filePath, int archiveNumber, FileAttributes attributes, DateTime lastWriteTime, long length)
			: this(null, filePath)
		{
			exists = true;
			this.archiveNumber = archiveNumber;
			this.attributes = attributes;
			this.lastWriteTime = lastWriteTime;
			this.length = length;
			initialized = true;
		}

		protected ArchiveFileInfo(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			archiveInfo = (ArchiveInfo)info.GetValue("archiveInfo", typeof(ArchiveInfo));
			name = info.GetString("name");
			path = info.GetString("path");
			initialized = info.GetBoolean("initialized");
			exists = info.GetBoolean("exists");
			archiveNumber = info.GetInt32("archiveNumber");
			attributes = (FileAttributes)info.GetValue("attributes", typeof(FileAttributes));
			lastWriteTime = info.GetDateTime("lastWriteTime");
			length = info.GetInt64("length");
		}

		[SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			base.GetObjectData(info, context);
			info.AddValue("archiveInfo", archiveInfo);
			info.AddValue("name", name);
			info.AddValue("path", path);
			info.AddValue("initialized", initialized);
			info.AddValue("exists", exists);
			info.AddValue("archiveNumber", archiveNumber);
			info.AddValue("attributes", attributes);
			info.AddValue("lastWriteTime", lastWriteTime);
			info.AddValue("length", length);
		}

		public override string ToString()
		{
			return FullName;
		}

		public override void Delete()
		{
			throw new NotSupportedException();
		}

		public new void Refresh()
		{
			base.Refresh();
			if (Archive != null)
			{
				string fileName = System.IO.Path.Combine(Path, Name);
				ArchiveFileInfo file = Archive.GetFile(fileName);
				if (file == null)
				{
					throw new FileNotFoundException("File not found in archive.", fileName);
				}
				Refresh(file);
			}
		}

		public void CopyTo(string destFileName)
		{
			CopyTo(destFileName, overwrite: false);
		}

		public void CopyTo(string destFileName, bool overwrite)
		{
			if (destFileName == null)
			{
				throw new ArgumentNullException("destFileName");
			}
			if (!overwrite && File.Exists(destFileName))
			{
				throw new IOException();
			}
			if (Archive == null)
			{
				throw new InvalidOperationException();
			}
			Archive.UnpackFile(System.IO.Path.Combine(Path, Name), destFileName);
		}

		public Stream OpenRead()
		{
			return Archive.OpenRead(System.IO.Path.Combine(Path, Name));
		}

		public StreamReader OpenText()
		{
			return Archive.OpenText(System.IO.Path.Combine(Path, Name));
		}

		protected virtual void Refresh(ArchiveFileInfo newFileInfo)
		{
			exists = newFileInfo.exists;
			length = newFileInfo.length;
			attributes = newFileInfo.attributes;
			lastWriteTime = newFileInfo.lastWriteTime;
		}
	}
	[Serializable]
	public abstract class ArchiveInfo : FileSystemInfo
	{
		public DirectoryInfo Directory => new DirectoryInfo(Path.GetDirectoryName(FullName));

		public string DirectoryName => Path.GetDirectoryName(FullName);

		public long Length => new FileInfo(FullName).Length;

		public override string Name => Path.GetFileName(FullName);

		public override bool Exists => File.Exists(FullName);

		protected ArchiveInfo(string path)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			OriginalPath = path;
			FullPath = Path.GetFullPath(path);
		}

		protected ArchiveInfo(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}

		public override string ToString()
		{
			return FullName;
		}

		public override void Delete()
		{
			File.Delete(FullName);
		}

		public void CopyTo(string destFileName)
		{
			File.Copy(FullName, destFileName);
		}

		public void CopyTo(string destFileName, bool overwrite)
		{
			File.Copy(FullName, destFileName, overwrite);
		}

		public void MoveTo(string destFileName)
		{
			File.Move(FullName, destFileName);
			FullPath = Path.GetFullPath(destFileName);
		}

		public bool IsValid()
		{
			using Stream stream = File.OpenRead(FullName);
			using CompressionEngine compressionEngine = CreateCompressionEngine();
			return compressionEngine.FindArchiveOffset(stream) >= 0;
		}

		public IList<ArchiveFileInfo> GetFiles()
		{
			return InternalGetFiles(null);
		}

		public IList<ArchiveFileInfo> GetFiles(string searchPattern)
		{
			if (searchPattern == null)
			{
				throw new ArgumentNullException("searchPattern");
			}
			string pattern = string.Format(CultureInfo.InvariantCulture, "^{0}$", new object[1] { Regex.Escape(searchPattern).Replace("\\*", ".*").Replace("\\?", ".") });
			Regex regex = new Regex(pattern, RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
			return InternalGetFiles((string match) => regex.IsMatch(match));
		}

		public void Unpack(string destDirectory)
		{
			Unpack(destDirectory, null);
		}

		public void Unpack(string destDirectory, EventHandler<ArchiveProgressEventArgs> progressHandler)
		{
			using CompressionEngine compressionEngine = CreateCompressionEngine();
			compressionEngine.Progress += progressHandler;
			ArchiveFileStreamContext archiveFileStreamContext = new ArchiveFileStreamContext(FullName, destDirectory, null);
			archiveFileStreamContext.EnableOffsetOpen = true;
			compressionEngine.Unpack(archiveFileStreamContext, null);
		}

		public void UnpackFile(string fileName, string destFileName)
		{
			if (fileName == null)
			{
				throw new ArgumentNullException("fileName");
			}
			if (destFileName == null)
			{
				throw new ArgumentNullException("destFileName");
			}
			UnpackFiles(new string[1] { fileName }, null, new string[1] { destFileName });
		}

		public void UnpackFiles(IList<string> fileNames, string destDirectory, IList<string> destFileNames)
		{
			UnpackFiles(fileNames, destDirectory, destFileNames, null);
		}

		public void UnpackFiles(IList<string> fileNames, string destDirectory, IList<string> destFileNames, EventHandler<ArchiveProgressEventArgs> progressHandler)
		{
			if (fileNames == null)
			{
				throw new ArgumentNullException("fileNames");
			}
			if (destFileNames == null)
			{
				if (destDirectory == null)
				{
					throw new ArgumentNullException("destFileNames");
				}
				destFileNames = fileNames;
			}
			if (destFileNames.Count != fileNames.Count)
			{
				throw new ArgumentOutOfRangeException("destFileNames");
			}
			IDictionary<string, string> fileNames2 = CreateStringDictionary(fileNames, destFileNames);
			UnpackFileSet(fileNames2, destDirectory, progressHandler);
		}

		public void UnpackFileSet(IDictionary<string, string> fileNames, string destDirectory)
		{
			UnpackFileSet(fileNames, destDirectory, null);
		}

		public void UnpackFileSet(IDictionary<string, string> fileNames, string destDirectory, EventHandler<ArchiveProgressEventArgs> progressHandler)
		{
			if (fileNames == null)
			{
				throw new ArgumentNullException("fileNames");
			}
			using CompressionEngine compressionEngine = CreateCompressionEngine();
			compressionEngine.Progress += progressHandler;
			ArchiveFileStreamContext archiveFileStreamContext = new ArchiveFileStreamContext(FullName, destDirectory, fileNames);
			archiveFileStreamContext.EnableOffsetOpen = true;
			compressionEngine.Unpack(archiveFileStreamContext, (string match) => fileNames.ContainsKey(match));
		}

		public Stream OpenRead(string fileName)
		{
			Stream stream = File.OpenRead(FullName);
			CompressionEngine compressionEngine = CreateCompressionEngine();
			return new CargoStream(compressionEngine.Unpack(stream, fileName), stream, compressionEngine);
		}

		public StreamReader OpenText(string fileName)
		{
			return new StreamReader(OpenRead(fileName));
		}

		public void Pack(string sourceDirectory)
		{
			Pack(sourceDirectory, includeSubdirectories: false, CompressionLevel.Max, null);
		}

		public void Pack(string sourceDirectory, bool includeSubdirectories, CompressionLevel compLevel, EventHandler<ArchiveProgressEventArgs> progressHandler)
		{
			IList<string> relativeFilePathsInDirectoryTree = GetRelativeFilePathsInDirectoryTree(sourceDirectory, includeSubdirectories);
			PackFiles(sourceDirectory, relativeFilePathsInDirectoryTree, relativeFilePathsInDirectoryTree, compLevel, progressHandler);
		}

		public void PackFiles(string sourceDirectory, IList<string> sourceFileNames, IList<string> fileNames)
		{
			PackFiles(sourceDirectory, sourceFileNames, fileNames, CompressionLevel.Max, null);
		}

		public void PackFiles(string sourceDirectory, IList<string> sourceFileNames, IList<string> fileNames, CompressionLevel compLevel, EventHandler<ArchiveProgressEventArgs> progressHandler)
		{
			if (sourceFileNames == null)
			{
				throw new ArgumentNullException("sourceFileNames");
			}
			if (fileNames == null)
			{
				string[] array = new string[sourceFileNames.Count];
				for (int i = 0; i < sourceFileNames.Count; i = checked(i + 1))
				{
					array[i] = Path.GetFileName(sourceFileNames[i]);
				}
				fileNames = array;
			}
			else if (fileNames.Count != sourceFileNames.Count)
			{
				throw new ArgumentOutOfRangeException("fileNames");
			}
			using CompressionEngine compressionEngine = CreateCompressionEngine();
			compressionEngine.Progress += progressHandler;
			IDictionary<string, string> files = CreateStringDictionary(fileNames, sourceFileNames);
			ArchiveFileStreamContext archiveFileStreamContext = new ArchiveFileStreamContext(FullName, sourceDirectory, files);
			archiveFileStreamContext.EnableOffsetOpen = true;
			compressionEngine.CompressionLevel = compLevel;
			compressionEngine.Pack(archiveFileStreamContext, fileNames);
		}

		public void PackFileSet(string sourceDirectory, IDictionary<string, string> fileNames)
		{
			PackFileSet(sourceDirectory, fileNames, CompressionLevel.Max, null);
		}

		public void PackFileSet(string sourceDirectory, IDictionary<string, string> fileNames, CompressionLevel compLevel, EventHandler<ArchiveProgressEventArgs> progressHandler)
		{
			if (fileNames == null)
			{
				throw new ArgumentNullException("fileNames");
			}
			string[] array = new string[fileNames.Count];
			fileNames.Keys.CopyTo(array, 0);
			using CompressionEngine compressionEngine = CreateCompressionEngine();
			compressionEngine.Progress += progressHandler;
			ArchiveFileStreamContext archiveFileStreamContext = new ArchiveFileStreamContext(FullName, sourceDirectory, fileNames);
			archiveFileStreamContext.EnableOffsetOpen = true;
			compressionEngine.CompressionLevel = compLevel;
			compressionEngine.Pack(archiveFileStreamContext, array);
		}

		internal IList<string> GetRelativeFilePathsInDirectoryTree(string dir, bool includeSubdirectories)
		{
			IList<string> list = new List<string>();
			RecursiveGetRelativeFilePathsInDirectoryTree(dir, string.Empty, includeSubdirectories, list);
			return list;
		}

		internal ArchiveFileInfo GetFile(string path)
		{
			IList<ArchiveFileInfo> list = InternalGetFiles((string match) => string.Compare(match, path, ignoreCase: true, CultureInfo.InvariantCulture) == 0);
			if (list == null || list.Count <= 0)
			{
				return null;
			}
			return list[0];
		}

		protected abstract CompressionEngine CreateCompressionEngine();

		private static IDictionary<string, string> CreateStringDictionary(IList<string> keys, IList<string> values)
		{
			IDictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			for (int i = 0; i < keys.Count; i = checked(i + 1))
			{
				dictionary.Add(keys[i], values[i]);
			}
			return dictionary;
		}

		private void RecursiveGetRelativeFilePathsInDirectoryTree(string dir, string relativeDir, bool includeSubdirectories, IList<string> fileList)
		{
			string[] files = System.IO.Directory.GetFiles(dir);
			for (int i = 0; i < files.Length; i++)
			{
				string fileName = Path.GetFileName(files[i]);
				fileList.Add(Path.Combine(relativeDir, fileName));
			}
			if (includeSubdirectories)
			{
				files = System.IO.Directory.GetDirectories(dir);
				for (int i = 0; i < files.Length; i++)
				{
					string fileName2 = Path.GetFileName(files[i]);
					RecursiveGetRelativeFilePathsInDirectoryTree(Path.Combine(dir, fileName2), Path.Combine(relativeDir, fileName2), includeSubdirectories, fileList);
				}
			}
		}

		private IList<ArchiveFileInfo> InternalGetFiles(Predicate<string> fileFilter)
		{
			using CompressionEngine compressionEngine = CreateCompressionEngine();
			ArchiveFileStreamContext archiveFileStreamContext = new ArchiveFileStreamContext(FullName, null, null);
			archiveFileStreamContext.EnableOffsetOpen = true;
			IList<ArchiveFileInfo> fileInfo = compressionEngine.GetFileInfo(archiveFileStreamContext, fileFilter);
			for (int i = 0; i < fileInfo.Count; i = checked(i + 1))
			{
				fileInfo[i].Archive = this;
			}
			return fileInfo;
		}
	}
	public class ArchiveProgressEventArgs : EventArgs
	{
		private ArchiveProgressType progressType;

		private string currentFileName;

		private int currentFileNumber;

		private int totalFiles;

		private long currentFileBytesProcessed;

		private long currentFileTotalBytes;

		private string currentArchiveName;

		private short currentArchiveNumber;

		private short totalArchives;

		private long currentArchiveBytesProcessed;

		private long currentArchiveTotalBytes;

		private long fileBytesProcessed;

		private long totalFileBytes;

		public ArchiveProgressType ProgressType => progressType;

		public string CurrentFileName => currentFileName;

		public int CurrentFileNumber => currentFileNumber;

		public int TotalFiles => totalFiles;

		public long CurrentFileBytesProcessed => currentFileBytesProcessed;

		public long CurrentFileTotalBytes => currentFileTotalBytes;

		public string CurrentArchiveName => currentArchiveName;

		public int CurrentArchiveNumber => currentArchiveNumber;

		public int TotalArchives => totalArchives;

		public long CurrentArchiveBytesProcessed => currentArchiveBytesProcessed;

		public long CurrentArchiveTotalBytes => currentArchiveTotalBytes;

		public long FileBytesProcessed => fileBytesProcessed;

		public long TotalFileBytes => totalFileBytes;

		public ArchiveProgressEventArgs(ArchiveProgressType progressType, string currentFileName, int currentFileNumber, int totalFiles, long currentFileBytesProcessed, long currentFileTotalBytes, string currentArchiveName, int currentArchiveNumber, int totalArchives, long currentArchiveBytesProcessed, long currentArchiveTotalBytes, long fileBytesProcessed, long totalFileBytes)
		{
			this.progressType = progressType;
			this.currentFileName = currentFileName;
			this.currentFileNumber = currentFileNumber;
			this.totalFiles = totalFiles;
			this.currentFileBytesProcessed = currentFileBytesProcessed;
			this.currentFileTotalBytes = currentFileTotalBytes;
			this.currentArchiveName = currentArchiveName;
			checked
			{
				this.currentArchiveNumber = (short)currentArchiveNumber;
				this.totalArchives = (short)totalArchives;
				this.currentArchiveBytesProcessed = currentArchiveBytesProcessed;
				this.currentArchiveTotalBytes = currentArchiveTotalBytes;
				this.fileBytesProcessed = fileBytesProcessed;
				this.totalFileBytes = totalFileBytes;
			}
		}
	}
	public enum ArchiveProgressType
	{
		StartFile,
		PartialFile,
		FinishFile,
		StartArchive,
		PartialArchive,
		FinishArchive
	}
	public class ArchiveFileStreamContext : IPackStreamContext, IUnpackStreamContext
	{
		private IList<string> archiveFiles;

		private string directory;

		private IDictionary<string, string> files;

		private bool extractOnlyNewerFiles;

		private bool enableOffsetOpen;

		public IList<string> ArchiveFiles => archiveFiles;

		public string Directory => directory;

		public IDictionary<string, string> Files => files;

		public bool ExtractOnlyNewerFiles
		{
			get
			{
				return extractOnlyNewerFiles;
			}
			set
			{
				extractOnlyNewerFiles = value;
			}
		}

		public bool EnableOffsetOpen
		{
			get
			{
				return enableOffsetOpen;
			}
			set
			{
				enableOffsetOpen = value;
			}
		}

		public ArchiveFileStreamContext(string archiveFile)
			: this(archiveFile, null, null)
		{
		}

		public ArchiveFileStreamContext(string archiveFile, string directory, IDictionary<string, string> files)
			: this(new string[1] { archiveFile }, directory, files)
		{
			if (archiveFile == null)
			{
				throw new ArgumentNullException("archiveFile");
			}
		}

		public ArchiveFileStreamContext(IList<string> archiveFiles, string directory, IDictionary<string, string> files)
		{
			if (archiveFiles == null || archiveFiles.Count == 0)
			{
				throw new ArgumentNullException("archiveFiles");
			}
			this.archiveFiles = archiveFiles;
			this.directory = directory;
			this.files = files;
		}

		public virtual string GetArchiveName(int archiveNumber)
		{
			if (archiveNumber < archiveFiles.Count)
			{
				return Path.GetFileName(archiveFiles[archiveNumber]);
			}
			return string.Empty;
		}

		public virtual Stream OpenArchiveWriteStream(int archiveNumber, string archiveName, bool truncate, CompressionEngine compressionEngine)
		{
			if (archiveNumber >= archiveFiles.Count)
			{
				return null;
			}
			if (string.IsNullOrEmpty(archiveName))
			{
				throw new ArgumentNullException("archiveName");
			}
			Stream stream = File.Open(Path.Combine(Path.GetDirectoryName(archiveFiles[0]), archiveName), truncate ? FileMode.OpenOrCreate : FileMode.Open, FileAccess.ReadWrite);
			if (enableOffsetOpen)
			{
				long num = compressionEngine.FindArchiveOffset(new DuplicateStream(stream));
				if (num < 0)
				{
					num = stream.Length;
				}
				if (num > 0)
				{
					stream = new OffsetStream(stream, num);
				}
				stream.Seek(0L, SeekOrigin.Begin);
			}
			if (truncate)
			{
				stream.SetLength(0L);
			}
			return stream;
		}

		public virtual void CloseArchiveWriteStream(int archiveNumber, string archiveName, Stream stream)
		{
			if (stream == null)
			{
				return;
			}
			stream.Close();
			if (!(stream is FileStream fileStream))
			{
				return;
			}
			string name = fileStream.Name;
			if (!string.IsNullOrEmpty(archiveName) && archiveName != Path.GetFileName(name))
			{
				string text = Path.Combine(Path.GetDirectoryName(archiveFiles[0]), archiveName);
				if (File.Exists(text))
				{
					File.Delete(text);
				}
				File.Move(name, text);
			}
		}

		public virtual Stream OpenFileReadStream(string path, out FileAttributes attributes, out DateTime lastWriteTime)
		{
			string text = TranslateFilePath(path);
			if (text == null)
			{
				attributes = FileAttributes.Normal;
				lastWriteTime = DateTime.Now;
				return null;
			}
			attributes = File.GetAttributes(text);
			lastWriteTime = File.GetLastWriteTime(text);
			return File.Open(text, FileMode.Open, FileAccess.Read, FileShare.Read);
		}

		public virtual void CloseFileReadStream(string path, Stream stream)
		{
			stream?.Close();
		}

		public virtual object GetOption(string optionName, object[] parameters)
		{
			return null;
		}

		public virtual Stream OpenArchiveReadStream(int archiveNumber, string archiveName, CompressionEngine compressionEngine)
		{
			if (archiveNumber >= archiveFiles.Count)
			{
				return null;
			}
			Stream stream = File.Open(archiveFiles[archiveNumber], FileMode.Open, FileAccess.Read, FileShare.Read);
			if (enableOffsetOpen)
			{
				long num = compressionEngine.FindArchiveOffset(new DuplicateStream(stream));
				if (num > 0)
				{
					stream = new OffsetStream(stream, num);
				}
				else
				{
					stream.Seek(0L, SeekOrigin.Begin);
				}
			}
			return stream;
		}

		public virtual void CloseArchiveReadStream(int archiveNumber, string archiveName, Stream stream)
		{
			stream?.Close();
		}

		public virtual Stream OpenFileWriteStream(string path, long fileSize, DateTime lastWriteTime)
		{
			string text = TranslateFilePath(path);
			if (text == null)
			{
				return null;
			}
			FileInfo fileInfo = new FileInfo(text);
			if (fileInfo.Exists)
			{
				if (extractOnlyNewerFiles && lastWriteTime != DateTime.MinValue && fileInfo.LastWriteTime >= lastWriteTime)
				{
					return null;
				}
				FileAttributes fileAttributes = FileAttributes.ReadOnly | FileAttributes.Hidden | FileAttributes.System;
				if ((fileInfo.Attributes & fileAttributes) != 0)
				{
					fileInfo.Attributes &= ~fileAttributes;
				}
			}
			if (!fileInfo.Directory.Exists)
			{
				fileInfo.Directory.Create();
			}
			return File.Open(text, FileMode.Create, FileAccess.Write, FileShare.None);
		}

		public virtual void CloseFileWriteStream(string path, Stream stream, FileAttributes attributes, DateTime lastWriteTime)
		{
			stream?.Close();
			string text = TranslateFilePath(path);
			if (text == null)
			{
				return;
			}
			FileInfo fileInfo = new FileInfo(text);
			if (lastWriteTime != DateTime.MinValue)
			{
				try
				{
					fileInfo.LastWriteTime = lastWriteTime;
				}
				catch (ArgumentException)
				{
				}
				catch (IOException)
				{
				}
			}
			try
			{
				fileInfo.Attributes = attributes;
			}
			catch (IOException)
			{
			}
		}

		private string TranslateFilePath(string path)
		{
			string text = ((files == null) ? path : files[path]);
			if (text != null && directory != null)
			{
				text = Path.Combine(directory, text);
			}
			return text;
		}
	}
	public class BasicUnpackStreamContext : IUnpackStreamContext
	{
		private Stream archiveStream;

		private Stream fileStream;

		public Stream FileStream => fileStream;

		public BasicUnpackStreamContext(Stream archiveStream)
		{
			this.archiveStream = archiveStream;
		}

		public Stream OpenArchiveReadStream(int archiveNumber, string archiveName, CompressionEngine compressionEngine)
		{
			return new DuplicateStream(archiveStream);
		}

		public void CloseArchiveReadStream(int archiveNumber, string archiveName, Stream stream)
		{
		}

		public Stream OpenFileWriteStream(string path, long fileSize, DateTime lastWriteTime)
		{
			fileStream = new MemoryStream(new byte[fileSize], 0, checked((int)fileSize), writable: true, publiclyVisible: true);
			return fileStream;
		}

		public void CloseFileWriteStream(string path, Stream stream, FileAttributes attributes, DateTime lastWriteTime)
		{
		}
	}
	public abstract class CompressionEngine : IDisposable
	{
		private CompressionLevel compressionLevel;

		private bool dontUseTempFiles;

		public bool UseTempFiles
		{
			get
			{
				return !dontUseTempFiles;
			}
			set
			{
				dontUseTempFiles = !value;
			}
		}

		public CompressionLevel CompressionLevel
		{
			get
			{
				return compressionLevel;
			}
			set
			{
				compressionLevel = value;
			}
		}

		public event EventHandler<ArchiveProgressEventArgs> Progress;

		protected CompressionEngine()
		{
			compressionLevel = CompressionLevel.Normal;
		}

		~CompressionEngine()
		{
			Dispose(disposing: false);
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		public void Pack(IPackStreamContext streamContext, IEnumerable<string> files)
		{
			if (files == null)
			{
				throw new ArgumentNullException("files");
			}
			Pack(streamContext, files, 0L);
		}

		public abstract void Pack(IPackStreamContext streamContext, IEnumerable<string> files, long maxArchiveSize);

		public abstract bool IsArchive(Stream stream);

		public virtual long FindArchiveOffset(Stream stream)
		{
			if (stream == null)
			{
				throw new ArgumentNullException("stream");
			}
			long num = 4L;
			long length = stream.Length;
			checked
			{
				for (long num2 = 0L; num2 <= length - num; num2 += num)
				{
					stream.Seek(num2, SeekOrigin.Begin);
					if (IsArchive(stream))
					{
						return num2;
					}
				}
				return -1L;
			}
		}

		public IList<ArchiveFileInfo> GetFileInfo(Stream stream)
		{
			return GetFileInfo(new BasicUnpackStreamContext(stream), null);
		}

		public abstract IList<ArchiveFileInfo> GetFileInfo(IUnpackStreamContext streamContext, Predicate<string> fileFilter);

		public IList<string> GetFiles(Stream stream)
		{
			return GetFiles(new BasicUnpackStreamContext(stream), null);
		}

		public IList<string> GetFiles(IUnpackStreamContext streamContext, Predicate<string> fileFilter)
		{
			if (streamContext == null)
			{
				throw new ArgumentNullException("streamContext");
			}
			IList<ArchiveFileInfo> fileInfo = GetFileInfo(streamContext, fileFilter);
			IList<string> list = new List<string>(fileInfo.Count);
			for (int i = 0; i < fileInfo.Count; i = checked(i + 1))
			{
				list.Add(fileInfo[i].Name);
			}
			return list;
		}

		public Stream Unpack(Stream stream, string path)
		{
			if (stream == null)
			{
				throw new ArgumentNullException("stream");
			}
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			BasicUnpackStreamContext basicUnpackStreamContext = new BasicUnpackStreamContext(stream);
			Unpack(basicUnpackStreamContext, (string match) => string.Compare(match, path, ignoreCase: true, CultureInfo.InvariantCulture) == 0);
			Stream fileStream = basicUnpackStreamContext.FileStream;
			if (fileStream != null)
			{
				fileStream.Position = 0L;
			}
			return fileStream;
		}

		public abstract void Unpack(IUnpackStreamContext streamContext, Predicate<string> fileFilter);

		protected void OnProgress(ArchiveProgressEventArgs e)
		{
			if (this.Progress != null)
			{
				this.Progress(this, e);
			}
		}

		protected virtual void Dispose(bool disposing)
		{
		}

		public static void DosDateAndTimeToDateTime(short dosDate, short dosTime, out DateTime dateTime)
		{
			if (dosDate == 0 && dosTime == 0)
			{
				dateTime = DateTime.MinValue;
				return;
			}
			SafeNativeMethods.DosDateTimeToFileTime(dosDate, dosTime, out var fileTime);
			dateTime = DateTime.FromFileTimeUtc(fileTime);
			dateTime = new DateTime(dateTime.Ticks, DateTimeKind.Local);
		}

		public static void DateTimeToDosDateAndTime(DateTime dateTime, out short dosDate, out short dosTime)
		{
			dateTime = new DateTime(dateTime.Ticks, DateTimeKind.Utc);
			long fileTime = dateTime.ToFileTimeUtc();
			SafeNativeMethods.FileTimeToDosDateTime(ref fileTime, out dosDate, out dosTime);
		}
	}
	public enum CompressionLevel
	{
		None = 0,
		Min = 1,
		Normal = 6,
		Max = 10
	}
	public class CargoStream : Stream
	{
		private Stream source;

		private List<IDisposable> cargo;

		public Stream Source => source;

		public IList<IDisposable> Cargo => cargo;

		public override bool CanRead => source.CanRead;

		public override bool CanWrite => source.CanWrite;

		public override bool CanSeek => source.CanSeek;

		public override long Length => source.Length;

		public override long Position
		{
			get
			{
				return source.Position;
			}
			set
			{
				source.Position = value;
			}
		}

		public CargoStream(Stream source, params IDisposable[] cargo)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			this.source = source;
			this.cargo = new List<IDisposable>(cargo);
		}

		public override void Flush()
		{
			source.Flush();
		}

		public override void SetLength(long value)
		{
			source.SetLength(value);
		}

		public override void Close()
		{
			source.Close();
			foreach (IDisposable item in cargo)
			{
				item.Dispose();
			}
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			return source.Read(buffer, offset, count);
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			source.Write(buffer, offset, count);
		}

		public override long Seek(long offset, SeekOrigin origin)
		{
			return source.Seek(offset, origin);
		}
	}
	public class DuplicateStream : Stream
	{
		private Stream source;

		private long position;

		public Stream Source => source;

		public override bool CanRead => source.CanRead;

		public override bool CanWrite => source.CanWrite;

		public override bool CanSeek => source.CanSeek;

		public override long Length => source.Length;

		public override long Position
		{
			get
			{
				return position;
			}
			set
			{
				position = value;
			}
		}

		public DuplicateStream(Stream source)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			this.source = OriginalStream(source);
		}

		public static Stream OriginalStream(Stream stream)
		{
			if (!(stream is DuplicateStream duplicateStream))
			{
				return stream;
			}
			return duplicateStream.Source;
		}

		public override void Flush()
		{
			source.Flush();
		}

		public override void SetLength(long value)
		{
			source.SetLength(value);
		}

		public override void Close()
		{
			source.Close();
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			long num = source.Position;
			source.Position = position;
			int result = source.Read(buffer, offset, count);
			position = source.Position;
			source.Position = num;
			return result;
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			long num = source.Position;
			source.Position = position;
			source.Write(buffer, offset, count);
			position = source.Position;
			source.Position = num;
		}

		public override long Seek(long offset, SeekOrigin origin)
		{
			long num = 0L;
			switch (origin)
			{
			case SeekOrigin.Current:
				num = position;
				break;
			case SeekOrigin.End:
				num = Length;
				break;
			}
			position = checked(num + offset);
			return position;
		}
	}
	public interface IPackStreamContext
	{
		string GetArchiveName(int archiveNumber);

		Stream OpenArchiveWriteStream(int archiveNumber, string archiveName, bool truncate, CompressionEngine compressionEngine);

		void CloseArchiveWriteStream(int archiveNumber, string archiveName, Stream stream);

		Stream OpenFileReadStream(string path, out FileAttributes attributes, out DateTime lastWriteTime);

		void CloseFileReadStream(string path, Stream stream);

		object GetOption(string optionName, object[] parameters);
	}
	public interface IUnpackStreamContext
	{
		Stream OpenArchiveReadStream(int archiveNumber, string archiveName, CompressionEngine compressionEngine);

		void CloseArchiveReadStream(int archiveNumber, string archiveName, Stream stream);

		Stream OpenFileWriteStream(string path, long fileSize, DateTime lastWriteTime);

		void CloseFileWriteStream(string path, Stream stream, FileAttributes attributes, DateTime lastWriteTime);
	}
	public class OffsetStream : Stream
	{
		private Stream source;

		private long sourceOffset;

		public Stream Source => source;

		public long Offset => sourceOffset;

		public override bool CanRead => source.CanRead;

		public override bool CanWrite => source.CanWrite;

		public override bool CanSeek => source.CanSeek;

		public override long Length => checked(source.Length - sourceOffset);

		public override long Position
		{
			get
			{
				return checked(source.Position - sourceOffset);
			}
			set
			{
				source.Position = checked(value + sourceOffset);
			}
		}

		public OffsetStream(Stream source, long offset)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			this.source = source;
			sourceOffset = offset;
			this.source.Seek(sourceOffset, SeekOrigin.Current);
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			return source.Read(buffer, offset, count);
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			source.Write(buffer, offset, count);
		}

		public override int ReadByte()
		{
			return source.ReadByte();
		}

		public override void WriteByte(byte value)
		{
			source.WriteByte(value);
		}

		public override void Flush()
		{
			source.Flush();
		}

		public override long Seek(long offset, SeekOrigin origin)
		{
			return checked(source.Seek(offset + ((origin == SeekOrigin.Begin) ? sourceOffset : 0), origin) - sourceOffset);
		}

		public override void SetLength(long value)
		{
			source.SetLength(checked(value + sourceOffset));
		}

		public override void Close()
		{
			source.Close();
		}
	}
	[SuppressUnmanagedCodeSecurity]
	internal static class SafeNativeMethods
	{
		[DllImport("kernel32.dll", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		internal static extern bool DosDateTimeToFileTime(short wFatDate, short wFatTime, out long fileTime);

		[DllImport("kernel32.dll", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		internal static extern bool FileTimeToDosDateTime(ref long fileTime, out short wFatDate, out short wFatTime);
	}
}

using System; using System.Collections.Generic; using System.Diagnostics; using System.Globalization; using System.IO; using System.Linq; 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 BepInEx; using BepInEx.Configuration; using BepInEx.Logging; using FixPluginTypesSerialization.Patchers; using FixPluginTypesSerialization.UnityPlayer; using FixPluginTypesSerialization.UnityPlayer.Structs.Default; using FixPluginTypesSerialization.Util; using FixPluginTypesSerialization.Util.Platform; 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.0", FrameworkDisplayName = ".NET Standard 2.0")] [assembly: AssemblyCompany("FixPluginTypesSerialization")] [assembly: AssemblyConfiguration("Release")] [assembly: AssemblyFileVersion("1.0.0.0")] [assembly: AssemblyInformationalVersion("1.0.0+cee13878e76b7575aaae028d3da3d4ff040d8322")] [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>("Overrides", "UnityVersionOverride", "", "Unity version is Major.Minor.Patch format i.e. 2017.2.1." + Environment.NewLine + "If specified, this version will be used instead of auto-detection" + Environment.NewLine + "from executable info. Specify only if the patcher doesn't work otherwise."); internal static ConfigEntry<FunctionOffsetLookup> FunctionOffsetLookupType = _config.Bind<FunctionOffsetLookup>("Overrides", "FunctionOffsetLookupType", FunctionOffsetLookup.PreferSupportedVersions, "PreferSupportedVersions - using values for supported versions, if a version is not supported trying to use pdb." + Environment.NewLine + "PreferPdb - using pdb, it will be downloaded from Unity symbols server,if there is no pdb or download failed trying to use values for supported versions." + Environment.NewLine + "Manual - using offsets from [Cache] section of the config, which you need to specify yourself as hex values."); 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; } PatternDiscoverer patternDiscoverer = new PatternDiscoverer((Process.GetCurrentProcess().Modules.Cast<ProcessModule>().FirstOrDefault(IsUnityPlayer) ?? Process.GetCurrentProcess().MainModule).BaseAddress, text); CommonUnityFunctions.Init(patternDiscoverer); AwakeFromLoad awakeFromLoad = new AwakeFromLoad(); IsAssemblyCreated isAssemblyCreated = new IsAssemblyCreated(); IsFileCreated isFileCreated = new IsFileCreated(); ScriptingManagerDeconstructor scriptingManagerDeconstructor = new ScriptingManagerDeconstructor(); ConvertSeparatorsToPlatform convertSeparatorsToPlatform = new ConvertSeparatorsToPlatform(); awakeFromLoad.Patch(patternDiscoverer, Config.MonoManagerAwakeFromLoadOffset); isAssemblyCreated.Patch(patternDiscoverer, Config.MonoManagerIsAssemblyCreatedOffset); if (!IsAssemblyCreated.IsApplied) { isFileCreated.Patch(patternDiscoverer, Config.IsFileCreatedOffset); } convertSeparatorsToPlatform.Patch(patternDiscoverer, Config.ConvertSeparatorsToPlatformOffset); scriptingManagerDeconstructor.Patch(patternDiscoverer, 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); } } } namespace FixPluginTypesSerialization.Util { internal class BytePattern { private readonly byte?[] pattern; private int[] jumpTable; public int Length => pattern.Length; public bool IsE8 => ((int?)pattern[0]).GetValueOrDefault() == 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(PatternDiscoverer patternDiscoverer) { IntPtr intPtr = patternDiscoverer.Discover(Config.MallocInternalOffset, new BytePattern[1] { Encoding.ASCII.GetBytes("malloc_internal") }); if (intPtr != IntPtr.Zero) { mallocInternal = (MallocInternalFunc)Marshal.GetDelegateForFunctionPointer(intPtr, typeof(MallocInternalFunc)); } IntPtr intPtr2 = patternDiscoverer.Discover(Config.FreeAllocInternalOffset, new BytePattern[1] { Encoding.ASCII.GetBytes("free_alloc_internal") }); 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 = patternDiscoverer.Discover(Config.ScriptingAssembliesOffset, new BytePattern[1] { Encoding.ASCII.GetBytes("m_ScriptingAssemblies@") }); 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; } } public enum FunctionOffsetLookup { PreferSupportedVersions, PreferPdb, Manual } public static class FunctionOffsets { public static bool TryGet(Version unityVersion, out Dictionary<string, long> offsets) { offsets = ((IntPtr.Size == 4) ? Get32(unityVersion) : Get64(unityVersion)); return offsets != null; } private static Dictionary<string, long> Get32(Version unityVersion) { return null; } private static Dictionary<string, long> Get64(Version unityVersion) { switch (unityVersion.Major) { case 5: switch (unityVersion.Minor) { case 0: switch (unityVersion.Build) { case 0: return CreateOffsets(1519584L, 0L, 2772736L, 1572448L, 2795760L, 11808L, 9536L, 0L); case 1: return CreateOffsets(1526224L, 0L, 2776448L, 1578976L, 2799424L, 11808L, 9536L, 0L); case 2: return CreateOffsets(1526512L, 0L, 2780208L, 1578704L, 2803280L, 11984L, 9712L, 0L); case 3: return CreateOffsets(1532016L, 0L, 2788720L, 1584288L, 2811408L, 11984L, 9712L, 0L); case 4: return CreateOffsets(1532352L, 0L, 2787216L, 1585264L, 2810400L, 11824L, 9552L, 0L); } break; case 1: switch (unityVersion.Build) { case 0: return CreateOffsets(1539536L, 0L, 2895136L, 1591456L, 2914064L, 11792L, 9520L, 0L); case 1: return CreateOffsets(1532352L, 0L, 2889568L, 1584848L, 2909008L, 11776L, 9504L, 0L); case 2: return CreateOffsets(1536608L, 0L, 2895968L, 1588528L, 2914816L, 11968L, 9696L, 0L); case 3: return CreateOffsets(1534064L, 0L, 2893280L, 1586352L, 2912464L, 11792L, 9520L, 0L); case 4: return CreateOffsets(1534560L, 0L, 2897920L, 1586960L, 2917712L, 11776L, 9504L, 0L); case 5: return CreateOffsets(1536544L, 0L, 2895200L, 1589008L, 2914736L, 11776L, 9504L, 0L); } break; case 2: switch (unityVersion.Build) { case 0: return CreateOffsets(1601024L, 0L, 2917232L, 1653200L, 2938816L, 11936L, 9664L, 0L); case 1: return CreateOffsets(1604832L, 0L, 2921792L, 1657232L, 2942912L, 11776L, 9504L, 0L); case 2: return CreateOffsets(1608448L, 0L, 2921632L, 1660080L, 2943344L, 11952L, 9680L, 0L); case 3: return CreateOffsets(1609760L, 0L, 2918432L, 1661824L, 2940192L, 11824L, 9552L, 0L); case 4: return CreateOffsets(1610208L, 0L, 2923312L, 1661584L, 2945072L, 11760L, 9488L, 0L); case 5: return CreateOffsets(1603040L, 0L, 2920608L, 1655584L, 2942368L, 11760L, 9488L, 0L); } break; case 3: switch (unityVersion.Build) { case 0: return CreateOffsets(2058016L, 0L, 3148928L, 2107216L, 3172256L, 1179552L, 1176448L, 0L); case 1: return CreateOffsets(2054016L, 0L, 3149200L, 2102688L, 3173328L, 1171392L, 1168288L, 0L); case 2: return CreateOffsets(2054240L, 0L, 3147872L, 2103040L, 3172048L, 1176608L, 1173504L, 0L); case 3: return CreateOffsets(2055600L, 0L, 3152432L, 2104288L, 3175856L, 1174752L, 1171648L, 0L); case 4: return CreateOffsets(1996128L, 0L, 3090368L, 2045792L, 3114800L, 1133136L, 1129424L, 0L); case 5: return CreateOffsets(2003360L, 0L, 3112208L, 2052592L, 3136096L, 1137840L, 1133504L, 0L); case 6: return CreateOffsets(2018064L, 0L, 3116768L, 2067408L, 3140608L, 1147680L, 1143344L, 0L); case 7: return CreateOffsets(2025424L, 0L, 3130592L, 2074400L, 3154544L, 1152864L, 1148528L, 0L); case 8: return CreateOffsets(2026160L, 0L, 3131296L, 2075056L, 3155232L, 1158080L, 1153744L, 0L); } break; case 4: switch (unityVersion.Build) { case 0: return CreateOffsets(2151120L, 0L, 3326704L, 2192800L, 3343888L, 1307984L, 1304112L, 0L); case 1: return CreateOffsets(2164448L, 0L, 3345952L, 2206416L, 3362960L, 1322688L, 1318816L, 0L); case 2: return CreateOffsets(2167920L, 0L, 3344976L, 2210608L, 3362080L, 1323072L, 1319200L, 0L); case 3: return CreateOffsets(2157424L, 0L, 3344160L, 2199552L, 3361968L, 1314432L, 1310560L, 0L); case 4: return CreateOffsets(2167120L, 0L, 3346880L, 2209696L, 3363392L, 1325200L, 1321328L, 0L); case 5: return CreateOffsets(2164688L, 0L, 3352400L, 2206656L, 3369104L, 1320624L, 1316752L, 0L); case 6: return CreateOffsets(2167600L, 0L, 3355312L, 2209344L, 3372816L, 1324048L, 1320176L, 0L); } break; case 5: switch (unityVersion.Build) { case 0: return CreateOffsets(3187616L, 0L, 2666208L, 3236944L, 2678768L, 80864L, 77712L, 0L); case 1: return CreateOffsets(3193200L, 0L, 2670816L, 3241920L, 2683376L, 81456L, 78288L, 0L); case 2: return CreateOffsets(3205712L, 0L, 2683728L, 3254592L, 2696288L, 81280L, 78112L, 0L); case 3: return CreateOffsets(3203472L, 0L, 2684544L, 3252048L, 2695808L, 81088L, 77920L, 0L); case 4: return CreateOffsets(3204368L, 0L, 2682752L, 3254256L, 2695376L, 81344L, 78176L, 0L); case 5: return CreateOffsets(3205552L, 0L, 2679536L, 3255328L, 2691840L, 80896L, 77728L, 0L); case 6: return CreateOffsets(3212144L, 0L, 2689424L, 3261824L, 2701120L, 81168L, 78000L, 0L); } break; case 6: switch (unityVersion.Build) { case 0: return CreateOffsets(8607808L, 0L, 7398368L, 6477584L, 7397984L, 8475808L, 8475984L, 0L); case 1: return CreateOffsets(8613168L, 0L, 7402064L, 6478288L, 7401680L, 8481280L, 8481456L, 0L); case 2: return CreateOffsets(8634192L, 0L, 7413264L, 6491008L, 7412880L, 8502496L, 8502672L, 0L); case 3: return CreateOffsets(8641584L, 0L, 7421536L, 6501520L, 7421152L, 8508976L, 8509152L, 0L); case 4: return CreateOffsets(8645968L, 0L, 7425024L, 6502240L, 7424640L, 8515008L, 8515184L, 0L); case 5: return CreateOffsets(8650080L, 0L, 7426080L, 6502768L, 7425696L, 8517088L, 8517264L, 0L); case 6: return CreateOffsets(8644208L, 0L, 7420704L, 6497312L, 7420320L, 8511584L, 8511760L, 0L); case 7: return CreateOffsets(8644208L, 0L, 7420704L, 6497312L, 7420320L, 8511584L, 8511760L, 0L); } break; } break; case 2017: switch (unityVersion.Minor) { case 1: switch (unityVersion.Build) { case 0: return CreateOffsets(5689904L, 0L, 8344128L, 7269760L, 8357424L, 9310656L, 9306960L, 0L); case 1: return CreateOffsets(5693664L, 0L, 8350688L, 7274656L, 8364608L, 9318256L, 9314560L, 0L); case 2: return CreateOffsets(5698352L, 0L, 8350896L, 7277376L, 8364816L, 9322400L, 9318704L, 0L); case 3: return CreateOffsets(5703968L, 0L, 8363488L, 7285696L, 8377360L, 9338048L, 9334352L, 0L); case 4: return CreateOffsets(5713616L, 0L, 8372080L, 7296256L, 8385872L, 9345600L, 9341904L, 0L); case 5: return CreateOffsets(5710224L, 0L, 8372640L, 7292560L, 8386560L, 9345104L, 9341408L, 0L); } break; case 2: switch (unityVersion.Build) { case 0: return CreateOffsets(4525712L, 0L, 3978000L, 4598144L, 3993984L, 1163072L, 1159376L, 0L); case 1: return CreateOffsets(4527072L, 0L, 3981312L, 4599904L, 3997552L, 1159344L, 1155648L, 0L); case 2: return CreateOffsets(4527520L, 0L, 3979856L, 4600704L, 3995840L, 1161024L, 1157328L, 0L); case 3: return CreateOffsets(4535296L, 0L, 3987264L, 4608480L, 4003456L, 1160272L, 1156576L, 0L); case 4: return CreateOffsets(4531840L, 0L, 3980800L, 4605552L, 3997264L, 1161952L, 1158256L, 0L); case 5: return CreateOffsets(4531568L, 0L, 3989296L, 4604384L, 4005408L, 1159136L, 1155440L, 0L); } break; case 3: switch (unityVersion.Build) { case 0: return CreateOffsets(6098128L, 6114480L, 0L, 6201264L, 5566256L, 2970112L, 2969968L, 0L); case 1: return CreateOffsets(6092560L, 6108592L, 0L, 6195360L, 5561584L, 2968608L, 2968464L, 0L); } break; case 4: switch (unityVersion.Build) { case 0: return CreateOffsets(6099152L, 6115168L, 0L, 6200912L, 5570992L, 2962832L, 2962688L, 0L); case 1: return CreateOffsets(6090224L, 6106352L, 0L, 6192160L, 5563088L, 2966992L, 2966848L, 0L); case 2: return CreateOffsets(6089152L, 6105184L, 0L, 6191344L, 5558704L, 2966256L, 2966112L, 0L); case 3: return CreateOffsets(6098288L, 6114416L, 0L, 6200832L, 5569856L, 2976272L, 2976128L, 0L); case 4: return CreateOffsets(6093440L, 6109568L, 0L, 6195728L, 5562016L, 2968944L, 2968800L, 0L); case 5: return CreateOffsets(6105040L, 6121072L, 0L, 6207424L, 5575792L, 2969376L, 2969232L, 0L); case 6: return CreateOffsets(6088256L, 6104304L, 0L, 6190176L, 5555632L, 2970272L, 2970128L, 0L); case 7: return CreateOffsets(6102032L, 6118064L, 0L, 6203936L, 5573216L, 2967184L, 2967040L, 0L); case 8: return CreateOffsets(6105072L, 6121200L, 0L, 6207488L, 5576496L, 2979936L, 2979792L, 0L); case 9: return CreateOffsets(6099504L, 6115632L, 0L, 6202080L, 5567344L, 2969632L, 2969488L, 0L); case 10: return CreateOffsets(6109760L, 6125808L, 0L, 6212096L, 5574160L, 2970560L, 2970416L, 0L); case 11: return CreateOffsets(6109840L, 6125872L, 0L, 6211920L, 5575440L, 2968192L, 2968048L, 0L); case 12: return CreateOffsets(6119152L, 6135168L, 0L, 6221536L, 5589472L, 2973952L, 2973808L, 0L); case 13: return CreateOffsets(6114544L, 6130672L, 0L, 6217040L, 5579888L, 2980080L, 2979936L, 0L); case 14: return CreateOffsets(6117312L, 6133440L, 0L, 6220256L, 5580752L, 2985280L, 2985136L, 0L); case 15: return CreateOffsets(6117904L, 6133936L, 0L, 6221280L, 5581568L, 2981136L, 2980992L, 0L); case 16: return CreateOffsets(6118368L, 6134400L, 0L, 6221312L, 5587808L, 2969936L, 2969792L, 0L); case 17: return CreateOffsets(6121104L, 6137136L, 0L, 6224032L, 5590048L, 2973232L, 2973088L, 0L); case 18: return CreateOffsets(6123024L, 6139152L, 0L, 6226080L, 5591712L, 2970976L, 2970832L, 0L); case 19: return CreateOffsets(6121200L, 6137216L, 0L, 6223728L, 5585680L, 2974192L, 2974048L, 0L); case 20: return CreateOffsets(6116240L, 6132272L, 0L, 6219808L, 5580752L, 2969056L, 2968912L, 0L); case 21: return CreateOffsets(6122640L, 6138688L, 0L, 6225712L, 5589936L, 2980784L, 2980640L, 0L); case 22: return CreateOffsets(6122640L, 6138688L, 0L, 6225712L, 5589936L, 2980784L, 2980640L, 0L); case 23: return CreateOffsets(6123424L, 6139456L, 0L, 6226704L, 5591328L, 2969376L, 2969232L, 0L); case 24: return CreateOffsets(6116784L, 6132800L, 0L, 6219984L, 5585888L, 2982864L, 2982720L, 0L); case 25: return CreateOffsets(6116208L, 6132432L, 0L, 6219616L, 5582304L, 2982720L, 2982576L, 0L); case 26: return CreateOffsets(6120352L, 6136576L, 0L, 6223792L, 5586720L, 2970096L, 2969952L, 0L); case 27: return CreateOffsets(6124624L, 6140848L, 0L, 6228048L, 5592176L, 2980256L, 2980112L, 0L); case 28: return CreateOffsets(6107520L, 6123856L, 0L, 6211152L, 5571904L, 2974000L, 2973856L, 0L); case 29: return CreateOffsets(6107520L, 6123856L, 0L, 6211152L, 5571904L, 2974000L, 2973856L, 0L); case 30: return CreateOffsets(6125328L, 6141680L, 0L, 6228896L, 5586656L, 2982912L, 2982768L, 0L); case 31: return CreateOffsets(6120704L, 6136944L, 0L, 6223984L, 5587728L, 2976064L, 2975920L, 0L); case 32: return CreateOffsets(6108816L, 6125056L, 0L, 6212208L, 5573056L, 2968016L, 2967872L, 0L); case 33: return CreateOffsets(6122272L, 6138624L, 0L, 6225696L, 5585472L, 2984416L, 2984272L, 0L); case 34: return CreateOffsets(6122512L, 6138848L, 0L, 6226176L, 5586752L, 2983696L, 2983552L, 0L); case 35: return CreateOffsets(6122752L, 6138976L, 0L, 6225952L, 5590960L, 2972096L, 2971952L, 0L); case 36: return CreateOffsets(6126272L, 6142496L, 0L, 6229648L, 5592816L, 2986848L, 2986704L, 0L); case 37: return CreateOffsets(6121616L, 6137856L, 0L, 6225232L, 5585360L, 2971200L, 2971056L, 0L); case 38: return CreateOffsets(6121424L, 6137664L, 0L, 6225056L, 5587040L, 2978944L, 2978800L, 0L); case 39: return CreateOffsets(6122736L, 6138976L, 0L, 6226288L, 5591712L, 2985440L, 2985296L, 0L); case 40: return CreateOffsets(6117872L, 6134096L, 0L, 6221616L, 5582608L, 2982928L, 2982784L, 0L); } break; } break; case 2018: switch (unityVersion.Minor) { case 1: switch (unityVersion.Build) { case 0: return CreateOffsets(5841104L, 5860640L, 0L, 5923328L, 5335888L, 2849008L, 2848960L, 0L); case 1: return CreateOffsets(5834512L, 5854048L, 0L, 5916592L, 5330832L, 2848048L, 2837376L, 0L); case 2: return CreateOffsets(5839264L, 5858800L, 0L, 5921712L, 5335696L, 2850784L, 2840256L, 0L); case 3: return CreateOffsets(5835600L, 5855136L, 0L, 5918256L, 5331712L, 2847920L, 2847872L, 0L); case 4: return CreateOffsets(5841024L, 5860560L, 0L, 5923008L, 5335648L, 2846960L, 2846912L, 0L); case 5: return CreateOffsets(5839920L, 5859456L, 0L, 5922656L, 5333936L, 2848240L, 2837568L, 0L); case 6: return CreateOffsets(5839104L, 5858640L, 0L, 5921408L, 5334368L, 2848368L, 2837744L, 0L); case 7: return CreateOffsets(5839888L, 5859424L, 0L, 5922480L, 5336160L, 2853216L, 2842784L, 0L); case 8: return CreateOffsets(5840960L, 5860512L, 0L, 5923280L, 5334480L, 2845504L, 2845456L, 0L); case 9: return CreateOffsets(5838832L, 5858368L, 0L, 5921024L, 5336560L, 2851392L, 2840816L, 0L); } break; case 2: switch (unityVersion.Build) { case 0: return CreateOffsets(6134752L, 6152240L, 0L, 6214400L, 5567824L, 3004448L, 3004400L, 0L); case 1: return CreateOffsets(6136480L, 6154000L, 0L, 6216368L, 5573280L, 3004016L, 3003968L, 0L); case 2: return CreateOffsets(6136784L, 6154272L, 0L, 6216768L, 5572768L, 3003648L, 3003600L, 0L); case 3: return CreateOffsets(6134160L, 6151664L, 0L, 6214032L, 5569712L, 3005856L, 2995456L, 0L); case 4: return CreateOffsets(6137600L, 6155104L, 0L, 6217568L, 5573328L, 3000704L, 2990400L, 0L); case 5: return CreateOffsets(6135904L, 6153408L, 0L, 6217008L, 5572336L, 3002448L, 3002400L, 0L); case 6: return CreateOffsets(6140624L, 6158128L, 0L, 6220336L, 5576304L, 3005888L, 3005840L, 0L); case 7: return CreateOffsets(6141280L, 6158768L, 0L, 6221712L, 5574560L, 3007168L, 3007120L, 0L); case 8: return CreateOffsets(6141072L, 6158560L, 0L, 6220944L, 5574192L, 3006624L, 3006576L, 0L); case 9: return CreateOffsets(6142976L, 6160496L, 0L, 6223184L, 5577760L, 3006608L, 2996400L, 0L); case 10: return CreateOffsets(6144720L, 6162240L, 0L, 6224928L, 5580864L, 3006832L, 2996528L, 0L); case 11: return CreateOffsets(6140448L, 6157936L, 0L, 6220560L, 5574288L, 3005024L, 3004976L, 0L); case 12: return CreateOffsets(6144960L, 6162448L, 0L, 6224608L, 5578288L, 3007536L, 2997088L, 0L); case 13: return CreateOffsets(6144784L, 6162288L, 0L, 6224528L, 5579264L, 3007344L, 2997040L, 0L); case 14: return CreateOffsets(6148432L, 6165920L, 0L, 6228176L, 5582640L, 3008544L, 2998192L, 0L); case 15: return CreateOffsets(6146896L, 6164416L, 0L, 6226704L, 5582336L, 3008848L, 3008800L, 0L); case 16: return CreateOffsets(6147104L, 6164624L, 0L, 6226800L, 5585456L, 3009728L, 3009680L, 0L); case 17: return CreateOffsets(6147104L, 6164624L, 0L, 6226800L, 5585456L, 3009728L, 3009680L, 0L); case 18: return CreateOffsets(6141616L, 6159120L, 0L, 6221296L, 5578512L, 3007008L, 3006960L, 0L); case 19: return CreateOffsets(6145424L, 6162928L, 0L, 6225184L, 5580576L, 3008768L, 3008720L, 0L); case 20: return CreateOffsets(6147296L, 6164800L, 0L, 6227184L, 5583056L, 3007440L, 2997184L, 0L); case 21: return CreateOffsets(6147296L, 6164800L, 0L, 6227184L, 5583056L, 3007440L, 2997184L, 0L); } break; case 3: switch (unityVersion.Build) { case 0: return CreateOffsets(9297584L, 9308880L, 0L, 9330880L, 8839872L, 6427856L, 6427808L, 0L); case 1: return CreateOffsets(9298944L, 9310240L, 0L, 9332240L, 8841232L, 6428736L, 6428688L, 0L); case 2: return CreateOffsets(9298880L, 9310176L, 0L, 9332176L, 8841168L, 6428720L, 6428672L, 0L); case 3: return CreateOffsets(9300864L, 9312160L, 0L, 9334160L, 8843152L, 6430848L, 6430800L, 0L); case 4: return CreateOffsets(9301808L, 9313104L, 0L, 9335104L, 8844096L, 6431776L, 6431728L, 0L); case 5: return CreateOffsets(9303232L, 9314528L, 0L, 9336528L, 8845360L, 6432080L, 6432032L, 0L); case 6: return CreateOffsets(9310592L, 9321872L, 0L, 9343872L, 8852688L, 6439856L, 6439808L, 0L); case 7: return CreateOffsets(9313440L, 9324720L, 0L, 9346720L, 8855536L, 6441168L, 6441120L, 0L); case 8: return CreateOffsets(9316512L, 9327792L, 0L, 9349792L, 8842976L, 6443808L, 6443760L, 0L); case 9: return CreateOffsets(9316768L, 9328048L, 0L, 9350048L, 8843232L, 6444048L, 6444000L, 0L); case 10: return CreateOffsets(9318192L, 9329472L, 0L, 9351472L, 8844400L, 6444848L, 6444800L, 0L); case 11: return CreateOffsets(9318256L, 9329536L, 0L, 9351536L, 8844464L, 6444784L, 6444736L, 0L); case 12: return CreateOffsets(9318160L, 9329440L, 0L, 9351440L, 8844336L, 6446272L, 6446224L, 0L); case 13: return CreateOffsets(9319200L, 9330480L, 0L, 9352480L, 8845168L, 6447104L, 6447056L, 0L); case 14: return CreateOffsets(9317152L, 9328432L, 0L, 9350432L, 8843168L, 6447504L, 6447456L, 0L); } break; case 4: switch (unityVersion.Build) { case 1: return CreateOffsets(9318256L, 9329536L, 0L, 9351536L, 8844272L, 6448576L, 6448528L, 0L); case 2: return CreateOffsets(9320864L, 9332144L, 0L, 9354144L, 8846880L, 6450800L, 6450752L, 0L); case 3: return CreateOffsets(9320768L, 9332048L, 0L, 9354048L, 8846784L, 6450560L, 6450512L, 0L); case 4: return CreateOffsets(9320640L, 9331920L, 0L, 9353920L, 8846640L, 6450688L, 6450640L, 0L); case 5: return CreateOffsets(9321040L, 9332320L, 0L, 9354320L, 8847008L, 6451552L, 6451504L, 0L); case 6: return CreateOffsets(9321952L, 9333232L, 0L, 9355232L, 8847920L, 6451568L, 6451520L, 0L); case 7: return CreateOffsets(9321952L, 9333232L, 0L, 9355232L, 8847920L, 6451568L, 6451520L, 0L); case 8: return CreateOffsets(9320432L, 9331712L, 0L, 9353712L, 8846352L, 6449696L, 6449648L, 0L); case 9: return CreateOffsets(9326096L, 9337376L, 0L, 9359376L, 8851888L, 6453808L, 6453760L, 0L); case 10: return CreateOffsets(9336368L, 9347648L, 0L, 9369648L, 8862128L, 6460048L, 6460000L, 0L); case 11: return CreateOffsets(9336816L, 9348096L, 0L, 9370096L, 8862576L, 6460544L, 6460496L, 0L); case 12: return CreateOffsets(9337168L, 9348448L, 0L, 9370448L, 8862928L, 6460896L, 6460848L, 0L); case 13: return CreateOffsets(9339296L, 9350576L, 0L, 9372576L, 8864832L, 6460512L, 6460464L, 0L); case 14: return CreateOffsets(9343008L, 9354288L, 0L, 9376048L, 8868544L, 6462976L, 6462928L, 0L); case 15: return CreateOffsets(9346320L, 9357600L, 0L, 9379360L, 8871840L, 6465216L, 6465168L, 0L); case 16: return CreateOffsets(9348000L, 9359280L, 0L, 9381040L, 8873504L, 6466592L, 6466544L, 0L); case 17: return CreateOffsets(9349424L, 9360704L, 0L, 9382464L, 8874928L, 6467872L, 6467824L, 0L); case 18: return CreateOffsets(9351392L, 9362672L, 0L, 9384432L, 8875168L, 6468128L, 6468080L, 0L); case 19: return CreateOffsets(9353920L, 9365200L, 0L, 9386960L, 8877696L, 6468832L, 6468784L, 0L); case 20: return CreateOffsets(9354640L, 9365920L, 0L, 9387680L, 8878352L, 6469520L, 6469472L, 0L); case 21: return CreateOffsets(9354608L, 9365888L, 0L, 9387648L, 8878288L, 6469488L, 6469440L, 0L); case 22: return CreateOffsets(9355392L, 9366672L, 0L, 9388432L, 8879072L, 6469920L, 6469872L, 0L); case 23: return CreateOffsets(9349008L, 9360288L, 0L, 9382048L, 8872688L, 6469296L, 6469248L, 0L); case 24: return CreateOffsets(9354976L, 9366256L, 0L, 9388016L, 8878656L, 6474432L, 6474384L, 0L); case 25: return CreateOffsets(9358448L, 9369728L, 0L, 9391488L, 8882128L, 6477616L, 6477568L, 0L); case 26: return CreateOffsets(9360176L, 9371456L, 0L, 9393216L, 8883840L, 6478464L, 6478416L, 0L); case 27: return CreateOffsets(9362704L, 9373984L, 0L, 9395744L, 8885872L, 6478688L, 6478640L, 0L); case 28: return CreateOffsets(9361728L, 9373008L, 0L, 9394768L, 8884896L, 6477680L, 6477632L, 0L); case 29: return CreateOffsets(9363568L, 9374848L, 0L, 9396608L, 8886736L, 6478832L, 6478784L, 0L); case 30: return CreateOffsets(9365728L, 9377008L, 0L, 9398816L, 8888896L, 6479888L, 6479840L, 0L); case 31: return CreateOffsets(9365968L, 9377248L, 0L, 9399056L, 8889136L, 6479904L, 6479856L, 0L); case 32: return CreateOffsets(9366304L, 9377584L, 0L, 9399392L, 8889472L, 6480000L, 6479952L, 0L); case 33: return CreateOffsets(9366320L, 9377600L, 0L, 9399408L, 8889488L, 6480000L, 6479952L, 0L); case 34: return CreateOffsets(9369360L, 9380640L, 0L, 9402448L, 8892528L, 6480000L, 6479952L, 0L); case 35: return CreateOffsets(9369712L, 9380992L, 0L, 9402800L, 8892880L, 6480352L, 6480304L, 0L); case 36: return CreateOffsets(9370320L, 9381600L, 0L, 9403408L, 8893280L, 6480688L, 6480640L, 0L); } break; } break; case 2019: switch (unityVersion.Minor) { case 1: switch (unityVersion.Build) { case 0: return CreateOffsets(9142272L, 9166192L, 0L, 9200784L, 8543344L, 6065712L, 6065664L, 0L); case 1: return CreateOffsets(9143856L, 9167776L, 0L, 9202368L, 8544928L, 6067216L, 6067168L, 0L); case 2: return CreateOffsets(9145552L, 9169472L, 0L, 9204064L, 8546624L, 6067984L, 6067936L, 0L); case 3: return CreateOffsets(9146416L, 9170336L, 0L, 9204928L, 8529248L, 6068992L, 6068944L, 0L); case 4: return CreateOffsets(9138256L, 9162176L, 0L, 9196768L, 8521088L, 6060064L, 6060016L, 0L); case 5: return CreateOffsets(9138256L, 9162176L, 0L, 9196768L, 8521088L, 6060064L, 6060016L, 0L); case 6: return CreateOffsets(9137808L, 9161728L, 0L, 9196320L, 8520512L, 6058848L, 6058800L, 0L); case 7: return CreateOffsets(9138304L, 9162224L, 0L, 9196816L, 8521008L, 6059136L, 6059088L, 0L); case 8: return CreateOffsets(9138224L, 9162144L, 0L, 9196736L, 8520928L, 6058912L, 6058864L, 0L); case 9: return CreateOffsets(9139280L, 9163200L, 0L, 9197792L, 8521984L, 6059792L, 6059744L, 0L); case 10: return CreateOffsets(9138688L, 9162624L, 0L, 9197216L, 8521392L, 6059968L, 6059920L, 0L); case 11: return CreateOffsets(9138720L, 9162656L, 0L, 9197248L, 8521424L, 6059968L, 6059920L, 0L); case 12: return CreateOffsets(9138720L, 9162656L, 0L, 9197248L, 8521424L, 6059968L, 6059920L, 0L); case 13: return CreateOffsets(9139200L, 9163136L, 0L, 9197728L, 8521904L, 6059776L, 6059728L, 0L); case 14: return CreateOffsets(9140224L, 9164160L, 0L, 9198880L, 8522928L, 6060784L, 6060736L, 0L); } break; case 2: switch (unityVersion.Build) { case 0: return CreateOffsets(8830144L, 8854096L, 0L, 8888896L, 8195296L, 5738272L, 5738224L, 0L); case 1: return CreateOffsets(8830880L, 8854832L, 0L, 8889632L, 8196048L, 5738352L, 5738304L, 0L); case 2: return CreateOffsets(8832304L, 8856256L, 0L, 8891056L, 8197472L, 5738448L, 5738400L, 0L); case 3: return CreateOffsets(8833472L, 8857424L, 0L, 8892224L, 8198640L, 5739584L, 5739536L, 0L); case 4: return CreateOffsets(8836032L, 8859984L, 0L, 8894784L, 8201200L, 5741568L, 5741520L, 0L); case 5: return CreateOffsets(8836160L, 8860112L, 0L, 8894912L, 8201264L, 5740976L, 5740928L, 0L); case 6: return CreateOffsets(8835888L, 8859840L, 0L, 8894640L, 8200992L, 5740496L, 5740448L, 0L); case 7: return CreateOffsets(8837152L, 8861104L, 0L, 8895664L, 8202256L, 5740416L, 5740368L, 0L); case 8: return CreateOffsets(8837488L, 8861456L, 0L, 8896016L, 8202512L, 5740656L, 5740608L, 0L); case 9: return CreateOffsets(8838368L, 8862336L, 0L, 8896896L, 8203392L, 5741088L, 5741040L, 0L); case 10: return CreateOffsets(8839008L, 8862976L, 0L, 8897536L, 8203888L, 5741600L, 5741552L, 0L); case 11: return CreateOffsets(8839552L, 8863520L, 0L, 8898080L, 8204432L, 5742048L, 5742000L, 0L); case 12: return CreateOffsets(8839696L, 8863664L, 0L, 8898224L, 8204576L, 5742080L, 5742032L, 0L); case 13: return CreateOffsets(8840752L, 8864720L, 0L, 8899280L, 8205632L, 5742160L, 5742112L, 0L); case 14: return CreateOffsets(8842256L, 8866224L, 0L, 8900784L, 8207120L, 5742704L, 5742656L, 0L); case 15: return CreateOffsets(8842736L, 8866704L, 0L, 8901264L, 8207600L, 5743184L, 5743136L, 0L); case 16: return CreateOffsets(8843440L, 8867408L, 0L, 8901968L, 8208272L, 5743728L, 5743680L, 0L); case 17: return CreateOffsets(8845744L, 8869712L, 0L, 8904272L, 8210576L, 5745920L, 5745872L, 0L); case 18: return CreateOffsets(8845136L, 8869104L, 0L, 8903664L, 8209968L, 5744992L, 5744944L, 0L); case 19: return CreateOffsets(8840176L, 8864144L, 0L, 8898704L, 8205008L, 5740032L, 5739984L, 0L); case 20: return CreateOffsets(8840400L, 8864368L, 0L, 8898928L, 8205200L, 5740224L, 5740176L, 0L); case 21: return CreateOffsets(8840400L, 8864368L, 0L, 8898928L, 8205200L, 5740224L, 5740176L, 0L); } break; case 3: switch (unityVersion.Build) { case 0: return CreateOffsets(9002592L, 9014576L, 0L, 9035568L, 8329232L, 5734800L, 5734704L, 0L); case 1: return CreateOffsets(9004928L, 9016912L, 0L, 9037904L, 8331648L, 5735296L, 5735200L, 0L); case 2: return CreateOffsets(9006448L, 9018432L, 0L, 9039424L, 8333168L, 5738096L, 5738000L, 0L); case 3: return CreateOffsets(9006592L, 9018576L, 0L, 9039568L, 8333312L, 5738112L, 5738016L, 0L); case 4: return CreateOffsets(9012320L, 9024304L, 0L, 9045296L, 8339040L, 5740016L, 5739920L, 0L); case 5: return CreateOffsets(9014880L, 9026864L, 0L, 9047856L, 8341600L, 5741152L, 5741056L, 0L); case 6: return CreateOffsets(9021328L, 9033312L, 0L, 9054368L, 8347568L, 5745680L, 5745584L, 0L); case 7: return CreateOffsets(9024528L, 9036512L, 0L, 9057568L, 8350736L, 5747968L, 5747872L, 0L); case 8: return CreateOffsets(9033456L, 9045440L, 0L, 9066496L, 8359664L, 5748608L, 5748512L, 0L); case 9: return CreateOffsets(9034000L, 9045984L, 0L, 9067040L, 8360208L, 5747904L, 5747808L, 0L); case 10: return CreateOffsets(9034928L, 9046912L, 0L, 9067968L, 8360784L, 5748128L, 5748032L, 0L); case 11: return CreateOffsets(9041712L, 9053696L, 0L, 9074752L, 8367376L, 5753664L, 5753568L, 0L); case 12: return CreateOffsets(9042576L, 9054560L, 0L, 9075616L, 8367808L, 5754080L, 5753984L, 0L); case 13: return CreateOffsets(9043520L, 9055504L, 0L, 9076560L, 8368720L, 5754912L, 5754816L, 0L); case 14: return CreateOffsets(9045920L, 9057904L, 0L, 9078960L, 8371104L, 5757152L, 5757056L, 0L); case 15: return CreateOffsets(9057024L, 9069008L, 0L, 9090064L, 8382144L, 5765296L, 5765200L, 0L); } break; case 4: switch (unityVersion.Build) { case 0: return CreateOffsets(9058752L, 9070736L, 0L, 9091792L, 8383872L, 5765664L, 5765568L, 0L); case 1: return CreateOffsets(9058816L, 9070768L, 0L, 9091856L, 8383936L, 5765664L, 5765568L, 0L); case 2: return CreateOffsets(9060704L, 9072656L, 0L, 9093744L, 8385824L, 5766816L, 5766720L, 0L); case 3: return CreateOffsets(9067440L, 9079392L, 0L, 9100480L, 8392560L, 5771232L, 5771136L, 0L); case 4: return CreateOffsets(9067552L, 9079504L, 0L, 9100592L, 8392672L, 5771232L, 5771136L, 0L); case 5: return CreateOffsets(9068288L, 9080240L, 0L, 9101328L, 8393392L, 5771584L, 5771488L, 0L); case 6: return CreateOffsets(9069664L, 9081616L, 0L, 9102704L, 8394752L, 5772672L, 5772576L, 0L); case 7: return CreateOffsets(9073056L, 9085008L, 0L, 9106096L, 8398112L, 5775648L, 5775552L, 0L); case 8: return CreateOffsets(9073008L, 9084960L, 0L, 9106048L, 8398064L, 5775184L, 5775088L, 0L); case 9: return CreateOffsets(9081712L, 9093664L, 0L, 9114752L, 8406224L, 5776832L, 5776736L, 0L); case 10: return CreateOffsets(9087568L, 9099520L, 0L, 9120608L, 8412080L, 5782096L, 5782000L, 0L); case 11: return CreateOffsets(9089136L, 9101088L, 0L, 9122176L, 8413760L, 5782416L, 5782320L, 0L); case 12: return CreateOffsets(9091056L, 9103008L, 0L, 9124096L, 8415344L, 5785168L, 5785072L, 0L); case 13: return CreateOffsets(9091792L, 9103744L, 0L, 9124832L, 8416080L, 5785440L, 5785344L, 0L); case 14: return CreateOffsets(9092352L, 9104304L, 0L, 9125392L, 8416640L, 5785776L, 5785680L, 0L); case 15: return CreateOffsets(9092848L, 9104800L, 0L, 9125888L, 8416976L, 5786064L, 5785968L, 0L); case 16: return CreateOffsets(9098160L, 9110112L, 0L, 9131232L, 8422144L, 5789232L, 5789136L, 0L); case 17: return CreateOffsets(9101728L, 9113680L, 0L, 9134800L, 8425008L, 5791824L, 5791728L, 0L); case 18: return CreateOffsets(9107216L, 9119168L, 0L, 9140288L, 8430512L, 5795952L, 5795856L, 0L); case 19: return CreateOffsets(9110464L, 9122416L, 0L, 9143536L, 8433616L, 5796864L, 5796768L, 0L); case 20: return CreateOffsets(9115296L, 9127248L, 0L, 9148368L, 8437840L, 5800832L, 5800736L, 0L); case 21: return CreateOffsets(9110672L, 9122688L, 0L, 9143808L, 8433184L, 5795968L, 5795872L, 0L); case 22: return CreateOffsets(9115872L, 9127888L, 0L, 9149008L, 8438336L, 5798352L, 5798256L, 0L); case 23: return CreateOffsets(9138784L, 9150800L, 0L, 9170672L, 8459856L, 5818064L, 5817968L, 0L); case 24: return CreateOffsets(9144336L, 9156320L, 0L, 9176112L, 8465104L, 5825632L, 5825536L, 0L); case 25: return CreateOffsets(9144416L, 9156400L, 0L, 9176192L, 8465248L, 5825712L, 5825616L, 0L); case 26: return CreateOffsets(9146160L, 9158144L, 0L, 9177936L, 8466288L, 5825760L, 5825664L, 0L); case 27: return CreateOffsets(9148608L, 9160592L, 0L, 9180272L, 8468752L, 5827792L, 5827696L, 0L); case 28: return CreateOffsets(9149168L, 9161152L, 0L, 9180832L, 8469280L, 5827984L, 5827888L, 0L); case 29: return CreateOffsets(9154368L, 9166368L, 0L, 9186048L, 8474480L, 5829488L, 5829392L, 0L); case 30: return CreateOffsets(9158224L, 9170224L, 0L, 9189904L, 8478336L, 5832976L, 5832880L, 0L); case 31: return CreateOffsets(9169952L, 9181936L, 0L, 9201616L, 8490064L, 5841152L, 5841056L, 0L); case 32: return CreateOffsets(9171328L, 9183312L, 0L, 9202992L, 8490320L, 5841600L, 5841504L, 0L); case 33: return CreateOffsets(9174592L, 9186576L, 0L, 9206256L, 8493584L, 5842464L, 5842368L, 0L); case 34: return CreateOffsets(9174576L, 9186560L, 0L, 9206240L, 8493568L, 5842416L, 5842320L, 0L); case 35: return CreateOffsets(9177728L, 9189712L, 0L, 9209392L, 8496720L, 5845248L, 5845152L, 0L); case 36: return CreateOffsets(9178992L, 9190976L, 0L, 9210656L, 8497968L, 5846416L, 5846320L, 0L); case 37: return CreateOffsets(9185360L, 9197344L, 0L, 9217008L, 8499712L, 5846544L, 5846448L, 0L); case 38: return CreateOffsets(9186160L, 9198144L, 0L, 9217808L, 8500480L, 5847360L, 5847264L, 0L); case 39: return CreateOffsets(9190464L, 9202448L, 0L, 9222112L, 8504784L, 5851648L, 5851552L, 0L); case 40: return CreateOffsets(9191424L, 9203408L, 0L, 9223072L, 8505728L, 5852480L, 5852384L, 0L); } break; } break; case 2020: switch (unityVersion.Minor) { case 1: switch (unityVersion.Build) { case 0: return CreateOffsets(8542848L, 8555104L, 0L, 8573920L, 7836576L, 5291184L, 5291088L, 0L); case 1: return CreateOffsets(8554816L, 8567072L, 0L, 8585888L, 7839760L, 5293008L, 5292912L, 0L); case 2: return CreateOffsets(8555040L, 8567296L, 0L, 8586112L, 7839984L, 5293232L, 5293136L, 0L); case 3: return CreateOffsets(8555136L, 8567392L, 0L, 8586208L, 7839888L, 5292896L, 5292800L, 0L); case 4: return CreateOffsets(8558144L, 8570400L, 0L, 8589216L, 7842480L, 5294512L, 5294416L, 0L); case 5: return CreateOffsets(8559504L, 8571728L, 0L, 8590576L, 7843552L, 5294336L, 5294240L, 0L); case 6: return CreateOffsets(8560112L, 8572336L, 0L, 8591184L, 7844160L, 5294912L, 5294816L, 0L); case 7: return CreateOffsets(8564240L, 8576464L, 0L, 8595312L, 7847888L, 5297120L, 5297024L, 0L); case 8: return CreateOffsets(8564064L, 8576288L, 0L, 8595136L, 7847712L, 5296976L, 5296880L, 0L); case 9: return CreateOffsets(8564496L, 8576720L, 0L, 8595568L, 7848144L, 5296720L, 5296624L, 0L); case 10: return CreateOffsets(8564688L, 8576912L, 0L, 8595760L, 7848336L, 5296992L, 5296896L, 0L); case 11: return CreateOffsets(8566320L, 8578544L, 0L, 8597392L, 7849968L, 5298736L, 5298640L, 0L); case 12: return CreateOffsets(8566672L, 8578896L, 0L, 8597744L, 7850320L, 5298864L, 5298768L, 0L); case 13: return CreateOffsets(8572176L, 8584400L, 0L, 8603248L, 7855856L, 5304352L, 5304256L, 0L); case 14: return CreateOffsets(8577376L, 8589616L, 0L, 8608368L, 7861024L, 5307440L, 5307344L, 0L); case 15: return CreateOffsets(8580352L, 8592592L, 0L, 8611376L, 7863840L, 5309536L, 5309440L, 0L); case 16: return CreateOffsets(8585936L, 8598176L, 0L, 8616960L, 7869040L, 5312880L, 5312784L, 0L); case 17: return CreateOffsets(8586304L, 8598544L, 0L, 8617328L, 7869408L, 5313072L, 5312976L, 0L); } break; case 2: switch (unityVersion.Build) { case 0: return CreateOffsets(9087040L, 9101408L, 0L, 9122512L, 8355392L, 5680336L, 5680240L, 26666624L); case 1: return CreateOffsets(9087040L, 9101408L, 0L, 9122512L, 8355392L, 5680336L, 5680240L, 26666624L); case 2: return CreateOffsets(9090976L, 9105344L, 0L, 9126448L, 8358752L, 5682848L, 5682752L, 26670784L); case 3: return CreateOffsets(9100640L, 9115008L, 0L, 9136112L, 8368192L, 5685776L, 5685680L, 26687232L); case 4: return CreateOffsets(9101840L, 9116208L, 0L, 9137344L, 8369392L, 5686848L, 5686752L, 26695488L); case 5: return CreateOffsets(9103824L, 9118192L, 0L, 9139328L, 8371376L, 5688016L, 5687920L, 26699712L); case 6: return CreateOffsets(9099936L, 9114304L, 0L, 9135440L, 8367488L, 5683312L, 5683216L, 26703744L); case 7: return CreateOffsets(9101744L, 9116112L, 0L, 9137248L, 8369296L, 5684752L, 5684656L, 26708096L); } break; case 3: switch (unityVersion.Build) { case 0: return CreateOffsets(9102800L, 9117168L, 0L, 9138304L, 8370352L, 5684832L, 5684736L, 26708096L); case 1: return CreateOffsets(9135888L, 9150256L, 0L, 9171392L, 8402912L, 5718320L, 5718224L, 26753152L); case 2: return CreateOffsets(9137280L, 9151648L, 0L, 9172784L, 8404144L, 5718288L, 5718192L, 26757248L); case 3: return CreateOffsets(9139248L, 9153616L, 0L, 9174752L, 8406048L, 5719504L, 5719408L, 26757248L); case 4: return CreateOffsets(9139568L, 9153936L, 0L, 9175072L, 8406368L, 5719520L, 5719424L, 26757248L); case 5: return CreateOffsets(9147488L, 9161856L, 0L, 9182992L, 8413136L, 5724112L, 5724016L, 26773696L); case 6: return CreateOffsets(9146384L, 9160752L, 0L, 9181888L, 8412032L, 5724160L, 5724064L, 26769600L); case 7: return CreateOffsets(9147248L, 9161616L, 0L, 9182752L, 8412528L, 5724576L, 5724480L, 26777792L); case 8: return CreateOffsets(9147952L, 9162320L, 0L, 9183456L, 8412240L, 5724080L, 5723984L, 26474688L); case 9: return CreateOffsets(9148192L, 9162560L, 0L, 9183696L, 8412400L, 5724272L, 5724176L, 26538752L); case 10: return CreateOffsets(9156768L, 9171136L, 0L, 9192272L, 8420640L, 5724928L, 5724832L, 26547008L); case 11: return CreateOffsets(9160864L, 9175232L, 0L, 9196368L, 8424768L, 5728624L, 5728528L, 26551232L); case 12: return CreateOffsets(9161808L, 9176176L, 0L, 9197312L, 8425696L, 5729328L, 5729232L, 26543040L); case 13: return CreateOffsets(9163456L, 9177824L, 0L, 9198960L, 8427216L, 5730144L, 5730048L, 26547136L); case 14: return CreateOffsets(9165152L, 9179600L, 0L, 9200736L, 8428912L, 5731824L, 5731728L, 26563520L); case 15: return CreateOffsets(9165120L, 9179568L, 0L, 9200704L, 8428896L, 5731824L, 5731728L, 26563520L); case 16: return CreateOffsets(9168512L, 9182944L, 0L, 9203904L, 8432208L, 5734288L, 5734192L, 26571712L); case 17: return CreateOffsets(9173248L, 9187680L, 0L, 9208640L, 8436928L, 5738592L, 5738496L, 26584256L); case 18: return CreateOffsets(9191056L, 9205488L, 0L, 9226448L, 8454496L, 5755536L, 5755440L, 26600640L); case 19: return CreateOffsets(9191200L, 9205632L, 0L, 9226592L, 8454928L, 5755040L, 5754944L, 26600576L); case 20: return CreateOffsets(9191680L, 9206112L, 0L, 9227072L, 8455296L, 5755216L, 5755120L, 26600576L); case 21: return CreateOffsets(9192784L, 9207216L, 0L, 9228176L, 8455472L, 5755168L, 5755072L, 26625152L); case 22: return CreateOffsets(9196320L, 9210752L, 0L, 9231712L, 8458960L, 5756528L, 5756432L, 26629248L); case 23: return CreateOffsets(9193808L, 9208240L, 0L, 9229200L, 8458000L, 5757024L, 5756928L, 26625344L); case 24: return CreateOffsets(9195328L, 9209760L, 0L, 9230720L, 8459424L, 5758448L, 5758352L, 26695168L); case 25: return CreateOffsets(9202192L, 9216624L, 0L, 9237584L, 8466400L, 5765376L, 5765280L, 26703360L); case 26: return CreateOffsets(9202848L, 9217280L, 0L, 9238240L, 8467040L, 5766048L, 5765952L, 26703360L); case 27: return CreateOffsets(9207264L, 9221696L, 0L, 9242656L, 8470784L, 5769712L, 5769616L, 26707520L); case 28: return CreateOffsets(9209568L, 9224000L, 0L, 9244960L, 8473024L, 5771328L, 5771232L, 26711616L); case 29: return CreateOffsets(9211408L, 9225840L, 0L, 9246800L, 8474864L, 5771968L, 5771872L, 26703552L); case 30: return CreateOffsets(9212528L, 9226960L, 0L, 9247920L, 8475984L, 5772784L, 5772688L, 26703552L); case 31: return CreateOffsets(9244416L, 9259040L, 0L, 9280736L, 8497744L, 5787920L, 5787824L, 26744576L); case 32: return CreateOffsets(9245184L, 9259808L, 0L, 9281504L, 8498496L, 5788320L, 5788224L, 26748672L); case 33: return CreateOffsets(9244608L, 9259232L, 0L, 9280928L, 8497856L, 5787920L, 5787824L, 26748672L); case 34: return CreateOffsets(9244960L, 9259584L, 0L, 9281280L, 8497920L, 5787904L, 5787808L, 26752768L); case 35: return CreateOffsets(9247424L, 9262048L, 0L, 9283744L, 8500256L, 5788576L, 5788480L, 26752768L); case 36: return CreateOffsets(9247872L, 9262496L, 0L, 9284192L, 8500704L, 5788832L, 5788736L, 26760960L); case 37: return CreateOffsets(9251104L, 9265728L, 0L, 9287424L, 8503936L, 5789952L, 5789856L, 26777344L); case 38: return CreateOffsets(9260896L, 9275552L, 0L, 9297248L, 8513648L, 5791632L, 5791536L, 26777472L); case 39: return CreateOffsets(9261504L, 9276160L, 0L, 9297856L, 8512864L, 5791952L, 5791856L, 26818368L); case 40: return CreateOffsets(9262560L, 9277216L, 0L, 9298912L, 8513920L, 5791984L, 5791888L, 26953536L); case 41: return CreateOffsets(9266896L, 9281552L, 0L, 9303248L, 8517680L, 5794032L, 5793936L, 26961920L); case 42: return CreateOffsets(9277136L, 9291792L, 0L, 9313488L, 8527648L, 5803488L, 5803392L, 26974208L); case 43: return CreateOffsets(9280848L, 9295504L, 0L, 9317200L, 8531360L, 5804160L, 5804064L, 26978304L); case 44: return CreateOffsets(9274672L, 9289280L, 0L, 9309952L, 8525120L, 5800848L, 5800752L, 26961856L); case 45: return CreateOffsets(8980480L, 8995088L, 0L, 9015760L, 8230560L, 5502768L, 5502672L, 26986432L); case 46: return CreateOffsets(8981712L, 8996320L, 0L, 9016992L, 8231792L, 5503600L, 5503504L, 26986496L); case 47: return CreateOffsets(8982128L, 8996736L, 0L, 9017408L, 8232208L, 5504064L, 5503968L, 26990592L); case 48: return CreateOffsets(8985392L, 9000000L, 0L, 9020672L, 8235664L, 5506688L, 5506592L, 26990592L); } break; } break; case 2021: switch (unityVersion.Minor) { case 1: switch (unityVersion.Build) { case 0: return CreateOffsets(9107152L, 9120176L, 0L, 9140112L, 8377760L, 5711216L, 5711120L, 26714752L); case 1: return CreateOffsets(9110304L, 9123328L, 0L, 9143264L, 8380848L, 5712688L, 5712592L, 26722944L); case 2: return CreateOffsets(9113344L, 9126368L, 0L, 9146304L, 8383744L, 5715584L, 5715488L, 26727040L); case 3: return CreateOffsets(9114656L, 9127680L, 0L, 9147616L, 8384640L, 5715888L, 5715792L, 26788480L); case 4: return CreateOffsets(9115632L, 9128656L, 0L, 9148592L, 8384608L, 5715568L, 5715472L, 26792576L); case 5: return CreateOffsets(9114752L, 9127776L, 0L, 9147696L, 8383792L, 5715440L, 5715344L, 26489472L); case 6: return CreateOffsets(9116704L, 9129728L, 0L, 9149648L, 8385456L, 5717264L, 5717168L, 26493568L); case 7: return CreateOffsets(9116688L, 9129712L, 0L, 9149632L, 8385440L, 5717168L, 5717072L, 26493568L); case 9: return CreateOffsets(9119360L, 9132464L, 0L, 9152384L, 8387840L, 5718240L, 5718144L, 26485440L); case 10: return CreateOffsets(9122064L, 9135168L, 0L, 9155088L, 8390288L, 5720304L, 5720208L, 26489536L); case 11: return CreateOffsets(9122064L, 9135168L, 0L, 9155088L, 8390288L, 5720304L, 5720208L, 26489536L); case 12: return CreateOffsets(9122128L, 9135232L, 0L, 9155152L, 8390336L, 5720352L, 5720256L, 26489536L); case 13: return CreateOffsets(9122272L, 9135376L, 0L, 9155296L, 8390480L, 5720496L, 5720400L, 26489536L); case 14: return CreateOffsets(9123696L, 9136800L, 0L, 9156720L, 8391904L, 5721936L, 5721840L, 26493632L); case 15: return CreateOffsets(9124368L, 9137488L, 0L, 9157328L, 8392640L, 5722672L, 5722576L, 26505920L); case 16: return CreateOffsets(9001600L, 9014720L, 0L, 9034560L, 8269728L, 5600688L, 5600592L, 26516224L); case 17: return CreateOffsets(9004032L, 9017152L, 0L, 9036992L, 8272096L, 5602304L, 5602208L, 26520320L); case 18: return CreateOffsets(9020048L, 9033168L, 0L, 9053008L, 8288016L, 5618256L, 5618160L, 26537024L); case 19: return CreateOffsets(9021216L, 9034336L, 0L, 9054176L, 8289184L, 5619216L, 5619120L, 26537024L); case 20: return CreateOffsets(9022272L, 9035392L, 0L, 9055232L, 8290240L, 5620112L, 5620016L, 26541120L); case 21: return CreateOffsets(9022752L, 9035872L, 0L, 9055712L, 8290672L, 5620336L, 5620240L, 26541120L); case 22: return CreateOffsets(9023920L, 9037040L, 0L, 9056880L, 8292032L, 5620320L, 5620224L, 26541120L); case 23: return CreateOffsets(9023392L, 9036512L, 0L, 9056352L, 8291504L, 5620032L, 5619936L, 26541120L); case 24: return CreateOffsets(9022208L, 9035328L, 0L, 9055168L, 8290352L, 5618944L, 5618848L, 26561600L); case 25: return CreateOffsets(9026880L, 9040000L, 0L, 9059840L, 8294112L, 5620704L, 5620608L, 26569792L); case 26: return CreateOffsets(9027472L, 9040592L, 0L, 9060432L, 8294688L, 5621152L, 5621056L, 26569792L); case 27: return CreateOffsets(9026768L, 9039888L, 0L, 9059728L, 8293984L, 5620224L, 5620128L, 26569792L); case 28: return CreateOffsets(9026528L, 9039648L, 0L, 9059488L, 8293680L, 5619808L, 5619712L, 26569792L); } break; case 2: switch (unityVersion.Build) { case 0: return CreateOffsets(6652704L, 6667376L, 0L, 6692368L, 5807344L, 2872928L, 2872848L, 27258624L); case 1: return CreateOffsets(6652976L, 6667648L, 0L, 6692640L, 5807568L, 2872928L, 2872848L, 27258624L); case 2: return CreateOffsets(6655264L, 6669936L, 0L, 6694928L, 5809856L, 2874560L, 2874480L, 27266880L); case 3: return CreateOffsets(6656032L, 6670704L, 0L, 6695696L, 5810656L, 2874464L, 2874384L, 27271040L); case 4: return CreateOffsets(6655456L, 6670128L, 0L, 6695120L, 5810080L, 2874688L, 2874608L, 27271232L); case 5: return CreateOffsets(6656720L, 6671392L, 0L, 6696384L, 5811344L, 2875344L, 2875264L, 27275200L); case 6: return CreateOffsets(6657024L, 6671696L, 0L, 6696688L, 5811648L, 2875344L, 2875264L, 27275264L); case 7: return CreateOffsets(6657344L, 6672016L, 0L, 6697008L, 5811968L, 2875664L, 2875584L, 27279360L); case 8: return CreateOffsets(6658624L, 6673296L, 0L, 6698288L, 5813216L, 2876048L, 2875968L, 27287616L); case 9: return CreateOffsets(6659744L, 6674416L, 0L, 6699408L, 5814192L, 2876384L, 2876304L, 27291776L); case 10: return CreateOffsets(6660320L, 6674992L, 0L, 6699984L, 5814064L, 2876384L, 2876304L, 27295872L); case 11: return CreateOffsets(6660240L, 6674912L, 0L, 6699904L, 5813984L, 2876272L, 2876192L, 27295872L); case 12: return CreateOffsets(6661344L, 6676016L, 0L, 6701008L, 5815104L, 2876528L, 2876448L, 27300096L); case 13: return CreateOffsets(6661360L, 6676032L, 0L, 6701024L, 5815104L, 2876528L, 2876448L, 27300096L); case 14: return CreateOffsets(6661744L, 6676416L, 0L, 6701408L, 5815488L, 2876528L, 2876448L, 27300096L); case 15: return CreateOffsets(6661744L, 6676416L, 0L, 6701408L, 5815488L, 2876528L, 2876448L, 27304192L); case 16: return CreateOffsets(6661744L, 6676416L, 0L, 6701408L, 5815488L, 2876528L, 2876448L, 27312384L); case 17: return CreateOffsets(6663264L, 6677952L, 0L, 6702672L, 5815616L, 2876528L, 2876448L, 27320576L); case 18: return CreateOffsets(6666800L, 6681488L, 0L, 6706208L, 5819664L, 2877440L, 2877360L, 27324672L); case 19: return CreateOffsets(6666928L, 6681616L, 0L, 6706336L, 5819792L, 2877744L, 2877664L, 27324672L); } break; case 3: switch (unityVersion.Build) { case 0: return CreateOffsets(6666928L, 6681616L, 0L, 6706336L, 5819792L, 2877744L, 2877664L, 27324672L); case 1: return CreateOffsets(6668880L, 6683568L, 0L, 6708288L, 5821696L, 2877744L, 2877664L, 27328768L); case 2: return CreateOffsets(6669776L, 6684464L, 0L, 6709184L, 5822160L, 2877744L, 2877664L, 27332864L); case 3: return CreateOffsets(6669856L, 6684544L, 0L, 6709264L, 5822240L, 2877840L, 2877760L, 27337024L); case 4: return CreateOffsets(6672928L, 6687616L, 0L, 6712336L, 5825312L, 2878608L, 2878528L, 27345152L); case 5: return CreateOffsets(6674656L, 6689344L, 0L, 6714064L, 5826928L, 2878640L, 2878560L, 27345216L); case 6: return CreateOffsets(6376752L, 6391440L, 0L, 6416160L, 5529024L, 2580704L, 2580624L, 27369792L); case 7: return CreateOffsets(6380896L, 6395584L, 0L, 6420304L, 5533168L, 2583872L, 2583792L, 27373888L); case 8: return CreateOffsets(6381040L, 6395728L, 0L, 6452416L, 5533312L, 2583936L, 2583856L, 27374208L); case 9: return CreateOffsets(6386512L, 6401152L, 0L, 6457664L, 5538928L, 2583632L, 2583552L, 27370112L); case 10: return CreateOffsets(6393664L, 6408304L, 0L, 6464816L, 5546064L, 2584256L, 2584176L, 27386560L); case 11: return CreateOffsets(6395648L, 6410288L, 0L, 6466800L, 5547456L, 2584576L, 2584496L, 27517632L); case 12: return CreateOffsets(6410224L, 6424864L, 0L, 6481392L, 5559296L, 2586112L, 2586032L, 27543424L); case 13: return CreateOffsets(6411888L, 6426528L, 0L, 6483056L, 5560272L, 2586288L, 2586208L, 27551616L); case 14: return CreateOffsets(6413456L, 6428096L, 0L, 6484624L, 5561808L, 2586528L, 2586448L, 27563968L); case 15: return CreateOffsets(6416896L, 6431536L, 0L, 6488064L, 5565216L, 2586608L, 2586528L, 27564032L); case 16: return CreateOffsets(6443840L, 6458480L, 0L, 6515008L, 5591552L, 2611616L, 2611536L, 27736704L); case 17: return CreateOffsets(6445008L, 6459648L, 0L, 6516176L, 5592960L, 2614560L, 2614480L, 27749120L); case 18: return CreateOffsets(6447856L, 6462496L, 0L, 6519040L, 5595792L, 2614864L, 2614784L, 27753344L); case 19: return CreateOffsets(6448480L, 6463120L, 0L, 6519664L, 5596128L, 2615088L, 2615008L, 27769728L); case 20: return CreateOffsets(6449712L, 6464352L, 0L, 6520896L, 5597360L, 2615744L, 2615664L, 27769792L); case 21: return CreateOffsets(6451840L, 6466480L, 0L, 6523024L, 5599184L, 2616480L, 2616400L, 27839424L); case 22: return CreateOffsets(6452016L, 6466656L, 0L, 6523200L, 5599360L, 2616480L, 2616400L, 27839424L); case 23: return CreateOffsets(6452656L, 6467296L, 0L, 6523840L, 5600192L, 2617376L, 2617296L, 27847680L); case 24: return CreateOffsets(6452688L, 6467328L, 0L, 6523872L, 5600176L, 2617376L, 2617296L, 27847680L); case 25: return CreateOffsets(6453056L, 6467696L, 0L, 6524240L, 5601376L, 2617424L, 2617344L, 27843584L); case 26: return CreateOffsets(6454560L, 6469200L, 0L, 6525744L, 5602864L, 2617472L, 2617392L, 27847680L); case 27: return CreateOffsets(6454800L, 6469440L, 0L, 6525984L, 5602880L, 2617472L, 2617392L, 27847680L); case 28: return CreateOffsets(6457680L, 6472320L, 0L, 6528864L, 5605600L, 2617744L, 2617664L, 27855872L); case 29: return CreateOffsets(6441072L, 6455712L, 0L, 6512256L, 5589024L, 2593760L, 2593680L, 27855936L); case 30: return CreateOffsets(6444464L, 6459104L, 0L, 6515648L, 5593776L, 2594128L, 2594048L, 27864128L); case 31: return CreateOffsets(6446528L, 6461168L, 0L, 6517712L, 5594896L, 2595088L, 2595008L, 27921472L); case 32: return CreateOffsets(6448704L, 6463344L, 0L, 6519888L, 5597008L, 2596272L, 2596192L, 27925568L); case 33: return CreateOffsets(6446528L, 6461168L, 0L, 6517712L, 5594304L, 2593680L, 2593600L, 27913152L); case 34: return CreateOffsets(6452272L, 6466912L, 0L, 6524096L, 5599184L, 2594336L, 2594256L, 27925504L); case 35: return CreateOffsets(6452992L, 6467632L, 0L, 6524816L, 5599904L, 2594464L, 2594384L, 27933696L); case 36: return CreateOffsets(6452832L, 6467472L, 0L, 6524656L, 5600048L, 2594528L, 2594448L, 27933696L); case 37: return CreateOffsets(6453200L, 6467840L, 0L, 6525024L, 5599552L, 2593536L, 2593456L, 27937792L); case 38: return CreateOffsets(6453920L, 6468560L, 0L, 6525744L, 5600272L, 2593536L, 2593456L, 27937792L); case 39: return CreateOffsets(6454176L, 6468816L, 0L, 6526048L, 5600528L, 2593248L, 2593168L, 27945984L); case 40: return CreateOffsets(6454912L, 6469552L, 0L, 6526784L, 5601200L, 2593504L, 2593424L, 27954176L); case 41: return CreateOffsets(6460032L, 6474672L, 0L, 6531904L, 5606800L, 2593840L, 2593760L, 27954176L); case 42: return CreateOffsets(6460256L, 6474896L, 0L, 6532128L, 5607024L, 2593840L, 2593760L, 27954176L); case 43: return CreateOffsets(6460304L, 6474944L, 0L, 6532176L, 5607072L, 2593840L, 2593760L, 27884544L); case 44: return CreateOffsets(6477024L, 6491664L, 0L, 6548896L, 5612048L, 2598800L, 2598720L, 27900928L); case 45: return CreateOffsets(6477072L, 6491712L, 0L, 6548944L, 5612096L, 2598800L, 2598720L, 27905024L); case 46: return CreateOffsets(6477072L, 6491712L, 0L, 6548944L, 5612096L, 2598800L, 2598720L, 28011520L); case 47: return CreateOffsets(6477072L, 6491712L, 0L, 6548944L, 5612096L, 2598800L, 2598720L, 28011520L); case 48: return CreateOffsets(6477072L, 6491712L, 0L, 6548944L, 5612096L, 2598800L, 2598720L, 28015616L); case 49: return CreateOffsets(6477072L, 6491712L, 0L, 6548944L, 5612096L, 2598800L, 2598720L, 28015616L); case 50: return CreateOffsets(6477072L, 6491712L, 0L, 6548944L, 5612096L, 2598800L, 2598720L, 28015616L); } break; } break; case 2022: switch (unityVersion.Minor) { case 1: switch (unityVersion.Build) { case 0: return CreateOffsets(6777184L, 6791680L, 0L, 6816768L, 5906960L, 2901088L, 2901008L, 27528640L); case 1: return CreateOffsets(6778016L, 6792528L, 0L, 6817616L, 5907392L, 2901232L, 2901152L, 27528640L); case 2: return CreateOffsets(6780976L, 6795488L, 0L, 6820576L, 5910352L, 2901600L, 2901520L, 27532672L); case 3: return CreateOffsets(6780976L, 6795488L, 0L, 6820576L, 5910352L, 2901600L, 2901520L, 27532672L); case 4: return CreateOffsets(6780608L, 6795120L, 0L, 6820208L, 5909984L, 2901600L, 2901520L, 27532672L); case 5: return CreateOffsets(6780608L, 6795120L, 0L, 6820208L, 5909984L, 2901600L, 2901520L, 27532672L); case 6: return CreateOffsets(6780528L, 6795040L, 0L, 6820128L, 5909600L, 2901600L, 2901520L, 27532672L); case 7: return CreateOffsets(6780528L, 6795040L, 0L, 6820128L, 5909600L, 2901600L, 2901520L, 27536768L); case 8: return CreateOffsets(6780848L, 6795360L, 0L, 6820448L, 5909920L, 2901600L, 2901520L, 27536768L); case 9: return CreateOffsets(6784272L, 6798784L, 0L, 6823872L, 5913344L, 2901888L, 2901808L, 27684224L); case 10: return CreateOffsets(6784272L, 6798784L, 0L, 6856288L, 5913344L, 2901888L, 2901808L, 27684480L); case 11: return CreateOffsets(6784272L, 6798784L, 0L, 6856288L, 5913344L, 2901888L, 2901808L, 27684480L); case 12: return CreateOffsets(6785312L, 6799824L, 0L, 6857344L, 5914368L, 2902112L, 2902032L, 27684544L); case 13: return CreateOffsets(6797280L, 6811792L, 0L, 6869312L, 5926352L, 2902112L, 2902032L, 27696832L); case 14: return CreateOffsets(6797104L, 6811616L, 0L, 6869136L, 5926176L, 2901952L, 2901872L, 27729600L); case 15: return CreateOffsets(6797104L, 6811616L, 0L, 6869136L, 5926176L, 2901952L, 2901872L, 27737792L); case 16: return CreateOffsets(6797360L, 6811872L, 0L, 6869392L, 5926176L, 2901952L, 2901872L, 27737792L); case 17: return CreateOffsets(6798208L, 6812720L, 0L, 6870240L, 5927024L, 2901936L, 2901856L, 27733696L); case 18: return CreateOffsets(6800912L, 6815424L, 0L, 6872944L, 5929184L, 2902288L, 2902208L, 27737920L); case 19: return CreateOffsets(6801392L, 6815904L, 0L, 6873424L, 5929664L, 2902608L, 2902528L, 27737920L); case 20: return CreateOffsets(6801376L, 6815888L, 0L, 6873408L, 5929648L, 2902592L, 2902512L, 27737920L); case 21: return CreateOffsets(6807376L, 6821888L, 0L, 6879408L, 5935264L, 2902992L, 2902912L, 27746176L); case 22: return CreateOffsets(6807568L, 6822080L, 0L, 6879600L, 5935456L, 2902992L, 2902912L, 27746176L); case 23: return CreateOffsets(6807968L, 6822480L, 0L, 6880000L, 5935744L, 2903152L, 2903072L, 27754368L); case 24: return CreateOffsets(6809360L, 6823872L, 0L, 6881392L, 5937024L, 2903152L, 2903072L, 27746176L); } break; case 2: switch (unityVersion.Build) { case 0: return CreateOffsets(7635360L, 7634128L, 0L, 7719360L, 6690192L, 3458912L, 6453920L, 28917696L); case 1: return CreateOffsets(7637952L, 7636720L, 0L, 7721952L, 6692784L, 3457664L, 6456512L, 28917760L); case 2: return CreateOffsets(7643824L, 7642592L, 0L, 7727824L, 6698096L, 3457296L, 6461824L, 28934144L); case 3: return CreateOffsets(7647840L, 7646608L, 0L, 7731840L, 6702048L, 3460656L, 6461728L, 28933120L); case 4: return CreateOffsets(7666592L, 7665360L, 0L, 7750896L, 6717104L, 3472224L, 6476864L, 28963136L); case 5: return CreateOffsets(7668512L, 7667280L, 0L, 7752832L, 6719024L, 3473280L, 6478784L, 28967168L); case 6: return CreateOffsets(7669008L, 7667776L, 0L, 7753328L, 6719184L, 3473216L, 6478944L, 28967232L); case 7: return CreateOffsets(7681936L, 7680704L, 0L, 7766256L, 6732192L, 3478656L, 6492608L, 28979520L); case 8: return CreateOffsets(7683840L, 7682608L, 0L, 7768160L, 6733888L, 3480368L, 6494320L, 28983616L); case 9: return CreateOffsets(7683616L, 7682384L, 0L, 7767936L, 6735184L, 3481280L, 6495616L, 28991808L); case 10: return CreateOffsets(7685120L, 7683888L, 0L, 7769440L, 6737008L, 3482176L, 6497424L, 28983616L); case 11: return CreateOffsets(7687392L, 7686160L, 0L, 7771712L, 6739120L, 3481888L, 6498848L, 28987776L); case 12: return CreateOffsets(7688928L, 7687696L, 0L, 7773248L, 6740656L, 3480112L, 6500384L, 28995968L); case 13: return CreateOffsets(7686160L, 7684928L, 0L, 7770480L, 6738016L, 3478880L, 6497744L, 28991872L); case 14: return CreateOffsets(7690688L, 7689456L, 0L, 7775008L, 6742544L, 3481072L, 6502272L, 29004224L); case 15: return CreateOffsets(7696432L, 7695200L, 0L, 7780784L, 6748528L, 3482784L, 6508256L, 29012416L); case 16: return CreateOffsets(7698016L, 7696784L, 0L, 7782368L, 6750352L, 3482544L, 6510080L, 29012288L); case 17: return CreateOffsets(7698752L, 7697520L, 0L, 7783104L, 6750816L, 3482528L, 6510528L, 29008128L); case 18: return CreateOffsets(7712128L, 7710896L, 0L, 7796480L, 6764032L, 3482960L, 6523504L, 29032896L); case 19: return CreateOffsets(7713040L, 7711808L, 0L, 7797392L, 6764944L, 3482992L, 6524416L, 29118976L); case 20: return CreateOffsets(7843536L, 7842304L, 0L, 7928272L, 6889552L, 3570320L, 6649504L, 29295232L); case 21: return CreateOffsets(7846064L, 7844832L, 0L, 7930800L, 6892224L, 3570592L, 6652176L, 29295296L); } break; case 3: switch (unityVersion.Build) { case 0: return CreateOffsets(7847584L, 7846352L, 0L, 7932528L, 6892992L, 3570704L, 6652400L, 29299392L); case 1: return CreateOffsets(7845168L, 7843936L, 0L, 7930080L, 6891360L, 3570512L, 6650848L, 29299456L); case 2: return CreateOffsets(7845584L, 7844352L, 0L, 7930496L, 6891600L, 3570656L, 6651088L, 29299456L); case 3: return CreateOffsets(7844976L, 7843744L, 0L, 7929888L, 6891504L, 3570768L, 6651024L, 29303552L); case 4: return CreateOffsets(7845360L, 7844128L, 0L, 7930272L, 6891872L, 3571136L, 6651392L, 29303552L); case 5: return CreateOffsets(7770736L, 7769504L, 0L, 7855648L, 6816912L, 3496112L, 6575392L, 29305024L); case 6: return CreateOffsets(7770304L, 7769072L, 0L, 7855216L, 6816176L, 3494512L, 6574496L, 29313280L); case 7: return CreateOffsets(7777520L, 7776288L, 0L, 7863936L, 6823312L, 3494432L, 6581392L, 29329856L); case 8: return CreateOffsets(7781552L, 7780320L, 0L, 7868240L, 6827904L, 3495520L, 6585968L, 29338048L); case 9: return CreateOffsets(7782592L, 7781360L, 0L, 7869280L, 6828848L, 3495632L, 6586912L, 29342272L); case 10: return CreateOffsets(7781968L, 7780736L, 0L, 7868656L, 6827888L, 3496800L, 6586336L, 29342208L); case 11: return CreateOffsets(7790496L, 7789264L, 0L, 7877248L, 6833280L, 3499872L, 6593040L, 29341760L); case 12: return CreateOffsets(7791136L, 7789904L, 0L, 7877920L, 6833904L, 3501472L, 6583520L, 29345984L); case 13: return CreateOffsets(7791744L, 7790512L, 0L, 7878528L, 6834000L, 3501568L, 6583616L, 29362368L); case 14: return CreateOffsets(7814944L, 7814464L, 0L, 7904272L, 6854512L, 3502448L, 6601600L, 29481152L); case 15: return CreateOffsets(7815904L, 7815424L, 0L, 7905408L, 6855280L, 3502128L, 6602368L, 29489344L); case 16: return CreateOffsets(7826928L, 7826448L, 0L, 7916400L, 6865920L, 3503072L, 6612752L, 29513984L); case 17: return CreateOffsets(7824736L, 7824256L, 0L, 7914208L, 6864000L, 3503088L, 6610832L, 29509824L); case 18: return CreateOffsets(7824704L, 7824224L, 0L, 7914176L, 6863968L, 3502960L, 6610800L, 29509824L); case 19: return CreateOffsets(7843760L, 7843280L, 0L, 7933232L, 6882768L, 3504816L, 6630560L, 29526336L); case 20: return CreateOffsets(7875552L, 7875072L, 0L, 7965056L, 6914528L, 3508912L, 6662224L, 29559104L); case 21: return CreateOffsets(7862512L, 7862032L, 0L, 7952016L, 6869728L, 3509376L, 6649920L, 29559104L); case 22: return CreateOffsets(7865344L, 7864864L, 0L, 7954848L, 6871856L, 3511008L, 6652048L, 29563200L); case 23: return CreateOffsets(7863952L, 7863472L, 0L, 7953456L, 6870464L, 3510576L, 6650656L, 29567296L); case 24: return CreateOffsets(7862496L, 7862016L, 0L, 7952000L, 6868048L, 3508096L, 6648240L, 29567296L); case 25: return CreateOffsets(7856480L, 7856000L, 0L, 7944384L, 6853104L, 3505952L, 6633520L, 29563200L); case 26: return CreateOffsets(7858592L, 7858112L, 0L, 7946496L, 6852256L, 3505904L, 6632656L, 29563456L); case 27: return CreateOffsets(7858800L, 7858320L, 0L, 7946704L, 6852464L, 3504288L, 6632864L, 29563520L); case 28: return CreateOffsets(7858368L, 7857888L, 0L, 7946272L, 6852032L, 3503968L, 6632432L, 29563520L); case 29: return CreateOffsets(7858448L, 7857968L, 0L, 7946352L, 6852112L, 3504048L, 6632512L, 29563520L); case 30: return CreateOffsets(7861344L, 7860864L, 0L, 7949168L, 6855008L, 3506688L, 6635408L, 29567552L); case 31: return CreateOffsets(7862352L, 7861872L, 0L, 7950176L, 6855824L, 3506848L, 6636224L, 29571648L); case 32: return CreateOffsets(7862496L, 7862016L, 0L, 7950320L, 6855968L, 3506848L, 6636368L, 29571648L); case 33: return CreateOffsets(7863168L, 7862688L, 0L, 7950992L, 6856352L, 3507248L, 6636256L, 29579840L); case 34: return CreateOffsets(7863552L, 7863072L, 0L, 7951376L, 6856752L, 3507440L, 6636656L, 29579904L); case 35: return CreateOffsets(7864592L, 7864112L, 0L, 7952416L, 6857792L, 3507456L, 6637552L, 29579840L); case 36: return CreateOffsets(7857456L, 7856976L, 0L, 7943120L, 6855472L, 3509600L, 6636608L, 29555264L); case 37: return CreateOffsets(7858496L, 7858016L, 0L, 7944160L, 6856512L, 3509504L, 6637696L, 29555264L); case 38: return CreateOffsets(7858352L, 7857872L, 0L, 7944016L, 6856368L, 3509456L, 6637552L, 29559424L); case 39: return CreateOffsets(7863408L, 7862928L, 0L, 7948624L, 6861408L, 3509024L, 6641200L, 29563456L); case 40: return CreateOffsets(7862784L, 7862304L, 0L, 7948000L, 6860784L, 3509216L, 6640592L, 29567552L); case 41: return CreateOffsets(7863360L, 7862880L, 0L, 7948576L, 6861040L, 3509216L, 6640848L, 29563456L); case 42: return CreateOffsets(7868624L, 7868144L, 0L, 7953840L, 6866304L, 3514400L, 6646032L, 29403776L); case 43: return CreateOffsets(7869152L, 7868672L, 0L, 7954432L, 6866832L, 3514560L, 6646560L, 29403712L); case 44: return CreateOffsets(7870288L, 7869808L, 0L, 7955568L, 6866944L, 3514416L, 6646672L, 29407808L); case 45: return CreateOffsets(7870880L, 7870400L, 0L, 7956160L, 6867536L, 3514432L, 6647264L, 29411968L); case 46: return CreateOffsets(7870752L, 7870272L, 0L, 7956032L, 6867408L, 3513872L, 6647136L, 29411968L); case 47: return CreateOffsets(7870944L, 7870464L, 0L, 7956224L, 6867600L, 3514016L, 6647328L, 29411904L); case 48: return CreateOffsets(7870912L, 7870432L, 0L, 7956192L, 6867568L, 3513968L, 6647296L, 29416000L); case 49: return CreateOffsets(7871568L, 7871088L, 0L, 7956848L, 6868224L, 3514624L, 6647952L, 29420096L); case 50: return CreateOffsets(7871440L, 7870960L, 0L, 7956720L, 6868096L, 3514576L, 6647744L, 29420096L); case 51: return CreateOffsets(7872928L, 7872448L, 0L, 7958208L, 6869584L, 3515472L, 6648640L, 29424192L); case 52: return CreateOffsets(7869776L, 7869296L, 0L, 7955056L, 6866432L, 3515584L, 6646816L, 29629312L); case 53: return CreateOffsets(7867584L, 7867104L, 0L, 7952864L, 6864880L, 3516576L, 6645568L, 29621120L); case 54: return CreateOffsets(7867392L, 7866912L, 0L, 7953120L, 6864688L, 3516400L, 6645328L, 29629376L); case 55: return CreateOffsets(7867856L, 7867376L, 0L, 7953584L, 6865136L, 3517040L, 6645776L, 29625408L); case 56: return CreateOffsets(7872736L, 7872256L, 0L, 7958464L, 6869920L, 3517872L, 6650336L, 29629504L); case 57: return CreateOffsets(7872976L, 7872496L, 0L, 7958704L, 6870128L, 3517808L, 6650288L, 29629504L); case 58: return CreateOffsets(7881888L, 7881408L, 0L, 7967616L, 6878304L, 3517008L, 6658576L, 29645888L); case 59: return CreateOffsets(7881376L, 7880896L, 0L, 7967104L, 6877840L, 3516384L, 6658112L, 29645824L); case 60: return CreateOffsets(7881392L, 7880912L, 0L, 7967120L, 6878496L, 3517168L, 6658768L, 29666368L); case 61: return CreateOffsets(7882048L, 7881568L, 0L, 7967776L, 6879040L, 3516880L, 6659184L, 29678656L); case 62: return CreateOffsets(7881008L, 0L, 6889888L, 7965760L, 6876448L, 3517936L, 6655536L, 29674624L); } break; } break; case 2023: switch (unityVersion.Minor) { case 1: switch (unityVersion.Build) { case 0: return CreateOffsets(6824560L, 6824016L, 0L, 6914080L, 5866960L, 2476800L, 5489344L, 28587648L); case 1: return CreateOffsets(6826352L, 6825808L, 0L, 6915872L, 5868752L, 2476976L, 5491168L, 28595840L); case 2: return CreateOffsets(6827456L, 6826912L, 0L, 6916976L, 5870496L, 2477888L, 5492912L, 28595840L); case 3: return CreateOffsets(6816704L, 6816160L, 0L, 6906224L, 5859744L, 2467136L, 5482208L, 28587648L); case 4: return CreateOffsets(6816736L, 6816192L, 0L, 6906256L, 5859776L, 2466688L, 5482192L, 28609600L); case 5: return CreateOffsets(6815968L, 6815424L, 0L, 6905488L, 5858960L, 2467248L, 5481376L, 28609600L); case 6: return CreateOffsets(6816400L, 6815856L, 0L, 6905920L, 5859392L, 2467328L, 5481648L, 28609600L); case 7: return CreateOffsets(6815216L, 6814672L, 0L, 6904736L, 5857920L, 2465872L, 5480176L, 28613696L); case 8: return CreateOffsets(6820336L, 6819792L, 0L, 6909856L, 5863088L, 2465664L, 5485104L, 28617728L); case 9: return CreateOffsets(6822976L, 6822432L, 0L, 6912768L, 5866416L, 2465712L, 5488416L, 28630080L); case 10: return CreateOffsets(6823552L, 6823008L, 0L, 6913344L, 5866944L, 2466208L, 5488944L, 28638272L); case 11: return CreateOffsets(6826448L, 6825904L, 0L, 6916240L, 5867984L, 2466320L, 5489984L, 28638272L); case 12: return CreateOffsets(6828720L, 6828176L, 0L, 6918512L, 5869888L, 2467312L, 5492480L, 28642496L); case 13: return CreateOffsets(6828992L, 6828448L, 0L, 6918784L, 5869984L, 2467872L, 5492560L, 28646592L); case 14: return CreateOffsets(6829424L, 6828880L, 0L, 6919216L, 5870368L, 2467888L, 5492944L, 28646656L); case 15: return CreateOffsets(6828320L, 6827776L, 0L, 6918112L, 5869312L, 2467792L, 5491776L, 28646656L); case 16: return CreateOffsets(6829280L, 6828736L, 0L, 6919072L, 5870272L, 2468448L, 5492352L, 28654848L); case 17: return CreateOffsets(6831440L, 6830896L, 0L, 6921152L, 5872336L, 2470672L, 5495888L, 28679488L); case 18: return CreateOffsets(6831792L, 6831248L, 0L, 6921552L, 5872672L, 2470912L, 5496224L, 28683584L); case 19: return CreateOffsets(6829024L, 6828480L, 0L, 6918784L, 5869904L, 2470928L, 5495696L, 28679488L); case 20: return CreateOffsets(6827824L, 6827280L, 0L, 6917296L, 5871216L, 2475888L, 5497056L, 28695872L); } break; case 2: switch (unityVersion.Build) { case 0: return CreateOffsets(7015696L, 7015120L, 0L, 7091776L, 6050128L, 2586768L, 2586960L, 29192896L); case 1: return CreateOffsets(7016576L, 7016000L, 0L, 7092672L, 6050928L, 2586416L, 2586608L, 29192896L); case 2: return CreateOffsets(7018288L, 7017712L, 0L, 7094384L, 6052832L, 2587200L, 2587392L, 29192896L); case 3: return CreateOffsets(7018224L, 7017648L, 0L, 7094320L, 6052768L, 2587216L, 2587408L, 29209280L); case 4: return CreateOffsets(7025840L, 7025264L, 0L, 7101952L, 6059616L, 2588864L, 2589056L, 29225664L); case 5: return CreateOffsets(7026144L, 7025568L, 0L, 7102256L, 6059888L, 2588880L, 2589072L, 29229760L); case 6: return CreateOffsets(7026192L, 7025616L, 0L, 7102304L, 6059936L, 2588928L, 2589120L, 29225664L); case 7: return CreateOffsets(7026224L, 7025648L, 0L, 7102336L, 6059968L, 2588928L, 2589120L, 29221568L); case 8: return CreateOffsets(7040464L, 7039888L, 0L, 7116576L, 6073936L, 2589024L, 2589216L, 29225792L); case 9: return CreateOffsets(7040496L, 7039920L, 0L, 7116608L, 6073968L, 2589040L, 2589232L, 29229888L); case 10: return CreateOffsets(7042400L, 7041824L, 0L, 7118512L, 6075856L, 2588944L, 2589136L, 29266816L); case 11: return CreateOffsets(7043184L, 7042608L, 0L, 7119296L, 6076592L, 2589648L, 2589840L, 29270848L); case 12: return CreateOffsets(7043584L, 7043008L, 0L, 7119696L, 6076752L, 2589808L, 2590000L, 29270848L); case 13: return CreateOffsets(7038816L, 7038240L, 0L, 7114928L, 6071552L, 2589904L, 2590096L, 29274944L); case 14: return CreateOffsets(7038928L, 7038352L, 0L, 7115040L, 6071568L, 2589904L, 2590096L, 29274944L); case 15: return CreateOffsets(7038832L, 7038256L, 0L, 7114944L, 6071568L, 2589904L, 2590096L, 29274944L); case 16: return CreateOffsets(7037424L, 7036848L, 0L, 7113536L, 6071664L, 2590000L, 2590192L, 29279040L); case 17: return CreateOffsets(7062768L, 7062192L, 0L, 7137456L, 6086256L, 2593776L, 2593968L, 29365056L); case 18: return CreateOffsets(7058160L, 7057584L, 0L, 7132848L, 6081824L, 2592432L, 2592624L, 29352768L); case 19: return CreateOffsets(7058160L, 7057584L, 0L, 7132848L, 6081824L, 2592432L, 2592624L, 29352768L); case 20: return CreateOffsets(7056848L, 7056272L, 0L, 7131536L, 6080496L, 2592640L, 2592832L, 29360960L); } break; } break; } return null; } private static Dictionary<string, long> CreateOffsets(long monoManagerAwakeFromLoadOffset, long monoManagerIsAssemblyCreatedOffset, long isFileCreatedOffset, long scriptingManagerDeconstructorOffset, long convertSeparatorsToPlatformOffset, long mallocInternalOffset, long freeAllocInternalOffset, long scriptingAssembliesOffset) { return new Dictionary<string, long> { ["MonoManagerAwakeFromLoadOffset"] = monoManagerAwakeFromLoadOffset, ["MonoManagerIsAssemblyCreatedOffset"] = monoManagerIsAssemblyCreatedOffset, ["IsFileCreatedOffset"] = isFileCreatedOffset, ["ScriptingManagerDeconstructorOffset"] = scriptingManagerDeconstructorOffset, ["ConvertSeparatorsToPlatformOffset"] = convertSeparatorsToPlatformOffset, ["MallocInternalOffset"] = mallocInternalOffset, ["FreeAllocInternalOffset"] = freeAllocInternalOffset, ["ScriptingAssembliesOffset"] = scriptingAssembliesOffset }; } } internal class MiniPdbReader { private readonly PeReader _peReader; private byte[] _pdbFile; internal bool IsPdbAvailable; internal bool UseCache; 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 supported versions"); 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 supported versions"); } } else { IsPdbAvailable = true; } } private bool DownloadUnityPdb(PeReader peReader) { if (DownloadUnityPdbCab(peReader)) { return true; } string url = peReader.RsdsPdbFileName + "/" + peReader.PdbGuid + "/" + peReader.RsdsPdbFileName; string text = Path.Combine(Path.GetTempPath(), "UnityEngine.pdb"); if (!Win32.DownloadUnitySymbolFile(url, text)) { return false; } _pdbFile = File.ReadAllBytes(text); File.Delete(text); return true; } private bool DownloadUnityPdbCab(PeReader peReader) { //IL_0071: Unknown result type (might be due to invalid IL or missing references) try { string text = peReader.RsdsPdbFileName.TrimEnd(new char[1] { 'b' }) + "_"; string url = peReader.RsdsPdbFileName + "/" + peReader.PdbGuid + "/" + text; string tempPath = Path.GetTempPath(); string text2 = Path.Combine(tempPath, "pdb.cab"); if (!Win32.DownloadUnitySymbolFile(url, text2)) { return false; } CabInfo val = new CabInfo(text2); Log.Info("Unpacking the compressed pdb"); ((ArchiveInfo)val).Unpack(tempPath); string path = Path.Combine(tempPath, "pdb.cab"); _pdbFile = File.ReadAllBytes(text2); File.Delete(text2); File.Delete(path); return true; } catch { return false; } } 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) { 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 CopyNativeAssemblyListToManagedV0(List<StringStorageDefaultV0> managedAssemblyList, Vector<StringStorageDefaultV0> assemblyNames) { managedAssemblyList.Clear(); for (StringStorageDefaultV0* ptr = assemblyNames.first; ptr != assemblyNames.last; ptr++) { managedAssemblyList.Add(*ptr); } } public unsafe static void AddAssembliesToManagedListV0(List<StringStorageDefaultV0> 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++; } StringStorageDefaultV0 stringStorageDefaultV = default(StringStorageDefaultV0); stringStorageDefaultV.data = intPtr; stringStorageDefaultV.extra1 = num; stringStorageDefaultV.size = num; stringStorageDefaultV.flags = 31uL; stringStorageDefaultV.extra2 = 0uL; StringStorageDefaultV0 item = stringStorageDefaultV; managedAssemblyList.Add(item); } } public unsafe static void AllocNativeAssemblyListFromManagedV0(List<StringStorageDefaultV0> managedAssemblyList, Vector<StringStorageDefaultV0>* assemblyNames) { StringStorageDefaultV0* ptr = (StringStorageDefaultV0*)(void*)Marshal.AllocHGlobal(Marshal.SizeOf(typeof(StringStorageDefaultV0)) * managedAssemblyList.Count); int i = 0; StringStorageDefaultV0* 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 PrintAssembliesV0(Vector<StringStorageDefaultV0> assemblyNames) { for (StringStorageDefaultV0* ptr = assemblyNames.first; ptr != assemblyNames.last; ptr++) { if (ptr->flags < 16) { Log.Warning("Ass: " + Marshal.PtrToStringAnsi((IntPtr)ptr)); } else { Log.Warning("Ass: " + Marshal.PtrToStringAnsi(ptr->data, (int)ptr->size)); } } } 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 class PatternDiscoverer { private readonly IntPtr unityModule; private readonly MiniPdbReader pdbReader; private readonly bool usePdb; private readonly Dictionary<string, long> functionOffsets; public PatternDiscoverer(IntPtr unityModule, string unityPlayerPath) { this.unityModule = unityModule; switch (Config.FunctionOffsetLookupType.Value) { case FunctionOffsetLookup.Manual: break; case FunctionOffsetLookup.PreferPdb: pdbReader = new MiniPdbReader(unityPlayerPath); usePdb = pdbReader.IsPdbAvailable; if (!usePdb) { if (!FunctionOffsets.TryGet(UseRightStructs.UnityVersion, out functionOffsets)) { throw new NotSupportedException($"Pdb not found and {UseRightStructs.UnityVersion} is not a supported version"); } Log.Info("Found offsets for current version, using them."); } break; case FunctionOffsetLookup.PreferSupportedVersions: if (!FunctionOffsets.TryGet(UseRightStructs.UnityVersion, out functionOffsets)) { pdbReader = new MiniPdbReader(unityPlayerPath); usePdb = pdbReader.IsPdbAvailable; if (!usePdb) { throw new NotSupportedException($"{UseRightStructs.UnityVersion} is not a supported version and pdb not found"); } } else { Log.Info("Found offsets for current version, using them."); } break; default: throw new ArgumentException("FunctionOffsetLookupType"); } } public IntPtr Discover(ConfigEntry<string> functionOffsetCache, BytePattern[] pdbPatterns) { if (usePdb) { return DiscoverWithPdb(functionOffsetCache, pdbPatterns); } long num; if (f

using System; using System.Collections.Generic; using System.Diagnostics; using System.Globalization; using System.IO; using System.Reflection; using System.Resources; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Serialization; using System.Security; using System.Security.Permissions; using System.Text; [assembly: CompilationRelaxations(8)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] [assembly: AssemblyDescription("Managed libraries for cabinet archive packing and unpacking")] [assembly: CLSCompliant(true)] [assembly: ComVisible(false)] [assembly: AllowPartiallyTrustedCallers] [assembly: AssemblyFileVersion("3.10.1.2213")] [assembly: AssemblyCompany("Outercurve Foundation")] [assembly: AssemblyCopyright("Copyright (c) Outercurve Foundation. All rights reserved.")] [assembly: AssemblyProduct("Windows Installer XML Toolset")] [assembly: AssemblyConfiguration("")] [assembly: NeutralResourcesLanguage("en-US")] [assembly: SecurityPermission(SecurityAction.RequestMinimum, Assertion = true, UnmanagedCode = true)] [assembly: AssemblyVersion("3.0.0.0")] namespace Microsoft.Tools.WindowsInstallerXml { internal static class WixDistribution { public static string NewsUrl = "http://wixtoolset.org/news/"; public static string ShortProduct = "WiX Toolset"; public static string SupportUrl = "http://wixtoolset.org/"; public static string TelemetryUrlFormat = "http://wixtoolset.org/telemetry/v{0}/?r={1}"; public static string ReplacePlaceholders(string original, Assembly assembly) { if ((object)assembly != null) { FileVersionInfo versionInfo = FileVersionInfo.GetVersionInfo(assembly.Location); original = original.Replace("[FileComments]", versionInfo.Comments); original = original.Replace("[FileCopyright]", versionInfo.LegalCopyright); original = original.Replace("[FileProductName]", versionInfo.ProductName); original = original.Replace("[FileVersion]", versionInfo.FileVersion); if (original.Contains("[FileVersionMajorMinor]")) { Version version = new Version(versionInfo.FileVersion); original = original.Replace("[FileVersionMajorMinor]", version.Major + "." + version.Minor); } if (TryGetAttribute<AssemblyCompanyAttribute>(assembly, out var attribute)) { original = original.Replace("[AssemblyCompany]", attribute.Company); } if (TryGetAttribute<AssemblyCopyrightAttribute>(assembly, out var attribute2)) { original = original.Replace("[AssemblyCopyright]", attribute2.Copyright); } if (TryGetAttribute<AssemblyDescriptionAttribute>(assembly, out var attribute3)) { original = original.Replace("[AssemblyDescription]", attribute3.Description); } if (TryGetAttribute<AssemblyProductAttribute>(assembly, out var attribute4)) { original = original.Replace("[AssemblyProduct]", attribute4.Product); } if (TryGetAttribute<AssemblyTitleAttribute>(assembly, out var attribute5)) { original = original.Replace("[AssemblyTitle]", attribute5.Title); } } original = original.Replace("[NewsUrl]", NewsUrl); original = original.Replace("[ShortProduct]", ShortProduct); original = original.Replace("[SupportUrl]", SupportUrl); return original; } private static bool TryGetAttribute<T>(Assembly assembly, out T attribute) where T : Attribute { attribute = null; object[] customAttributes = assembly.GetCustomAttributes(typeof(T), inherit: false); if (customAttributes != null && customAttributes.Length != 0) { attribute = customAttributes[0] as T; } return attribute != null; } } } namespace Microsoft.Deployment.Compression.Cab { internal class CabPacker : CabWorker { private const string TempStreamName = "%%TEMP%%"; private NativeMethods.FCI.Handle fciHandle; private NativeMethods.FCI.PFNALLOC fciAllocMemHandler; private NativeMethods.FCI.PFNFREE fciFreeMemHandler; private NativeMethods.FCI.PFNOPEN fciOpenStreamHandler; private NativeMethods.FCI.PFNREAD fciReadStreamHandler; private NativeMethods.FCI.PFNWRITE fciWriteStreamHandler; private NativeMethods.FCI.PFNCLOSE fciCloseStreamHandler; private NativeMethods.FCI.PFNSEEK fciSeekStreamHandler; private NativeMethods.FCI.PFNFILEPLACED fciFilePlacedHandler; private NativeMethods.FCI.PFNDELETE fciDeleteFileHandler; private NativeMethods.FCI.PFNGETTEMPFILE fciGetTempFileHandler; private NativeMethods.FCI.PFNGETNEXTCABINET fciGetNextCabinet; private NativeMethods.FCI.PFNSTATUS fciCreateStatus; private NativeMethods.FCI.PFNGETOPENINFO fciGetOpenInfo; private IPackStreamContext context; private FileAttributes fileAttributes; private DateTime fileLastWriteTime; private int maxCabBytes; private long totalFolderBytesProcessedInCurrentCab; private CompressionLevel compressionLevel; private bool dontUseTempFiles; private IList<Stream> tempStreams; public bool UseTempFiles { get { return !dontUseTempFiles; } set { dontUseTempFiles = !value; } } public CompressionLevel CompressionLevel { get { //IL_0001: Unknown result type (might be due to invalid IL or missing references) return compressionLevel; } set { //IL_0001: Unknown result type (might be due to invalid IL or missing references) //IL_0002: Unknown result type (might be due to invalid IL or missing references) compressionLevel = value; } } public CabPacker(CabEngine cabEngine) : base(cabEngine) { //IL_0103: Unknown result type (might be due to invalid IL or missing references) fciAllocMemHandler = base.CabAllocMem; fciFreeMemHandler = base.CabFreeMem; fciOpenStreamHandler = CabOpenStreamEx; fciReadStreamHandler = CabReadStreamEx; fciWriteStreamHandler = CabWriteStreamEx; fciCloseStreamHandler = CabCloseStreamEx; fciSeekStreamHandler = CabSeekStreamEx; fciFilePlacedHandler = CabFilePlaced; fciDeleteFileHandler = CabDeleteFile; fciGetTempFileHandler = CabGetTempFile; fciGetNextCabinet = CabGetNextCabinet; fciCreateStatus = CabCreateStatus; fciGetOpenInfo = CabGetOpenInfo; tempStreams = new List<Stream>(); compressionLevel = (CompressionLevel)6; } private void CreateFci(long maxArchiveSize) { NativeMethods.FCI.CCAB cCAB = new NativeMethods.FCI.CCAB(); checked { if (maxArchiveSize > 0 && maxArchiveSize < cCAB.cb) { cCAB.cb = Math.Max(32768, (int)maxArchiveSize); } object option = context.GetOption("maxFolderSize", (object[])null); if (option != null) { long num = Convert.ToInt64(option, CultureInfo.InvariantCulture); if (num > 0 && num < cCAB.cbFolderThresh) { cCAB.cbFolderThresh = (int)num; } } maxCabBytes = cCAB.cb; cCAB.szCab = context.GetArchiveName(0); if (cCAB.szCab == null) { throw new FileNotFoundException("Cabinet name not provided by stream context."); } cCAB.setID = (short)new Random().Next(-32768, 32768); base.CabNumbers[cCAB.szCab] = 0; currentArchiveName = cCAB.szCab; totalArchives = 1; base.CabStream = null; base.Erf.Clear(); fciHandle = NativeMethods.FCI.Create(base.ErfHandle.AddrOfPinnedObject(), fciFilePlacedHandler, fciAllocMemHandler, fciFreeMemHandler, fciOpenStreamHandler, fciReadStreamHandler, fciWriteStreamHandler, fciCloseStreamHandler, fciSeekStreamHandler, fciDeleteFileHandler, fciGetTempFileHandler, cCAB, IntPtr.Zero); CheckError(extracting: false); } } [SecurityPermission(SecurityAction.Assert, UnmanagedCode = true)] public void Pack(IPackStreamContext streamContext, IEnumerable<string> files, long maxArchiveSize) { //IL_01d0: Unknown result type (might be due to invalid IL or missing references) if (streamContext == null) { throw new ArgumentNullException("streamContext"); } if (files == null) { throw new ArgumentNullException("files"); } lock (this) { try { context = streamContext; ResetProgressData(); CreateFci(maxArchiveSize); checked { FileAttributes fileAttributes = default(FileAttributes); DateTime dateTime = default(DateTime); foreach (string file in files) { Stream stream = context.OpenFileReadStream(file, ref fileAttributes, ref dateTime); if (stream != null) { totalFileBytes += stream.Length; totalFiles++; context.CloseFileReadStream(file, stream); } } long num = 0L; currentFileNumber = -1; FileAttributes attributes = default(FileAttributes); DateTime lastWriteTime = default(DateTime); foreach (string file2 in files) { Stream stream2 = context.OpenFileReadStream(file2, ref attributes, ref lastWriteTime); if (stream2 == null) { continue; } if (stream2.Length >= 2147450880) { throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, "File {0} exceeds maximum file size for cabinet format.", new object[1] { file2 })); } if (num > 0) { bool flag = num + stream2.Length >= 2147450880; if (!flag) { flag = Convert.ToBoolean(streamContext.GetOption("nextFolder", new object[2] { file2, currentFolderNumber }), CultureInfo.InvariantCulture); } if (flag) { FlushFolder(); num = 0L; } } if (currentFolderTotalBytes > 0) { currentFolderTotalBytes = 0L; currentFolderNumber++; num = 0L; } currentFileName = file2; currentFileNumber++; currentFileTotalBytes = stream2.Length; currentFileBytesProcessed = 0L; OnProgress((ArchiveProgressType)0); num += stream2.Length; AddFile(file2, stream2, attributes, lastWriteTime, execute: false, CompressionLevel); } FlushFolder(); FlushCabinet(); } } finally { if (base.CabStream != null) { context.CloseArchiveWriteStream((int)currentArchiveNumber, currentArchiveName, base.CabStream); base.CabStream = null; } if (base.FileStream != null) { context.CloseFileReadStream(currentFileName, base.FileStream); base.FileStream = null; } context = null; if (fciHandle != null) { fciHandle.Dispose(); fciHandle = null; } } } } internal override int CabOpenStreamEx(string path, int openFlags, int shareMode, out int err, IntPtr pv) { //IL_010d: Unknown result type (might be due to invalid IL or missing references) //IL_0113: Expected O, but got Unknown if (base.CabNumbers.ContainsKey(path)) { Stream stream = base.CabStream; if (stream == null) { short num = base.CabNumbers[path]; currentFolderTotalBytes = 0L; stream = context.OpenArchiveWriteStream((int)num, path, true, (CompressionEngine)(object)base.CabEngine); if (stream == null) { throw new FileNotFoundException(string.Format(CultureInfo.InvariantCulture, "Cabinet {0} not provided.", new object[1] { num })); } currentArchiveName = path; currentArchiveTotalBytes = Math.Min(totalFolderBytesProcessedInCurrentCab, maxCabBytes); currentArchiveBytesProcessed = 0L; OnProgress((ArchiveProgressType)3); base.CabStream = stream; } path = "%%CAB%%"; } else { if (path == "%%TEMP%%") { Stream stream2 = new MemoryStream(); tempStreams.Add(stream2); int result = base.StreamHandles.AllocHandle(stream2); err = 0; return result; } if (path != "%%CAB%%") { path = Path.Combine(Path.GetTempPath(), path); Stream stream3 = new FileStream(path, FileMode.Open, FileAccess.ReadWrite); tempStreams.Add(stream3); stream3 = (Stream)new DuplicateStream(stream3); int result2 = base.StreamHandles.AllocHandle(stream3); err = 0; return result2; } } return base.CabOpenStreamEx(path, openFlags, shareMode, out err, pv); } internal override int CabWriteStreamEx(int streamHandle, IntPtr memory, int cb, out int err, IntPtr pv) { int num = base.CabWriteStreamEx(streamHandle, memory, cb, out err, pv); checked { if (num > 0 && err == 0 && DuplicateStream.OriginalStream(base.StreamHandles[streamHandle]) == DuplicateStream.OriginalStream(base.CabStream)) { currentArchiveBytesProcessed += cb; if (currentArchiveBytesProcessed > currentArchiveTotalBytes) { currentArchiveBytesProcessed = currentArchiveTotalBytes; } } return num; } } internal override int CabCloseStreamEx(int streamHandle, out int err, IntPtr pv) { Stream stream = DuplicateStream.OriginalStream(base.StreamHandles[streamHandle]); checked { if (stream == DuplicateStream.OriginalStream(base.FileStream)) { context.CloseFileReadStream(currentFileName, stream); base.FileStream = null; long num = currentFileTotalBytes - currentFileBytesProcessed; currentFileBytesProcessed += num; fileBytesProcessed += num; OnProgress((ArchiveProgressType)2); currentFileTotalBytes = 0L; currentFileBytesProcessed = 0L; currentFileName = null; } else if (stream == DuplicateStream.OriginalStream(base.CabStream)) { if (stream.CanWrite) { stream.Flush(); } currentArchiveBytesProcessed = currentArchiveTotalBytes; OnProgress((ArchiveProgressType)5); currentArchiveNumber++; totalArchives++; context.CloseArchiveWriteStream(unchecked((int)currentArchiveNumber), currentArchiveName, stream); currentArchiveName = base.NextCabinetName; currentArchiveBytesProcessed = (currentArchiveTotalBytes = 0L); totalFolderBytesProcessedInCurrentCab = 0L; base.CabStream = null; } else { stream.Close(); tempStreams.Remove(stream); } return base.CabCloseStreamEx(streamHandle, out err, pv); } } protected override void Dispose(bool disposing) { try { if (disposing && fciHandle != null) { fciHandle.Dispose(); fciHandle = null; } } finally { base.Dispose(disposing); } } private static NativeMethods.FCI.TCOMP GetCompressionType(CompressionLevel compLevel) { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0002: Invalid comparison between Unknown and I4 //IL_0006: Unknown result type (might be due to invalid IL or missing references) //IL_0009: Invalid comparison between Unknown and I4 //IL_0010: Unknown result type (might be due to invalid IL or missing references) //IL_0012: Unknown result type (might be due to invalid IL or missing references) //IL_0013: Unknown result type (might be due to invalid IL or missing references) //IL_0016: Unknown result type (might be due to invalid IL or missing references) //IL_0018: Expected I4, but got Unknown //IL_000d: Unknown result type (might be due to invalid IL or missing references) if ((int)compLevel < 1) { return NativeMethods.FCI.TCOMP.TYPE_NONE; } if ((int)compLevel > 10) { compLevel = (CompressionLevel)10; } int num = checked(6 * (compLevel - 1)) / 9; return (NativeMethods.FCI.TCOMP)checked((ushort)(3 | (3840 + (num << 8)))); } private void AddFile(string name, Stream stream, FileAttributes attributes, DateTime lastWriteTime, bool execute, CompressionLevel compLevel) { //IL_0020: Unknown result type (might be due to invalid IL or missing references) base.FileStream = stream; fileAttributes = attributes & (FileAttributes.ReadOnly | FileAttributes.Hidden | FileAttributes.System | FileAttributes.Archive); fileLastWriteTime = lastWriteTime; currentFileName = name; NativeMethods.FCI.TCOMP compressionType = GetCompressionType(compLevel); IntPtr intPtr = IntPtr.Zero; try { Encoding encoding = Encoding.ASCII; if (Encoding.UTF8.GetByteCount(name) > name.Length) { encoding = Encoding.UTF8; fileAttributes |= FileAttributes.Normal; } byte[] bytes = encoding.GetBytes(name); intPtr = Marshal.AllocHGlobal(checked(bytes.Length + 1)); Marshal.Copy(bytes, 0, intPtr, bytes.Length); Marshal.WriteByte(intPtr, bytes.Length, 0); base.Erf.Clear(); NativeMethods.FCI.AddFile(fciHandle, string.Empty, intPtr, execute, fciGetNextCabinet, fciCreateStatus, fciGetOpenInfo, compressionType); } finally { if (intPtr != IntPtr.Zero) { Marshal.FreeHGlobal(intPtr); } } CheckError(extracting: false); base.FileStream = null; currentFileName = null; } private void FlushFolder() { base.Erf.Clear(); NativeMethods.FCI.FlushFolder(fciHandle, fciGetNextCabinet, fciCreateStatus); CheckError(extracting: false); } private void FlushCabinet() { base.Erf.Clear(); NativeMethods.FCI.FlushCabinet(fciHandle, fGetNextCab: false, fciGetNextCabinet, fciCreateStatus); CheckError(extracting: false); } private int CabGetOpenInfo(string path, out short date, out short time, out short attribs, out int err, IntPtr pv) { //IL_0020: Unknown result type (might be due to invalid IL or missing references) //IL_002a: Expected O, but got Unknown CompressionEngine.DateTimeToDosDateAndTime(fileLastWriteTime, ref date, ref time); attribs = checked((short)fileAttributes); Stream stream = base.FileStream; base.FileStream = (Stream)new DuplicateStream(stream); int result = base.StreamHandles.AllocHandle(stream); err = 0; return result; } private int CabFilePlaced(IntPtr pccab, string filePath, long fileSize, int continuation, IntPtr pv) { return 0; } private int CabGetNextCabinet(IntPtr pccab, uint prevCabSize, IntPtr pv) { NativeMethods.FCI.CCAB cCAB = new NativeMethods.FCI.CCAB(); Marshal.PtrToStructure(pccab, (object)cCAB); cCAB.szDisk = string.Empty; cCAB.szCab = context.GetArchiveName(cCAB.iCab); base.CabNumbers[cCAB.szCab] = checked((short)cCAB.iCab); base.NextCabinetName = cCAB.szCab; Marshal.StructureToPtr((object)cCAB, pccab, fDeleteOld: false); return 1; } private int CabCreateStatus(NativeMethods.FCI.STATUS typeStatus, uint cb1, uint cb2, IntPtr pv) { checked { switch (typeStatus) { case NativeMethods.FCI.STATUS.FILE: if (cb2 != 0 && currentFileBytesProcessed < currentFileTotalBytes) { if (currentFileBytesProcessed + cb2 > currentFileTotalBytes) { cb2 = (uint)currentFileTotalBytes - (uint)currentFileBytesProcessed; } currentFileBytesProcessed += cb2; fileBytesProcessed += cb2; OnProgress((ArchiveProgressType)1); } break; case NativeMethods.FCI.STATUS.FOLDER: if (cb1 == 0) { currentFolderTotalBytes = cb2 - totalFolderBytesProcessedInCurrentCab; totalFolderBytesProcessedInCurrentCab = cb2; } else if (currentFolderTotalBytes == 0L) { OnProgress((ArchiveProgressType)4); } break; } return 0; } } private int CabGetTempFile(IntPtr tempNamePtr, int tempNameSize, IntPtr pv) { string s = ((!UseTempFiles) ? "%%TEMP%%" : Path.GetFileName(Path.GetTempFileName())); byte[] bytes = Encoding.ASCII.GetBytes(s); if (bytes.Length >= tempNameSize) { return -1; } Marshal.Copy(bytes, 0, tempNamePtr, bytes.Length); Marshal.WriteByte(tempNamePtr, bytes.Length, 0); return 1; } private int CabDeleteFile(string path, out int err, IntPtr pv) { try { if (path != "%%TEMP%%") { path = Path.Combine(Path.GetTempPath(), path); File.Delete(path); } } catch (IOException) { } err = 0; return 1; } } public class CabEngine : CompressionEngine { private CabPacker packer; private CabUnpacker unpacker; private CabPacker Packer { get { if (packer == null) { packer = new CabPacker(this); } return packer; } } private CabUnpacker Unpacker { get { if (unpacker == null) { unpacker = new CabUnpacker(this); } return unpacker; } } protected override void Dispose(bool disposing) { if (disposing) { if (packer != null) { packer.Dispose(); packer = null; } if (unpacker != null) { unpacker.Dispose(); unpacker = null; } } ((CompressionEngine)this).Dispose(disposing); } public override void Pack(IPackStreamContext streamContext, IEnumerable<string> files, long maxArchiveSize) { //IL_0007: Unknown result type (might be due to invalid IL or missing references) Packer.CompressionLevel = ((CompressionEngine)this).CompressionLevel; Packer.UseTempFiles = ((CompressionEngine)this).UseTempFiles; Packer.Pack(streamContext, files, maxArchiveSize); } public override bool IsArchive(Stream stream) { return Unpacker.IsArchive(stream); } public override IList<ArchiveFileInfo> GetFileInfo(IUnpackStreamContext streamContext, Predicate<string> fileFilter) { return Unpacker.GetFileInfo(streamContext, fileFilter); } public override void Unpack(IUnpackStreamContext streamContext, Predicate<string> fileFilter) { Unpacker.Unpack(streamContext, fileFilter); } internal void ReportProgress(ArchiveProgressEventArgs e) { ((CompressionEngine)this).OnProgress(e); } } internal abstract class CabWorker : IDisposable { internal const string CabStreamName = "%%CAB%%"; private CabEngine cabEngine; private HandleManager<Stream> streamHandles; private Stream cabStream; private Stream fileStream; private NativeMethods.ERF erf; private GCHandle erfHandle; private IDictionary<string, short> cabNumbers; private string nextCabinetName; private bool suppressProgressEvents; private byte[] buf; protected string currentFileName; protected int currentFileNumber; protected int totalFiles; protected long currentFileBytesProcessed; protected long currentFileTotalBytes; protected short currentFolderNumber; protected long currentFolderTotalBytes; protected string currentArchiveName; protected short currentArchiveNumber; protected short totalArchives; protected long currentArchiveBytesProcessed; protected long currentArchiveTotalBytes; protected long fileBytesProcessed; protected long totalFileBytes; public CabEngine CabEngine => cabEngine; internal NativeMethods.ERF Erf => erf; internal GCHandle ErfHandle => erfHandle; internal HandleManager<Stream> StreamHandles => streamHandles; internal bool SuppressProgressEvents { get { return suppressProgressEvents; } set { suppressProgressEvents = value; } } internal IDictionary<string, short> CabNumbers => cabNumbers; internal string NextCabinetName { get { return nextCabinetName; } set { nextCabinetName = value; } } internal Stream CabStream { get { return cabStream; } set { cabStream = value; } } internal Stream FileStream { get { return fileStream; } set { fileStream = value; } } protected CabWorker(CabEngine cabEngine) { this.cabEngine = cabEngine; streamHandles = new HandleManager<Stream>(); erf = new NativeMethods.ERF(); erfHandle = GCHandle.Alloc(erf, GCHandleType.Pinned); cabNumbers = new Dictionary<string, short>(1); buf = new byte[32768]; } ~CabWorker() { Dispose(disposing: false); } public void Dispose() { Dispose(disposing: true); GC.SuppressFinalize(this); } protected void ResetProgressData() { currentFileName = null; currentFileNumber = 0; totalFiles = 0; currentFileBytesProcessed = 0L; currentFileTotalBytes = 0L; currentFolderNumber = 0; currentFolderTotalBytes = 0L; currentArchiveName = null; currentArchiveNumber = 0; totalArchives = 0; currentArchiveBytesProcessed = 0L; currentArchiveTotalBytes = 0L; fileBytesProcessed = 0L; totalFileBytes = 0L; } protected void OnProgress(ArchiveProgressType progressType) { //IL_0008: Unknown result type (might be due to invalid IL or missing references) //IL_005d: Unknown result type (might be due to invalid IL or missing references) //IL_0063: Expected O, but got Unknown if (!suppressProgressEvents) { ArchiveProgressEventArgs e = new ArchiveProgressEventArgs(progressType, currentFileName, (currentFileNumber >= 0) ? currentFileNumber : 0, totalFiles, currentFileBytesProcessed, currentFileTotalBytes, currentArchiveName, (int)currentArchiveNumber, (int)totalArchives, currentArchiveBytesProcessed, currentArchiveTotalBytes, fileBytesProcessed, totalFileBytes); CabEngine.ReportProgress(e); } } internal IntPtr CabAllocMem(int byteCount) { return Marshal.AllocHGlobal((IntPtr)byteCount); } internal void CabFreeMem(IntPtr memPointer) { Marshal.FreeHGlobal(memPointer); } internal int CabOpenStream(string path, int openFlags, int shareMode) { int err; return CabOpenStreamEx(path, openFlags, shareMode, out err, IntPtr.Zero); } internal virtual int CabOpenStreamEx(string path, int openFlags, int shareMode, out int err, IntPtr pv) { //IL_0011: Unknown result type (might be due to invalid IL or missing references) //IL_001b: Expected O, but got Unknown path = path.Trim(); Stream stream = cabStream; cabStream = (Stream)new DuplicateStream(stream); int result = streamHandles.AllocHandle(stream); err = 0; return result; } internal int CabReadStream(int streamHandle, IntPtr memory, int cb) { int err; return CabReadStreamEx(streamHandle, memory, cb, out err, IntPtr.Zero); } internal virtual int CabReadStreamEx(int streamHandle, IntPtr memory, int cb, out int err, IntPtr pv) { Stream stream = streamHandles[streamHandle]; int num = cb; if (num > buf.Length) { buf = new byte[num]; } num = stream.Read(buf, 0, num); Marshal.Copy(buf, 0, memory, num); err = 0; return num; } internal int CabWriteStream(int streamHandle, IntPtr memory, int cb) { int err; return CabWriteStreamEx(streamHandle, memory, cb, out err, IntPtr.Zero); } internal virtual int CabWriteStreamEx(int streamHandle, IntPtr memory, int cb, out int err, IntPtr pv) { Stream stream = streamHandles[streamHandle]; if (cb > buf.Length) { buf = new byte[cb]; } Marshal.Copy(memory, buf, 0, cb); stream.Write(buf, 0, cb); err = 0; return cb; } internal int CabCloseStream(int streamHandle) { int err; return CabCloseStreamEx(streamHandle, out err, IntPtr.Zero); } internal virtual int CabCloseStreamEx(int streamHandle, out int err, IntPtr pv) { streamHandles.FreeHandle(streamHandle); err = 0; return 0; } internal int CabSeekStream(int streamHandle, int offset, int seekOrigin) { int err; return CabSeekStreamEx(streamHandle, offset, seekOrigin, out err, IntPtr.Zero); } internal virtual int CabSeekStreamEx(int streamHandle, int offset, int seekOrigin, out int err, IntPtr pv) { checked { offset = (int)streamHandles[streamHandle].Seek(offset, unchecked((SeekOrigin)seekOrigin)); err = 0; return offset; } } protected virtual void Dispose(bool disposing) { if (disposing) { if (cabStream != null) { cabStream.Close(); cabStream = null; } if (fileStream != null) { fileStream.Close(); fileStream = null; } } if (erfHandle.IsAllocated) { erfHandle.Free(); } } protected void CheckError(bool extracting) { if (Erf.Error) { throw new CabException(Erf.Oper, Erf.Type, CabException.GetErrorMessage(Erf.Oper, Erf.Type, extracting)); } } } [Serializable] public class CabException : ArchiveException { private static ResourceManager errorResources; private int error; private int errorCode; public int Error => error; public int ErrorCode => errorCode; internal static ResourceManager ErrorResources { get { if (errorResources == null) { errorResources = new ResourceManager(typeof(CabException).Namespace + ".Errors", typeof(CabException).Assembly); } return errorResources; } } public CabException(string message, Exception innerException) : this(0, 0, message, innerException) { } public CabException(string message) : this(0, 0, message, null) { } public CabException() : this(0, 0, null, null) { } internal CabException(int error, int errorCode, string message, Exception innerException) : base(message, innerException) { this.error = error; this.errorCode = errorCode; } internal CabException(int error, int errorCode, string message) : this(error, errorCode, message, null) { } protected CabException(SerializationInfo info, StreamingContext context) : base(info, context) { if (info == null) { throw new ArgumentNullException("info"); } error = info.GetInt32("cabError"); errorCode = info.GetInt32("cabErrorCode"); } [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)] public override void GetObjectData(SerializationInfo info, StreamingContext context) { if (info == null) { throw new ArgumentNullException("info"); } info.AddValue("cabError", error); info.AddValue("cabErrorCode", errorCode); ((Exception)this).GetObjectData(info, context); } internal static string GetErrorMessage(int error, int errorCode, bool extracting) { int num = (extracting ? 2000 : 1000); string text = ErrorResources.GetString(checked(num + error).ToString(CultureInfo.InvariantCulture.NumberFormat), CultureInfo.CurrentCulture); if (text == null) { text = ErrorResources.GetString(num.ToString(CultureInfo.InvariantCulture.NumberFormat), CultureInfo.CurrentCulture); } if (errorCode != 0) { string @string = ErrorResources.GetString("1", CultureInfo.CurrentCulture); text = string.Format(CultureInfo.InvariantCulture, "{0} " + @string, new object[2] { text, errorCode }); } return text; } } internal class CabUnpacker : CabWorker { private NativeMethods.FDI.Handle fdiHandle; private NativeMethods.FDI.PFNALLOC fdiAllocMemHandler; private NativeMethods.FDI.PFNFREE fdiFreeMemHandler; private NativeMethods.FDI.PFNOPEN fdiOpenStreamHandler; private NativeMethods.FDI.PFNREAD fdiReadStreamHandler; private NativeMethods.FDI.PFNWRITE fdiWriteStreamHandler; private NativeMethods.FDI.PFNCLOSE fdiCloseStreamHandler; private NativeMethods.FDI.PFNSEEK fdiSeekStreamHandler; private IUnpackStreamContext context; private List<ArchiveFileInfo> fileList; private int folderId; private Predicate<string> filter; [SecurityPermission(SecurityAction.Assert, UnmanagedCode = true)] public CabUnpacker(CabEngine cabEngine) : base(cabEngine) { fdiAllocMemHandler = base.CabAllocMem; fdiFreeMemHandler = base.CabFreeMem; fdiOpenStreamHandler = base.CabOpenStream; fdiReadStreamHandler = base.CabReadStream; fdiWriteStreamHandler = base.CabWriteStream; fdiCloseStreamHandler = base.CabCloseStream; fdiSeekStreamHandler = base.CabSeekStream; fdiHandle = NativeMethods.FDI.Create(fdiAllocMemHandler, fdiFreeMemHandler, fdiOpenStreamHandler, fdiReadStreamHandler, fdiWriteStreamHandler, fdiCloseStreamHandler, fdiSeekStreamHandler, 1, base.ErfHandle.AddrOfPinnedObject()); if (base.Erf.Error) { int oper = base.Erf.Oper; int type = base.Erf.Type; base.ErfHandle.Free(); throw new CabException(oper, type, CabException.GetErrorMessage(oper, type, extracting: true)); } } [SecurityPermission(SecurityAction.Assert, UnmanagedCode = true)] public bool IsArchive(Stream stream) { if (stream == null) { throw new ArgumentNullException("stream"); } lock (this) { short id; int cabFolderCount; int fileCount; return IsCabinet(stream, out id, out cabFolderCount, out fileCount); } } [SecurityPermission(SecurityAction.Assert, UnmanagedCode = true)] public IList<ArchiveFileInfo> GetFileInfo(IUnpackStreamContext streamContext, Predicate<string> fileFilter) { if (streamContext == null) { throw new ArgumentNullException("streamContext"); } lock (this) { context = streamContext; filter = fileFilter; base.NextCabinetName = string.Empty; fileList = new List<ArchiveFileInfo>(); bool flag = base.SuppressProgressEvents; base.SuppressProgressEvents = true; try { short num = 0; while (base.NextCabinetName != null) { base.Erf.Clear(); base.CabNumbers[base.NextCabinetName] = num; NativeMethods.FDI.Copy(fdiHandle, base.NextCabinetName, string.Empty, 0, CabListNotify, IntPtr.Zero, IntPtr.Zero); CheckError(extracting: true); num = checked((short)(num + 1)); } List<ArchiveFileInfo> list = fileList; fileList = null; return list.AsReadOnly(); } finally { base.SuppressProgressEvents = flag; if (base.CabStream != null) { context.CloseArchiveReadStream((int)currentArchiveNumber, currentArchiveName, base.CabStream); base.CabStream = null; } context = null; } } } [SecurityPermission(SecurityAction.Assert, UnmanagedCode = true)] public void Unpack(IUnpackStreamContext streamContext, Predicate<string> fileFilter) { checked { lock (this) { IList<ArchiveFileInfo> fileInfo = GetFileInfo(streamContext, fileFilter); ResetProgressData(); if (fileInfo != null) { totalFiles = fileInfo.Count; for (int i = 0; i < fileInfo.Count; i++) { totalFileBytes += fileInfo[i].Length; if (fileInfo[i].ArchiveNumber >= totalArchives) { int num = fileInfo[i].ArchiveNumber + 1; totalArchives = (short)num; } } } context = streamContext; fileList = null; base.NextCabinetName = string.Empty; folderId = -1; currentFileNumber = -1; try { short num2 = 0; while (base.NextCabinetName != null) { base.Erf.Clear(); base.CabNumbers[base.NextCabinetName] = num2; NativeMethods.FDI.Copy(fdiHandle, base.NextCabinetName, string.Empty, 0, CabExtractNotify, IntPtr.Zero, IntPtr.Zero); CheckError(extracting: true); num2++; } } finally { if (base.CabStream != null) { context.CloseArchiveReadStream(unchecked((int)currentArchiveNumber), currentArchiveName, base.CabStream); base.CabStream = null; } if (base.FileStream != null) { context.CloseFileWriteStream(currentFileName, base.FileStream, FileAttributes.Normal, DateTime.Now); base.FileStream = null; } context = null; } } } } internal override int CabOpenStreamEx(string path, int openFlags, int shareMode, out int err, IntPtr pv) { if (base.CabNumbers.ContainsKey(path)) { Stream stream = base.CabStream; if (stream == null) { short num = base.CabNumbers[path]; stream = context.OpenArchiveReadStream((int)num, path, (CompressionEngine)(object)base.CabEngine); if (stream == null) { throw new FileNotFoundException(string.Format(CultureInfo.InvariantCulture, "Cabinet {0} not provided.", new object[1] { num })); } currentArchiveName = path; currentArchiveNumber = num; checked { if (totalArchives <= currentArchiveNumber) { int num2 = currentArchiveNumber + 1; totalArchives = (short)num2; } currentArchiveTotalBytes = stream.Length; currentArchiveBytesProcessed = 0L; if (folderId != -3) { OnProgress((ArchiveProgressType)3); } base.CabStream = stream; } } path = "%%CAB%%"; } return base.CabOpenStreamEx(path, openFlags, shareMode, out err, pv); } internal override int CabReadStreamEx(int streamHandle, IntPtr memory, int cb, out int err, IntPtr pv) { int result = base.CabReadStreamEx(streamHandle, memory, cb, out err, pv); checked { if (err == 0 && base.CabStream != null && fileList == null && DuplicateStream.OriginalStream(base.StreamHandles[streamHandle]) == DuplicateStream.OriginalStream(base.CabStream)) { currentArchiveBytesProcessed += cb; if (currentArchiveBytesProcessed > currentArchiveTotalBytes) { currentArchiveBytesProcessed = currentArchiveTotalBytes; } } return result; } } internal override int CabWriteStreamEx(int streamHandle, IntPtr memory, int cb, out int err, IntPtr pv) { int num = base.CabWriteStreamEx(streamHandle, memory, cb, out err, pv); checked { if (num > 0 && err == 0) { currentFileBytesProcessed += cb; fileBytesProcessed += cb; OnProgress((ArchiveProgressType)1); } return num; } } internal override int CabCloseStreamEx(int streamHandle, out int err, IntPtr pv) { Stream stream = DuplicateStream.OriginalStream(base.StreamHandles[streamHandle]); if (stream == DuplicateStream.OriginalStream(base.CabStream)) { if (folderId != -3) { OnProgress((ArchiveProgressType)5); } context.CloseArchiveReadStream((int)currentArchiveNumber, currentArchiveName, stream); currentArchiveName = base.NextCabinetName; currentArchiveBytesProcessed = (currentArchiveTotalBytes = 0L); base.CabStream = null; } return base.CabCloseStreamEx(streamHandle, out err, pv); } protected override void Dispose(bool disposing) { try { if (disposing && fdiHandle != null) { fdiHandle.Dispose(); fdiHandle = null; } } finally { base.Dispose(disposing); } } private static string GetFileName(NativeMethods.FDI.NOTIFICATION notification) { Encoding encoding = ((((uint)notification.attribs & 0x80u) != 0) ? Encoding.UTF8 : Encoding.Default); int i; for (i = 0; Marshal.ReadByte(notification.psz1, i) != 0; i = checked(i + 1)) { } byte[] array = new byte[i]; Marshal.Copy(notification.psz1, array, 0, i); string text = encoding.GetString(array); if (Path.IsPathRooted(text)) { text = text.Replace(Path.VolumeSeparatorChar.ToString() ?? "", ""); } return text; } private bool IsCabinet(Stream cabStream, out short id, out int cabFolderCount, out int fileCount) { int num = base.StreamHandles.AllocHandle(cabStream); try { base.Erf.Clear(); NativeMethods.FDI.CABINFO pfdici; bool result = NativeMethods.FDI.IsCabinet(fdiHandle, num, out pfdici) != 0; if (base.Erf.Error) { if (base.Erf.Oper != 3) { throw new CabException(base.Erf.Oper, base.Erf.Type, CabException.GetErrorMessage(base.Erf.Oper, base.Erf.Type, extracting: true)); } result = false; } id = pfdici.setID; cabFolderCount = pfdici.cFolders; fileCount = pfdici.cFiles; return result; } finally { base.StreamHandles.FreeHandle(num); } } private int CabListNotify(NativeMethods.FDI.NOTIFICATIONTYPE notificationType, NativeMethods.FDI.NOTIFICATION notification) { checked { switch (notificationType) { case NativeMethods.FDI.NOTIFICATIONTYPE.CABINET_INFO: { string text = Marshal.PtrToStringAnsi(notification.psz1); base.NextCabinetName = ((text.Length != 0) ? text : null); return 0; } case NativeMethods.FDI.NOTIFICATIONTYPE.PARTIAL_FILE: return 0; case NativeMethods.FDI.NOTIFICATIONTYPE.COPY_FILE: { string fileName = GetFileName(notification); if ((filter == null || filter(fileName)) && fileList != null) { FileAttributes fileAttributes = unchecked((FileAttributes)(notification.attribs & 0x27)); if (fileAttributes == (FileAttributes)0) { fileAttributes = FileAttributes.Normal; } DateTime lastWriteTime = default(DateTime); CompressionEngine.DosDateAndTimeToDateTime(notification.date, notification.time, ref lastWriteTime); long length = notification.cb; CabFileInfo item = new CabFileInfo(fileName, notification.iFolder, notification.iCabinet, fileAttributes, lastWriteTime, length); fileList.Add((ArchiveFileInfo)(object)item); currentFileNumber = fileList.Count - 1; fileBytesProcessed += notification.cb; } totalFiles++; totalFileBytes += notification.cb; return 0; } default: return 0; } } } private int CabExtractNotify(NativeMethods.FDI.NOTIFICATIONTYPE notificationType, NativeMethods.FDI.NOTIFICATION notification) { switch (notificationType) { case NativeMethods.FDI.NOTIFICATIONTYPE.CABINET_INFO: if (base.NextCabinetName != null && base.NextCabinetName.StartsWith("?", StringComparison.Ordinal)) { base.NextCabinetName = base.NextCabinetName.Substring(1); } else { string text = Marshal.PtrToStringAnsi(notification.psz1); base.NextCabinetName = ((text.Length != 0) ? text : null); } return 0; case NativeMethods.FDI.NOTIFICATIONTYPE.NEXT_CABINET: { string key = Marshal.PtrToStringAnsi(notification.psz1); base.CabNumbers[key] = notification.iCabinet; base.NextCabinetName = "?" + base.NextCabinetName; return 0; } case NativeMethods.FDI.NOTIFICATIONTYPE.COPY_FILE: return CabExtractCopyFile(notification); case NativeMethods.FDI.NOTIFICATIONTYPE.CLOSE_FILE_INFO: return CabExtractCloseFile(notification); default: return 0; } } private int CabExtractCopyFile(NativeMethods.FDI.NOTIFICATION notification) { checked { if (notification.iFolder != folderId) { if (notification.iFolder != -3 && folderId != -1) { currentFolderNumber++; } folderId = notification.iFolder; } string fileName = GetFileName(notification); if (filter == null || filter(fileName)) { currentFileNumber++; currentFileName = fileName; currentFileBytesProcessed = 0L; currentFileTotalBytes = notification.cb; OnProgress((ArchiveProgressType)0); DateTime dateTime = default(DateTime); CompressionEngine.DosDateAndTimeToDateTime(notification.date, notification.time, ref dateTime); Stream stream = context.OpenFileWriteStream(fileName, unchecked((long)notification.cb), dateTime); if (stream != null) { base.FileStream = stream; return base.StreamHandles.AllocHandle(stream); } fileBytesProcessed += notification.cb; OnProgress((ArchiveProgressType)2); currentFileName = null; } return 0; } } private int CabExtractCloseFile(NativeMethods.FDI.NOTIFICATION notification) { Stream stream = base.StreamHandles[notification.hf]; base.StreamHandles.FreeHandle(notification.hf); string fileName = GetFileName(notification); FileAttributes fileAttributes = (FileAttributes)(notification.attribs & 0x27); if (fileAttributes == (FileAttributes)0) { fileAttributes = FileAttributes.Normal; } DateTime dateTime = default(DateTime); CompressionEngine.DosDateAndTimeToDateTime(notification.date, notification.time, ref dateTime); stream.Flush(); context.CloseFileWriteStream(fileName, stream, fileAttributes, dateTime); base.FileStream = null; checked { long num = currentFileTotalBytes - currentFileBytesProcessed; currentFileBytesProcessed += num; fileBytesProcessed += num; OnProgress((ArchiveProgressType)2); currentFileName = null; return 1; } } } [Serializable] public class CabFileInfo : ArchiveFileInfo { private int cabFolder; public CabInfo Cabinet => (CabInfo)(object)((ArchiveFileInfo)this).Archive; public string CabinetName => ((ArchiveFileInfo)this).ArchiveName; public int CabinetFolderNumber { get { if (cabFolder < 0) { ((ArchiveFileInfo)this).Refresh(); } return cabFolder; } } public CabFileInfo(CabInfo cabinetInfo, string filePath) : base((ArchiveInfo)(object)cabinetInfo, filePath) { if (cabinetInfo == null) { throw new ArgumentNullException("cabinetInfo"); } cabFolder = -1; } internal CabFileInfo(string filePath, int cabFolder, int cabNumber, FileAttributes attributes, DateTime lastWriteTime, long length) : base(filePath, cabNumber, attributes, lastWriteTime, length) { this.cabFolder = cabFolder; } protected CabFileInfo(SerializationInfo info, StreamingContext context) : base(info, context) { cabFolder = info.GetInt32("cabFolder"); } [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)] public override void GetObjectData(SerializationInfo info, StreamingContext context) { ((ArchiveFileInfo)this).GetObjectData(info, context); info.AddValue("cabFolder", cabFolder); } protected override void Refresh(ArchiveFileInfo newFileInfo) { ((ArchiveFileInfo)this).Refresh(newFileInfo); cabFolder = ((CabFileInfo)(object)newFileInfo).cabFolder; } } [Serializable] public class CabInfo : ArchiveInfo { public CabInfo(string path) : base(path) { } protected CabInfo(SerializationInfo info, StreamingContext context) : base(info, context) { } protected override CompressionEngine CreateCompressionEngine() { return (CompressionEngine)(object)new CabEngine(); } public IList<CabFileInfo> GetFiles() { IList<ArchiveFileInfo> files = ((ArchiveInfo)this).GetFiles(); List<CabFileInfo> list = new List<CabFileInfo>(files.Count); foreach (CabFileInfo item in files) { list.Add(item); } return list.AsReadOnly(); } public IList<CabFileInfo> GetFiles(string searchPattern) { IList<ArchiveFileInfo> files = ((ArchiveInfo)this).GetFiles(searchPattern); List<CabFileInfo> list = new List<CabFileInfo>(files.Count); foreach (CabFileInfo item in files) { list.Add(item); } return list.AsReadOnly(); } } internal sealed class HandleManager<T> where T : class { private List<T> handles; public T this[int handle] { get { if (handle > 0 && handle <= handles.Count) { return handles[checked(handle - 1)]; } return null; } } public HandleManager() { handles = new List<T>(); } public int AllocHandle(T obj) { handles.Add(obj); return handles.Count; } public void FreeHandle(int handle) { if (handle > 0 && handle <= handles.Count) { handles[checked(handle - 1)] = null; } } } internal static class NativeMethods { internal static class FCI { [UnmanagedFunctionPointer(CallingConvention.Cdecl)] internal delegate IntPtr PFNALLOC(int cb); [UnmanagedFunctionPointer(CallingConvention.Cdecl)] internal delegate void PFNFREE(IntPtr pv); [UnmanagedFunctionPointer(CallingConvention.Cdecl)] internal delegate int PFNOPEN(string path, int oflag, int pmode, out int err, IntPtr pv); [UnmanagedFunctionPointer(CallingConvention.Cdecl)] internal delegate int PFNREAD(int fileHandle, IntPtr memory, int cb, out int err, IntPtr pv); [UnmanagedFunctionPointer(CallingConvention.Cdecl)] internal delegate int PFNWRITE(int fileHandle, IntPtr memory, int cb, out int err, IntPtr pv); [UnmanagedFunctionPointer(CallingConvention.Cdecl)] internal delegate int PFNCLOSE(int fileHandle, out int err, IntPtr pv); [UnmanagedFunctionPointer(CallingConvention.Cdecl)] internal delegate int PFNSEEK(int fileHandle, int dist, int seekType, out int err, IntPtr pv); [UnmanagedFunctionPointer(CallingConvention.Cdecl)] internal delegate int PFNDELETE(string path, out int err, IntPtr pv); [UnmanagedFunctionPointer(CallingConvention.Cdecl)] internal delegate int PFNGETNEXTCABINET(IntPtr pccab, uint cbPrevCab, IntPtr pv); [UnmanagedFunctionPointer(CallingConvention.Cdecl)] internal delegate int PFNFILEPLACED(IntPtr pccab, string path, long fileSize, int continuation, IntPtr pv); [UnmanagedFunctionPointer(CallingConvention.Cdecl)] internal delegate int PFNGETOPENINFO(string path, out short date, out short time, out short pattribs, out int err, IntPtr pv); [UnmanagedFunctionPointer(CallingConvention.Cdecl)] internal delegate int PFNSTATUS(STATUS typeStatus, uint cb1, uint cb2, IntPtr pv); [UnmanagedFunctionPointer(CallingConvention.Cdecl)] internal delegate int PFNGETTEMPFILE(IntPtr tempNamePtr, int tempNameSize, IntPtr pv); internal enum ERROR { NONE, OPEN_SRC, READ_SRC, ALLOC_FAIL, TEMP_FILE, BAD_COMPR_TYPE, CAB_FILE, USER_ABORT, MCI_FAIL } internal enum TCOMP : ushort { MASK_TYPE = 15, TYPE_NONE = 0, TYPE_MSZIP = 1, TYPE_QUANTUM = 2, TYPE_LZX = 3, BAD = 15, MASK_LZX_WINDOW = 7936, LZX_WINDOW_LO = 3840, LZX_WINDOW_HI = 5376, SHIFT_LZX_WINDOW = 8, MASK_QUANTUM_LEVEL = 240, QUANTUM_LEVEL_LO = 16, QUANTUM_LEVEL_HI = 112, SHIFT_QUANTUM_LEVEL = 4, MASK_QUANTUM_MEM = 7936, QUANTUM_MEM_LO = 2560, QUANTUM_MEM_HI = 5376, SHIFT_QUANTUM_MEM = 8, MASK_RESERVED = 57344 } internal enum STATUS : uint { FILE, FOLDER, CABINET } [StructLayout(LayoutKind.Sequential)] internal class CCAB { internal int cb = int.MaxValue; internal int cbFolderThresh = 2147450880; internal int cbReserveCFHeader; internal int cbReserveCFFolder; internal int cbReserveCFData; internal int iCab; internal int iDisk; internal int fFailOnIncompressible; internal short setID; [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)] internal string szDisk = string.Empty; [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)] internal string szCab = string.Empty; [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)] internal string szCabPath = string.Empty; } internal class Handle : SafeHandle { public override bool IsInvalid => handle == IntPtr.Zero; internal Handle() : base(IntPtr.Zero, ownsHandle: true) { } [SecurityPermission(SecurityAction.Assert, UnmanagedCode = true)] protected override bool ReleaseHandle() { return Destroy(handle); } } internal const int MIN_DISK = 32768; internal const int MAX_DISK = int.MaxValue; internal const int MAX_FOLDER = 2147450880; internal const int MAX_FILENAME = 256; internal const int MAX_CABINET_NAME = 256; internal const int MAX_CAB_PATH = 256; internal const int MAX_DISK_NAME = 256; internal const int CPU_80386 = 1; [DllImport("cabinet.dll", BestFitMapping = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, EntryPoint = "FCICreate", ThrowOnUnmappableChar = true)] internal static extern Handle Create(IntPtr perf, PFNFILEPLACED pfnfcifp, PFNALLOC pfna, PFNFREE pfnf, PFNOPEN pfnopen, PFNREAD pfnread, PFNWRITE pfnwrite, PFNCLOSE pfnclose, PFNSEEK pfnseek, PFNDELETE pfndelete, PFNGETTEMPFILE pfnfcigtf, [MarshalAs(UnmanagedType.LPStruct)] CCAB pccab, IntPtr pv); [DllImport("cabinet.dll", BestFitMapping = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, EntryPoint = "FCIAddFile", ThrowOnUnmappableChar = true)] internal static extern int AddFile(Handle hfci, string pszSourceFile, IntPtr pszFileName, [MarshalAs(UnmanagedType.Bool)] bool fExecute, PFNGETNEXTCABINET pfnfcignc, PFNSTATUS pfnfcis, PFNGETOPENINFO pfnfcigoi, TCOMP typeCompress); [DllImport("cabinet.dll", BestFitMapping = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, EntryPoint = "FCIFlushCabinet", ThrowOnUnmappableChar = true)] internal static extern int FlushCabinet(Handle hfci, [MarshalAs(UnmanagedType.Bool)] bool fGetNextCab, PFNGETNEXTCABINET pfnfcignc, PFNSTATUS pfnfcis); [DllImport("cabinet.dll", BestFitMapping = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, EntryPoint = "FCIFlushFolder", ThrowOnUnmappableChar = true)] internal static extern int FlushFolder(Handle hfci, PFNGETNEXTCABINET pfnfcignc, PFNSTATUS pfnfcis); [DllImport("cabinet.dll", BestFitMapping = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, EntryPoint = "FCIDestroy", ThrowOnUnmappableChar = true)] [SuppressUnmanagedCodeSecurity] [return: MarshalAs(UnmanagedType.Bool)] internal static extern bool Destroy(IntPtr hfci); } internal static class FDI { [UnmanagedFunctionPointer(CallingConvention.Cdecl)] internal delegate IntPtr PFNALLOC(int cb); [UnmanagedFunctionPointer(CallingConvention.Cdecl)] internal delegate void PFNFREE(IntPtr pv); [UnmanagedFunctionPointer(CallingConvention.Cdecl)] internal delegate int PFNOPEN(string path, int oflag, int pmode); [UnmanagedFunctionPointer(CallingConvention.Cdecl)] internal delegate int PFNREAD(int hf, IntPtr pv, int cb); [UnmanagedFunctionPointer(CallingConvention.Cdecl)] internal delegate int PFNWRITE(int hf, IntPtr pv, int cb); [UnmanagedFunctionPointer(CallingConvention.Cdecl)] internal delegate int PFNCLOSE(int hf); [UnmanagedFunctionPointer(CallingConvention.Cdecl)] internal delegate int PFNSEEK(int hf, int dist, int seektype); [UnmanagedFunctionPointer(CallingConvention.Cdecl)] internal delegate int PFNNOTIFY(NOTIFICATIONTYPE fdint, NOTIFICATION fdin); internal enum ERROR { NONE, CABINET_NOT_FOUND, NOT_A_CABINET, UNKNOWN_CABINET_VERSION, CORRUPT_CABINET, ALLOC_FAIL, BAD_COMPR_TYPE, MDI_FAIL, TARGET_FILE, RESERVE_MISMATCH, WRONG_CABINET, USER_ABORT } internal enum NOTIFICATIONTYPE { CABINET_INFO, PARTIAL_FILE, COPY_FILE, CLOSE_FILE_INFO, NEXT_CABINET, ENUMERATE } internal struct CABINFO { internal int cbCabinet; internal short cFolders; internal short cFiles; internal short setID; internal short iCabinet; internal int fReserve; internal int hasprev; internal int hasnext; } [StructLayout(LayoutKind.Sequential)] internal class NOTIFICATION { internal int cb; internal IntPtr psz1; internal IntPtr psz2; internal IntPtr psz3; internal IntPtr pv; internal IntPtr hf_ptr; internal short date; internal short time; internal short attribs; internal short setID; internal short iCabinet; internal short iFolder; internal int fdie; internal int hf => (int)hf_ptr; } internal class Handle : SafeHandle { public override bool IsInvalid => handle == IntPtr.Zero; internal Handle() : base(IntPtr.Zero, ownsHandle: true) { } protected override bool ReleaseHandle() { return Destroy(handle); } } internal const int MAX_DISK = int.MaxValue; internal const int MAX_FILENAME = 256; internal const int MAX_CABINET_NAME = 256; internal const int MAX_CAB_PATH = 256; internal const int MAX_DISK_NAME = 256; internal const int CPU_80386 = 1; [DllImport("cabinet.dll", BestFitMapping = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, EntryPoint = "FDICreate", ThrowOnUnmappableChar = true)] internal static extern Handle Create([MarshalAs(UnmanagedType.FunctionPtr)] PFNALLOC pfnalloc, [MarshalAs(UnmanagedType.FunctionPtr)] PFNFREE pfnfree, PFNOPEN pfnopen, PFNREAD pfnread, PFNWRITE pfnwrite, PFNCLOSE pfnclose, PFNSEEK pfnseek, int cpuType, IntPtr perf); [DllImport("cabinet.dll", BestFitMapping = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, EntryPoint = "FDICopy", ThrowOnUnmappableChar = true)] internal static extern int Copy(Handle hfdi, string pszCabinet, string pszCabPath, int flags, PFNNOTIFY pfnfdin, IntPtr pfnfdid, IntPtr pvUser); [DllImport("cabinet.dll", BestFitMapping = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, EntryPoint = "FDIDestroy", ThrowOnUnmappableChar = true)] [SuppressUnmanagedCodeSecurity] [return: MarshalAs(UnmanagedType.Bool)] internal static extern bool Destroy(IntPtr hfdi); [DllImport("cabinet.dll", BestFitMapping = false, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, EntryPoint = "FDIIsCabinet", ThrowOnUnmappableChar = true)] internal static extern int IsCabinet(Handle hfdi, int hf, out CABINFO pfdici); } [StructLayout(LayoutKind.Sequential)] internal class ERF { private int erfOper; private int erfType; private int fError; internal int Oper { get { return erfOper; } set { erfOper = value; } } internal int Type { get { return erfType; } set { erfType = value; } } internal bool Error { get { return fError != 0; } set { fError = (value ? 1 : 0); } } internal void Clear() { Oper = 0; Type = 0; Error = false; } } } }

Lethal Company

FixPluginTypesSerialization

Details

Categories

BepInEx/patchers/FixPluginTypesSerialization/FixPluginTypesSerialization.dll

BepInEx/patchers/FixPluginTypesSerialization/Microsoft.Deployment.Compression.Cab.dll

BepInEx/patchers/FixPluginTypesSerialization/Microsoft.Deployment.Compression.dll

Categories

BepInEx/patchers/FixPluginTypesSerialization/FixPluginTypesSerialization.dll

BepInEx/patchers/FixPluginTypesSerialization/Microsoft.Deployment.Compression.Cab.dll

BepInEx/patchers/FixPluginTypesSerialization/Microsoft.Deployment.Compression.dll

Categories