using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using EntityStates;
using HG.Reflection;
using HarmonyLib;
using HarmonyLib.Public.Patching;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Collections.Generic;
using MonoDetour;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using MonoMod.RuntimeDetour.HookGen;
using MonoMod.Utils;
using RoR2;
using RoR2.Achievements;
using RoR2.ConVar;
using RoR2.ContentManagement;
using RoR2.EntitlementManagement;
using RoR2.Items;
using RoR2.Networking;
using RoR2.UI;
using RoR2.UI.MainMenu;
using RoR2BepInExPack.GameAssetPaths.Version_1_39_0;
using RoR2BepInExPack.LegacyAssetSystem;
using RoR2BepInExPack.ModCompatibility;
using RoR2BepInExPack.ReflectionHooks;
using RoR2BepInExPack.UnityEngineHooks;
using RoR2BepInExPack.VanillaFixes;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("0Harmony")]
[assembly: IgnoresAccessChecksTo("HGUnityUtils")]
[assembly: AssemblyCompany("RoR2BepInExPack")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.43.0")]
[assembly: AssemblyInformationalVersion("1.43.0+6757a9cd683ac03d499276599cef90b52c9aa39f")]
[assembly: AssemblyProduct("RoR2BepInExPack")]
[assembly: AssemblyTitle("RoR2BepInExPack")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.43.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class 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;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NativeIntegerAttribute : Attribute
	{
		public readonly bool[] TransformFlags;

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace RoR2BepInExPack
{
	internal static class HookWatcher
	{
		internal class HookInfo
		{
			internal enum HookKind
			{
				On,
				IL,
				Native
			}

			internal HookKind Kind;

			internal Assembly? Owner;

			internal MethodBase? OriginalManaged;

			internal IntPtr OriginalNative;

			internal Delegate? HookDelegate;

			internal IntPtr HookIntPtr;

			internal MethodBase? HookMethodBase;
		}

		private static Hook _harmonyWatcher;

		private static bool _isMonoDetourPresent;

		internal static bool RedirectFixFrameRateDependantLogicHooks;

		private static DetourModManager ModManager { get; set; }

		internal static void Init()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Expected O, but got Unknown
			try
			{
				_isMonoDetourPresent = (object)Type.GetType("MonoDetour.MonoDetourHook, com.github.MonoDetour")?.GetMethod("TryGetFrom") != null;
			}
			catch (Exception data)
			{
				Log.Error(data);
			}
			ModManager = new DetourModManager();
			ModManager.OnHook += LogOnHook;
			ModManager.OnILHook += LogILHook;
			ModManager.OnDetour += LogDetour;
			ModManager.OnNativeDetour += LogNativeDetour;
			HookEndpointManager.OnAdd += LogHookAdd;
			HookEndpointManager.OnModify += LogHookModify;
			HookEndpointManager.OnRemove += LogHookRemove;
			_harmonyWatcher = new Hook((MethodBase)typeof(Job<MethodInfo>).GetMethod("AddPatch", (BindingFlags)(-1)), (Delegate)new Action<Action<Job<MethodInfo>, AttributePatch>, Job<MethodInfo>, AttributePatch>(HarmonyAddPatchWatcher), new HookConfig
			{
				ManualApply = true
			});
			_harmonyWatcher.Apply();
		}

		private static void HarmonyAddPatchWatcher(Action<Job<MethodInfo>, AttributePatch> orig, Job<MethodInfo> self, AttributePatch patch)
		{
			orig(self, patch);
			try
			{
				Assembly assembly = patch.info.method.DeclaringType.Assembly;
				string text = (string.IsNullOrEmpty(assembly.Location) ? assembly.GetName().Name : Path.GetFileName(assembly.Location));
				Log.Debug($"Harmony {patch.type} {GeneralExtensions.FullDescription((MethodBase)patch.info.method)} added by {text} for: {GeneralExtensions.FullDescription(self.original)}");
			}
			catch (Exception data)
			{
				Log.Debug(data);
			}
		}

		internal static void Destroy()
		{
			_harmonyWatcher.Undo();
			_harmonyWatcher.Free();
			HookEndpointManager.OnRemove -= LogHookRemove;
			HookEndpointManager.OnModify -= LogHookModify;
			HookEndpointManager.OnAdd -= LogHookAdd;
			ModManager.OnNativeDetour -= LogNativeDetour;
			ModManager.OnDetour -= LogDetour;
			ModManager.OnILHook -= LogILHook;
			ModManager.OnHook -= LogOnHook;
			ModManager.Dispose();
			ModManager = null;
		}

		private static void LogOnHook(Assembly hookOwner, MethodBase from, MethodBase to, object target)
		{
			LogHook(new HookInfo
			{
				Kind = HookInfo.HookKind.On,
				Owner = hookOwner,
				OriginalManaged = from,
				HookMethodBase = to
			});
		}

		private static void LogILHook(Assembly hookOwner, MethodBase from, Manipulator manipulator)
		{
			if (!_isMonoDetourPresent || !IfMonoDetourHookDoSpecializedLog(manipulator, from))
			{
				LogHook(new HookInfo
				{
					Kind = HookInfo.HookKind.IL,
					Owner = hookOwner,
					OriginalManaged = from,
					HookDelegate = (Delegate?)(object)manipulator
				});
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static bool IfMonoDetourHookDoSpecializedLog(Manipulator manipulator, MethodBase from)
		{
			MonoDetourHook val = default(MonoDetourHook);
			if (!MonoDetourHook.TryGetFrom(manipulator, ref val))
			{
				return false;
			}
			string text;
			if (val.ApplierType.Name.EndsWith("Detour", StringComparison.InvariantCulture))
			{
				string name = val.ApplierType.Name;
				text = name.Substring(0, name.Length - 6);
			}
			else
			{
				text = val.ApplierType.Name;
			}
			LogHook(new HookInfo
			{
				Kind = HookInfo.HookKind.IL,
				Owner = val.Manipulator.Module.Assembly,
				OriginalManaged = from,
				HookMethodBase = val.Manipulator
			}, "added", " MonoDetour<" + text + ">");
			return true;
		}

		private static void LogDetour(Assembly hookOwner, MethodBase from, MethodBase to)
		{
			LogHook(new HookInfo
			{
				Kind = HookInfo.HookKind.On,
				Owner = hookOwner,
				OriginalManaged = from,
				HookMethodBase = to
			});
		}

		private static void LogNativeDetour(Assembly hookOwner, MethodBase originalMethod, IntPtr from, IntPtr to)
		{
			LogHook(new HookInfo
			{
				Kind = HookInfo.HookKind.Native,
				Owner = hookOwner,
				OriginalNative = from,
				HookIntPtr = to
			});
		}

		private static bool LogHookAdd(MethodBase from, Delegate to)
		{
			return LogHook(GetHookInfo(from, to));
		}

		private static bool LogHookModify(MethodBase from, Delegate to)
		{
			return LogHook(GetHookInfo(from, to), "modifier");
		}

		private static bool LogHookRemove(MethodBase from, Delegate to)
		{
			return LogHook(GetHookInfo(from, to), "removed");
		}

		private static HookInfo GetHookInfo(MethodBase from, Delegate to)
		{
			HookInfo hookInfo = new HookInfo
			{
				Owner = to.Method.Module.Assembly,
				OriginalManaged = from
			};
			Manipulator val = (Manipulator)(object)((to is Manipulator) ? to : null);
			if (val != null)
			{
				hookInfo.Kind = HookInfo.HookKind.IL;
				hookInfo.HookDelegate = (Delegate?)(object)val;
			}
			else
			{
				hookInfo.Kind = HookInfo.HookKind.On;
				hookInfo.HookDelegate = to;
			}
			return hookInfo;
		}

		private static bool LogHook(HookInfo hookInfo, string context = "added", string? specifier = null)
		{
			HookInfo hookInfo2 = hookInfo;
			if (hookInfo2.OriginalManaged == null)
			{
				return true;
			}
			string text = "Not Found";
			if (hookInfo2.Owner != null)
			{
				text = Path.GetFileName(hookInfo2.Owner.Location);
			}
			Type declaringType = hookInfo2.OriginalManaged.DeclaringType;
			string name = hookInfo2.OriginalManaged.Name;
			string text2 = ((declaringType != null) ? (declaringType.FullName + "." + name) : name);
			Log.Debug($"{hookInfo2.Kind}Hook{specifier} {GetToIdentifier()} {context} by assembly: {text} for: {text2}");
			return true;
			string? GetToIdentifier()
			{
				if ((object)hookInfo2.HookDelegate != null)
				{
					Type type = hookInfo2.HookDelegate.Method?.DeclaringType;
					string text3 = hookInfo2.HookDelegate.Method?.Name;
					if (!(type != null))
					{
						return text3;
					}
					return type.FullName + "." + text3;
				}
				if (hookInfo2.HookMethodBase != null)
				{
					Type declaringType2 = hookInfo2.HookMethodBase.DeclaringType;
					string name2 = hookInfo2.HookMethodBase.Name;
					if (!(declaringType2 != null))
					{
						return name2;
					}
					return declaringType2.FullName + "." + name2;
				}
				return "";
			}
		}
	}
	internal static class Log
	{
		internal static ManualLogSource _logSource;

		internal static void Init(ManualLogSource logSource)
		{
			_logSource = logSource;
		}

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

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

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

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

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

		internal static void Warning(object data)
		{
			_logSource.LogWarning(data);
		}
	}
	[BepInPlugin("___riskofthunder.RoR2BepInExPack", "RoR2BepInExPack", "1.43.0")]
	public class RoR2BepInExPack : BaseUnityPlugin
	{
		public const string PluginGUID = "___riskofthunder.RoR2BepInExPack";

		public const string PluginName = "RoR2BepInExPack";

		public const string PluginVersion = "1.43.0";

		private void Awake()
		{
			Log.Init(((BaseUnityPlugin)this).Logger);
			RoR2Application.isModded = true;
			HookWatcher.Init();
			FrankenMonoPrintStackOverflowException.Init();
			FixLRAPIReturns.Init(((BaseUnityPlugin)this).Info);
			InitHooks();
			Application.quitting += OnApplicationQuitting;
		}

		private void OnEnable()
		{
			EnableHooks();
		}

		private void OnDisable()
		{
			DisableHooks();
		}

		private void OnDestroy()
		{
			DestroyHooks();
			HookWatcher.Destroy();
		}

		private void InitHooks()
		{
			ILLine.Init();
			AutoCatchReflectionTypeLoadException.Init();
			SaferAchievementManager.Init();
			SaferResourceAvailability.Init();
			SaferSearchableAttribute.Init();
			FixConsoleLog.Init();
			FixConVar.Init();
			FixDeathAnimLog.Init();
			FixExtraGameModesMenu.Init();
			SaferWWise.Init();
			FixNullEntitlement.Init();
			FixNonLethalOneHP.Init();
			FixRunScaling.Init();
			FixDedicatedServerMaxPlayerCount.Init();
			FixHasEffectiveAuthority.Init();
			FixSystemInitializer.Init();
			FixRuleBookViewerStrip.Init();
			LogNetworkInvokeException.Init();
			FixDuplicateItemTiers.Init();
			LegacyResourcesDetours.Init();
			LegacyShaderDetours.Init();
			FixMultiCorrupt.Init(((BaseUnityPlugin)this).Config);
			HarmonyMatchException.Init();
		}

		private static void EnableHooks()
		{
			ILLine.Enable();
			AutoCatchReflectionTypeLoadException.Enable();
			SaferAchievementManager.Enable();
			SaferResourceAvailability.Enable();
			SaferSearchableAttribute.Enable();
			FixConsoleLog.Enable();
			FixConVar.Enable();
			FixDeathAnimLog.Enable();
			FixExtraGameModesMenu.Enable();
			SaferWWise.Enable();
			FixNullEntitlement.Enable();
			FixNonLethalOneHP.Enable();
			FixRunScaling.Enable();
			FixDedicatedServerMaxPlayerCount.Enable();
			FixHasEffectiveAuthority.Enable();
			FixRuleBookViewerStrip.Enable();
			LogNetworkInvokeException.Enable();
			FixDuplicateItemTiers.Enable();
			LegacyResourcesDetours.Enable();
			LegacyShaderDetours.Enable();
			FixMultiCorrupt.Enable();
			HarmonyMatchException.Enable();
		}

		private static void DisableHooks()
		{
			HarmonyMatchException.Disable();
			FixMultiCorrupt.Disable();
			LegacyShaderDetours.Disable();
			LegacyResourcesDetours.Disable();
			FixDuplicateItemTiers.Disable();
			LogNetworkInvokeException.Disable();
			FixHasEffectiveAuthority.Disable();
			FixDedicatedServerMaxPlayerCount.Disable();
			FixRunScaling.Disable();
			FixNonLethalOneHP.Disable();
			FixNullEntitlement.Disable();
			SaferWWise.Disable();
			FixExtraGameModesMenu.Disable();
			FixDeathAnimLog.Disable();
			FixConsoleLog.Disable();
			FixConVar.Disable();
			FixRuleBookViewerStrip.Disable();
			SaferSearchableAttribute.Disable();
			SaferResourceAvailability.Disable();
			SaferAchievementManager.Disable();
			AutoCatchReflectionTypeLoadException.Disable();
			ILLine.Disable();
		}

		private static void DestroyHooks()
		{
			HarmonyMatchException.Destroy();
			FixMultiCorrupt.Destroy();
			LegacyShaderDetours.Destroy();
			LegacyResourcesDetours.Destroy();
			FixDuplicateItemTiers.Destroy();
			LogNetworkInvokeException.Destroy();
			FixHasEffectiveAuthority.Destroy();
			FixDedicatedServerMaxPlayerCount.Destroy();
			FixRunScaling.Destroy();
			FixNonLethalOneHP.Destroy();
			FixNullEntitlement.Destroy();
			SaferWWise.Destroy();
			FixExtraGameModesMenu.Destroy();
			FixDeathAnimLog.Destroy();
			FixConsoleLog.Destroy();
			FixConVar.Destroy();
			FixRuleBookViewerStrip.Destroy();
			SaferSearchableAttribute.Destroy();
			SaferResourceAvailability.Destroy();
			SaferAchievementManager.Destroy();
			AutoCatchReflectionTypeLoadException.Destroy();
			ILLine.Destroy();
		}

		private void OnApplicationQuitting()
		{
			//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_000b: Expected O, but got Unknown
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject();
			Object.DontDestroyOnLoad((Object)val);
			Scene scene = val.scene;
			GameObject[] rootGameObjects = ((Scene)(ref scene)).GetRootGameObjects();
			foreach (GameObject val2 in rootGameObjects)
			{
				try
				{
					Object.DestroyImmediate((Object)(object)val2);
				}
				catch (Exception data)
				{
					Log.Error(data);
				}
			}
		}
	}
}
namespace RoR2BepInExPack.Utilities
{
	public class FixedConditionalWeakTable<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IReadOnlyDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, FixedConditionalWeakTableManager.IShrinkable where TKey : class where TValue : class
	{
		private readonly struct WeakReferenceWrapper<T> where T : class
		{
			public readonly int targetHashCode;

			public readonly WeakReference<T> weakReference;

			public readonly T target;

			public WeakReferenceWrapper(T target, bool strongReference)
			{
				targetHashCode = target.GetHashCode();
				if (strongReference)
				{
					this.target = target;
					weakReference = null;
				}
				else
				{
					this.target = null;
					weakReference = new WeakReference<T>(target);
				}
			}

			public WeakReferenceWrapper(int targetHashCode)
			{
				this.targetHashCode = targetHashCode;
				target = null;
				weakReference = null;
			}
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		private readonly struct WeakReferenceWrapperComparer<T> : IEqualityComparer<WeakReferenceWrapper<T>> where T : class
		{
			public bool Equals(WeakReferenceWrapper<T> first, WeakReferenceWrapper<T> second)
			{
				T target = first.target;
				T target2 = second.target;
				T target3;
				if (target == null && first.weakReference == null)
				{
					return !second.weakReference.TryGetTarget(out target3);
				}
				if (target2 == null && second.weakReference == null)
				{
					return !first.weakReference.TryGetTarget(out target3);
				}
				if (target == null && !first.weakReference.TryGetTarget(out target))
				{
					return false;
				}
				if (target2 == null && !second.weakReference.TryGetTarget(out target2))
				{
					return false;
				}
				return target == target2;
			}

			public int GetHashCode(WeakReferenceWrapper<T> obj)
			{
				return obj.targetHashCode;
			}
		}

		[CompilerGenerated]
		private sealed class <GetEnumerator>d__32 : IEnumerator<KeyValuePair<TKey, TValue>>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private KeyValuePair<TKey, TValue> <>2__current;

			public FixedConditionalWeakTable<TKey, TValue> <>4__this;

			private IEnumerator<KeyValuePair<WeakReferenceWrapper<TKey>, TValue>> <>7__wrap1;

			KeyValuePair<TKey, TValue> IEnumerator<KeyValuePair<TKey, TValue>>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetEnumerator>d__32(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					FixedConditionalWeakTable<TKey, TValue> fixedConditionalWeakTable = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = fixedConditionalWeakTable.valueByKey.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					while (<>7__wrap1.MoveNext())
					{
						<>7__wrap1.Current.Deconstruct(out var key, out var value);
						WeakReferenceWrapper<TKey> weakReferenceWrapper = key;
						TValue value2 = value;
						if (weakReferenceWrapper.weakReference.TryGetTarget(out var target))
						{
							<>2__current = new KeyValuePair<TKey, TValue>(target, value2);
							<>1__state = 1;
							return true;
						}
					}
					<>m__Finally1();
					<>7__wrap1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private ConstructorInfo cachedConstructor;

		private readonly ConcurrentDictionary<WeakReferenceWrapper<TKey>, TValue> valueByKey = new ConcurrentDictionary<WeakReferenceWrapper<TKey>, TValue>(default(WeakReferenceWrapperComparer<TKey>));

		public TValue this[TKey key]
		{
			get
			{
				return valueByKey[new WeakReferenceWrapper<TKey>(key, strongReference: true)];
			}
			set
			{
				valueByKey[new WeakReferenceWrapper<TKey>(key, strongReference: false)] = value;
			}
		}

		public ICollection<TKey> Keys
		{
			get
			{
				List<TKey> list = new List<TKey>(valueByKey.Count);
				foreach (WeakReferenceWrapper<TKey> key in valueByKey.Keys)
				{
					if (key.weakReference.TryGetTarget(out var target))
					{
						list.Add(target);
					}
				}
				return list.AsReadOnly();
			}
		}

		public ICollection<TValue> Values
		{
			get
			{
				List<TValue> list = new List<TValue>(valueByKey.Count);
				foreach (KeyValuePair<WeakReferenceWrapper<TKey>, TValue> item2 in valueByKey)
				{
					item2.Deconstruct(out var key, out var value);
					WeakReferenceWrapper<TKey> weakReferenceWrapper = key;
					TValue item = value;
					if (weakReferenceWrapper.weakReference.TryGetTarget(out var _))
					{
						list.Add(item);
					}
				}
				return list.AsReadOnly();
			}
		}

		public int Count
		{
			get
			{
				int num = 0;
				foreach (WeakReferenceWrapper<TKey> key in valueByKey.Keys)
				{
					if (key.weakReference.TryGetTarget(out var _))
					{
						num++;
					}
				}
				return num;
			}
		}

		public int SpeculativeCount => valueByKey.Count;

		bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => false;

		IEnumerable<TKey> IReadOnlyDictionary<TKey, TValue>.Keys => Keys;

		IEnumerable<TValue> IReadOnlyDictionary<TKey, TValue>.Values => Values;

		public FixedConditionalWeakTable()
		{
			FixedConditionalWeakTableManager.Add(this);
		}

		public void Add(TKey key, TValue value)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			if (!valueByKey.TryAdd(new WeakReferenceWrapper<TKey>(key, strongReference: false), value))
			{
				throw new ArgumentException("The key already exists");
			}
		}

		public bool Remove(TKey key)
		{
			TValue value;
			return valueByKey.TryRemove(new WeakReferenceWrapper<TKey>(key, strongReference: true), out value);
		}

		public bool TryGetValue(TKey key, out TValue value)
		{
			return valueByKey.TryGetValue(new WeakReferenceWrapper<TKey>(key, strongReference: true), out value);
		}

		public TValue GetValue(TKey key, Func<TKey, TValue> defaultFunc)
		{
			if (TryGetValue(key, out var value))
			{
				return value;
			}
			value = defaultFunc(key);
			Add(key, value);
			return value;
		}

		public TValue GetOrCreateValue(TKey key)
		{
			if (TryGetValue(key, out var value))
			{
				return value;
			}
			if ((object)cachedConstructor == null)
			{
				Type typeFromHandle = typeof(TValue);
				cachedConstructor = typeFromHandle.GetConstructor(Array.Empty<Type>());
				if ((object)cachedConstructor == null)
				{
					throw new MissingMethodException(typeFromHandle.FullName + " doesn't have public parameterless constructor");
				}
			}
			value = (TValue)cachedConstructor.Invoke(Array.Empty<object>());
			Add(key, value);
			return value;
		}

		void FixedConditionalWeakTableManager.IShrinkable.Shrink()
		{
			foreach (KeyValuePair<WeakReferenceWrapper<TKey>, TValue> item in valueByKey)
			{
				if (!item.Key.weakReference.TryGetTarget(out var _))
				{
					valueByKey.TryRemove(new WeakReferenceWrapper<TKey>(item.Key.targetHashCode), out var _);
				}
			}
		}

		public bool ContainsKey(TKey key)
		{
			return valueByKey.ContainsKey(new WeakReferenceWrapper<TKey>(key, strongReference: true));
		}

		public void Clear()
		{
			valueByKey.Clear();
		}

		void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> kvp)
		{
			Add(kvp.Key, kvp.Value);
		}

		bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> kvp)
		{
			if (TryGetValue(kvp.Key, out var value))
			{
				return EqualityComparer<TValue>.Default.Equals(value, kvp.Value);
			}
			return false;
		}

		void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			if (arrayIndex < 0 || arrayIndex >= array.Length)
			{
				throw new ArgumentOutOfRangeException("arrayIndex", "arrayIndex is not a valid index in array");
			}
			int count = Count;
			if (arrayIndex + count > array.Length)
			{
				throw new ArgumentOutOfRangeException("array", "Destination array is not long enough to copy all the items in the collection.");
			}
			foreach (KeyValuePair<WeakReferenceWrapper<TKey>, TValue> item in valueByKey)
			{
				item.Deconstruct(out var key, out var value);
				WeakReferenceWrapper<TKey> weakReferenceWrapper = key;
				TValue value2 = value;
				if (weakReferenceWrapper.weakReference.TryGetTarget(out var target))
				{
					array[arrayIndex++] = new KeyValuePair<TKey, TValue>(target, value2);
				}
			}
		}

		bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> kvp)
		{
			if (TryGetValue(kvp.Key, out var value) && EqualityComparer<TValue>.Default.Equals(value, kvp.Value))
			{
				return Remove(kvp.Key);
			}
			return false;
		}

		[IteratorStateMachine(typeof(FixedConditionalWeakTable<, >.<GetEnumerator>d__32))]
		public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetEnumerator>d__32(0)
			{
				<>4__this = this
			};
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	internal static class FixedConditionalWeakTableManager
	{
		internal interface IShrinkable
		{
			void Shrink();
		}

		private const int shrinkAttemptDelay = 2000;

		private static readonly object lockObject = new object();

		private static readonly List<WeakReference<IShrinkable>> instances = new List<WeakReference<IShrinkable>>();

		private static int lastCollectionCount = 0;

		public static void Add(IShrinkable weakTable)
		{
			lock (lockObject)
			{
				if (instances.Count == 0)
				{
					new Thread(ShrinkThreadLoop).Start();
				}
				instances.Add(new WeakReference<IShrinkable>(weakTable));
			}
		}

		private static void ShrinkThreadLoop()
		{
			while (true)
			{
				Thread.Sleep(2000);
				int num = GC.CollectionCount(2);
				if (lastCollectionCount == num)
				{
					continue;
				}
				lastCollectionCount = num;
				lock (lockObject)
				{
					for (int num2 = instances.Count - 1; num2 >= 0; num2--)
					{
						if (!instances[num2].TryGetTarget(out var target))
						{
							instances.RemoveAt(num2);
						}
						else
						{
							target.Shrink();
						}
					}
					if (instances.Count == 0)
					{
						break;
					}
				}
			}
		}
	}
	public static class NativeDetourExtensions
	{
		private static readonly FieldInfo backupNativeField = typeof(NativeDetour).GetField("_BackupNative", (BindingFlags)(-1));

		public static T GenerateTrampolineWithRecursionSupport<T>(this NativeDetour detour, uint bytesCount) where T : Delegate
		{
			if (!typeof(Delegate).IsAssignableFrom(typeof(T)))
			{
				throw new InvalidOperationException($"Type {typeof(T)} not a delegate type.");
			}
			return detour.GenerateNativeProxy(typeof(T).GetMethod("Invoke"), bytesCount).CreateDelegate(typeof(T)) as T;
		}

		public static MethodInfo GenerateNativeProxy(this NativeDetour detour, MethodBase signature, uint bytesCount)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			Type type = (signature as MethodInfo)?.ReturnType ?? typeof(void);
			ParameterInfo[] parameters = signature.GetParameters();
			Type[] array = new Type[parameters.Length];
			for (int i = 0; i < parameters.Length; i++)
			{
				array[i] = parameters[i].ParameterType;
			}
			DynamicMethodDefinition val = new DynamicMethodDefinition("Native<" + ((long)detour.Data.Method).ToString("X16", CultureInfo.InvariantCulture) + ">", type, array);
			MethodInfo methodInfo;
			try
			{
				methodInfo = DetourHelper.Pin<MethodInfo>(DetourHelper.StubCriticalDetour(val).Generate());
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
			IntPtr nativeStart = DetourHelper.GetNativeStart((MethodBase)methodInfo);
			NativeDetourData val2 = DetourHelper.Native.Create(nativeStart.Add(bytesCount), detour.Data.Method.Add(bytesCount), (byte?)null);
			NativeDetourData val3 = default(NativeDetourData);
			val3.Method = nativeStart;
			val3.Size = bytesCount + val2.Size;
			NativeDetourData val4 = val3;
			DetourHelper.MakeWritable(DetourHelper.Native, val4);
			IntPtr from = (IntPtr)backupNativeField.GetValue(detour);
			uint num = bytesCount - detour.Data.Size;
			Write(from, nativeStart, detour.Data.Size);
			if (num != 0)
			{
				Write(detour.Data.Method.Add(detour.Data.Size), nativeStart.Add(detour.Data.Size), num);
			}
			DetourHelper.Native.Apply(val2);
			DetourHelper.MakeExecutable(DetourHelper.Native, val4);
			DetourHelper.FlushICache(DetourHelper.Native, val4);
			DetourHelper.Native.Free(val4);
			return methodInfo;
		}

		private unsafe static void Write(IntPtr from, IntPtr to, uint size)
		{
			byte* ptr = (byte*)from.ToPointer();
			int num = 0;
			for (int i = 0; i < size; i++)
			{
				DetourHelper.Write(to, ref num, ptr[i]);
			}
		}

		public static IntPtr Add(this IntPtr ptr, long offset)
		{
			return new IntPtr(ptr.ToInt64() + offset);
		}

		public static IntPtr Add(this IntPtr ptr, uint offset)
		{
			return new IntPtr(ptr.ToInt64() + offset);
		}
	}
}
namespace RoR2BepInExPack.VanillaFixes
{
	internal class HarmonyMatchException
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__FixHarmonyMatchException;

			public static Action<ILContext> <1>__ApplyILLabels;

			public static Action<ILContext> <2>__UnApplyILLabels;
		}

		private static ILHook _hook;

		internal static void Init()
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(HarmonyManipulator), "ApplyManipulators", (Type[])null, (Type[])null) ?? AccessTools.DeclaredMethod(typeof(HarmonyManipulator), "ApplyILManipulators", (Type[])null, (Type[])null);
			if ((object)methodInfo == null)
			{
				Log.Error("Could not apply fix for HarmonyMatchException, target method is invalid");
				return;
			}
			object obj = <>O.<0>__FixHarmonyMatchException;
			if (obj == null)
			{
				Manipulator val = FixHarmonyMatchException;
				<>O.<0>__FixHarmonyMatchException = val;
				obj = (object)val;
			}
			_hook = new ILHook((MethodBase)methodInfo, (Manipulator)obj, new ILHookConfig
			{
				ManualApply = true
			});
		}

		internal static void Enable()
		{
			ILHook hook = _hook;
			if (hook != null)
			{
				hook.Apply();
			}
		}

		internal static void Disable()
		{
			ILHook hook = _hook;
			if (hook != null)
			{
				hook.Undo();
			}
		}

		internal static void Destroy()
		{
			ILHook hook = _hook;
			if (hook != null)
			{
				hook.Free();
			}
		}

		internal static void FixHarmonyMatchException(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			int num = default(int);
			MethodReference val2 = default(MethodReference);
			if (!val.TryGotoNext((MoveType)1, new Func<Instruction, bool>[5]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdnull(x),
				(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, ref num),
				(Instruction x) => ILPatternMatchingExt.MatchCallvirt(x, ref val2),
				(Instruction x) => ILPatternMatchingExt.MatchCallvirt(x, (MethodBase)AccessTools.Method(typeof(MethodBase), "Invoke", new Type[2]
				{
					typeof(object),
					typeof(object[])
				}, (Type[])null)),
				(Instruction x) => ILPatternMatchingExt.MatchPop(x)
			}))
			{
				Log.Error("Could not apply fix for FixHarmonyMatchException");
				return;
			}
			val.Emit(OpCodes.Ldarg_0);
			val.EmitDelegate<Action<ILContext>>((Action<ILContext>)ApplyILLabels);
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchPop(x)
			});
			val.Emit(OpCodes.Ldarg_0);
			val.EmitDelegate<Action<ILContext>>((Action<ILContext>)UnApplyILLabels);
		}

		internal static void ApplyILLabels(ILContext il)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			ILContext obj = il;
			if (((obj != null) ? obj.Instrs : null) == null)
			{
				return;
			}
			Enumerator<Instruction> enumerator = il.Instrs.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					Instruction current = enumerator.Current;
					if (((current != null) ? current.Operand : null) == null)
					{
						continue;
					}
					object operand = current.Operand;
					Instruction val = (Instruction)((operand is Instruction) ? operand : null);
					if (val != null)
					{
						current.Operand = il.DefineLabel(val);
					}
					else if (current.Operand is Instruction[] source)
					{
						current.Operand = source.Select((Instruction t) => il.DefineLabel(t)).ToArray();
					}
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
		}

		internal static void UnApplyILLabels(ILContext il)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (((il != null) ? il.Instrs : null) == null || il.IsReadOnly)
			{
				return;
			}
			Enumerator<Instruction> enumerator = il.Instrs.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					Instruction current = enumerator.Current;
					if (((current != null) ? current.Operand : null) == null)
					{
						continue;
					}
					object operand = current.Operand;
					ILLabel val = (ILLabel)((operand is ILLabel) ? operand : null);
					if (val != null)
					{
						current.Operand = val.Target;
					}
					else if (current.Operand is ILLabel[] source)
					{
						current.Operand = source.Select((ILLabel l) => l.Target).ToArray();
					}
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
		}
	}
	internal class ILLine
	{
		private static ILHook _hook;

		internal static void Init()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			HookConfig val = default(HookConfig);
			val.ManualApply = true;
			_hook = new ILHook((MethodBase)typeof(StackTrace).GetMethod("AddFrames", (BindingFlags)(-1)), new Manipulator(ShowILLine));
		}

		internal static void Enable()
		{
			_hook.Apply();
		}

		internal static void Disable()
		{
			_hook.Undo();
		}

		internal static void Destroy()
		{
			_hook.Free();
		}

		private static void ShowILLine(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			try
			{
				val.GotoNext(new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, (MethodBase)typeof(StackFrame).GetMethod("GetFileLineNumber", (BindingFlags)(-1)))
				});
				val.RemoveRange(2);
				val.EmitDelegate<Func<StackFrame, string>>((Func<StackFrame, string>)GetLineOrIL);
			}
			catch (Exception arg)
			{
				Log.Error(string.Format("{0} hook 1 failed.{1}{2}", "ShowILLine", Environment.NewLine, arg));
			}
			try
			{
				val.Index = 0;
				int frameLocIndex = -1;
				val.GotoNext((MoveType)2, new Func<Instruction, bool>[2]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, ref frameLocIndex),
					(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, (MethodBase)typeof(StackFrame).GetMethod("GetInternalMethodName", (BindingFlags)(-1)))
				});
				val.Emit(OpCodes.Ldloc, frameLocIndex);
				val.EmitDelegate<Func<string, StackFrame, string>>((Func<string, StackFrame, string>)AppendLineOrIL);
			}
			catch (Exception arg2)
			{
				Log.Error(string.Format("{0} hook 2 failed.{1}{2}", "ShowILLine", Environment.NewLine, arg2));
			}
		}

		private static string GetLineOrIL(StackFrame instance)
		{
			int fileLineNumber = instance.GetFileLineNumber();
			if (fileLineNumber != -1 && fileLineNumber != 0)
			{
				return fileLineNumber.ToString();
			}
			return "IL_" + instance.GetILOffset().ToString("X4");
		}

		private static string AppendLineOrIL(string currentText, StackFrame instance)
		{
			return currentText + " (at " + GetLineOrIL(instance) + ")";
		}
	}
	internal class FixConsoleLog
	{
		private static Hook _hook;

		internal static void Init()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			HookConfig val = default(HookConfig);
			val.ManualApply = true;
			HookConfig val2 = val;
			_hook = new Hook((MethodBase)typeof(UnitySystemConsoleRedirector).GetMethod("Redirect", (BindingFlags)(-1)), typeof(FixConsoleLog).GetMethod("DoNothing", (BindingFlags)(-1)), val2);
		}

		internal static void Enable()
		{
			_hook.Apply();
		}

		internal static void Disable()
		{
			_hook.Undo();
		}

		internal static void Destroy()
		{
			_hook.Free();
		}

		private static void DoNothing()
		{
		}
	}
	internal static class FixConVar
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__ScanAllAssemblies;

			public static Action <1>__LoadAllConVars;
		}

		private static ILHook _ilHook;

		internal static void Init()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			try
			{
				ILHookConfig val = default(ILHookConfig);
				val.ManualApply = true;
				ILHookConfig val2 = val;
				MethodInfo? methodInfo = typeof(Console).GetNestedTypes((BindingFlags)(-1)).FirstOrDefault((Type t) => t.Name.Contains("InitConVarsCoroutine")).GetMethods((BindingFlags)(-1))
					.FirstOrDefault((MethodInfo m) => m.Name.Contains("MoveNext"));
				object obj = <>O.<0>__ScanAllAssemblies;
				if (obj == null)
				{
					Manipulator val3 = ScanAllAssemblies;
					<>O.<0>__ScanAllAssemblies = val3;
					obj = (object)val3;
				}
				_ilHook = new ILHook((MethodBase)methodInfo, (Manipulator)obj, ref val2);
			}
			catch (Exception data)
			{
				Log.Error(data);
			}
		}

		internal static void Enable()
		{
			ILHook ilHook = _ilHook;
			if (ilHook != null)
			{
				ilHook.Apply();
			}
		}

		internal static void Disable()
		{
			ILHook ilHook = _ilHook;
			if (ilHook != null)
			{
				ilHook.Undo();
			}
		}

		internal static void Destroy()
		{
			ILHook ilHook = _ilHook;
			if (ilHook != null)
			{
				ilHook.Free();
			}
		}

		private static void ScanAllAssemblies(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.EmitDelegate<Action>((Action)LoadAllConVars);
			val.Emit(OpCodes.Ldc_I4_0);
			val.Emit(OpCodes.Ret);
		}

		private static bool IsMonoFriendlyType(this Type type)
		{
			if (type.GetFields((BindingFlags)(-1)).Any((FieldInfo fi) => fi.FieldType.Name == "MonoFNPtrFakeClass"))
			{
				Log.Debug($"Not scanning {type} for ConVars due to it containing delegate pointer field(s)");
				return false;
			}
			return true;
		}

		private static void LoadAllConVars()
		{
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			Console instance = Console.instance;
			instance.allConVars = new Dictionary<string, BaseConVar>();
			instance.archiveConVars = new List<BaseConVar>();
			List<Type> list = new List<Type>();
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				try
				{
					if (assembly.GetCustomAttribute<OptInAttribute>() != null)
					{
						list.AddRange(from t in assembly.GetTypes()
							where t.IsMonoFriendlyType()
							select t);
					}
				}
				catch (Exception data)
				{
					Log.Debug(data);
				}
			}
			foreach (Type item in list)
			{
				try
				{
					FieldInfo[] fields = item.GetFields(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
					foreach (FieldInfo fieldInfo in fields)
					{
						try
						{
							if (fieldInfo.FieldType.IsSubclassOf(typeof(BaseConVar)))
							{
								if (fieldInfo.IsStatic)
								{
									BaseConVar val = (BaseConVar)fieldInfo.GetValue(null);
									instance.RegisterConVarInternal(val);
								}
								else if (item.GetCustomAttribute<CompilerGeneratedAttribute>() == null)
								{
									Debug.LogError((object)("ConVar defined as " + item.Name + "." + fieldInfo.Name + " could not be registered. ConVars must be static fields."));
								}
							}
						}
						catch (Exception data2)
						{
							Log.Debug(data2);
						}
					}
					MethodInfo[] methods = item.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
					foreach (MethodInfo methodInfo in methods)
					{
						try
						{
							if (((MemberInfo)methodInfo).GetCustomAttribute<ConVarProviderAttribute>() == null)
							{
								continue;
							}
							if (methodInfo.ReturnType != typeof(IEnumerable<BaseConVar>) || methodInfo.GetParameters().Length != 0)
							{
								Debug.LogError((object)"ConVar provider {type.Name}.{methodInfo.Name} does not match the signature \"static IEnumerable<ConVar.BaseConVar>()\".");
								continue;
							}
							if (!methodInfo.IsStatic)
							{
								Debug.LogError((object)("ConVar provider " + item.Name + "." + methodInfo.Name + " could not be invoked. Methods marked with the ConVarProvider attribute must be static."));
								continue;
							}
							foreach (BaseConVar item2 in (IEnumerable<BaseConVar>)methodInfo.Invoke(null, Array.Empty<object>()))
							{
								instance.RegisterConVarInternal(item2);
							}
						}
						catch (Exception data3)
						{
							Log.Debug(data3);
						}
					}
				}
				catch (Exception data4)
				{
					Log.Debug(data4);
				}
			}
			AudioManager.cvVolumeMaster.fallbackString = ((BaseConVar)AudioManager.cvVolumeMaster).GetString();
			foreach (BaseConVar value in instance.allConVars.Values)
			{
				try
				{
					if ((value.flags & 0x10) != 0)
					{
						value.defaultValue = value.GetString();
					}
					else if (value.defaultValue != null)
					{
						value.AttemptSetString(value.defaultValue);
					}
				}
				catch (Exception data5)
				{
					Log.Error(data5);
				}
			}
		}
	}
	internal class FixDeathAnimLog
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__FixLackingAnim;
		}

		private static ILHook _ilHook;

		internal static void Init()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			ILHookConfig val = default(ILHookConfig);
			val.ManualApply = true;
			ILHookConfig val2 = val;
			MethodInfo? method = typeof(GenericCharacterDeath).GetMethod("PlayDeathAnimation", (BindingFlags)(-1));
			object obj = <>O.<0>__FixLackingAnim;
			if (obj == null)
			{
				Manipulator val3 = FixLackingAnim;
				<>O.<0>__FixLackingAnim = val3;
				obj = (object)val3;
			}
			_ilHook = new ILHook((MethodBase)method, (Manipulator)obj, ref val2);
		}

		internal static void Enable()
		{
			_ilHook.Apply();
		}

		internal static void Disable()
		{
			_ilHook.Undo();
		}

		internal static void Destroy()
		{
			_ilHook.Free();
		}

		private static void FixLackingAnim(ILContext il)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			ILLabel label = val.DefineLabel();
			MethodReference val2 = default(MethodReference);
			if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[3]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 0),
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, ref val2),
				(Instruction x) => ILPatternMatchingExt.MatchBrfalse(x, ref label)
			}))
			{
				val.Emit(OpCodes.Ldloc_0);
				val.EmitDelegate<Func<Animator, bool>>((Func<Animator, bool>)delegate(Animator anim)
				{
					for (int i = 0; i < anim.layerCount; i++)
					{
						if (anim.HasState(i, Animator.StringToHash("Death")))
						{
							return true;
						}
					}
					return false;
				});
				val.Emit(OpCodes.Brfalse, (object)label);
			}
			else
			{
				Log.Error("FixDeathAnimLog TryGotoNext failed, not applying patch");
			}
		}
	}
	internal class FixDedicatedServerMaxPlayerCount
	{
		private static Hook _hook;

		private static Hook _hook2;

		internal static void Init()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Expected O, but got Unknown
			HookConfig val = default(HookConfig);
			val.ManualApply = true;
			HookConfig val2 = val;
			_hook = new Hook((MethodBase)typeof(NetworkManager).GetMethod("StartHost", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(ConnectionConfig),
				typeof(int)
			}, null), (Delegate)new Func<Func<NetworkManager, ConnectionConfig, int, NetworkClient>, NetworkManager, ConnectionConfig, int, NetworkClient>(FixUsageOfMaxPlayerCountVariable), ref val2);
			_hook2 = new Hook((MethodBase)typeof(NetworkManager).GetMethod("StartServer", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(ConnectionConfig),
				typeof(int)
			}, null), (Delegate)new Func<Func<NetworkManager, ConnectionConfig, int, bool>, NetworkManager, ConnectionConfig, int, bool>(FixUsageOfMaxPlayerCountVariable2), ref val2);
		}

		internal static void Enable()
		{
			_hook.Apply();
			_hook2.Apply();
		}

		internal static void Disable()
		{
			_hook2.Undo();
			_hook.Undo();
		}

		internal static void Destroy()
		{
			_hook2.Free();
			_hook.Free();
		}

		private static NetworkClient FixUsageOfMaxPlayerCountVariable(Func<NetworkManager, ConnectionConfig, int, NetworkClient> orig, NetworkManager self, ConnectionConfig config, int maxConnections)
		{
			return orig(self, config, SvMaxPlayersConVar.instance.intValue);
		}

		private static bool FixUsageOfMaxPlayerCountVariable2(Func<NetworkManager, ConnectionConfig, int, bool> orig, NetworkManager self, ConnectionConfig config, int maxConnections)
		{
			return orig(self, config, SvMaxPlayersConVar.instance.intValue);
		}
	}
	internal class FixDuplicateItemTiers
	{
		private static Hook _hook;

		internal static void Init()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			HookConfig val = default(HookConfig);
			val.ManualApply = true;
			HookConfig val2 = val;
			_hook = new Hook((MethodBase)typeof(ItemTierCatalog).GetMethod("Init", (BindingFlags)(-1)), typeof(FixDuplicateItemTiers).GetMethod("ReassignDuplicateTiers", (BindingFlags)(-1)), val2);
		}

		internal static void Enable()
		{
			_hook.Apply();
		}

		internal static void Disable()
		{
			_hook.Undo();
		}

		internal static void Destroy()
		{
			_hook.Free();
		}

		private static void ReassignDuplicateTiers(Action orig)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Invalid comparison between Unknown and I4
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				ItemTier val = (ItemTier)1000;
				ItemTierDef val2 = Addressables.LoadAssetAsync<ItemTierDef>((object)RoR2_DLC3.FoodTier_asset).WaitForCompletion();
				ItemTierDef[] itemTierDefs = ContentManager.itemTierDefs;
				foreach (ItemTierDef val3 in itemTierDefs)
				{
					if ((int)val3._tier >= 10 && val3._tier != val && (Object)(object)val3 != (Object)(object)val2)
					{
						val3._tier = val;
					}
				}
			}
			catch (Exception data)
			{
				Log.Error(data);
			}
			orig();
		}
	}
	internal class FixExtraGameModesMenu
	{
		private static Hook _hook;

		internal static void Init()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			HookConfig val = default(HookConfig);
			val.ManualApply = true;
			HookConfig val2 = val;
			_hook = new Hook((MethodBase)typeof(MainMenuController).GetMethod("Start", (BindingFlags)(-1)), typeof(FixExtraGameModesMenu).GetMethod("FixIt", (BindingFlags)(-1)), val2);
		}

		internal static void Enable()
		{
			_hook.Apply();
		}

		internal static void Disable()
		{
			_hook.Undo();
		}

		internal static void Destroy()
		{
			_hook.Free();
		}

		private static void FixIt(Action<MainMenuController> orig, MainMenuController self)
		{
			orig(self);
			MPButton val = ((IEnumerable<MPButton>)((Component)self.extraGameModeMenuScreen).GetComponentsInChildren<MPButton>()).FirstOrDefault((Func<MPButton, bool>)((MPButton b) => ((Object)b).name == "GenericMenuButton (Eclipse)"));
			if (Object.op_Implicit((Object)(object)val))
			{
				val.defaultFallbackButton = true;
			}
		}
	}
	internal class FixHasEffectiveAuthority
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__FixHook;
		}

		private static ILHook _ilHook;

		internal static void Init()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			ILHookConfig val = default(ILHookConfig);
			val.ManualApply = true;
			ILHookConfig val2 = val;
			MethodInfo? method = typeof(Util).GetMethod("HasEffectiveAuthority", (BindingFlags)(-1), null, new Type[1] { typeof(NetworkIdentity) }, null);
			object obj = <>O.<0>__FixHook;
			if (obj == null)
			{
				Manipulator val3 = FixHook;
				<>O.<0>__FixHook = val3;
				obj = (object)val3;
			}
			_ilHook = new ILHook((MethodBase)method, (Manipulator)obj, ref val2);
		}

		internal static void Enable()
		{
			_ilHook.Apply();
		}

		internal static void Disable()
		{
			_ilHook.Undo();
		}

		internal static void Destroy()
		{
			_ilHook.Free();
		}

		private static void FixHook(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[3]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<NetworkIdentity>(x, "get_clientAuthorityOwner"),
				(Instruction x) => ILPatternMatchingExt.MatchLdnull(x),
				(Instruction x) => ILPatternMatchingExt.MatchCeq(x)
			}))
			{
				val.Emit(OpCodes.Dup);
				val.Emit(OpCodes.Brtrue, val.Next);
				val.Emit(OpCodes.Pop);
				val.Emit(OpCodes.Ldarg_0);
				val.Emit<NetworkIdentity>(OpCodes.Callvirt, "get_clientAuthorityOwner");
				val.Emit(OpCodes.Isinst, typeof(ULocalConnectionToClient));
				val.Emit(OpCodes.Ldnull);
				val.Emit(OpCodes.Ceq);
				val.Emit(OpCodes.Ldc_I4_0);
				val.Emit(OpCodes.Ceq);
			}
			else
			{
				Log.Error("FixHasEffectiveAuthority TryGotoNext failed, not applying patch");
			}
		}
	}
	internal class FixLRAPIReturns
	{
		internal static void Init(PluginInfo pluginInfo)
		{
			try
			{
				string text = Path.Combine(Application.streamingAssetsPath, "lrapi_returns.json");
				if (File.Exists(text))
				{
					Log.Info("lrapi_returns.json already exists in StreamingAssets, skipping fix.");
				}
				else
				{
					File.Copy(Path.Combine(Directory.GetParent(pluginInfo.Location).FullName, "lrapi_returns.json"), text);
				}
			}
			catch (Exception data)
			{
				Log.Error(data);
			}
		}
	}
	internal class FixNonLethalOneHP
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__FixLethality;
		}

		private static ILHook _ilHook;

		internal static void Init()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			ILHookConfig val = default(ILHookConfig);
			val.ManualApply = true;
			ILHookConfig val2 = val;
			MethodInfo? method = typeof(HealthComponent).GetMethod("TakeDamageProcess", (BindingFlags)(-1));
			object obj = <>O.<0>__FixLethality;
			if (obj == null)
			{
				Manipulator val3 = FixLethality;
				<>O.<0>__FixLethality = val3;
				obj = (object)val3;
			}
			_ilHook = new ILHook((MethodBase)method, (Manipulator)obj, ref val2);
		}

		internal static void Enable()
		{
			_ilHook.Apply();
		}

		internal static void Disable()
		{
			_ilHook.Undo();
		}

		internal static void Destroy()
		{
			_ilHook.Free();
		}

		private static void FixLethality(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			ILLabel val2 = default(ILLabel);
			if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[3]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdfld(x, typeof(HealthComponent).GetField("health", (BindingFlags)(-1))),
				(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 1f),
				(Instruction x) => ILPatternMatchingExt.MatchBltUn(x, ref val2)
			}))
			{
				int index = val.Index;
				val.Index = index - 1;
				val.Emit(OpCodes.Ldarg_0);
				val.EmitDelegate<Func<float, HealthComponent, float>>((Func<float, HealthComponent, float>)((float targetHealth, HealthComponent self) => (!(self.health > 0f)) ? targetHealth : 0f));
			}
			else
			{
				Log.Error("FixNonLethalOneHP TryGotoNext failed, not applying patch");
			}
		}
	}
	internal class FixRuleBookViewerStrip
	{
		private static Hook _hook;

		internal static void Init()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			if (_hook == null)
			{
				_hook = new Hook((MethodBase)typeof(RuleBookViewerStrip).GetMethod("SetData", (BindingFlags)(-1)), typeof(FixRuleBookViewerStrip).GetMethod("FindIndexAndSetWidth", (BindingFlags)(-1)), new HookConfig
				{
					ManualApply = true
				});
			}
		}

		internal static void Enable()
		{
			Hook hook = _hook;
			if (hook != null)
			{
				hook.Apply();
			}
		}

		internal static void Disable()
		{
			Hook hook = _hook;
			if (hook != null)
			{
				hook.Undo();
			}
		}

		internal static void Destroy()
		{
			Hook hook = _hook;
			if (hook != null)
			{
				hook.Free();
			}
			_hook = null;
		}

		private static void FindIndexAndSetWidth(Action<RuleBookViewerStrip, List<RuleChoiceDef>, int> orig, RuleBookViewerStrip self, List<RuleChoiceDef> choices, int index)
		{
			orig(self, choices, index);
			int i = 0;
			for (int count = choices.Count; i < count; i++)
			{
				if (index == choices[i].localIndex)
				{
					self.currentDisplayChoiceIndex = i;
					break;
				}
			}
			if (!Object.op_Implicit((Object)(object)((Component)self).GetComponent<LayoutElement>()))
			{
				((Component)self).gameObject.AddComponent<LayoutElement>().minWidth = 64f;
			}
		}
	}
	internal static class FixRunScaling
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__CalculateDifficultyCoefficientOnRunStart;

			public static Action<Run> <1>__CallRecalculateDifficultyCoefficent;
		}

		private static ILHook _ilHook;

		internal static void Init()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			ILHookConfig val = default(ILHookConfig);
			val.ManualApply = true;
			ILHookConfig val2 = val;
			MethodInfo? method = typeof(Run).GetMethod("Start", (BindingFlags)(-1));
			object obj = <>O.<0>__CalculateDifficultyCoefficientOnRunStart;
			if (obj == null)
			{
				Manipulator val3 = CalculateDifficultyCoefficientOnRunStart;
				<>O.<0>__CalculateDifficultyCoefficientOnRunStart = val3;
				obj = (object)val3;
			}
			_ilHook = new ILHook((MethodBase)method, (Manipulator)obj, ref val2);
		}

		internal static void Enable()
		{
			_ilHook.Apply();
		}

		internal static void Disable()
		{
			_ilHook.Undo();
		}

		internal static void Destroy()
		{
			_ilHook.Free();
		}

		private static void CalculateDifficultyCoefficientOnRunStart(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction i) => ILPatternMatchingExt.MatchStfld<Run>(i, "allowNewParticipants")
			}))
			{
				if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
				{
					(Instruction i) => ILPatternMatchingExt.MatchStfld<Run>(i, "allowNewParticipants")
				}))
				{
					val.Emit(OpCodes.Ldarg_0);
					val.EmitDelegate<Action<Run>>((Action<Run>)CallRecalculateDifficultyCoefficent);
				}
				else
				{
					Log.Error("CalculateDifficultyCoefficientOnRunStart TryGotoNext 2 failed, not applying patch");
				}
			}
			else
			{
				Log.Error("CalculateDifficultyCoefficientOnRunStart TryGotoNext 1 failed, not applying patch");
			}
			static void CallRecalculateDifficultyCoefficent(Run instance)
			{
				if (NetworkServer.active && Object.op_Implicit((Object)(object)instance))
				{
					instance.RecalculateDifficultyCoefficent();
				}
			}
		}
	}
	internal class FixSystemInitializer
	{
		[StructLayout(LayoutKind.Auto)]
		[CompilerGenerated]
		private struct <>c__DisplayClass3_0
		{
			public HashSet<Type> initializedTypes;
		}

		[CompilerGenerated]
		private sealed class <LogBadCycle>d__3 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private <>c__DisplayClass3_0 <>8__1;

			private Stopwatch <multiLoopTimer>5__2;

			private int <yields>5__3;

			private StringBuilder <logBadCycle>5__4;

			private SystemInitializerAttribute <initializerAttribute2>5__5;

			private IEnumerator <thisStep>5__6;

			private List<IEnumerator> <coroutineStack>5__7;

			private long <accumulatedTime>5__8;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <LogBadCycle>d__3(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = default(<>c__DisplayClass3_0);
				<multiLoopTimer>5__2 = null;
				<logBadCycle>5__4 = null;
				<initializerAttribute2>5__5 = null;
				<thisStep>5__6 = null;
				<coroutineStack>5__7 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				HashSet<Type> hashSet;
				int num;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					SystemInitializerAttribute.initializerAttributes = new Queue<SystemInitializerAttribute>();
					SystemInitializerAttribute.initThread = new Thread((ThreadStart)SystemInitializerAttribute.ExecuteStatic);
					SystemInitializerAttribute.initThread.Start();
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					goto IL_0093;
				case 2:
					<>1__state = -1;
					goto IL_0093;
				case 3:
					<>1__state = -1;
					goto IL_0449;
				case 4:
					{
						<>1__state = -1;
						goto IL_0449;
					}
					IL_0093:
					if (SystemInitializerAttribute.initThread.IsAlive)
					{
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					SystemInitializerAttribute.initThread = null;
					hashSet = new HashSet<Type>();
					foreach (Type preInitializedType in SystemInitializerAttribute.preInitializedTypes)
					{
						hashSet.Add(preInitializedType);
					}
					<>8__1.initializedTypes = hashSet;
					SystemInitializerAttribute.preInitializedTypes.Clear();
					new Stopwatch().Start();
					<multiLoopTimer>5__2 = new Stopwatch();
					<multiLoopTimer>5__2.Start();
					<yields>5__3 = 0;
					num = 0;
					<logBadCycle>5__4 = new StringBuilder();
					goto IL_0487;
					IL_0487:
					while (true)
					{
						if (SystemInitializerAttribute.initializerAttributes.Count > 0)
						{
							<initializerAttribute2>5__5 = SystemInitializerAttribute.initializerAttributes.Dequeue();
							if (<LogBadCycle>g__InitializerDependenciesMet|3_0(<initializerAttribute2>5__5, ref <>8__1))
							{
								break;
							}
							<logBadCycle>5__4.Append("Re-enqueuing initializer: Type=" + <initializerAttribute2>5__5.associatedType.FullName + ",Method=" + <initializerAttribute2>5__5.methodInfo.Name);
							SystemInitializerAttribute.initializerAttributes.Enqueue(<initializerAttribute2>5__5);
							num++;
							if (num < SystemInitializerAttribute.initializerAttributes.Count + 10)
							{
								continue;
							}
							Log.Error("SystemInitializerAttribute infinite loop detected.currentMethod=" + <initializerAttribute2>5__5.associatedType.FullName + "." + <initializerAttribute2>5__5.methodInfo.Name + $"\n{<logBadCycle>5__4}");
						}
						SystemInitializerAttribute.initializerAttributes = null;
						SystemInitializerAttribute.hasExecuted = true;
						return false;
					}
					<thisStep>5__6 = <initializerAttribute2>5__5.methodInfo.Invoke(null, Array.Empty<object>()) as IEnumerator;
					<coroutineStack>5__7 = new List<IEnumerator> { <thisStep>5__6 };
					<multiLoopTimer>5__2.Stop();
					<accumulatedTime>5__8 = <multiLoopTimer>5__2.ElapsedMilliseconds;
					<multiLoopTimer>5__2.Start();
					if (<accumulatedTime>5__8 > SystemInitializerAttribute.FRAME_TIME_THRESHOLD_MS)
					{
						<accumulatedTime>5__8 = 0L;
						<multiLoopTimer>5__2.Stop();
						<multiLoopTimer>5__2.Reset();
						<multiLoopTimer>5__2.Start();
						<yields>5__3++;
						<>2__current = null;
						<>1__state = 3;
						return true;
					}
					goto IL_0449;
					IL_0449:
					while (<thisStep>5__6 != null)
					{
						while (<accumulatedTime>5__8 < SystemInitializerAttribute.FRAME_TIME_THRESHOLD_MS && <thisStep>5__6 != null)
						{
							if (!<thisStep>5__6.MoveNext())
							{
								<coroutineStack>5__7.RemoveAt(<coroutineStack>5__7.Count - 1);
								<thisStep>5__6 = ((<coroutineStack>5__7.Count <= 0) ? null : <coroutineStack>5__7[<coroutineStack>5__7.Count - 1]);
							}
							else if (<thisStep>5__6.Current != null)
							{
								<coroutineStack>5__7.Add(<thisStep>5__6.Current as IEnumerator);
								<thisStep>5__6 = <coroutineStack>5__7[<coroutineStack>5__7.Count - 1];
							}
							<multiLoopTimer>5__2.Stop();
							<accumulatedTime>5__8 = <multiLoopTimer>5__2.ElapsedMilliseconds;
							<multiLoopTimer>5__2.Start();
						}
						if (<accumulatedTime>5__8 > SystemInitializerAttribute.FRAME_TIME_THRESHOLD_MS)
						{
							<accumulatedTime>5__8 = 0L;
							<multiLoopTimer>5__2.Stop();
							<multiLoopTimer>5__2.Reset();
							<multiLoopTimer>5__2.Start();
						}
						if (<thisStep>5__6 != null)
						{
							<yields>5__3++;
							<accumulatedTime>5__8 = 0L;
							<multiLoopTimer>5__2.Stop();
							<multiLoopTimer>5__2.Reset();
							<multiLoopTimer>5__2.Start();
							<>2__current = null;
							<>1__state = 4;
							return true;
						}
					}
					<>8__1.initializedTypes.Add(<initializerAttribute2>5__5.associatedType);
					num = 0;
					<initializerAttribute2>5__5 = null;
					<thisStep>5__6 = null;
					<coroutineStack>5__7 = null;
					goto IL_0487;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static Hook _hook;

		private static Hook _hook2;

		internal static void Init()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			_hook = new Hook((MethodBase)typeof(SystemInitializerAttribute).GetMethod("ExecuteStatic", (BindingFlags)(-1)), typeof(FixSystemInitializer).GetMethod("EnqueueAllInitializers", (BindingFlags)(-1)));
			_hook2 = new Hook((MethodBase)typeof(SystemInitializerAttribute).GetMethod("ExecuteCoroutine", (BindingFlags)(-1)), typeof(FixSystemInitializer).GetMethod("LogBadCycle", (BindingFlags)(-1)));
		}

		[IteratorStateMachine(typeof(<LogBadCycle>d__3))]
		private static IEnumerator LogBadCycle()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LogBadCycle>d__3(0);
		}

		private static void EnqueueAllInitializers(Action _)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			foreach (SearchableAttribute instance in SearchableAttribute.GetInstances<SystemInitializerAttribute>())
			{
				MethodInfo methodInfo = (MethodInfo)instance.target;
				if (methodInfo.IsStatic)
				{
					SystemInitializerAttribute val = (SystemInitializerAttribute)instance;
					val.methodInfo = methodInfo;
					val.associatedType = methodInfo.DeclaringType;
					SystemInitializerAttribute.initializerAttributes.Enqueue(val);
				}
			}
		}

		[CompilerGenerated]
		internal static bool <LogBadCycle>g__InitializerDependenciesMet|3_0(SystemInitializerAttribute initializerAttribute, ref <>c__DisplayClass3_0 P_1)
		{
			Type[] dependencies = initializerAttribute.dependencies;
			foreach (Type item in dependencies)
			{
				P_1.initializedTypes.Contains(item);
				if (!P_1.initializedTypes.Contains(item))
				{
					return false;
				}
			}
			return true;
		}
	}
	internal static class LogNetworkInvokeException
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__AddExceptionLogging;

			public static Func<string, object, string> <1>__Format;
		}

		private static IDetour _detour;

		internal static void Init()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			MethodInfo? method = typeof(NetworkConnection).GetMethod("InvokeDelegateWithCatch");
			object obj = <>O.<0>__AddExceptionLogging;
			if (obj == null)
			{
				Manipulator val = AddExceptionLogging;
				<>O.<0>__AddExceptionLogging = val;
				obj = (object)val;
			}
			_detour = (IDetour)new ILHook((MethodBase)method, (Manipulator)obj, new ILHookConfig
			{
				ManualApply = true
			});
		}

		internal static void Enable()
		{
			_detour.Apply();
		}

		internal static void Disable()
		{
			_detour.Undo();
		}

		internal static void Destroy()
		{
			_detour.Free();
		}

		private static void AddExceptionLogging(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			ILLabel val3 = default(ILLabel);
			string text = default(string);
			if (val.TryGotoNext(new Func<Instruction, bool>[3]
			{
				(Instruction a) => ILPatternMatchingExt.MatchLeaveS(a, ref val3),
				(Instruction a) => ILPatternMatchingExt.MatchPop(a),
				(Instruction a) => ILPatternMatchingExt.MatchLdstr(a, ref text)
			}))
			{
				val.Index += 1;
				VariableDefinition val2 = new VariableDefinition(((MemberReference)val.Body.Method).Module.ImportReference(typeof(Exception)));
				val.Body.Variables.Add(val2);
				val.Next.Operand = val2;
				val.Next.OpCode = OpCodes.Stloc;
				val.Index += 2;
				Instruction prev = val.Prev;
				prev.Operand = prev.Operand?.ToString() + Environment.NewLine + "{0}";
				val.Emit(OpCodes.Ldloc, val2);
				val.Emit(OpCodes.Call, (MethodBase)new Func<string, object, string>(string.Format).Method);
			}
			else
			{
				Log.Error("ILHook LogNetworkInvokeException.AddExceptionLogging failed.");
			}
		}
	}
	public class SaferAchievementManager
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass12_0
		{
			public Dictionary<string, AchievementDef> achievementIdentifierToDef;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass12_1
		{
			public AchievementDef achievementDef;

			internal string <SaferCollectAchievementDefs>b__4()
			{
				return Language.GetStringFormatted("UNLOCK_VIA_ACHIEVEMENT_FORMAT", new object[2]
				{
					Language.GetString(achievementDef.nameToken),
					Language.GetString(achievementDef.descriptionToken)
				});
			}

			internal string <SaferCollectAchievementDefs>b__5()
			{
				return Language.GetStringFormatted("UNLOCKED_FORMAT", new object[2]
				{
					Language.GetString(achievementDef.nameToken),
					Language.GetString(achievementDef.descriptionToken)
				});
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass12_2
		{
			public string currentAchievementIdentifier;

			public <>c__DisplayClass12_0 CS$<>8__locals1;

			internal bool <SaferCollectAchievementDefs>b__6(string v)
			{
				return CS$<>8__locals1.achievementIdentifierToDef[v].prerequisiteAchievementIdentifier == currentAchievementIdentifier;
			}
		}

		[CompilerGenerated]
		private sealed class <SaferCollectAchievementDefs>d__12 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Dictionary<string, AchievementDef> achievementIdentifierToDef;

			private <>c__DisplayClass12_0 <>8__1;

			private List<AchievementDef> <achievementDefs>5__2;

			private int <typesProcessedThisFrame>5__3;

			private List<Assembly>.Enumerator <>7__wrap3;

			private IEnumerator<Type> <>7__wrap4;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SaferCollectAchievementDefs>d__12(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if ((uint)(num - -4) <= 1u || num == 1)
				{
					try
					{
						if (num == -4 || num == 1)
						{
							try
							{
							}
							finally
							{
								<>m__Finally2();
							}
						}
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>8__1 = null;
				<achievementDefs>5__2 = null;
				<>7__wrap3 = default(List<Assembly>.Enumerator);
				<>7__wrap4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_02af: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_02db: Unknown result type (might be due to invalid IL or missing references)
				//IL_0301: Unknown result type (might be due to invalid IL or missing references)
				//IL_0327: Unknown result type (might be due to invalid IL or missing references)
				//IL_032f: Unknown result type (might be due to invalid IL or missing references)
				//IL_033c: Unknown result type (might be due to invalid IL or missing references)
				//IL_034e: Expected O, but got Unknown
				//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01eb: Expected O, but got Unknown
				//IL_0518: Unknown result type (might be due to invalid IL or missing references)
				//IL_0527: Unknown result type (might be due to invalid IL or missing references)
				//IL_0529: Unknown result type (might be due to invalid IL or missing references)
				//IL_054e: Unknown result type (might be due to invalid IL or missing references)
				//IL_055d: Unknown result type (might be due to invalid IL or missing references)
				//IL_055f: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -4;
						goto IL_0457;
					}
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass12_0();
					<>8__1.achievementIdentifierToDef = achievementIdentifierToDef;
					<achievementDefs>5__2 = new List<AchievementDef>();
					<>8__1.achievementIdentifierToDef.Clear();
					List<Assembly> list = new List<Assembly>();
					Assembly assembly = typeof(RoR2BepInExPack).Assembly;
					Assembly assembly2 = typeof(BaseAchievement).Assembly;
					list.Add(assembly2);
					string name = assembly2.GetName().Name;
					Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
					foreach (Assembly assembly3 in assemblies)
					{
						if (assembly3.GetName().Name.StartsWith("MMHOOK_") || assembly3 == assembly)
						{
							continue;
						}
						AssemblyName[] referencedAssemblies = assembly3.GetReferencedAssemblies();
						for (int j = 0; j < referencedAssemblies.Length; j++)
						{
							if (referencedAssemblies[j].Name == name)
							{
								list.Add(assembly3);
								break;
							}
						}
					}
					<typesProcessedThisFrame>5__3 = 0;
					<>7__wrap3 = list.GetEnumerator();
					<>1__state = -3;
					goto IL_0474;
					IL_0457:
					while (<>7__wrap4.MoveNext())
					{
						Type current = <>7__wrap4.Current;
						RegisterAchievementAttribute val = null;
						try
						{
							val = (RegisterAchievementAttribute)current.GetCustomAttributes(inherit: false).FirstOrDefault((object v) => v is RegisterAchievementAttribute);
							if (SaferAchievementManager.OnRegisterAchievementAttributeFound != null)
							{
								val = SaferAchievementManager.OnRegisterAchievementAttributeFound(current, val);
							}
						}
						catch (Exception ex)
						{
							Log.Debug("RegisterAchievementAttribute type.GetCustomAttributes(false) failed for :  " + current.FullName + Environment.NewLine + ex);
						}
						if (val == null)
						{
							continue;
						}
						if (<>8__1.achievementIdentifierToDef.ContainsKey(val.identifier))
						{
							Debug.LogErrorFormat("Class {0} attempted to register as achievement {1}, but class {2} has already registered as that achievement.", new object[3]
							{
								current.FullName,
								val.identifier,
								AchievementManager.achievementNamesToDefs[val.identifier].type.FullName
							});
						}
						else
						{
							<>c__DisplayClass12_1 CS$<>8__locals0 = new <>c__DisplayClass12_1();
							UnlockableDef unlockableDef = UnlockableCatalog.GetUnlockableDef(val.unlockableRewardIdentifier);
							CS$<>8__locals0.achievementDef = new AchievementDef
							{
								identifier = val.identifier,
								unlockableRewardIdentifier = val.unlockableRewardIdentifier,
								prerequisiteAchievementIdentifier = val.prerequisiteAchievementIdentifier,
								nameToken = "ACHIEVEMENT_" + val.identifier.ToUpper(CultureInfo.InvariantCulture) + "_NAME",
								descriptionToken = "ACHIEVEMENT_" + val.identifier.ToUpper(CultureInfo.InvariantCulture) + "_DESCRIPTION",
								type = current,
								serverTrackerType = val.serverTrackerType,
								lunarCoinReward = val.lunarCoinReward
							};
							if (Object.op_Implicit((Object)(object)unlockableDef) && Object.op_Implicit((Object)(object)unlockableDef.achievementIcon))
							{
								CS$<>8__locals0.achievementDef.SetAchievedIcon(unlockableDef.achievementIcon);
							}
							else
							{
								CS$<>8__locals0.achievementDef.iconPath = "Textures/AchievementIcons/tex" + val.identifier + "Icon";
								CS$<>8__locals0.achievementDef.PreloadIcon();
							}
							AchievementManager.achievementIdentifiers.Add(val.identifier);
							<>8__1.achievementIdentifierToDef.Add(val.identifier, CS$<>8__locals0.achievementDef);
							<achievementDefs>5__2.Add(CS$<>8__locals0.achievementDef);
							if ((Object)(object)unlockableDef != (Object)null)
							{
								unlockableDef.getHowToUnlockString = () => Language.GetStringFormatted("UNLOCK_VIA_ACHIEVEMENT_FORMAT", new object[2]
								{
									Language.GetString(CS$<>8__locals0.achievementDef.nameToken),
									Language.GetString(CS$<>8__locals0.achievementDef.descriptionToken)
								});
								unlockableDef.getUnlockedString = () => Language.GetStringFormatted("UNLOCKED_FORMAT", new object[2]
								{
									Language.GetString(CS$<>8__locals0.achievementDef.nameToken),
									Language.GetString(CS$<>8__locals0.achievementDef.descriptionToken)
								});
							}
						}
						if (++<typesProcessedThisFrame>5__3 > 100)
						{
							<typesProcessedThisFrame>5__3 = 0;
							<>2__current = null;
							<>1__state = 1;
							return true;
						}
					}
					<>m__Finally2();
					<>7__wrap4 = null;
					goto IL_0474;
					IL_0474:
					if (<>7__wrap3.MoveNext())
					{
						Type[] types = <>7__wrap3.Current.GetTypes();
						<>7__wrap4 = (from _type in types
							where _type.IsSubclassOf(typeof(BaseAchievement))
							orderby _type.Name
							select _type).GetEnumerator();
						<>1__state = -4;
						goto IL_0457;
					}
					<>m__Finally1();
					<>7__wrap3 = default(List<Assembly>.Enumerator);
					SaferAchievementManager.OnCollectAchievementDefs?.Invoke(AchievementManager.achievementIdentifiers, <>8__1.achievementIdentifierToDef, <achievementDefs>5__2);
					AchievementManager.achievementDefs = <achievementDefs>5__2.ToArray();
					AchievementManager.SortAchievements(AchievementManager.achievementDefs);
					AchievementManager.serverAchievementDefs = AchievementManager.achievementDefs.Where((AchievementDef achievementDef) => achievementDef.serverTrackerType != null).ToArray();
					for (int k = 0; k < AchievementManager.achievementDefs.Length; k++)
					{
						AchievementManager.achievementDefs[k].index = new AchievementIndex
						{
							intValue = k
						};
					}
					for (int l = 0; l < AchievementManager.serverAchievementDefs.Length; l++)
					{
						AchievementManager.serverAchievementDefs[l].serverIndex = new ServerAchievementIndex
						{
							intValue = l
						};
					}
					for (int m = 0; m < AchievementManager.achievementIdentifiers.Count; m++)
					{
						<>c__DisplayClass12_2 CS$<>8__locals1 = new <>c__DisplayClass12_2();
						CS$<>8__locals1.CS$<>8__locals1 = <>8__1;
						CS$<>8__locals1.currentAchievementIdentifier = AchievementManager.achievementIdentifiers[m];
						CS$<>8__locals1.CS$<>8__locals1.achievementIdentifierToDef[CS$<>8__locals1.currentAchievementIdentifier].childAchievementIdentifiers = AchievementManager.achievementIdentifiers.Where((string v) => CS$<>8__locals1.CS$<>8__locals1.achievementIdentifierToDef[v].prerequisiteAchievementIdentifier == CS$<>8__locals1.currentAchievementIdentifier).ToArray();
					}
					((Action)_achievementManagerOnAchievementsRegisteredFieldInfo.GetValue(null))?.Invoke();
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>7__wrap3).Dispose();
			}

			private void <>m__Finally2()
			{
				<>1__state = -3;
				if (<>7__wrap4 != null)
				{
					<>7__wrap4.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static Hook _hook;

		private static FieldInfo _achievementManagerOnAchievementsRegisteredFieldInfo;

		public static event Func<Type, RegisterAchievementAttribute, RegisterAchievementAttribute> OnRegisterAchievementAttributeFound;

		public static event Action<List<string>, Dictionary<string, AchievementDef>, List<AchievementDef>> OnCollectAchievementDefs;

		internal static void Init()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			HookConfig val = default(HookConfig);
			val.ManualApply = true;
			HookConfig val2 = val;
			_hook = new Hook((MethodBase)typeof(AchievementManager).GetMethod("CollectAchievementDefs", (BindingFlags)(-1)), typeof(SaferAchievementManager).GetMethod("SaferCollectAchievementDefs", (BindingFlags)(-1)), val2);
			_achievementManagerOnAchievementsRegisteredFieldInfo = typeof(AchievementManager).GetField("onAchievementsRegistered", (BindingFlags)(-1));
		}

		internal static void Enable()
		{
			_hook.Apply();
		}

		internal static void Disable()
		{
			_hook.Undo();
		}

		internal static void Destroy()
		{
			_hook.Free();
		}

		[IteratorStateMachine(typeof(<SaferCollectAchievementDefs>d__12))]
		private static IEnumerator SaferCollectAchievementDefs(Dictionary<string, AchievementDef> achievementIdentifierToDef)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SaferCollectAchievementDefs>d__12(0)
			{
				achievementIdentifierToDef = achievementIdentifierToDef
			};
		}
	}
	internal class SaferResourceAvailability
	{
		private delegate void orig_MakeAvailable(ref ResourceAvailability self);

		private static Hook _hook;

		private static FieldInfo _onAvailableBackingFieldInfo;

		internal static void Init()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			HookConfig val = default(HookConfig);
			val.ManualApply = true;
			HookConfig val2 = val;
			_hook = new Hook((MethodBase)typeof(ResourceAvailability).GetMethod("MakeAvailable", (BindingFlags)(-1)), typeof(SaferResourceAvailability).GetMethod("TryCatchEachLoopIteration", (BindingFlags)(-1)), val2);
			_onAvailableBackingFieldInfo = typeof(ResourceAvailability).GetField("onAvailable", BindingFlags.Instance | BindingFlags.NonPublic);
		}

		internal static void Enable()
		{
			_hook.Apply();
		}

		internal static void Disable()
		{
			_hook.Undo();
		}

		internal static void Destroy()
		{
			_hook.Free();
		}

		private static void TryCatchEachLoopIteration(orig_MakeAvailable orig, ref ResourceAvailability self)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			if (((ResourceAvailability)(ref self)).available)
			{
				return;
			}
			((ResourceAvailability)(ref self)).available = true;
			Action action = (Action)_onAvailableBackingFieldInfo.GetValue(self);
			if (action == null)
			{
				return;
			}
			Delegate[] invocationList = action.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				Action action2 = (Action)invocationList[i];
				try
				{
					action2();
				}
				catch (Exception data)
				{
					Log.Error(data);
				}
			}
			_onAvailableBackingFieldInfo.SetValue(self, null);
		}
	}
	internal class SaferSearchableAttribute
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__SaferScanAssemblyILManipulator;

			public static Action<Assembly> <1>__SaferScanAssembly;
		}

		private static ILHook _ilHook;

		internal static void Init()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			ILHookConfig val = default(ILHookConfig);
			val.ManualApply = true;
			ILHookConfig val2 = val;
			MethodInfo? method = typeof(SearchableAttribute).GetMethod("ScanAssembly", (BindingFlags)(-1));
			object obj = <>O.<0>__SaferScanAssemblyILManipulator;
			if (obj == null)
			{
				Manipulator val3 = SaferScanAssemblyILManipulator;
				<>O.<0>__SaferScanAssemblyILManipulator = val3;
				obj = (object)val3;
			}
			_ilHook = new ILHook((MethodBase)method, (Manipulator)obj, val2);
		}

		internal static void Enable()
		{
			_ilHook.Apply();
		}

		internal static void Disable()
		{
			_ilHook.Undo();
		}

		internal static void Destroy()
		{
			_ilHook.Free();
		}

		private static void DeterministicInitTimingHook(Action<Console> orig, Console self)
		{
			try
			{
				typeof(SearchableAttribute).TypeInitializer.Invoke(null, null);
			}
			catch (Exception data)
			{
				Log.Error(data);
			}
			orig(self);
		}

		private static void SaferScanAssemblyILManipulator(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.Emit(OpCodes.Ldarg_0);
			val.EmitDelegate<Action<Assembly>>((Action<Assembly>)SaferScanAssembly);
			val.Emit(OpCodes.Ret);
		}

		private static void SaferScanAssembly(Assembly ass)
		{
			if (SearchableAttribute.assemblyBlacklist.Contains(ass.FullName))
			{
				return;
			}
			SearchableAttribute.assemblyBlacklist.Add(ass.FullName);
			if (ass.GetCustomAttribute<OptInAttribute>() == null)
			{
				return;
			}
			Type[] types = ass.GetTypes();
			foreach (Type type in types)
			{
				SearchableAttribute[] array = Array.Empty<SearchableAttribute>();
				try
				{
					array = (from a in type.GetCustomAttributes(inherit: false)
						where a is SearchableAttribute
						select a).Cast<SearchableAttribute>().ToArray();
				}
				catch (Exception ex)
				{
					Log.Debug("ScanAssembly type.GetCustomAttributes(false) failed for :  " + type.FullName + Environment.NewLine + ex);
				}
				SearchableAttribute[] array2 = array;
				foreach (SearchableAttribute val in array2)
				{
					try
					{
						SearchableAttribute.RegisterAttribute(val, (object)type);
					}
					catch (Exception ex2)
					{
						Log.Debug("SearchableAttribute.RegisterAttribute(attribute, type) failed for : " + type.FullName + Environment.NewLine + ex2);
					}
				}
				MemberInfo[] array3 = Array.Empty<MemberInfo>();
				try
				{
					array3 = type.GetMembers(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				}
				catch (Exception ex3)
				{
					Log.Debug("type.GetMembers failed for : " + type.FullName + Environment.NewLine + ex3);
				}
				MemberInfo[] array4 = array3;
				foreach (MemberInfo memberInfo in array4)
				{
					SearchableAttribute[] array5 = Array.Empty<SearchableAttribute>();
					try
					{
						array5 = (from a in memberInfo.GetCustomAttributes(inherit: false)
							where a is SearchableAttribute
							select a).Cast<SearchableAttribute>().ToArray();
					}
					catch (Exception ex4)
					{
						Log.Debug("memberInfo.GetCustomAttributes(false) failed for : " + type.FullName + Environment.NewLine + memberInfo.Name + Environment.NewLine + ex4);
					}
					array2 = array5;
					foreach (SearchableAttribute val2 in array2)
					{
						try
						{
							SearchableAttribute.RegisterAttribute(val2, (object)memberInfo);
						}
						catch (Exception ex5)
						{
							Log.Debug("SearchableAttribute.RegisterAttribute(attribute, memberInfo) failed for : " + type.FullName + Environment.NewLine + memberInfo.Name + Environment.NewLine + ex5);
						}
					}
				}
			}
		}
	}
}
namespace RoR2BepInExPack.UnityEngineHooks
{
	internal static class FrankenMonoPrintStackOverflowException
	{
		[DllImport("kernel32", ExactSpelling = true)]
		private unsafe static extern int FlushInstructionCache(nint handle, void* baseAddr, nuint size);

