using System;
using System.Collections;
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.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using BepInEx.Unity.IL2CPP.Hook;
using BepInEx.Unity.IL2CPP.Utils;
using Clonesoft.Json;
using Clonesoft.Json.Converters;
using Clonesoft.Json.Serialization;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.Runtime;
using Il2CppSystem;
using Il2CppSystem.Reflection;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using SemanticVersioning;
using TheArchive.Core;
using TheArchive.Core.Attributes;
using TheArchive.Core.Attributes.Feature;
using TheArchive.Core.Attributes.Feature.Settings;
using TheArchive.Core.Bootstrap;
using TheArchive.Core.Discord;
using TheArchive.Core.Exceptions;
using TheArchive.Core.FeaturesAPI;
using TheArchive.Core.FeaturesAPI.Components;
using TheArchive.Core.FeaturesAPI.Settings;
using TheArchive.Core.Localization;
using TheArchive.Core.Managers;
using TheArchive.Core.Models;
using TheArchive.Core.ModulesAPI;
using TheArchive.Core.Settings;
using TheArchive.Interfaces;
using TheArchive.Loader;
using TheArchive.Utilities;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("TheArchive.IL2CPP")]
[assembly: InternalsVisibleTo("TheArchive.MONO")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("7bb66dc5-d29d-4cdd-bb82-d228abe35bda")]
[assembly: AssemblyFileVersion("0.0.656")]
[assembly: AssemblyInformationalVersion("0.0.656-main+9e73217")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("TheArchive.Core")]
[assembly: AssemblyConfiguration("R_BIE")]
[assembly: AssemblyProduct("TheArchive.Core")]
[assembly: AssemblyTitle("TheArchive.Core")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.656.0")]
[module: UnverifiableCode]
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 NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
}
internal class ThisAssembly
{
	public class Git
	{
		public class BaseVersion
		{
			public const string Major = "0";

			public const string Minor = "0";

			public const string Patch = "0";
		}

		public class SemVer
		{
			public const string Major = "0";

			public const string Minor = "0";

			public const string Patch = "656";

			public const string Label = "";

			public const string DashLabel = "";

			public const string Source = "Default";
		}

		public const bool IsDirty = false;

		public const string IsDirtyString = "false";

		public const string RepositoryUrl = "https://github.com/Tuesday1028/GTFO_TheArchive";

		public const string Branch = "main";

		public const string Commit = "9e73217";

		public const string Sha = "9e732175a6a125ba6d9be550e3bfc3f775f3bf88";

		public const string CommitDate = "2025-02-12T10:45:59+08:00";

		public const string Commits = "656";

		public const string Tag = "";

		public const string BaseTag = "";
	}
}
namespace TheArchive
{
	public static class ArchiveMod
	{
		public const string GUID = "dev.AuriRex.gtfo.TheArchive";

		public const string MOD_NAME = "TheArchive";

		public const string ABBREVIATION = "Ar";

		public const string AUTHOR = "AuriRex";

		public const string VERSION_STRING = "0.0.656";

		public const string GITHUB_REPOSITORY_NAME = "GTFO_TheArchive";

		public const string GITHUB_OWNER_NAME = "AuriRex";

		public const string GITHUB_LINK = "https://github.com/AuriRex/GTFO_TheArchive";

		public static readonly bool GIT_IS_DIRTY = false;

		public const string GIT_COMMIT_SHORT_HASH = "9e73217";

		public const string GIT_COMMIT_DATE = "2025-02-12T10:45:59+08:00";

		public const string GIT_BASE_TAG = "";

		public const uint GTFO_STEAM_APPID = 493520u;

		public const string MTFO_GUID = "com.dak.MTFO";

		public const string ARCHIVE_CORE_FEATURE_GROUP = "Archive Core";

		public static readonly string CORE_PATH = Assembly.GetAssembly(typeof(ArchiveMod)).Location;

		private static JsonSerializerSettings _jsonSerializerSettings = null;

		private static string _currentlySelectedRundownKey = string.Empty;

		private static IArchiveModule _mainModule;

		private static readonly HashSet<Assembly> _inspectedAssemblies = new HashSet<Assembly>();

		private static readonly HashSet<Type> _typesToInitOnDataBlocksReady = new HashSet<Type>();

		private static readonly HashSet<Type> _typesToInitOnGameDataInit = new HashSet<Type>();

		private static readonly HashSet<IInitializable> _iinitializablesToInjectOnGameDataInit = new HashSet<IInitializable>();

		private static readonly HashSet<Assembly> _moduleAssemblies = new HashSet<Assembly>();

		private static readonly List<Type> _moduleTypes = new List<Type>();

		private const string kArchiveSettingsFile = "TheArchive_Settings.json";

		private static Harmony _harmonyInstance;

		public static ArchiveSettings Settings { get; private set; } = new ArchiveSettings();


		public static JsonSerializerSettings JsonSerializerSettings
		{
			get
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Expected O, but got Unknown
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Expected O, but got Unknown
				if (_jsonSerializerSettings == null)
				{
					_jsonSerializerSettings = new JsonSerializerSettings
					{
						Formatting = (Formatting)1
					};
					_jsonSerializerSettings.Converters.Add((JsonConverter)new StringEnumConverter());
					_jsonSerializerSettings.ContractResolver = (IContractResolver)(object)ArchiveContractResolver.Instance;
				}
				return _jsonSerializerSettings;
			}
		}

		public static bool IsPlayingModded { get; private set; } = false;


		public static Utils.RundownID CurrentRundown { get; private set; } = Utils.RundownID.RundownUnitialized;


		public static GameBuildInfo CurrentBuildInfo { get; private set; }

		public static int CurrentGameState { get; private set; }

		public static bool IsOnALTBuild { get; private set; }

		public static bool IsInitialized { get; private set; } = false;


		public static string CurrentlySelectedRundownKey
		{
			get
			{
				return _currentlySelectedRundownKey;
			}
			internal set
			{
				_currentlySelectedRundownKey = value;
				ArchiveLogger.Debug($"Setting {"CurrentlySelectedRundownKey"} to \"{_currentlySelectedRundownKey}\".");
				if (string.IsNullOrEmpty(_currentlySelectedRundownKey))
				{
					CurrentlySelectedRundownPersistentID = 0u;
					return;
				}
				try
				{
					CurrentlySelectedRundownPersistentID = uint.Parse(_currentlySelectedRundownKey.Replace("Local_", ""));
				}
				catch (Exception ex)
				{
					ArchiveLogger.Error($"Failed to parse selected rundown persistentId from {"CurrentlySelectedRundownKey"} \"{CurrentlySelectedRundownKey}\"!");
					ArchiveLogger.Exception(ex);
				}
			}
		}

		public static uint CurrentlySelectedRundownPersistentID { get; set; } = 0u;


		public static HashSet<IArchiveModule> Modules { get; private set; } = new HashSet<IArchiveModule>();


		public static Type IL2CPP_BaseType { get; private set; } = null;


		public static event Action<Utils.RundownID> GameDataInitialized;

		public static event Action DataBlocksReady;

		public static event Action<int> GameStateChanged;

		public static event Action<bool> ApplicationFocusStateChanged;

		internal static event Action<IArchiveModule> OnNewModuleRegistered;

		internal static void OnApplicationStart(IArchiveLogger logger, Harmony harmonyInstance)
		{
			ArchiveLogger.logger = logger;
			_harmonyInstance = harmonyInstance;
			if (GIT_IS_DIRTY)
			{
				ArchiveLogger.Warning("Git is dirty, this is a development build!");
			}
			try
			{
				if (LoaderWrapper.IsGameIL2CPP())
				{
					IL2CPP_BaseType = ImplementationManager.FindTypeInCurrentAppDomain("Il2CppSystem.Object", exactMatch: true);
					ArchiveLogger.Debug("IL2CPP_BaseType: " + IL2CPP_BaseType?.FullName);
					if (IL2CPP_BaseType == null)
					{
						throw new Exception();
					}
				}
			}
			catch (Exception ex)
			{
				ArchiveLogger.Error("IL2CPP base type \"Il2CppSystem.Object\" could not be resolved!");
				ArchiveLogger.Exception(ex);
			}
			LoadConfig();
			if (LoaderWrapper.IsModInstalled("com.dak.MTFO"))
			{
				IsPlayingModded = true;
			}
			GTFOLogger.Logger = LoaderWrapper.CreateLoggerInstance("GTFO-Internals", ConsoleColor.DarkGray);
			CurrentRundown = BuildDB.GetCurrentRundownID(BuildDB.BuildNumber);
			ArchiveLogger.Msg(ConsoleColor.DarkMagenta, $"Current game revision determined to be {BuildDB.BuildNumber}! ({CurrentRundown})");
			GameBuildInfo currentBuildInfo = default(GameBuildInfo);
			currentBuildInfo.BuildNumber = BuildDB.BuildNumber;
			currentBuildInfo.Rundown = CurrentRundown;
			CurrentBuildInfo = currentBuildInfo;
			IsOnALTBuild = CurrentRundown.IsIncludedIn(Utils.RundownFlags.RundownAltOne.ToLatest());
			string path = Path.Combine(LoaderWrapper.GameDirectory, "steam_appid.txt");
			if (!File.Exists(path))
			{
				ArchiveLogger.Notice("Creating \"steam_appid.txt\" in GTFO folder ...");
				File.WriteAllText(path, $"{493520}");
			}
			FeatureManager.Internal_Init();
			try
			{
				_mainModule = CreateAndInitModule(LoadMainArchiveModule(LoaderWrapper.IsGameIL2CPP()).GetTypes().First((Type t) => typeof(IArchiveModule).IsAssignableFrom(t)));
			}
			catch (ReflectionTypeLoadException ex2)
			{
				ArchiveLogger.Error("Failed loading main module!!");
				ArchiveLogger.Exception(ex2);
				ArchiveLogger.Notice($"Loader Exceptions ({ex2.LoaderExceptions.Length}):");
				Exception[] loaderExceptions = ex2.LoaderExceptions;
				foreach (Exception obj in loaderExceptions)
				{
					ArchiveLogger.Warning(obj.Message);
					ArchiveLogger.Debug(obj.StackTrace);
				}
				ArchiveLogger.Info("-------------");
			}
			InitializeArchiveModuleChainloader();
			try
			{
				ApplyPatches(CurrentRundown);
			}
			catch (Exception ex3)
			{
				ArchiveLogger.Exception(ex3);
			}
		}

		internal static void OnApplicationQuit()
		{
			InitSingletonBase<FeatureManager>.Instance.OnApplicationQuit();
			CustomSettingsManager.OnApplicationQuit();
		}

		private static void LoadConfig()
		{
			LoadConfig(Path.Combine(LocalFiles.ModLocalLowPath, "TheArchive_Settings.json"));
		}

		private static void LoadConfig(string path)
		{
			try
			{
				ArchiveLogger.Info("Loading config file ... [" + path + "]");
				if (File.Exists(path))
				{
					Settings = JsonConvert.DeserializeObject<ArchiveSettings>(File.ReadAllText(path), JsonSerializerSettings);
				}
				SaveConfig(path);
			}
			catch (Exception ex)
			{
				ArchiveLogger.Exception(ex);
			}
		}

		private static void SaveConfig(string path)
		{
			ArchiveLogger.Debug("Saving config file ... [" + path + "]");
			File.WriteAllText(path, JsonConvert.SerializeObject((object)Settings, JsonSerializerSettings));
		}

		public static bool RegisterArchiveModule(Assembly asm)
		{
			foreach (Type item in from t in asm.GetTypes()
				where typeof(IArchiveModule).IsAssignableFrom(t)
				select t)
			{
				if (RegisterArchiveModule(item))
				{
					return true;
				}
			}
			return false;
		}

		public static bool RegisterArchiveModule(Type moduleType)
		{
			if (moduleType == null)
			{
				throw new ArgumentException("Module can't be null!");
			}
			if (_moduleTypes.Contains(moduleType))
			{
				throw new ArgumentException("Module \"" + moduleType.Name + "\" is already registered!");
			}
			if (!typeof(IArchiveModule).IsAssignableFrom(moduleType))
			{
				throw new ArgumentException($"Type \"{moduleType.Name}\" does not implement {"IArchiveModule"}!");
			}
			IArchiveModule archiveModule = CreateAndInitModule(moduleType);
			ArchiveMod.OnNewModuleRegistered?.Invoke(archiveModule);
			if (CurrentRundown != Utils.RundownID.RundownUnitialized)
			{
				archiveModule.Patcher?.PatchRundownSpecificMethods(archiveModule.GetType().Assembly);
				return true;
			}
			return false;
		}

		internal static void InitializeArchiveModuleChainloader()
		{
			((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Finished += delegate
			{
				ArchiveModuleChainloader.Initialize();
			};
		}

		internal static void InvokeGameDataInitialized()
		{
			if (IsInitialized)
			{
				ArchiveLogger.Info("Reload triggered, skipping init.");
				return;
			}
			IsInitialized = true;
			ArchiveLogger.Info("GameData has been initialized, invoking event.");
			try
			{
				PresenceFormatter.Setup();
			}
			catch (Exception ex)
			{
				ArchiveLogger.Exception(ex);
			}
			foreach (Type item in _typesToInitOnGameDataInit)
			{
				IInitializable initializable = null;
				try
				{
					InitInitializables(item, out initializable);
				}
				catch (Exception ex2)
				{
					ArchiveLogger.Error("Trying to Init \"" + item.FullName + "\" threw an exception:");
					ArchiveLogger.Exception(ex2);
				}
				try
				{
					InjectInstanceIntoModules(initializable);
				}
				catch (Exception ex3)
				{
					ArchiveLogger.Error("Trying to Inject \"" + item.FullName + "\" threw an exception:");
					ArchiveLogger.Exception(ex3);
				}
			}
			foreach (IInitializable item2 in _iinitializablesToInjectOnGameDataInit)
			{
				try
				{
					InjectInstanceIntoModules(item2);
				}
				catch (Exception ex4)
				{
					ArchiveLogger.Error("Trying to Inject \"" + item2.GetType().FullName + "\" threw an exception:");
					ArchiveLogger.Exception(ex4);
				}
			}
			InitSingletonBase<FeatureManager>.Instance.OnGameDataInitialized();
			ArchiveMod.GameDataInitialized?.Invoke(CurrentRundown);
		}

		internal static void InvokeDataBlocksReady()
		{
			try
			{
				DataBlockManager.Setup();
			}
			catch (Exception ex)
			{
				ArchiveLogger.Exception(ex);
			}
			ArchiveLogger.Info("DataBlocks should be ready to be interacted with, invoking event.");
			foreach (Type item in _typesToInitOnDataBlocksReady)
			{
				IInitializable initializable = null;
				try
				{
					InitInitializables(item, out initializable);
				}
				catch (Exception ex2)
				{
					ArchiveLogger.Error("Trying to Init \"" + item.FullName + "\" threw an exception:");
					ArchiveLogger.Exception(ex2);
				}
				try
				{
					InjectInstanceIntoModules(initializable);
				}
				catch (Exception ex3)
				{
					ArchiveLogger.Error("Trying to Inject \"" + item.FullName + "\" threw an exception:");
					ArchiveLogger.Exception(ex3);
				}
			}
			InitSingletonBase<FeatureManager>.Instance.OnDatablocksReady();
			CustomSettingsManager.OnGameDataInited();
			ArchiveMod.DataBlocksReady?.Invoke();
		}

		internal static void InvokeGameStateChanged(int eGameState_state)
		{
			CurrentGameState = eGameState_state;
			ArchiveMod.GameStateChanged?.Invoke(eGameState_state);
		}

		internal static void InvokeApplicationFocusChanged(bool focus)
		{
			ArchiveMod.ApplicationFocusStateChanged?.Invoke(focus);
		}

		public static void InjectInstanceIntoModules(object instance)
		{
			if (instance == null)
			{
				return;
			}
			foreach (IArchiveModule module in Modules)
			{
				InjectInstanceIntoModules(instance, module);
			}
		}

		private static void InjectInstanceIntoModules(object instance, IArchiveModule module)
		{
			foreach (PropertyInfo item in from p in module.GetType().GetProperties()
				where p.SetMethod != null && !p.SetMethod.IsStatic && p.PropertyType.IsAssignableFrom(instance.GetType())
				select p)
			{
				item.SetValue(module, instance);
			}
		}

		private static void InitInitializables(Type type, out IInitializable initializable)
		{
			ArchiveLogger.Debug("Creating instance of: \"" + type.FullName + "\".");
			IInitializable initializable2 = (initializable = (IInitializable)Activator.CreateInstance(type));
			bool flag = true;
			Type type2 = typeof(InitSingletonBase<>).MakeGenericType(type);
			bool flag2 = type2.IsAssignableFrom(type);
			if (flag2)
			{
				type2.GetProperty("Instance", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).SetValue(null, initializable2);
			}
			if (typeof(IInjectLogger).IsAssignableFrom(type))
			{
				((IInjectLogger)initializable2).Logger = LoaderWrapper.CreateArSubLoggerInstance(type.Name, ConsoleColor.Green);
			}
			if (typeof(IInitCondition).IsAssignableFrom(type))
			{
				IInitCondition initCondition = (IInitCondition)initializable2;
				try
				{
					flag = initCondition.InitCondition();
				}
				catch (Exception ex)
				{
					ArchiveLogger.Error("InitCondition method on Type \"" + type.FullName + "\" failed!");
					ArchiveLogger.Warning("This IInitializable won't be initialized.");
					ArchiveLogger.Exception(ex);
					flag = false;
				}
			}
			if (!flag)
			{
				return;
			}
			try
			{
				initializable2.Init();
				if (flag2)
				{
					type2.GetProperty("HasBeenInitialized", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).SetValue(null, true);
				}
			}
			catch (Exception ex2)
			{
				ArchiveLogger.Error("Init method on Type \"" + type.FullName + "\" failed!");
				ArchiveLogger.Exception(ex2);
			}
		}

		private static void InspectType(Type type, IArchiveModule module)
		{
			if (typeof(Feature).IsAssignableFrom(type) && type != typeof(Feature))
			{
				InitSingletonBase<FeatureManager>.Instance.InitFeature(type, module);
			}
			else if (typeof(IInitImmediately).IsAssignableFrom(type) && !type.IsInterface && !type.IsAbstract)
			{
				IInitializable initializable = null;
				try
				{
					InitInitializables(type, out initializable);
				}
				catch (Exception ex)
				{
					ArchiveLogger.Error("Trying to Init \"" + type.FullName + "\" (immediately) threw an exception:");
					ArchiveLogger.Exception(ex);
				}
				if (initializable != null)
				{
					_iinitializablesToInjectOnGameDataInit.Add(initializable);
				}
			}
			else if (typeof(IInitAfterGameDataInitialized).IsAssignableFrom(type) && !type.IsInterface && !type.IsAbstract)
			{
				_typesToInitOnGameDataInit.Add(type);
			}
			else if (typeof(IInitAfterDataBlocksReady).IsAssignableFrom(type) && !type.IsInterface && !type.IsAbstract)
			{
				_typesToInitOnDataBlocksReady.Add(type);
			}
		}

		internal static IArchiveModule CreateAndInitModule(Type moduleType)
		{
			if (moduleType == null)
			{
				throw new ArgumentException("Parameter moduleType can not be null!");
			}
			Stopwatch stopwatch = new Stopwatch();
			stopwatch.Start();
			_moduleTypes.Add(moduleType);
			ArchiveLogger.Info("Initializing module \"" + moduleType.FullName + "\" ...");
			IArchiveModule archiveModule = (IArchiveModule)Activator.CreateInstance(moduleType);
			if (string.IsNullOrWhiteSpace(archiveModule.ModuleGroup))
			{
				throw new Exception($"ArchiveModule: {archiveModule.GetType().FullName}, {"ModuleGroup"} can not be null!");
			}
			FeatureGroups.GetOrCreateModuleGroup(archiveModule.ModuleGroup);
			Type[] types = moduleType.Assembly.GetTypes();
			for (int i = 0; i < types.Length; i++)
			{
				InspectType(types[i], archiveModule);
			}
			_moduleAssemblies.Add(moduleType.Assembly);
			if (archiveModule.UsesLegacyPatches)
			{
				archiveModule.Patcher = new ArchiveLegacyPatcher(_harmonyInstance, moduleType.Assembly.GetName().Name + "_" + moduleType.FullName + "_ArchivePatcher");
			}
			try
			{
				archiveModule.Init();
				if (archiveModule.ApplyHarmonyPatches)
				{
					ArchiveLogger.Warning("Applying regular Harmony patches on module \"" + moduleType.FullName + "\" ...");
					_harmonyInstance.PatchAll(moduleType.Assembly);
				}
			}
			catch (Exception ex)
			{
				ArchiveLogger.Error("Error while trying to init \"" + moduleType.FullName + "\"!");
				ArchiveLogger.Exception(ex);
			}
			Modules.Add(archiveModule);
			stopwatch.Stop();
			ArchiveLogger.Debug($"Creation of \"{moduleType.FullName}\" took {stopwatch.Elapsed:ss\\.fff} seconds.");
			return archiveModule;
		}

		private static void ApplyPatches(Utils.RundownID rundownID)
		{
			if (rundownID == Utils.RundownID.RundownUnitialized)
			{
				return;
			}
			foreach (IArchiveModule module in Modules)
			{
				module.Patcher?.PatchRundownSpecificMethods(module.GetType().Assembly);
			}
		}

		internal static void UnpatchAll()
		{
			foreach (IArchiveModule module in Modules)
			{
				UnpatchModule(module);
			}
		}

		public static void UnpatchModule(Type moduleType)
		{
			if (!_moduleTypes.Contains(moduleType))
			{
				throw new ArgumentException("Can't unpatch non patched module \"" + moduleType.FullName + "\".");
			}
			foreach (IArchiveModule module in Modules)
			{
				if (module.GetType() == moduleType)
				{
					UnpatchModule(module);
					return;
				}
			}
			throw new ArgumentException("Can't unpatch module \"" + moduleType.FullName + "\", module not found.");
		}

		public static void UnpatchModule(IArchiveModule module)
		{
			try
			{
				module.Patcher?.Unpatch();
				module.OnExit();
			}
			catch (Exception ex)
			{
				ArchiveLogger.Error($"Error while trying to unpatch and/or run {"OnExit"} in module \"{module?.GetType()?.FullName ?? "Unknown"}\"!");
				ArchiveLogger.Exception(ex);
			}
			Modules.Remove(module);
			_moduleTypes.Remove(module.GetType());
		}

		public static void OnSceneWasLoaded(int buildIndex, string sceneName)
		{
			foreach (IArchiveModule module in Modules)
			{
				try
				{
					module?.OnSceneWasLoaded(buildIndex, sceneName);
				}
				catch (Exception ex)
				{
					ArchiveLogger.Error($"Error while trying to run {"OnSceneWasLoaded"} in module \"{module?.GetType()?.FullName ?? "Unknown"}\"!");
					ArchiveLogger.Exception(ex);
				}
			}
		}

		public static void OnUpdate()
		{
			InitSingletonBase<FeatureManager>.Instance.OnUpdate();
		}

		public static void OnLateUpdate()
		{
			foreach (IArchiveModule module in Modules)
			{
				try
				{
					module?.OnLateUpdate();
				}
				catch (Exception ex)
				{
					ArchiveLogger.Error($"Error while trying to run {"OnLateUpdate"} in module \"{module?.GetType()?.FullName ?? "Unknown"}\"!");
					ArchiveLogger.Exception(ex);
				}
			}
			InitSingletonBase<FeatureManager>.Instance.OnLateUpdate();
		}

		private static Assembly LoadMainArchiveModule(bool isIl2Cpp)
		{
			try
			{
				if (isIl2Cpp)
				{
					ArchiveLogger.Notice("Loading IL2CPP module ...");
					byte[] array = Utils.LoadFromResource("TheArchive.Resources.TheArchive.IL2CPP.dll");
					if (array.Length < 100)
					{
						throw new BadImageFormatException("IL2CPP Module is too small, this version might not contain the module build but a dummy dll!");
					}
					return Assembly.Load(array);
				}
				ArchiveLogger.Notice("Loading MONO module ...");
				byte[] array2 = Utils.LoadFromResource("TheArchive.Resources.TheArchive.MONO.dll");
				if (array2.Length < 100)
				{
					throw new BadImageFormatException("MONO Module is too small, this version might not contain the module build but a dummy dll!");
				}
				return Assembly.Load(array2);
			}
			catch (Exception ex)
			{
				ArchiveLogger.Error($"Could not load {(isIl2Cpp ? "IL2CPP" : "MONO")} module! {ex}: {ex.Message}");
				ArchiveLogger.Error(ex.StackTrace ?? "");
				return null;
			}
		}
	}
}
namespace TheArchive.Utilities
{
	public static class AccessorExtensions
	{
		public static IValueAccessor<T, MT> OrAlternative<T, MT>(this IValueAccessor<T, MT> self, Func<IValueAccessor<T, MT>> func)
		{
			if (self != null && self.HasMember)
			{
				return self;
			}
			if (func == null)
			{
				throw new NullReferenceException("Parameter func may not be null!");
			}
			return func();
		}
	}
	public interface IValueAccessor<T, MT>
	{
		bool CanGet { get; }

		bool CanSet { get; }

		bool HasMember { get; }

		MT Get(T instance);

		void Set(T instance, MT value);
	}
	public interface IStaticValueAccessor<T, MT> : IValueAccessor<T, MT>
	{
		bool IsStatic { get; }

		MT GetStaticValue();

		void SetStaticValue(MT value);
	}
	public abstract class AccessorBase
	{
		protected static readonly Dictionary<string, AccessorBase> Accessors = new Dictionary<string, AccessorBase>();

		public static object[] NoParams { get; private set; } = Array.Empty<object>();


		public static BindingFlags AnyBindingFlags => BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		public string Identifier { get; private set; }

		public bool IgnoreErrors { get; private set; }

		public abstract bool HasMemberBeenFound { get; }

		protected AccessorBase(string identifier, bool ignoreErrors)
		{
			Identifier = identifier;
			IgnoreErrors = ignoreErrors;
		}