		internal unsafe static void Init()
		{
			Process currentProcess = Process.GetCurrentProcess();
			byte* ptr = *(byte**)(void*)(currentProcess.Modules.Cast<ProcessModule>().Single((ProcessModule m) => m.ModuleName == "mono-2.0-bdwgc.dll").BaseAddress + 7697544);
			if (*(long*)ptr != 2372415452946843733L)
			{
				Log.Warning("Unable to apply SOE fix");
				return;
			}
			*ptr = 144;
			FlushInstructionCache(currentProcess.Handle, ptr, 128u);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void Recurse()
		{
			Recurse();
		}
	}
}
namespace RoR2BepInExPack.ReflectionHooks
{
	internal class AutoCatchReflectionTypeLoadException
	{
		private static Hook _onHook;

		private static Hook _onHook2;

		internal static void Init()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Expected O, but got Unknown
			HookConfig val = default(HookConfig);
			val.ManualApply = true;
			HookConfig val2 = val;
			_onHook = new Hook((MethodBase)typeof(Assembly).GetMethods((BindingFlags)(-1)).First((MethodInfo m) => m.Name == "GetTypes" && m.GetParameters().Length == 0 && (m.MethodImplementationFlags & MethodImplAttributes.InternalCall) == 0), typeof(AutoCatchReflectionTypeLoadException).GetMethod("SaferGetTypes", (BindingFlags)(-1)), ref val2);
			val = default(HookConfig);
			val.ManualApply = true;
			HookConfig val3 = val;
			_onHook2 = new Hook((MethodBase)typeof(Assembly).GetMethods((BindingFlags)(-1)).First((MethodInfo m) => m.Name == "GetExportedTypes" && m.GetParameters().Length == 0 && (m.MethodImplementationFlags & MethodImplAttributes.InternalCall) == 0), typeof(AutoCatchReflectionTypeLoadException).GetMethod("SaferGetTypes", (BindingFlags)(-1)), ref val3);
		}

		internal static void Enable()
		{
			_onHook.Apply();
			_onHook2.Apply();
		}

		internal static void Disable()
		{
			_onHook.Undo();
			_onHook2.Undo();
		}

		internal static void Destroy()
		{
			_onHook.Free();
			_onHook2.F