		public static IValueAccessor<T, MT> GetValueAccessor<T, MT>(string memberName, bool throwOnError = false)
		{
			if (LoaderWrapper.IsGameIL2CPP() && LoaderWrapper.IsIL2CPPType(typeof(T)))
			{
				return PropertyAccessor<T, MT>.GetAccessor(memberName, !throwOnError);
			}
			MemberInfo memberInfo = typeof(T).GetMember(memberName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault();
			if (!(memberInfo is PropertyInfo))
			{
				if (memberInfo is FieldInfo)
				{
					return FieldAccessor<T, MT>.GetAccessor(memberName, !throwOnError);
				}
				if (throwOnError)
				{
					throw new ArgumentException($"Member with name \"{memberName}\" could not be found in type \"{typeof(T).Name}\" or isn't {"IValueAccessor"} compatible.", "memberName");
				}
				return null;
			}
			return PropertyAccessor<T, MT>.GetAccessor(memberName, !throwOnError);
		}

		public static IStaticValueAccessor<T, MT> GetStaticValueAccessor<T, MT>(string memberName, bool throwOnError = false)
		{
			IValueAccessor<T, MT> valueAccessor = GetValueAccessor<T, MT>(memberName, throwOnError);
			if (valueAccessor != null)
			{
				IStaticValueAccessor<T, MT> staticValueAccessor = valueAccessor as IStaticValueAccessor<T, MT>;
				if (throwOnError && !staticValueAccessor.IsStatic)
				{
					throw new ArgumentException("Member with name \"" + memberName + "\" is not static!", "memberName");
				}
				return staticValueAccessor;
			}
			return null;
		}
	}
	public class FieldAccessor<T, FT> : AccessorBase, IValueAccessor<T, FT>, IStaticValueAccessor<T, FT>
	{
		private readonly FieldInfo _field;

		public override bool HasMemberBeenFound => _field != null;

		public bool CanGet => true;

		public bool CanSet => true;

		public bool HasMember => HasMemberBeenFound;

		public bool IsStatic => _field?.IsStatic ?? false;

		public static FieldAccessor<T, FT> GetAccessor(string fieldName, bool ignoreErrors = false)
		{
			string text = "Field_" + typeof(T).FullName + "_" + fieldName;
			if (AccessorBase.Accessors.TryGetValue(text, out var value))
			{
				return (FieldAccessor<T, FT>)value;
			}
			value = new FieldAccessor<T, FT>(text, fieldName, ignoreErrors);
			AccessorBase.Accessors.Add(text, value);
			return (FieldAccessor<T, FT>)value;
		}

		private FieldAccessor(string identifier, string fieldName, bool ignoreErrors = false)
			: base(identifier, ignoreErrors)
		{
			_field = typeof(T).GetField(fieldName, AccessorBase.AnyBindingFlags);
		}

		public FT Get(T instance)
		{
			try
			{
				return (FT)_field.GetValue(instance);
			}
			catch (NullReferenceException ex)
			{
				if (!base.IgnoreErrors)
				{
					if (!HasMemberBeenFound)
					{
						ArchiveLogger.Warning($"NullReferenceException while getting {"FieldAccessor"} field \"{base.Identifier}\"! If this is intentional consider setting {"IgnoreErrors"} to true.");
						return default(FT);
					}
					ArchiveLogger.Error($"NullReferenceException while getting {"FieldAccessor"} field \"{base.Identifier}\"!");
					throw ex;
				}
			}
			catch (Exception ex2)
			{
				ArchiveLogger.Error($"Exception while getting {"FieldAccessor"} field \"{base.Identifier}\"!");
				ArchiveLogger.Exception(ex2);
			}
			return default(FT);
		}

		public void Set(T instance, FT value)
		{
			try
			{
				_field.SetValue(instance, value);
			}
			catch (NullReferenceException ex)
			{
				if (!base.IgnoreErrors)
				{
					if (HasMemberBeenFound)
					{
						ArchiveLogger.Error($"NullReferenceException while setting {"FieldAccessor"} field \"{base.Identifier}\"!");
						throw ex;
					}
					ArchiveLogger.Warning($"NullReferenceException while setting {"FieldAccessor"} field \"{base.Identifier}\"! If this is intentional consider setting {"IgnoreErrors"} to true.");
				}
			}
			catch (Exception ex2)
			{
				ArchiveLogger.Error($"Exception while setting {"FieldAccessor"} field \"{base.Identifier}\"!");
				ArchiveLogger.Exception(ex2);
			}
		}

		public FT GetStaticValue()
		{
			return Get(default(T));
		}

		public void SetStaticValue(FT value)
		{
			Set(default(T), value);
		}
	}
	public class PropertyAccessor<T, PT> : AccessorBase, IValueAccessor<T, PT>, IStaticValueAccessor<T, PT>
	{
		private readonly PropertyInfo _property;

		public override bool HasMemberBeenFound => _property != null;

		public bool CanGet => _property?.GetGetMethod(nonPublic: true) != null;

		public bool CanSet => _property?.GetSetMethod(nonPublic: true) != null;

		public bool HasMember => HasMemberBeenFound;

		public bool IsStatic => (_property?.GetGetMethod(nonPublic: true) ?? _property?.GetSetMethod(nonPublic: true))?.IsStatic ?? false;

		public static PropertyAccessor<T, PT> GetAccessor(string propertyName, bool ignoreErrors = false)
		{
			string text = "Property_" + typeof(T).FullName + "_" + propertyName;
			if (AccessorBase.Accessors.TryGetValue(text, out var value))
			{
				return (PropertyAccessor<T, PT>)value;
			}
			value = new PropertyAccessor<T, PT>(text, propertyName, ignoreErrors);
			AccessorBase.Accessors.Add(text, value);
			return (PropertyAccessor<T, PT>)value;
		}

		private PropertyAccessor(string identifier, string propertyName, bool ignoreErrors = false)
			: base(identifier, ignoreErrors)
		{
			_property = typeof(T).GetProperty(propertyName, AccessorBase.AnyBindingFlags);
		}

		public PT Get(T instance)
		{
			try
			{
				return (PT)_property.GetValue(instance);
			}
			catch (NullReferenceException ex)
			{
				if (!base.IgnoreErrors)
				{
					if (!HasMemberBeenFound)
					{
						ArchiveLogger.Warning($"NullReferenceException while getting {"PropertyAccessor"} property \"{base.Identifier}\"! If this is intentional consider setting {"IgnoreErrors"} to true.");
						return default(PT);
					}
					ArchiveLogger.Error($"NullReferenceException while getting {"PropertyAccessor"} property \"{base.Identifier}\"!");
					throw ex;
				}
			}
			catch (Exception ex2)
			{
				ArchiveLogger.Error($"Exception while getting {"PropertyAccessor"} property \"{base.Identifier}\"!");
				ArchiveLogger.Exception(ex2);
			}
			return default(PT);
		}

		public void Set(T instance, PT value)
		{
			try
			{
				_property.SetValue(instance, value);
			}
			catch (NullReferenceException ex)
			{
				if (!base.IgnoreErrors)
				{
					if (HasMemberBeenFound)
					{
						ArchiveLogger.Error($"NullReferenceException while setting {"PropertyAccessor"} property \"{base.Identifier}\"!");
						throw ex;
					}
					ArchiveLogger.Warning($"NullReferenceException while setting {"PropertyAccessor"} property \"{base.Identifier}\"! If this is intentional consider setting {"IgnoreErrors"} to true.");
				}
			}
			catch (Exception ex2)
			{
				ArchiveLogger.Error($"Exception while setting {"PropertyAccessor"} property \"{base.Identifier}\"!");
				ArchiveLogger.Exception(ex2);
			}
		}

		public PT GetStaticValue()
		{
			return Get(default(T));
		}

		public void SetStaticValue(PT value)
		{
			Set(default(T), value);
		}
	}
	public class MethodAccessor<T, RT> : AccessorBase
	{
		private readonly MethodInfo _method;

		public bool IsMethodStatic => _method.IsStatic;

		public override bool HasMemberBeenFound => _method != null;

		public static MethodAccessor<T, RT> GetAccessor(string methodName, Type[] parameterTypes = null, bool ignoreErrors = false)
		{
			string text = $"Method_{typeof(T).FullName}_{typeof(RT)}_{methodName}";
			if (parameterTypes != null)
			{
				text = text + "_" + string.Join("_", parameterTypes.Select((Type pt) => pt.Name));
			}
			if (AccessorBase.Accessors.TryGetValue(text, out var value))
			{
				return (MethodAccessor<T, RT>)value;
			}
			value = new MethodAccessor<T, RT>(text, methodName, parameterTypes, ignoreErrors);
			AccessorBase.Accessors.Add(text, value);
			return (MethodAccessor<T, RT>)value;
		}

		private MethodAccessor(string identifier, string methodName, Type[] parameterTypes, bool ignoreErrors = false)
			: base(identifier, ignoreErrors)
		{
			try
			{
				if (parameterTypes == null)
				{
					_method = typeof(T).GetMethod(methodName, AccessorBase.AnyBindingFlags);
				}
				else
				{
					_method = typeof(T).GetMethod(methodName, AccessorBase.AnyBindingFlags, null, parameterTypes, null);
				}
			}
			catch (Exception ex)
			{
				ArchiveLogger.Error($"Method \"{methodName}\" in Type {typeof(T).FullName} could not be resolved on {ex.Source}!");
				ArchiveLogger.Exception(ex);
			}
		}

		public RT Invoke(T instance, params object[] parameters)
		{
			try
			{
				object obj = _method.Invoke(instance, parameters ?? AccessorBase.NoParams);
				if (obj == null)
				{
					return default(RT);
				}
				return (RT)obj;
			}
			catch (NullReferenceException ex)
			{
				if (!base.IgnoreErrors)
				{
					if (!HasMemberBeenFound)
					{
						ArchiveLogger.Warning($"NullReferenceException while calling {"MethodAccessor"} method \"{base.Identifier}\"! If this is intentional consider setting {"IgnoreErrors"} to true.");
						return default(RT);
					}
					ArchiveLogger.Error($"NullReferenceException while calling {"MethodAccessor"} method \"{base.Identifier}\"!");
					throw ex;
				}
			}
			catch (Exception ex2)
			{
				ArchiveLogger.Error($"Exception while calling {"MethodAccessor"} method \"{base.Identifier}\"!");
				ArchiveLogger.Exception(ex2);
			}
			return default(RT);
		}

		public RT Invoke(T instance)
		{
			return Invoke(instance, null);
		}
	}
	public class MethodAccessor<T> : AccessorBase
	{
		private readonly MethodInfo _method;

		public bool IsMethodStatic => _method.IsStatic;

		public override bool HasMemberBeenFound => _method != null;

		public int ParameterCount { get; private set; }

		public static MethodAccessor<T> GetAccessor(string methodName, Type[] parameterTypes = null, bool ignoreErrors = false)
		{
			string text = "Method_" + typeof(T).FullName + "_void_" + methodName;
			if (parameterTypes != null && parameterTypes != Array.Empty<Type>())
			{
				text = text + "_" + string.Join("_", parameterTypes.Select((Type pt) => pt.Name));
			}
			if (AccessorBase.Accessors.TryGetValue(text, out var value))
			{
				return (MethodAccessor<T>)value;
			}
			value = new MethodAccessor<T>(text, methodName, parameterTypes, ignoreErrors);
			AccessorBase.Accessors.Add(text, value);
			return (MethodAccessor<T>)value;
		}

		private MethodAccessor(string identifier, string methodName, Type[] parameterTypes, bool ignoreErrors = false)
			: base(identifier, ignoreErrors)
		{
			try
			{
				if (parameterTypes == null)
				{
					_method = typeof(T).GetMethod(methodName, AccessorBase.AnyBindingFlags);
				}
				else
				{
					_method = typeof(T).GetMethod(methodName, AccessorBase.AnyBindingFlags, null, parameterTypes, null);
				}
				if (!ignoreErrors && _method == null)
				{
					throw new Exception("Method not found!");
				}
				if (_method != null)
				{
					ParameterCount = _method.GetParameters().Length;
				}
			}
			catch (Exception ex)
			{
				ArchiveLogger.Error($"Method \"{methodName}\" in Type {typeof(T).FullName} could not be resolved on {ex.Source}!");
				ArchiveLogger.Exception(ex);
				ArchiveLogger.Debug($"Constructor debug data:\nidentifier:{identifier}\nmethodName:{methodName}\nparameterTypes:{string.Join(", ", parameterTypes.Select((Type p) => p.FullName))}");
				StackFrame frame = new StackTrace().GetFrame(2);
				ArchiveLogger.Debug($"FileName:{frame.GetFileName()} {frame.GetFileLineNumber()}\nMethod:{frame.GetMethod().DeclaringType.FullName}:{frame.GetMethod().Name}");
				PrintDebug();
			}
		}

		private void PrintDebug()
		{
			if (!(_method == null))
			{
				ArchiveLogger.Debug($"Method debug data:\nName:{_method.Name}\nDeclaringType:{_method.DeclaringType.FullName}\nReturnType:{_method.ReturnType}\nParameter Count:{_method.GetParameters()?.Count() ?? 0}\nParameters:{string.Join(", ", from p in _method.GetParameters()
					select p.ParameterType.FullName)}");
			}
		}

		public void Invoke(T instance, params object[] parameters)
		{
			try
			{
				if (parameters != null && parameters.Length > ParameterCount)
				{
					parameters = parameters.Take(ParameterCount).ToArray();
				}
				_method.Invoke(instance, parameters ?? AccessorBase.NoParams);
			}
			catch (NullReferenceException ex)
			{
				if (!base.IgnoreErrors)
				{
					if (HasMemberBeenFound)
					{
						ArchiveLogger.Error($"NullReferenceException while calling {"MethodAccessor"} method \"{base.Identifier}\"!");
						throw ex;
					}
					ArchiveLogger.Warning($"NullReferenceException while calling {"MethodAccessor"} method \"{base.Identifier}\"! If this is intentional consider setting {"IgnoreErrors"} to true.");
				}
			}
			catch (Exception ex2)
			{
				ArchiveLogger.Error($"Exception while calling {"MethodAccessor"} method \"{base.Identifier}\"!");
				ArchiveLogger.Exception(ex2);
				PrintDebug();
			}
		}

		public void Invoke(T instance)
		{
			Invoke(instance, null);
		}
	}
	public class ArchiveLogger
	{
		internal static IArchiveLogger logger;

		public static void Success(string msg)
		{
			logger.Msg(ConsoleColor.Green, msg);
		}

		public static void Notice(string msg)
		{
			logger.Msg(ConsoleColor.Cyan, msg);
		}

		public static void Msg(ConsoleColor col, string msg)
		{
			logger.Msg(col, msg);
		}

		public static void Debug(string msg)
		{
			logger.Msg(ConsoleColor.DarkGray, msg);
		}

		public static void Info(string msg)
		{
			logger.Info(msg);
		}

		public static void Warning(string msg)
		{
			logger.Msg(ConsoleColor.DarkYellow, msg);
		}

		public static void Error(string msg)
		{
			logger.Error(msg);
		}

		public static void Msg(string v)
		{
			Info(v);
		}

		public static void Exception(Exception ex)
		{
			Error($"{ex}: {ex.Message}\n{ex.StackTrace}");
		}
	}
	public static class GTFOLogger
	{
		private static readonly HashSet<string> _ignoreListExact = new HashSet<string> { "show crosshair", "Setting and getting Body Position/Rotation, IK Goals, Lookat and BoneLocalRotation should only be done in OnAnimatorIK or OnStateIK" };

		private static readonly HashSet<string> _ignoreListStartsWith = new HashSet<string> { "Wielding new item in slot", "Backend.", "BE.OnGameEvent" };

		internal static IArchiveLogger Logger { private get; set; }

		public static void Ignore(string str)
		{
			_ignoreListExact.Add(str);
		}

		public static void Log(string message)
		{
			if (!_ignoreListExact.Contains(message) && !_ignoreListStartsWith.Any((string s) => message.StartsWith(s)))
			{
				Logger.Info(message);
			}
		}

		public static void Warn(string message)
		{
			if (!_ignoreListExact.Contains(message) && !_ignoreListStartsWith.Any((string s) => message.StartsWith(s)))
			{
				Logger.Warning(message);
			}
		}

		public static void Error(string message)
		{
			if (!_ignoreListExact.Contains(message) && !_ignoreListStartsWith.Any((string s) => message.StartsWith(s)))
			{
				Logger.Error(message);
			}
		}
	}
	public static class ImplementationManagerExtensions
	{
		public static void RegisterForIdentifier(this Type type, string identifier)
		{
			ImplementationManager.RegisterGameType(identifier, type);
		}

		public static void RegisterSelf<T>(this T type) where T : Type
		{
			if (type.IsGenericTypeDefinition)
			{
				type.RegisterForIdentifier(type.Name.Split('`')[0] + "<" + ((type.GenericTypeArguments.Length > 1) ? string.Join(",", new string[type.GenericTypeArguments.Length - 1]) : string.Empty) + ">");
			}
			else
			{
				type.RegisterForIdentifier(type.Name);
			}
		}
	}
	public class LocalFiles
	{
		public const string GTFO_SETTINGS_JSON = "GTFO_Settings.json";

		public const string GTFO_FAVORITES_JSON = "GTFO_Favorites.json";

		public const string GTFO_BOT_FAVORITES_JSON = "GTFO_BotFavorites.json";

		private static string _modLocalLowPath;

		private static string _modDefaultGameLogsAndCachePath;

		private static string _modDefaultSaveDataPath;

		private static string _dataBlockDumpPath;

		private static string _savePath;

		private static string _gameLogsAndCacheSavePath;

		private static string _versionSpecificLogsAndCachePath;

		private static string _versionSpecificSavePath;

		private static string _otherConfigsPath;

		private static string _featureConfigsPath;

		private static string _filesPath;

		private static string _settingsPath;

		private static string _favoritesPath;

		private static string _botFavoritesPath;

		private static string _boostersPath;

		private static string _vanityItemsPath;

		private static string _vanityItemsLayerDropsPath;

		private static string _progressionPath;

		public static string ModLocalLowPath
		{
			get
			{
				if (_modLocalLowPath == null)
				{
					_modLocalLowPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "AppData", "LocalLow", "GTFO_TheArchive");
					if (!Directory.Exists(_modLocalLowPath))
					{
						Directory.CreateDirectory(_modLocalLowPath);
					}
				}
				return _modLocalLowPath;
			}
		}

		public static string ModDefaultGameLogsAndCachePath
		{
			get
			{
				if (_modDefaultGameLogsAndCachePath == null)
				{
					_modDefaultGameLogsAndCachePath = Path.Combine(ModLocalLowPath, "GameLogsAndCache");
					if (!Directory.Exists(_modDefaultGameLogsAndCachePath))
					{
						Directory.CreateDirectory(_modDefaultGameLogsAndCachePath);
					}
				}
				return _modDefaultGameLogsAndCachePath;
			}
		}

		public static string ModDefaultSaveDataPath
		{
			get
			{
				if (_modDefaultSaveDataPath == null)
				{
					_modDefaultSaveDataPath = Path.Combine(ModLocalLowPath, "SaveData");
					if (!Directory.Exists(_modLocalLowPath))
					{
						Directory.CreateDirectory(_modLocalLowPath);
					}
				}
				return _modDefaultSaveDataPath;
			}
		}

		public static string DataBlockDumpPath
		{
			get
			{
				if (string.IsNullOrEmpty(_dataBlockDumpPath))
				{
					_dataBlockDumpPath = Path.Combine(SaveDirectoryPath, "DataBlocks", $"Build_{BuildDB.BuildNumber}_{ArchiveMod.CurrentRundown}");
					if (!Directory.Exists(_dataBlockDumpPath))
					{
						Directory.CreateDirectory(_dataBlockDumpPath);
					}
				}
				return _dataBlockDumpPath;
			}
		}

		public static string SaveDirectoryPath
		{
			get
			{
				if (string.IsNullOrEmpty(_savePath))
				{
					_savePath = (string.IsNullOrWhiteSpace(ArchiveMod.Settings.CustomFileSaveLocation) ? ModDefaultSaveDataPath : ArchiveMod.Settings.CustomFileSaveLocation);
					if (!Directory.Exists(_savePath))
					{
						Directory.CreateDirectory(_savePath);
					}
				}
				return _savePath;
			}
		}

		public static string GameLogsAndCachePath
		{
			get
			{
				if (_gameLogsAndCacheSavePath == null)
				{
					_gameLogsAndCacheSavePath = (string.IsNullOrWhiteSpace(ArchiveMod.Settings.CustomLogsAndCacheLocation) ? ModDefaultGameLogsAndCachePath : ArchiveMod.Settings.CustomLogsAndCacheLocation);
					if (!Directory.Exists(_gameLogsAndCacheSavePath))
					{
						Directory.CreateDirectory(_gameLogsAndCacheSavePath);
					}
				}
				return _gameLogsAndCacheSavePath;
			}
		}

		public static string VersionSpecificLogsAndCachePath
		{
			get
			{
				if (string.IsNullOrEmpty(_versionSpecificLogsAndCachePath))
				{
					_versionSpecificLogsAndCachePath = Path.Combine(GameLogsAndCachePath, $"{((int)ArchiveMod.CurrentRundown).ToString().PadLeft(2, '0')}_{ArchiveMod.CurrentRundown}_Data", "appdata");
					if (!Directory.Exists(_versionSpecificLogsAndCachePath))
					{
						Directory.CreateDirectory(_versionSpecificLogsAndCachePath);
					}
				}
				return _versionSpecificLogsAndCachePath;
			}
		}

		public static string VersionSpecificSaveDirectoryPath
		{
			get
			{
				if (string.IsNullOrEmpty(_versionSpecificSavePath))
				{
					if (LoaderWrapper.IsModInstalled("com.dak.MTFO"))
					{
						_versionSpecificSavePath = Path.Combine(SaveDirectoryPath, "Modded", "TODO_USE_MTFO_FOLDER_HERE_Data");
					}
					else
					{
						_versionSpecificSavePath = GetVersionSpecificSaveDirectoryPath(ArchiveMod.CurrentRundown);
					}
					if (!Directory.Exists(_versionSpecificSavePath))
					{
						Directory.CreateDirectory(_versionSpecificSavePath);
						try
						{
							if (!CopyMostRecentSaveFiles(ArchiveMod.CurrentRundown - 1, ArchiveMod.CurrentRundown))
							{
								ArchiveLogger.Notice("Creating new game settings file(s)!");
							}
						}
						catch (Exception ex)
						{
							ArchiveLogger.Warning($"Caught an exception while trying to copy over older settings files: {ex}: {ex.Message}");
							ArchiveLogger.Debug(ex.StackTrace);
						}
					}
				}
				return _versionSpecificSavePath;
			}
		}

		public static string OtherConfigsDirectoryPath
		{
			get
			{
				if (string.IsNullOrEmpty(_otherConfigsPath))
				{
					_otherConfigsPath = Path.Combine(SaveDirectoryPath, "OtherConfigs");
					if (!Directory.Exists(_otherConfigsPath))
					{
						Directory.CreateDirectory(_otherConfigsPath);
					}
				}
				return _otherConfigsPath;
			}
		}

		public static string FeatureConfigsDirectoryPath
		{
			get
			{
				if (string.IsNullOrEmpty(_featureConfigsPath))
				{
					_featureConfigsPath = Path.Combine(SaveDirectoryPath, "FeatureSettings");
					if (!Directory.Exists(_featureConfigsPath))
					{
						Directory.CreateDirectory(_featureConfigsPath);
					}
				}
				return _featureConfigsPath;
			}
		}

		public static string FilesDirectoryPath
		{
			get
			{
				if (string.IsNullOrEmpty(_filesPath))
				{
					_filesPath = Path.Combine(VersionSpecificSaveDirectoryPath, "Files");
					if (!Directory.Exists(_filesPath))
					{
						Directory.CreateDirectory(_filesPath);
					}
				}
				return _filesPath;
			}
		}

		public static string SettingsPath
		{
			get
			{
				if (string.IsNullOrEmpty(_settingsPath))
				{
					_settingsPath = Path.Combine(VersionSpecificSaveDirectoryPath, "GTFO_Settings.json");
				}
				return _settingsPath;
			}
		}

		public static string FavoritesPath
		{
			get
			{
				if (string.IsNullOrEmpty(_favoritesPath))
				{
					_favoritesPath = Path.Combine(VersionSpecificSaveDirectoryPath, "GTFO_Favorites.json");
				}
				return _favoritesPath;
			}
		}

		public static string BotFavoritesPath
		{
			get
			{
				if (string.IsNullOrEmpty(_botFavoritesPath))
				{
					_botFavoritesPath = Path.Combine(VersionSpecificSaveDirectoryPath, "GTFO_BotFavorites.json");
				}
				return _botFavoritesPath;
			}
		}

		public static string BoostersPath
		{
			get
			{
				if (string.IsNullOrEmpty(_boostersPath))
				{
					_boostersPath = Path.Combine(VersionSpecificSaveDirectoryPath, "Booster_Data.json");
				}
				return _boostersPath;
			}
		}

		public static string VanityItemsPath
		{
			get
			{
				if (string.IsNullOrEmpty(_vanityItemsPath))
				{
					_vanityItemsPath = Path.Combine(VersionSpecificSaveDirectoryPath, "VanityItems_Data.json");
				}
				return _vanityItemsPath;
			}
		}

		public static string VanityItemsLayerDropsPath
		{
			get
			{
				if (string.IsNullOrEmpty(_vanityItemsLayerDropsPath))
				{
					_vanityItemsLayerDropsPath = Path.Combine(VersionSpecificSaveDirectoryPath, "VanityItemsLayerDrops_Data.json");
				}
				return _vanityItemsLayerDropsPath;
			}
		}

		private static string LocalProgressionBasePathNoExtension
		{
			get
			{
				if (string.IsNullOrEmpty(_progressionPath))
				{
					_progressionPath = Path.Combine(VersionSpecificSaveDirectoryPath, "RundownProgression_Data");
				}
				return _progressionPath;
			}
		}

		internal static bool CopyFromBaseGameLocation(Utils.RundownID copyTo)
		{
			string path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "AppData", "LocalLow", "10 Chambers Collective", "GTFO");
			string text = Path.Combine(path, "GTFO_Settings.txt");
			string text2 = Path.Combine(path, "GTFO_Favorites.txt");
			string text3 = Path.Combine(path, "GTFO_BotFavorites.txt");
			if (File.Exists(text))
			{
				string settingsPath = GetSettingsPath(copyTo);
				ArchiveLogger.Debug($"Copying vanilla game settings file! (\"{text}\" -> \"{settingsPath}\")");
				File.Copy(text, settingsPath);
				string favoritesPath = GetFavoritesPath(copyTo);
				string botFavoritesPath = GetBotFavoritesPath(copyTo);
				if (File.Exists(text2))
				{
					ArchiveLogger.Debug($"Copying vanilla game favorites file! (\"{text2}\" -> \"{favoritesPath}\")");
					File.Copy(text2, favoritesPath);
				}
				if (File.Exists(text3))
				{
					ArchiveLogger.Debug($"Copying vanilla game bot favorites file! (\"{text3}\" -> \"{botFavoritesPath}\")");
					File.Copy(text3, botFavoritesPath);
				}
				return true;
			}
			return false;
		}

		internal static bool CopyMostRecentSaveFiles(Utils.RundownID copyFrom, Utils.RundownID copyTo, int maxStep = 3)
		{
			if (copyFrom < Utils.RundownID.RundownOne)
			{
				return CopyFromBaseGameLocation(copyTo);
			}
			string settingsPath = GetSettingsPath(copyFrom);
			if (!File.Exists(settingsPath))
			{
				if (maxStep <= 1)
				{
					return CopyFromBaseGameLocation(copyTo);
				}
				return CopyMostRecentSaveFiles(copyFrom - 1, copyTo, maxStep - 1);
			}
			string settingsPath2 = GetSettingsPath(copyTo);
			ArchiveLogger.Debug($"Copying most recent settings file! (\"{settingsPath}\" -> \"{settingsPath2}\")");
			File.Copy(settingsPath, settingsPath2);
			if (!ArchiveMod.IsPlayingModded)
			{
				string favoritesPath = GetFavoritesPath(copyTo);
				string favoritesPath2 = GetFavoritesPath(copyFrom);
				if (File.Exists(favoritesPath2))
				{
					ArchiveLogger.Debug($"Copying most recent favorites file! (\"{favoritesPath2}\" -> \"{favoritesPath}\")");
					File.Copy(favoritesPath2, favoritesPath);
				}
				string botFavoritesPath = GetBotFavoritesPath(copyTo);
				string botFavoritesPath2 = GetBotFavoritesPath(copyFrom);
				if (File.Exists(botFavoritesPath2))
				{
					ArchiveLogger.Debug($"Copying most recent bot favorites file! (\"{botFavoritesPath2}\" -> \"{botFavoritesPath}\")");
					File.Copy(botFavoritesPath2, botFavoritesPath);
				}
			}
			return true;
		}

		public static string GetVersionSpecificSaveDirectoryPath(Utils.RundownID rundown)
		{
			string saveDirectoryPath = SaveDirectoryPath;
			DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(6, 2);
			int num = (int)rundown;
			defaultInterpolatedStringHandler.AppendFormatted(num.ToString().PadLeft(2, '0'));
			defaultInterpolatedStringHandler.AppendLiteral("_");
			defaultInterpolatedStringHandler.AppendFormatted(rundown);
			defaultInterpolatedStringHandler.AppendLiteral("_Data");
			return Path.Combine(saveDirectoryPath, defaultInterpolatedStringHandler.ToStringAndClear());
		}

		public static string GetSettingsPath(Utils.RundownID rundown)
		{
			return Path.Combine(GetVersionSpecificSaveDirectoryPath(rundown), "GTFO_Settings.json");
		}

		public static string GetFavoritesPath(Utils.RundownID rundown)
		{
			return Path.Combine(GetVersionSpecificSaveDirectoryPath(rundown), "GTFO_Favorites.json");
		}

		public static string GetBotFavoritesPath(Utils.RundownID rundown)
		{
			return Path.Combine(GetVersionSpecificSaveDirectoryPath(rundown), "GTFO_BotFavorites.json");
		}

		public static string GetLocalProgressionPathForKey(string rundownKey)
		{
			return LocalProgressionBasePathNoExtension + "_" + rundownKey + ".json";
		}

		public static void SaveToFilesDir(string filename, string jsonOrSomething)
		{
			string text = Path.Combine(FilesDirectoryPath, filename);
			if (string.IsNullOrEmpty(jsonOrSomething))
			{
				ArchiveLogger.Msg(ConsoleColor.DarkRed, "Saving \"" + filename + "\" to disk failed because the data is null or empty! Path: " + text);
				return;
			}
			ArchiveLogger.Msg(ConsoleColor.Blue, "Saving \"" + filename + "\" to disk at: " + text);
			File.WriteAllText(text, jsonOrSomething);
		}

		public static string LoadFromFilesDir(string filename, bool isJson = true)
		{
			string text = Path.Combine(FilesDirectoryPath, filename);
			ArchiveLogger.Msg(ConsoleColor.Green, "Loading \"" + filename + "\" from disk at: " + text);
			if (!File.Exists(text))
			{
				if (!isJson)
				{
					return string.Empty;
				}
				return "{}";
			}
			return File.ReadAllText(text);
		}

		public static T LoadConfig<T>(out bool fileExists, bool saveIfNonExistent = true) where T : new()
		{
			string path = Path.Combine(OtherConfigsDirectoryPath, typeof(T).Name + ".json");
			if (!File.Exists(path))
			{
				T val = new T();
				if (saveIfNonExistent)
				{
					SaveConfig(val);
				}
				fileExists = false;
				return val;
			}
			fileExists = true;
			return JsonConvert.DeserializeObject<T>(File.ReadAllText(path), ArchiveMod.JsonSerializerSettings);
		}

		public static T LoadConfig<T>(bool saveIfNonExistent = true) where T : new()
		{
			bool fileExists;
			return LoadConfig<T>(out fileExists, saveIfNonExistent);
		}

		public static void SaveConfig<T>(T config)
		{
			File.WriteAllText(Path.Combine(OtherConfigsDirectoryPath, typeof(T).Name + ".json"), JsonConvert.SerializeObject((object)config, ArchiveMod.JsonSerializerSettings));
		}

		internal static object LoadFeatureConfig(string moduleIdentifier, string featureIdentifier, Type configType, out bool fileExists, bool saveIfNonExistent = true)
		{
			if (string.IsNullOrWhiteSpace(featureIdentifier))
			{
				throw new ArgumentException("Parameter featureIdentifier may not be null or whitespace.");
			}
			if (configType == null)
			{
				throw new ArgumentNullException("Parameter configType may not be null.");
			}
			string text = Path.Combine(FeatureConfigsDirectoryPath, moduleIdentifier);
			if (!Directory.Exists(text))
			{
				Directory.CreateDirectory(text);
			}
			string path = Path.Combine(text, featureIdentifier + "_" + configType.Name + ".json");
			if (!File.Exists(path))
			{
				object obj = Activator.CreateInstance(configType);
				if (saveIfNonExistent)
				{
					SaveFeatureConfig(moduleIdentifier, featureIdentifier, configType, obj);
				}
				fileExists = false;
				return obj;
			}
			fileExists = true;
			try
			{
				return JsonConvert.DeserializeObject(File.ReadAllText(path), configType, ArchiveMod.JsonSerializerSettings);
			}
			catch
			{
				object obj2 = Activator.CreateInstance(configType);
				if (saveIfNonExistent)
				{
					SaveFeatureConfig(moduleIdentifier, featureIdentifier, configType, obj2);
				}
				fileExists = false;
				return obj2;
			}
		}

		internal static FeatureLocalizationData LoadFeatureLocalizationText(Feature feature)
		{
			string text = Path.Combine(Path.GetDirectoryName((feature.ModuleGroup == "Archive Core") ? ArchiveMod.CORE_PATH : feature.FeatureInternal.OriginAssembly.Location), "Localization");
			if (!Directory.Exists(text))
			{
				Directory.CreateDirectory(text);
			}
			string path = Path.Combine(text, feature.Identifier + "_Localization.json");
			if (!File.Exists(path))
			{
				FeatureLocalizationData featureLocalizationData = FeatureInternal.GenerateFeatureLocalization(feature);
				File.WriteAllText(path, JsonConvert.SerializeObject((object)featureLocalizationData, ArchiveMod.JsonSerializerSettings));
				return featureLocalizationData;
			}
			FeatureLocalizationData featureLocalizationData2 = JsonConvert.DeserializeObject<FeatureLocalizationData>(File.ReadAllText(path), ArchiveMod.JsonSerializerSettings);
			string input = JsonConvert.SerializeObject((object)featureLocalizationData2, ArchiveMod.JsonSerializerSettings);
			FeatureLocalizationData featureLocalizationData3 = FeatureInternal.GenerateFeatureLocalization(feature, featureLocalizationData2);
			string text2 = JsonConvert.SerializeObject((object)featureLocalizationData3, ArchiveMod.JsonSerializerSettings);
			if (text2.HashString() != input.HashString())
			{
				File.WriteAllText(path, text2);
			}
			return featureLocalizationData3;
		}

		internal static object LoadFeatureConfig(string moduleIdentifier, string featureIdentifier, Type configType, bool saveIfNonExistent = true)
		{
			bool fileExists;
			return LoadFeatureConfig(moduleIdentifier, featureIdentifier, configType, out fileExists, saveIfNonExistent);
		}

		internal static void SaveFeatureConfig(string moduleIdentifier, string featureIdentifier, Type configType, object configInstance)
		{
			if (string.IsNullOrWhiteSpace(featureIdentifier))
			{
				throw new ArgumentException("Parameter featureIdentifier may not be null or whitespace.");
			}
			if (configType == null)
			{
				throw new ArgumentNullException("Parameter configType may not be null.");
			}
			if (configInstance == null)
			{
				throw new ArgumentNullException("Parameter configInstance may not be null.");
			}
			string text = Path.Combine(FeatureConfigsDirectoryPath, moduleIdentifier);
			if (!Directory.Exists(text))
			{
				Directory.CreateDirectory(text);
			}
			string text2 = Path.Combine(text, featureIdentifier + "_" + configType.Name + ".json");
			ArchiveLogger.Debug("Saving Feature Setting to: " + text2);
			File.WriteAllText(text2, JsonConvert.SerializeObject(configInstance, ArchiveMod.JsonSerializerSettings));
		}
	}
	public static class MetadataHelper
	{
		internal static IEnumerable<CustomAttribute> GetCustomAttributes<T>(TypeDefinition td, bool inherit) where T : Attribute
		{
			List<CustomAttribute> list = new List<CustomAttribute>();
			Type type = typeof(T);
			TypeDefinition val = td;
			do
			{
				list.AddRange(((IEnumerable<CustomAttribute>)val.CustomAttributes).Where((CustomAttribute ca) => ((MemberReference)ca.AttributeType).FullName == type.FullName));
				TypeReference baseType = val.BaseType;
				val = ((baseType != null) ? baseType.Resolve() : null);
			}
			while (inherit && ((val != null) ? ((MemberReference)val).FullName : null) != typeof(object).FullName);
			return list;
		}

		public static ArchiveModule GetMetadata(Type pluginType)
		{
			object[] customAttributes = pluginType.GetCustomAttributes(typeof(ArchiveModule), inherit: false);
			if (customAttributes.Length == 0)
			{
				return null;
			}
			return (ArchiveModule)customAttributes[0];
		}

		public static ArchiveModule GetMetadata(object plugin)
		{
			return GetMetadata(plugin.GetType());
		}

		public static T[] GetAttributes<T>(Type pluginType) where T : Attribute
		{
			return (T[])pluginType.GetCustomAttributes(typeof(T), inherit: true);
		}

		public static T[] GetAttributes<T>(Assembly assembly) where T : Attribute
		{
			return (T[])assembly.GetCustomAttributes(typeof(T), inherit: true);
		}

		public static IEnumerable<T> GetAttributes<T>(object plugin) where T : Attribute
		{
			return GetAttributes<T>(plugin.GetType());
		}

		public static T[] GetAttributes<T>(MemberInfo member) where T : Attribute
		{
			return (T[])member.GetCustomAttributes(typeof(T), inherit: true);
		}

		public static IEnumerable<ArchiveDependency> GetDependencies(Type plugin)
		{
			return plugin.GetCustomAttributes(typeof(ArchiveDependency), inherit: true).Cast<ArchiveDependency>();
		}
	}
	public static class PresenceFormatter
	{
		[AttributeUsage(AttributeTargets.Property)]
		public class PresenceFormatProvider : Attribute
		{
			private PropertyInfo _propertyInfo;

			public string Identifier { get; private set; }

			public bool IsValid => _propertyInfo != null;

			public Type PropertyType => PropertyInfo.PropertyType;

			public string DebugIdentifier => $"{PropertyInfo.DeclaringType.Name}.{PropertyInfo.Name} (ASM:{PropertyInfo.DeclaringType.Assembly.GetName().Name})";

			internal PropertyInfo PropertyInfo => _propertyInfo ?? throw new Exception($"PropertyInfo not set on {"PresenceFormatProvider"} with ID \"{Identifier}\"!");

			public PresenceFormatProvider(string identifier)
			{
				Identifier = identifier;
			}

			internal void SetPropertyInfo(PropertyInfo propertyInfo)
			{
				if (propertyInfo == null)
				{
					throw new ArgumentException($"Provided {"PresenceFormatProvider"} {"PropertyInfo"} may not be null! (ID:{Identifier})");
				}
				MethodInfo? getMethod = propertyInfo.GetGetMethod();
				if ((object)getMethod == null || !getMethod.IsStatic)
				{
					throw new ArgumentException($"Provided {"PresenceFormatProvider"} {"PropertyInfo"} has to implement a static get method! (ID:{Identifier})");
				}
				_propertyInfo = propertyInfo;
			}

			public object GetValue()
			{
				return PropertyInfo.GetValue(null);
			}
		}

		[AttributeUsage(AttributeTargets.Property)]
		internal class FallbackPresenceFormatProvider : PresenceFormatProvider
		{
			public bool NoNotImplementedWarning { get; private set; }

			public FallbackPresenceFormatProvider(string identifier, bool noNotImplementedWarning = false)
				: base(identifier)
			{
				NoNotImplementedWarning = noNotImplementedWarning;
			}
		}

		private static readonly Dictionary<string, PresenceFormatProvider> _formatters = new Dictionary<string, PresenceFormatProvider>();

		private static readonly List<Type> _typesToCheckForProviders = new List<Type>();

		private static IArchiveLogger _logger;

		private static IArchiveLogger Logger => _logger ?? (_logger = LoaderWrapper.CreateArSubLoggerInstance("PresenceFormatter", ConsoleColor.DarkMagenta));

		internal static void Setup()
		{
			Logger.Debug("Setting up providers ...");
			typeof(PresenceManager).RegisterAllPresenceFormatProviders(throwOnDuplicate: false);
			foreach (Type typesToCheckForProvider in _typesToCheckForProviders)
			{
				PropertyInfo[] properties = typesToCheckForProvider.GetProperties();
				foreach (PropertyInfo propertyInfo in properties)
				{
					try
					{
						PresenceFormatProvider customAttribute = propertyInfo.GetCustomAttribute<PresenceFormatProvider>();
						if (customAttribute != null)
						{
							customAttribute.SetPropertyInfo(propertyInfo);
							RegisterFormatter(customAttribute);
						}
					}
					catch (Exception ex)
					{
						Logger.Exception(ex);
					}
				}
			}
			foreach (KeyValuePair<string, PresenceFormatProvider> item in _formatters.Where((KeyValuePair<string, PresenceFormatProvider> kvp) => kvp.Value is FallbackPresenceFormatProvider && !((FallbackPresenceFormatProvider)kvp.Value).NoNotImplementedWarning))
			{
				Logger.Warning("Identifier \"" + item.Key + "\" has not been implemented! Using Fallback default values!");
			}
		}

		public static void RegisterAllPresenceFormatProviders(this Type type, bool throwOnDuplicate = true)
		{
			if (type == null)
			{
				throw new ArgumentException("Type must not be null!");
			}
			if (_typesToCheckForProviders.Contains(type))
			{
				if (throwOnDuplicate)
				{
					throw new ArgumentException("Duplicate Type registered: \"" + type?.FullName + "\"");
				}
			}
			else
			{
				_typesToCheckForProviders.Add(type);
			}
		}

		public static void RegisterFormatter(PresenceFormatProvider pfp)
		{
			if (!pfp.IsValid)
			{
				return;
			}
			bool flag = false;
			if (_formatters.TryGetValue(pfp.Identifier, out var value))
			{
				if (pfp is FallbackPresenceFormatProvider)
				{
					return;
				}
				if (!(value is FallbackPresenceFormatProvider))
				{
					throw new ArgumentException($"Duplicate formatter identifier: \"{pfp.Identifier}\" (\"{pfp.DebugIdentifier}\")");
				}
				_formatters.Remove(pfp.Identifier);
				flag = true;
			}
			_formatters.Add(pfp.Identifier, pfp);
			Logger.Debug($"{(flag ? " (Fallback Overridden)" : ((pfp is FallbackPresenceFormatProvider) ? " (Fallback)" : string.Empty))} Registered: \"{pfp.Identifier}\" => {pfp.DebugIdentifier}");
		}

		internal static object Get(string identifier)
		{
			_formatters.TryGetValue(identifier, out var value);
			return value?.GetValue();
		}

		internal static T Get<T>(string identifier)
		{
			_formatters.TryGetValue(identifier, out var value);
			if (value == null)
			{
				return default(T);
			}
			if (!value.PropertyType.IsAssignableFrom(typeof(T)) && typeof(T) != typeof(string))
			{
				throw new ArgumentException($"The property at identifier \"{identifier}\" is not declared as Type \"{typeof(T).Name}\"!");
			}
			return (T)value.GetValue();
		}

		public static string Format(this string formatString, params (string search, string replace)[] extraFormatters)
		{
			return FormatPresenceString(formatString, extraFormatters);
		}

		public static string FormatPresenceString(string formatString)
		{
			return FormatPresenceString(formatString, null);
		}

		public static string FormatPresenceString(string formatString, params (string search, string replace)[] extraFormatters)
		{
			return FormatPresenceString(formatString, stripAllTMPTags: true, extraFormatters);
		}

		public static string FormatPresenceString(string formatString, bool stripAllTMPTags = true, params (string search, string replace)[] extraFormatters)
		{
			string text = formatString;
			foreach (KeyValuePair<string, PresenceFormatProvider> formatter in _formatters)
			{
				if (text.Contains("%" + formatter.Key + "%"))
				{
					text = text.ReplaceCaseInsensitive("%" + formatter.Key + "%", formatter.Value.GetValue()?.ToString() ?? "null");
				}
			}
			if (extraFormatters != null)
			{
				for (int i = 0; i < extraFormatters.Length; i++)
				{
					(string, string) tuple = extraFormatters[i];
					if (text.Contains("%" + tuple.Item1 + "%"))
					{
						text = text.ReplaceCaseInsensitive("%" + tuple.Item1 + "%", tuple.Item2);
					}
				}
			}
			if (stripAllTMPTags)
			{
				return Utils.StripTMPTagsRegex(text.Trim());
			}
			return text.Trim();
		}
	}
	public static class RundownFlagsExtensions
	{
		private static IEnumerable<Utils.RundownFlags> _allFlagsOrdered;

		public static IEnumerable<Utils.RundownFlags> AllFlagsOrdered
		{
			get
			{
				if (_allFlagsOrdered == null)
				{
					_allFlagsOrdered = (from Utils.RundownFlags x in Enum.GetValues(typeof(Utils.RundownFlags))
						orderby x
						select x).Skip(2);
				}
				return _allFlagsOrdered;
			}
		}

		public static bool IsIncludedIn(this Utils.RundownID rundownID, Utils.RundownFlags flags)
		{
			return Utils.FlagsContain(flags, rundownID);
		}

		public static Utils.RundownFlags To(this Utils.RundownFlags flags, Utils.RundownFlags to)
		{
			if (to == Utils.RundownFlags.Latest)
			{
				return flags.ToLatest();
			}
			if (flags > to)
			{
				return Utils.FlagsFromTo(to, flags);
			}
			return Utils.FlagsFromTo(flags, to);
		}

		public static Utils.RundownFlags ToLatest(this Utils.RundownFlags flags)
		{
			return Utils.FlagsFromTo(flags, Utils.RundownFlags.Latest);
		}

		public static Utils.RundownFlags LowestRundownFlag(this Utils.RundownFlags flags)
		{
			return AllFlagsOrdered.FirstOrDefault((Utils.RundownFlags x) => flags.HasFlag(x));
		}

		public static Utils.RundownFlags HighestRundownFlag(this Utils.RundownFlags flags)
		{
			return AllFlagsOrdered.LastOrDefault((Utils.RundownFlags x) => flags.HasFlag(x));
		}

		[Obsolete]
		public static int GetIntValue<T>(this T thisEnum) where T : IConvertible
		{
			if (thisEnum is Enum)
			{
				Type type = thisEnum.GetType();
				foreach (int value in Enum.GetValues(type))
				{
					ref T reference = ref thisEnum;
					T val = default(T);
					if (val == null)
					{
						val = reference;
						reference = ref val;
					}
					if (value == reference.ToInt32(CultureInfo.InvariantCulture) && type.GetField(type.GetEnumName(value)).GetCustomAttributes(typeof(Utils.ValueAttribute), inherit: false).FirstOrDefault() is Utils.ValueAttribute valueAttribute && valueAttribute.Type == typeof(int))
					{
						return (int)valueAttribute.Value;
					}
				}
			}
			return -1;
		}
	}
	public class UnityMessages
	{
		public const string Awake = "Awake";

		public const string Start = "Start";

		public const string Update = "Update";

		public const string FixedUpdate = "FixedUpdate";

		public const string LateUpdate = "LateUpdate";

		public const string OnEnable = "OnEnable";

		public const string OnDisable = "OnDisable";

		public const string OnDestroy = "OnDestroy";

		public const string OnApplicationFocus = "OnApplicationFocus";

		public const string OnApplicationQuit = "OnApplicationQuit";
	}
	public static class Utils
	{
		[Obsolete]
		public class ValueAttribute : Attribute
		{
			public object Value { get; private set; }

			public Type Type { get; private set; }

			public ValueAttribute(object value)
			{
				Value = value;
				Type = value.GetType();
			}
		}

		public enum RundownID
		{
			Latest = -2,
			RundownUnitialized,
			RundownUnknown,
			RundownOne,
			RundownTwo,
			RundownThree,
			RundownFour,
			RundownFive,
			RundownSix,
			RundownSeven,
			RundownAltOne,
			RundownAltTwo,
			RundownAltThree,
			RundownAltFour,
			RundownAltFive,
			RundownAltSix,
			RundownEight
		}

		[Flags]
		public enum RundownFlags
		{
			Latest = -2,
			None = 0,
			RundownOne = 1,
			RundownTwo = 2,
			RundownThree = 4,
			RundownFour = 8,
			RundownFive = 0x10,
			RundownSix = 0x20,
			RundownSeven = 0x40,
			RundownAltOne = 0x80,
			RundownAltTwo = 0x100,
			RundownAltThree = 0x200,
			RundownAltFour = 0x400,
			RundownAltFive = 0x800,
			RundownAltSix = 0x1000,
			RundownEight = 0x2000,
			All = 0x3FFF
		}

		public const BindingFlags AnyBindingFlagss = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		private static Type _UnityEngine_Random;

		private static MethodInfo _UnityEngine_Random_RandomRangeInt;

		private static MethodInfo _UnityEngine_Random_Range;

		private static Type _UnityEngine_Time;

		private static PropertyInfo _UnityEngine_time_PI;

		public const string EXTENDED_WITHOUT_TMP_TAGS = "://EXTENDED";

		public const string EXTENDED = "<color=orange><size=80%>://EXTENDED</size></color>";

		private static RundownID? _latestRundownID;

		private const RundownFlags LatestRundownFlags = RundownFlags.RundownEight;

		internal static float Unity_Time => (float)_UnityEngine_time_PI.GetValue(null);

		static Utils()
		{
			_UnityEngine_Random = Type.GetType("UnityEngine.Random, UnityEngine.CoreModule, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null");
			_UnityEngine_Time = Type.GetType("UnityEngine.Time, UnityEngine.CoreModule, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null");
			_UnityEngine_time_PI = _UnityEngine_Time.GetProperty("time");
			_latestRundownID = null;
			try
			{
				_UnityEngine_Random_RandomRangeInt = _UnityEngine_Random.GetMethod("RandomRangeInt");
			}
			catch (Exception)
			{
			}
			try
			{
				_UnityEngine_Random_Range = _UnityEngine_Random.GetMethod("Range", new Type[2]
				{
					typeof(int),
					typeof(int)
				});
			}
			catch (Exception)
			{
			}
		}

		internal static int RandomRangeInt(int min, int max)
		{
			if (_UnityEngine_Random_RandomRangeInt != null)
			{
				return (int)_UnityEngine_Random_RandomRangeInt.Invoke(null, new object[2] { min, max });
			}
			return (int)_UnityEngine_Random_Range.Invoke(null, new object[2] { min, max });
		}

		public static T PickRandom<T>(this T[] array)
		{
			if (array.Length == 0)
			{
				return default(T);
			}
			return (T)array.GetValue(RandomRangeInt(0, array.Length - 1));
		}

		public static string StripTMPTagsRegex(string input)
		{
			return Regex.Replace(input, "<.*?>", string.Empty);
		}

		public static T PickRandom<T>(this List<T> list)
		{
			return list.ToArray().PickRandom();
		}

		public static T PickRandomExcept<T>(this T[] array, T except)
		{
			if (array.Length == 1)
			{
				return array[0];
			}
			int num = 0;
			T result;
			do
			{
				result = array.PickRandom();
				num++;
			}
			while (result.Equals(except) && num < 20);
			return result;
		}

		public static T PickRandomExcept<T>(this List<T> list, T except)
		{
			if (list != null)
			{
				return list.ToArray().PickRandomExcept(except);
			}
			return default(T);
		}

		public static T PickRandomExcept<T>(this T[] array, Func<T, bool> selectFunction)
		{
			if (array.Length == 1)
			{
				return array[0];
			}
			int num = 0;
			T val;
			do
			{
				val = array.PickRandom();
				num++;
			}
			while (!selectFunction(val) && num < 20);
			return val;
		}

		public static T PickRandomExcept<T>(this List<T> list, Func<T, bool> selectFunction)
		{
			if (list != null)
			{
				return list.ToArray().PickRandomExcept(selectFunction);
			}
			return default(T);
		}

		public static bool TryPickRandom<T>(this T[] array, out T value)
		{
			if (array.Length == 0)
			{
				value = default(T);
				return false;
			}
			value = array[RandomRangeInt(0, array.Length - 1)];
			return true;
		}

		public static bool TryPickRandom<T>(this List<T> list, out T value)
		{
			if (list.Count == 0)
			{
				value = default(T);
				return false;
			}
			value = list[RandomRangeInt(0, list.Count - 1)];
			return true;
		}

		public static T GetEnumFromName<T>(string name) where T : struct
		{
			if (Enum.TryParse<T>(name, out var result))
			{
				return result;
			}
			ArchiveLogger.Warning($"{"GetEnumFromName"} couldn't resolve enum \"{name}\" from type \"{typeof(T).FullName}\"!");
			return default(T);
		}

		public static bool TryGetEnumFromName<T>(string name, out T value) where T : struct
		{
			if (Enum.TryParse<T>(name, out value))
			{
				return true;
			}
			return false;
		}

		public static object StartCoroutine(IEnumerator routine)
		{
			return LoaderWrapper.StartCoroutine(routine);
		}

		public static void StopCoroutine(object coroutineToken)
		{
			LoaderWrapper.StopCoroutine(coroutineToken);
		}

		public static string GetRundownTag(RundownFlags rundowns, bool generalizeLatest = false)
		{
			Enum.TryParse<RundownID>(rundowns.LowestRundownFlag().ToString(), out var result);
			Enum.TryParse<RundownID>(rundowns.HighestRundownFlag().ToString(), out var result2);
			if (result2 == RundownID.RundownUnknown)
			{
				result2 = GetLatestRundownID();
			}
			bool flag = result2 == GetLatestRundownID();
			if (result == result2)
			{
				string value = "R";
				if (result >= RundownID.RundownAltOne && result < RundownID.RundownEight)
				{
					value = "A";
					result = result - 8 + 1;
				}
				if (result >= RundownID.RundownEight)
				{
					result -= 6;
				}
				return $"{value}{result}";
			}
			string value2 = "R";
			if (result >= RundownID.RundownAltOne && result < RundownID.RundownEight)
			{
				value2 = "A";
				result = result - 8 + 1;
			}
			else if (result >= RundownID.RundownEight)
			{
				result -= 6;
			}
			string text = "R";
			if (result2 >= RundownID.RundownAltOne && result2 < RundownID.RundownEight)
			{
				text = "A";
				result2 = result2 - 8 + 1;
			}
			else if (result2 >= RundownID.RundownEight)
			{
				result2 -= 6;
			}
			DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(1, 3);
			defaultInterpolatedStringHandler.AppendFormatted(value2);
			defaultInterpolatedStringHandler.AppendFormatted((int)result);
			defaultInterpolatedStringHandler.AppendLiteral("-");
			object value3;
			if (!(flag && generalizeLatest))
			{
				string text2 = text;
				int num = (int)result2;
				value3 = text2 + num;
			}
			else
			{
				value3 = "RL";
			}
			defaultInterpolatedStringHandler.AppendFormatted((string?)value3);
			return defaultInterpolatedStringHandler.ToStringAndClear();
		}

		public static string GetRundownTitle()
		{
			return GetRundownTitle(ArchiveMod.CurrentRundown);
		}

		public static string GetRundownTitle(RundownID rundown)
		{
			return rundown switch
			{
				RundownID.RundownOne => "Rundown Protocol #001", 
				RundownID.RundownTwo => "Infection", 
				RundownID.RundownThree => "The Vessel", 
				RundownID.RundownFour => "Contact", 
				RundownID.RundownFive => "Rebirth", 
				RundownID.RundownSix => "Destination", 
				RundownID.RundownSeven => "Rise", 
				_ => "Unknown", 
			};
		}

		public static string GetHash(byte[] bytes)
		{
			using SHA256 sHA = SHA256.Create();
			byte[] array = sHA.ComputeHash(bytes);
			StringBuilder stringBuilder = new StringBuilder();
			byte[] array2 = array;
			foreach (byte b in array2)
			{
				stringBuilder.Append(b.ToString("x2"));
			}
			return stringBuilder.ToString();
		}

		public static string UsersafeFormat(string format, params string[] replacementData)
		{
			for (int i = 0; i < replacementData.Length; i++)
			{
				string text = $"{{{i}}}";
				if (format.Contains(text))
				{
					format = format.ReplaceCaseInsensitive(text, replacementData[i]);
				}
			}
			return format;
		}

		public static IList ToSystemListSlow(object allBlocks, Type type)
		{
			if (LoaderWrapper.IsGameIL2CPP())
			{
				Type type2 = ImplementationManager.GameTypeByIdentifier("GenericList").MakeGenericType(type);
				IList list = (IList)Activator.CreateInstance(typeof(List<>).MakeGenericType(type));
				IEnumerator enumerator = ((IEnumerable)type2.GetMethod("ToArray", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).Invoke(allBlocks, Array.Empty<object>())).GetEnumerator();
				while (enumerator.MoveNext())
				{
					list.Add(enumerator.Current);
				}
				return list;
			}
			return (IList)allBlocks;
		}

		public static string ToRoman(int number)
		{
			if (number < 0 || number > 3999)
			{
				throw new ArgumentOutOfRangeException("insert value betwheen 1 and 3999");
			}
			if (number < 1)
			{
				return string.Empty;
			}
			if (number >= 1000)
			{
				return "M" + ToRoman(number - 1000);
			}
			if (number >= 900)
			{
				return "CM" + ToRoman(number - 900);
			}
			if (number >= 500)
			{
				return "D" + ToRoman(number - 500);
			}
			if (number >= 400)
			{
				return "CD" + ToRoman(number - 400);
			}
			if (number >= 100)
			{
				return "C" + ToRoman(number - 100);
			}
			if (number >= 90)
			{
				return "XC" + ToRoman(number - 90);
			}
			if (number >= 50)
			{
				return "L" + ToRoman(number - 50);
			}
			if (number >= 40)
			{
				return "XL" + ToRoman(number - 40);
			}
			if (number >= 10)
			{
				return "X" + ToRoman(number - 10);
			}
			if (number >= 9)
			{
				return "IX" + ToRoman(number - 9);
			}
			if (number >= 5)
			{
				return "V" + ToRoman(number - 5);
			}
			if (number >= 4)
			{
				return "IV" + ToRoman(number - 4);
			}
			if (number >= 1)
			{
				return "I" + ToRoman(number - 1);
			}
			throw new ArgumentOutOfRangeException("something bad happened");
		}

		public static bool IsPowerOfTwo(ulong x)
		{
			if (x != 0L)
			{
				return (x & (x - 1)) == 0;
			}
			return false;
		}

		public static string ReplaceCaseInsensitive(this string input, string search, string replacement)
		{
			return Regex.Replace(input, Regex.Escape(search), replacement.Replace("$", "$$"), RegexOptions.IgnoreCase);
		}

		public static byte[] LoadFromResource(string resourcePath)
		{
			return GetResource(Assembly.GetCallingAssembly(), resourcePath);
		}

		public static byte[] GetResource(Assembly assembly, string resourcePath)
		{
			Stream manifestResourceStream = assembly.GetManifestResourceStream(resourcePath);
			byte[] array = new byte[manifestResourceStream.Length];
			manifestResourceStream.Read(array, 0, (int)manifestResourceStream.Length);
			return array;
		}

		public static string GetStartupTextForRundown(RundownID currentRundownID)
		{
			StringBuilder stringBuilder = new StringBuilder();
			switch (currentRundownID)
			{
			case RundownID.RundownOne:
				stringBuilder.Append("<color=red>Rundown #001</color>");
				break;
			case RundownID.RundownTwo:
				stringBuilder.Append("<color=red>Rundown #002 Infection</color>");
				break;
			case RundownID.RundownThree:
				stringBuilder.Append("<color=red>Rundown #003 The Vessel</color>");
				break;
			case RundownID.RundownFour:
				stringBuilder.Append("<color=red>Rundown #004 Contact</color>");
				break;
			case RundownID.RundownFive:
				stringBuilder.Append("<color=red>Rundown #005 Rebirth</color>");
				break;
			default:
				return "<color=red>Rundown #??? Yo Waddup?!</color>\n\nThis shouldn't happen unless you somehow modified the datablocks in R1 to R5 builds ...\nAnyways, things are probably gonna break :)";
			}
			stringBuilder.Append("\n");
			stringBuilder.Append("<size=80%><color=#8211b2>The Archive active.</color></size>\n\n");
			return stringBuilder.ToString();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public static RundownID GetLatestRundownID()
		{
			RundownID valueOrDefault = _latestRundownID.GetValueOrDefault();
			if (!_latestRundownID.HasValue)
			{
				valueOrDefault = GetEnumFromName<RundownID>(GetLatestRundownFlags().ToString());
				_latestRundownID = valueOrDefault;
				return valueOrDefault;
			}
			return valueOrDefault;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public static RundownFlags GetLatestRundownFlags()
		{
			return RundownFlags.RundownEight;
		}

		public static bool FlagsContain(RundownFlags flags, RundownID id)
		{
			if (flags == RundownFlags.None)
			{
				return false;
			}
			if (id == RundownID.RundownUnknown)
			{
				return false;
			}
			RundownFlags latestRundownFlags = GetLatestRundownFlags();
			if (flags == RundownFlags.Latest)
			{
				flags = latestRundownFlags;
			}
			if (id == RundownID.Latest)
			{
				id = GetLatestRundownID();
			}
			if (!Enum.TryParse<RundownFlags>(id.ToString(), out var result))
			{
				return false;
			}
			return (flags & result) == result;
		}

		public static RundownFlags FlagsFromTo(RundownFlags from, RundownFlags to)
		{
			if (from == RundownFlags.Latest)
			{
				from = GetLatestRundownFlags();
			}
			if (to == RundownFlags.Latest)
			{
				to = GetLatestRundownFlags();
			}
			if (from == to)
			{
				return from;
			}
			if (from > to)
			{
				throw new ArgumentException($"{"from"} ({from}) may not be larger than {"to"} ({to})!");
			}
			if (!IsPowerOfTwo((ulong)from) || !IsPowerOfTwo((ulong)to) || from > to)
			{
				return RundownFlags.None;
			}
			RundownFlags? rundownFlags = null;
			for (int num = (int)from; num <= (int)to; num *= 2)
			{
				rundownFlags = (RundownFlags?)((!rundownFlags.HasValue) ? ((ValueType)new RundownFlags?((RundownFlags)num)) : ((ValueType)((uint?)rundownFlags | (uint)num)));
			}
			return rundownFlags.Value;
		}

		public static bool AnyRundownConstraintMatches(MemberInfo memberInfo)
		{
			IEnumerable<RundownConstraint> customAttributes = memberInfo.GetCustomAttributes<RundownConstraint>();
			if (customAttributes.Count() == 0)
			{
				return true;
			}
			RundownID rundown = ArchiveMod.CurrentBuildInfo.Rundown;
			foreach (RundownConstraint item in customAttributes)
			{
				if (item.Matches(rundown))
				{
					return true;
				}
			}
			return false;
		}

		public static bool AnyBuildConstraintMatches(MemberInfo memberInfo)
		{
			IEnumerable<BuildConstraint> customAttributes = memberInfo.GetCustomAttributes<BuildConstraint>();
			if (customAttributes.Count() == 0)
			{
				return true;
			}
			int buildNumber = ArchiveMod.CurrentBuildInfo.BuildNumber;
			foreach (BuildConstraint item in customAttributes)
			{
				if (item.Matches(buildNumber))
				{
					return true;
				}
			}
			return false;
		}

		public static bool TryGetMethodByName(Type type, string name, out MethodInfo methodInfo)
		{
			if (type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).Any((MethodInfo x) => x.Name.Equals(name)))
			{
				methodInfo = type.GetMethod(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				return true;
			}
			methodInfo = null;
			return false;
		}

		public static HashSet<Type> GetNestedClasses(Type type)
		{
			List<Type> list = new List<Type> { type };
			Type[] nestedTypes = type.GetNestedTypes();
			foreach (Type type2 in nestedTypes)
			{
				if (type2.IsClass)
				{
					list.AddRange(GetNestedClasses(type2));
				}
			}
			return list.ToHashSet();
		}

		public static string ByteArrayToString(byte[] data)
		{
			StringBuilder stringBuilder = new StringBuilder(data.Length * 2);
			foreach (byte b in data)
			{
				stringBuilder.AppendFormat("{0:x2}", b);
			}
			return stringBuilder.ToString();
		}

		public static string HashString(this string input)
		{
			using SHA256 sHA = SHA256.Create();
			byte[] bytes = Encoding.UTF8.GetBytes(input);
			return BitConverter.ToString(sHA.ComputeHash(bytes)).Replace("-", "").ToLower();
		}

		public static string HashStream(Stream stream)
		{
			using SHA256 sHA = SHA256.Create();
			byte[] array = new byte[4096];
			int inputCount;
			while ((inputCount = stream.Read(array, 0, array.Length)) > 0)
			{
				sHA.TransformBlock(array, 0, inputCount, array, 0);
			}
			sHA.TransformFinalBlock(new byte[0], 0, 0);
			return ByteArrayToString(sHA.Hash);
		}
	}
}
namespace TheArchive.Loader
{
	public static class LoaderWrapper
	{
		public static class ClassInjector
		{
			public static IntPtr DerivedConstructorPointer<T>()
			{
				return ClassInjector.DerivedConstructorPointer<T>();
			}

			public static void DerivedConstructorBody(Il2CppObjectBase objectBase)
			{
				ClassInjector.DerivedConstructorBody(objectBase);
			}

			public static void RegisterTypeInIl2Cpp<T>(bool logSuccess = false) where T : class
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Expected O, but got Unknown
				RegisterTypeOptions val = new RegisterTypeOptions();
				val.set_LogSuccess(logSuccess);
				ClassInjector.RegisterTypeInIl2Cpp<T>(val);
			}

			public static void RegisterTypeInIl2CppWithInterfaces<T>(bool logSuccess = false, params Type[] interfaces) where T : class
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Expected O, but got Unknown
				RegisterTypeOptions val = new RegisterTypeOptions();
				val.set_Interfaces(Il2CppInterfaceCollection.op_Implicit(interfaces));
				val.set_LogSuccess(logSuccess);
				ClassInjector.RegisterTypeInIl2Cpp<T>(val);
			}
		}

		public static string GameDirectory => Paths.GameRootPath;

		public static string UserDataDirectory => Path.Combine(GameDirectory, "UserData");

		public static bool IsIL2CPPType(Type type)
		{
			if (!IsGameIL2CPP())
			{
				return false;
			}
			return ArchiveMod.IL2CPP_BaseType.IsAssignableFrom(type);
		}

		public static bool IsGameIL2CPP()
		{
			return true;
		}

		public static IArchiveLogger CreateLoggerInstance(string name, ConsoleColor col = ConsoleColor.White)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			return new BIE_LogWrapper(new ManualLogSource(name));
		}

		public static IArchiveLogger CreateArSubLoggerInstance(string name, ConsoleColor col = ConsoleColor.White)
		{
			return CreateLoggerInstance("Ar::" + name, col);
		}

		public static IArchiveLogger WrapLogger(ManualLogSource loggerInstance)
		{
			return new BIE_LogWrapper(loggerInstance);
		}

		public static object StartCoroutine(IEnumerator routine)
		{
			return MonoBehaviourExtensions.StartCoroutine(BIE_ArchiveMod.MainComponent, routine);
		}

		public static void StopCoroutine(object coroutineToken)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			BIE_ArchiveMod.MainComponent.StopCoroutine((Coroutine)coroutineToken);
		}

		public unsafe static void* GetIl2CppMethod<T>(string methodName, string returnTypeName, bool isGeneric, params string[] argTypes) where T : Il2CppObjectBase
		{
			void** ptr = (void**)IL2CPP.GetIl2CppMethod(Il2CppClassPointerStore<T>.NativeClassPtr, isGeneric, methodName, returnTypeName, argTypes).ToPointer();
			if (ptr == null)
			{
				return ptr;
			}
			return *ptr;
		}

		public unsafe static TDelegate GetIl2CppMethod<T, TDelegate>(string methodName, string returnTypeName, bool isGeneric, params string[] argTypes) where T : Il2CppObjectBase where TDelegate : Delegate
		{
			void* il2CppMethod = GetIl2CppMethod<T>(methodName, returnTypeName, isGeneric, argTypes);
			if (il2CppMethod == null)
			{
				return null;
			}
			return Marshal.GetDelegateForFunctionPointer<TDelegate>((IntPtr)il2CppMethod);
		}

		public unsafe static INativeDetour ApplyNativeHook<TClass, TDelegate>(string methodName, string returnType, string[] paramTypes, TDelegate to, out TDelegate original) where TClass : Object where TDelegate : Delegate
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			IntPtr nativeClassPtr = Il2CppClassPointerStore<TClass>.NativeClassPtr;
			if (nativeClassPtr == IntPtr.Zero)
			{
				throw new ArgumentException(typeof(TClass).Name + " does not exist in il2cpp domain");
			}
			return INativeDetour.CreateAndApply<TDelegate>(UnityVersionHandler.Wrap((Il2CppMethodInfo*)(void*)IL2CPP.il2cpp_method_get_from_reflection(((Il2CppObjectBase)new MethodInfo(IL2CPP.il2cpp_method_get_object(IL2CPP.GetIl2CppMethod(nativeClassPtr, false, methodName, returnType, paramTypes), nativeClassPtr))).Pointer)).MethodPointer, to, ref original);
		}

		public unsafe static INativeDetour ApplyNativeHook<TClass, TDelegate>(string methodName, string returnType, string[] paramTypes, Type[] genericArguments, TDelegate to, out TDelegate original) where TClass : Object where TDelegate : Delegate
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			IntPtr nativeClassPtr = Il2CppClassPointerStore<TClass>.NativeClassPtr;
			if (nativeClassPtr == IntPtr.Zero)
			{
				throw new ArgumentException(typeof(TClass).Name + " does not exist in il2cpp domain");
			}
			MethodInfo val = new MethodInfo(IL2CPP.il2cpp_method_get_object(IL2CPP.GetIl2CppMethod(nativeClassPtr, true, methodName, returnType, paramTypes), nativeClassPtr));
			val.MakeGenericMethod(((IEnumerable<Type>)genericArguments).Select((Func<Type, Type>)Il2CppType.From).ToArray());
			return INativeDetour.CreateAndApply<TDelegate>(UnityVersionHandler.Wrap((Il2CppMethodInfo*)(void*)IL2CPP.il2cpp_method_get_from_reflection(((Il2CppObjectBase)val).Pointer)).MethodPointer, to, ref original);
		}

		public static bool IsModInstalled(string guid)
		{
			PluginInfo value;
			ModuleInfo value2;
			return ((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.TryGetValue(guid, out value) | (ArchiveModuleChainloader.Instance?.Modules.TryGetValue(guid, out value2) ?? false);
		}
	}
	[BepInPlugin("dev.AuriRex.gtfo.TheArchive", "TheArchive", "0.0.656")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class BIE_ArchiveMod : BasePlugin
	{
		public class TheArchive_BIE_Controller : MonoBehaviour
		{
			public TheArchive_BIE_Controller(IntPtr ptr)
				: base(ptr)
			{
			}

			public void Awake()
			{
				Object.DontDestroyOnLoad((Object)(object)this);
				((Object)this).hideFlags = (HideFlags)61;
			}

			public void Update()
			{
				ArchiveMod.OnUpdate();
			}

			public void LateUpdate()
			{
				ArchiveMod.OnLateUpdate();
			}
		}

		public static MonoBehaviour MainComponent { get; private set; }

		public override void Load()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			Harmony harmonyInstance = new Harmony("dev.AuriRex.gtfo.TheArchive");
			ArchiveMod.OnApplicationStart(LoaderWrapper.WrapLogger(((BasePlugin)this).Log), harmonyInstance);
			Application.quitting += Action.op_Implicit((Action)delegate
			{
				ArchiveMod.OnApplicationQuit();
			});
			MainComponent = (MonoBehaviour)(object)((BasePlugin)this).AddComponent<TheArchive_BIE_Controller>();
		}

		public override bool Unload()
		{
			ArchiveMod.OnApplicationQuit();
			return ((BasePlugin)this).Unload();
		}
	}
	internal class BIE_LogWrapper : IArchiveLogger
	{
		private readonly ManualLogSource _logger;

		public BIE_LogWrapper(ManualLogSource logger)
		{
			_logger = logger;
			if (!Logger.Sources.Contains((ILogSource)(object)_logger))
			{
				Logger.Sources.Add((ILogSource)(object)_logger);
			}
		}

		public void Success(string msg)
		{
			_logger.LogMessage((object)msg);
		}

		public void Notice(string msg)
		{
			_logger.LogMessage((object)msg);
		}

		public void Info(string msg)
		{
			_logger.LogInfo((object)msg);
		}

		public void Fail(string msg)
		{
			_logger.LogInfo((object)msg);
		}

		public void Msg(ConsoleColor col, string msg)
		{
			_logger.LogMessage((object)msg);
		}

		public void Msg(string msg)
		{
			_logger.LogMessage((object)msg);
		}

		public void Debug(string msg)
		{
			_logger.LogDebug((object)msg);
		}

		public void Warning(string msg)
		{
			_logger.LogWarning((object)msg);
		}

		public void Error(string msg)
		{
			_logger.LogError((object)msg);
		}

		public void Exception(Exception ex)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			ManualLogSource logger = _logger;
			bool flag = default(bool);
			BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(3, 3, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\n");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.StackTrace);
			}
			logger.LogError(val);
		}
	}
}
namespace TheArchive.Interfaces
{
	public interface IArchiveLogger
	{
		void Success(string msg);

		void Notice(string msg);

		void Msg(ConsoleColor col, string msg);

		void Info(string msg);

		void Fail(string msg);

		void Debug(string msg);

		void Warning(string msg);

		void Error(string msg);

		void Exception(Exception ex);
	}
	public interface IBaseGameConverter<CT> where CT : class, new()
	{
		CT FromBaseGame(object baseGame, CT existingCT = null);

		object ToBaseGame(CT customType, object existingBaseGame = null);

		Type GetBaseGameType();

		Type GetCustomType();
	}
	public interface IInitAfterDataBlocksReady : IInitializable
	{
	}
	public interface IInitAfterGameDataInitialized : IInitializable
	{
	}
	public interface IInitCondition
	{
		bool InitCondition();
	}
	public interface IInitializable
	{
		void Init();
	}
	public interface IInitImmediately : IInitializable
	{
	}
	public interface IInjectLogger
	{
		IArchiveLogger Logger { get; set; }
	}
}
namespace TheArchive.Core
{
	internal class ArchiveContractResolver : DefaultContractResolver
	{
		public static readonly ArchiveContractResolver Instance = new ArchiveContractResolver();

		protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			JsonProperty val = ((DefaultContractResolver)this).CreateProperty(member, memberSerialization);
			if (typeof(ISettingsComponent).IsAssignableFrom(val.PropertyType))
			{
				val.Ignored = true;
			}
			return val;
		}
	}
	public class ArchiveLegacyNativePatcher
	{
		[Obsolete("Just a janky mess, wouldn't recommend using")]
		public class ArchiveLegacyNativePatch : Attribute
		{
			public bool HasType => Type != null;

			public int ParameterCount
			{
				get
				{
					Type[] parameterTypes = ParameterTypes;
					if (parameterTypes == null)
					{
						return 0;
					}
					return parameterTypes.Length;
				}
			}

			public string ReturnTypeString => ReturnType?.Name ?? "void";

			public Type Type { get; internal set; }

			public Type ReturnType { get; set; }

			public string MethodName { get; private set; }

			public Utils.RundownFlags RundownsToPatch { get; private set; }

			public bool GeneralPurposePatch { get; private set; }

			public Type[] ParameterTypes { get; internal set; }

			public ArchiveLegacyNativePatch(Type type, string methodName, Utils.RundownFlags rundowns, Type[] parameterTypes = null, Type returnType = null)
			{
				Type = type;
				MethodName = methodName;
				RundownsToPatch = rundowns;
				ParameterTypes = parameterTypes;
				ReturnType = returnType;
			}

			public ArchiveLegacyNativePatch(Type type, string methodName, Utils.RundownFlags from, Utils.RundownFlags to, Type[] parameterTypes = null, Type returnType = null)
			{
				Type = type;
				MethodName = methodName;
				RundownsToPatch = from.To(to);
				ParameterTypes = parameterTypes;
				ReturnType = returnType;
			}

			public ArchiveLegacyNativePatch(Type type, string methodName, Type[] parameterTypes = null, Type returnType = null)
			{
				Type = type;
				MethodName = methodName;
				ParameterTypes = parameterTypes;
				ReturnType = returnType;
				GeneralPurposePatch = true;
			}
		}

		public class LegacyNativePatchInstance
		{
			public const string kReplacementMethodName = "Replacement";

			public Type DelegateType { get; }

			public Delegate OriginalMethod { get; }

			public bool WasNotAbleToSetProperty { get; }

			private LegacyNativePatchInstance(ArchiveLegacyNativePatch nativePatchInfo, Type patchContainingType)
			{
				if (!ArchiveLegacyPatcher.TryGetMethodByName(nativePatchInfo.Type, nativePatchInfo.MethodName, out var _))
				{
					throw new ArgumentException($"Could not find the original method \"{nativePatchInfo.Type.FullName}.{nativePatchInfo.MethodName}\" targeted by patch \"{patchContainingType.FullName}\"");
				}
				if (!ArchiveLegacyPatcher.TryGetMethodByName(patchContainingType, "Replacement", out var _))
				{
					throw new ArgumentException($"Could not find \"{"Replacement"}\" method for patch \"{patchContainingType.FullName}\"!");
				}
				DelegateType = NativeDelegates.Get(nativePatchInfo);
			}

			internal static LegacyNativePatchInstance CreatePatch(ArchiveLegacyNativePatch nativePatchInfo, Type patchContainingType)
			{
				return new LegacyNativePatchInstance(nativePatchInfo, patchContainingType);
			}
		}

		public static class NativeDelegates
		{
			public delegate void void_Param_0(IntPtr s, IntPtr n);

			public delegate void void_Param_1(IntPtr s, IntPtr a, IntPtr n);

			public delegate void void_Param_2(IntPtr s, IntPtr a, IntPtr b, IntPtr n);

			public delegate void void_Param_3(IntPtr s, IntPtr a, IntPtr b, IntPtr c, IntPtr n);

			internal static Type Get(ArchiveLegacyNativePatch nativePatchInfo)
			{
				string text = $"{nativePatchInfo.ReturnTypeString}_Param_{nativePatchInfo.ParameterCount}";
				Type? nestedType = typeof(NativeDelegates).GetNestedType(text, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				if (nestedType == null)
				{
					throw new NotImplementedException(text);
				}
				return nestedType;
			}
		}

		private Utils.RundownID _currentRundown;

		private Type[] _patchTypes;

		private List<LegacyNativePatchInstance> _patchInstances = new List<LegacyNativePatchInstance>();

		public void ApplyNativePatches(Utils.RundownID currentRundown, Assembly assembly)
		{
			_currentRundown = currentRundown;
			ArchiveLogger.Msg(ConsoleColor.Magenta, "Applying Native Patches for assembly \"" + assembly.GetName().Name + "\" ...");
			if (_patchTypes == null)
			{
				_patchTypes = ArchiveLegacyPatcher.GetAllTypesWithPatchAttribute(typeof(ArchiveLegacyNativePatch), assembly);
			}
			Type[] patchTypes = _patchTypes;
			foreach (Type type in patchTypes)
			{
				try
				{
					ArchiveLegacyNativePatch customAttribute = type.GetCustomAttribute<ArchiveLegacyNativePatch>();
					ArchiveLegacyPatcher.TryGetBindToSettingsAttribute(type, out var bindPatchToSettingsInfo);
					if (!ArchiveLegacyPatcher.IsPatchEnabledInSettings(ArchiveMod.Settings, bindPatchToSettingsInfo, type.FullName))
					{
						ArchiveLogger.Msg(ConsoleColor.DarkMagenta, $"[{bindPatchToSettingsInfo.BindToSetting}==false] Skipped native patch: \"{type.FullName}\". ({customAttribute.RundownsToPatch})");
						continue;
					}
					if (!customAttribute.GeneralPurposePatch && !Utils.FlagsContain(customAttribute.RundownsToPatch, currentRundown))
					{
						ArchiveLogger.Warning($"Not native patching meth