using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using InjectionLibrary.Attributes;
using InjectionLibrary.Exceptions;
using InjectionLibrary.Patches;
using InjectionLibrary.Utils;
using Microsoft.CodeAnalysis;
using Mono;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Collections.Generic;
using MonoMod.Utils;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("BepInEx")]
[assembly: IgnoresAccessChecksTo("Mono.Cecil")]
[assembly: IgnoresAccessChecksTo("Mono.Cecil.Mdb")]
[assembly: IgnoresAccessChecksTo("Mono.Cecil.Pdb")]
[assembly: IgnoresAccessChecksTo("Mono.Cecil.Rocks")]
[assembly: AssemblyCompany("mattymatty")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.2")]
[assembly: AssemblyInformationalVersion("1.0.2+cf0d25cc571708f756abc63e502c228d473f4737")]
[assembly: AssemblyProduct("MonkeyInjectionLibrary")]
[assembly: AssemblyTitle("MonkeyInjectionLibrary")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.2.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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace InjectionLibrary
{
	public enum ErrorHandlingStrategy
	{
		Terminate,
		Ignore,
		LogWarning,
		LogError
	}
	public enum ErrorLevel
	{
		None,
		Soft,
		Hard
	}
	internal static class Preloader
	{
		private static class DevelopConfig
		{
			internal static ConfigEntry<bool> Enabled;

			internal static ConfigEntry<string> OutputPath;

			internal static ConfigEntry<string> OutputExtension;

			public static void Init()
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				ConfigFile val = new ConfigFile(Utility.CombinePaths(new string[2] { MainDir, "MonkeyInjectionLibrary.Development.cfg" }), true, Plugin);
				Enabled = val.Bind<bool>("DevelOptions", "Enabled", false, "Enable development dll output");
				OutputPath = val.Bind<string>("DevelOptions", "OutputPath", MainDir, "Folder where to write the modified dlls");
				OutputExtension = val.Bind<string>("DevelOptions", "OutputExtension", ".pdll", "Extension to use for the modified dlls\n( Do not use .dll if outputting inside the BepInEx folders )");
				PropertyInfo property = ((object)val).GetType().GetProperty("OrphanedEntries", BindingFlags.Instance | BindingFlags.NonPublic);
				Dictionary<ConfigDefinition, string> dictionary = (Dictionary<ConfigDefinition, string>)property.GetValue(val, null);
				dictionary.Clear();
				val.Save();
			}
		}

		private static class ModConfig
		{
			internal static ConfigEntry<bool> EnhancedCompatibility;

			public static void Init()
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				ConfigFile val = new ConfigFile(Utility.CombinePaths(new string[2]
				{
					Paths.ConfigPath,
					"MonkeyInjectionLibrary.cfg"
				}), true, Plugin);
				EnhancedCompatibility = val.Bind<bool>("LoadOptions", "enhanced_compatibility", false, "Try to load missing assemblies from BepInEx folders");
				PropertyInfo property = ((object)val).GetType().GetProperty("OrphanedEntries", BindingFlags.Instance | BindingFlags.NonPublic);
				Dictionary<ConfigDefinition, string> dictionary = (Dictionary<ConfigDefinition, string>)property.GetValue(val, null);
				dictionary.Clear();
				val.Save();
			}
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static AssemblyResolveEventHandler <>9__23_0;

			public static ResolveEventHandler <>9__23_1;

			public static Func<CustomAttribute, bool> <>9__25_0;

			public static Func<CustomAttribute, bool> <>9__25_1;

			public static Func<CustomAttribute, bool> <>9__25_2;

			internal AssemblyDefinition <Initialize>b__23_0(object _, AssemblyNameReference reference)
			{
				AssemblyName assemblyName = default(AssemblyName);
				if (!Utility.TryParseAssemblyName(reference.FullName, ref assemblyName))
				{
					Log.LogWarning((object)("Could not parse assembly name: " + reference.FullName));
					return null;
				}
				AssemblyDefinition result = default(AssemblyDefinition);
				foreach (string item in new string[3]
				{
					Paths.BepInExAssemblyDirectory,
					Paths.PluginPath,
					Paths.PatcherPluginPath
				}.Concat(Paths.DllSearchPaths))
				{
					if (Utility.TryResolveDllAssembly(assemblyName, item, _readerParameters, ref result))
					{
						return result;
					}
				}
				Log.LogWarning((object)$"Could not find assembly: {assemblyName}");
				return null;
			}

			internal Assembly <Initialize>b__23_1(object _, ResolveEventArgs args)
			{
				AssemblyName assemblyName = new AssemblyName(args.Name);
				Assembly result = default(Assembly);
				foreach (string item in new string[3]
				{
					Paths.BepInExAssemblyDirectory,
					Paths.PluginPath,
					Paths.PatcherPluginPath
				}.Concat(Paths.DllSearchPaths))
				{
					if (Utility.TryResolveDllAssembly(assemblyName, item, ref result))
					{
						return result;
					}
				}
				return null;
			}

			internal bool <EnumerateTargetDlLs>b__25_0(CustomAttribute x)
			{
				return ((MemberReference)x.AttributeType).FullName == RequiresInjectionAttributeName;
			}

			internal bool <EnumerateTargetDlLs>b__25_1(CustomAttribute at)
			{
				return ((MemberReference)at.AttributeType).FullName == HandleErrorsAttributeName;
			}

			internal bool <EnumerateTargetDlLs>b__25_2(CustomAttribute at)
			{
				return ((MemberReference)at.AttributeType).FullName == InjectInterfaceAttributeName;
			}
		}

		[CompilerGenerated]
		private sealed class <EnumerateTargetDlLs>d__25 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private Dictionary<string, Dictionary<string, List<(TypeDefinition @interface, ErrorHandlingStrategy strategy)>>>.KeyCollection.Enumerator <>7__wrap1;

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

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

			[DebuggerHidden]
			public <EnumerateTargetDlLs>d__25(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = default(Dictionary<string, Dictionary<string, List<(TypeDefinition, ErrorHandlingStrategy)>>>.KeyCollection.Enumerator);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0183: Unknown result type (might be due to invalid IL or missing references)
				//IL_0188: Unknown result type (might be due to invalid IL or missing references)
				//IL_0239: Unknown result type (might be due to invalid IL or missing references)
				//IL_023e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0247: Unknown result type (might be due to invalid IL or missing references)
				//IL_024e: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						string[] files = Directory.GetFiles(Path.GetFullPath(Paths.PluginPath), "*.dll", SearchOption.AllDirectories);
						string[] array = files;
						foreach (string text in array)
						{
							try
							{
								AssemblyDefinition val = AssemblyDefinition.ReadAssembly(text, _readerParameters);
								if (!val.HasCustomAttributes)
								{
									val.Dispose();
									continue;
								}
								CustomAttribute val2 = ((IEnumerable<CustomAttribute>)val.CustomAttributes).FirstOrDefault((Func<CustomAttribute, bool>)((CustomAttribute x) => ((MemberReference)x.AttributeType).FullName == RequiresInjectionAttributeName));
								if (val2 == null)
								{
									val.Dispose();
									continue;
								}
								Log.LogDebug((object)("Assembly " + ((AssemblyNameReference)val.Name).Name + " Wants to inject something"));
								if (((AssemblyNameReference)val.Name).Name != Path.GetFileNameWithoutExtension(text))
								{
									inError = ErrorLevel.Soft;
									Log.LogError((object)("\r\n⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f\r\nFound assembly \"" + Path.GetRelativePath(Paths.BepInExRootPath, text) + "\"\r\nwith AssemblyName of \"" + ((AssemblyNameReference)val.Name).Name + "\".\r\nThe file name has to be the same as the AssemblyName!\r\n⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f⚠\ufe0f"));
									break;
								}
								LoadedAssemblies.AddLast(val);
								ErrorHandlingStrategy item = ErrorHandlingStrategy.Terminate;
								CustomAttribute val3 = ((IEnumerable<CustomAttribute>)val.CustomAttributes).FirstOrDefault((Func<CustomAttribute, bool>)((CustomAttribute at) => ((MemberReference)at.AttributeType).FullName == HandleErrorsAttributeName));
								CustomAttributeArgument val4;
								if (val3 != null)
								{
									val4 = val3.ConstructorArguments[0];
									item = (ErrorHandlingStrategy)((CustomAttributeArgument)(ref val4)).Value;
								}
								Enumerator<TypeDefinition> enumerator = val.MainModule.Types.GetEnumerator();
								try
								{
									while (enumerator.MoveNext())
									{
										TypeDefinition current = enumerator.Current;
										if (!current.HasCustomAttributes)
										{
											continue;
										}
										CustomAttribute[] array2 = ((IEnumerable<CustomAttribute>)current.CustomAttributes).Where((CustomAttribute at) => ((MemberReference)at.AttributeType).FullName == InjectInterfaceAttributeName).ToArray();
										if (!array2.Any())
										{
											continue;
										}
										Log.LogDebug((object)("Found " + ((MemberReference)current).FullName));
										CustomAttribute[] array3 = array2;
										foreach (CustomAttribute val5 in array3)
										{
											val4 = val5.ConstructorArguments[0];
											TypeReference val6 = (TypeReference)((CustomAttributeArgument)(ref val4)).Value;
											string text2 = val6.Scope.Name + ".dll";
											string fullName = ((MemberReference)val6).FullName;
											TargetTypes.Add(fullName + " from " + text2);
											if (!Interfaces.TryGetValue(text2, out Dictionary<string, List<(TypeDefinition, ErrorHandlingStrategy)>> value))
											{
												value = new Dictionary<string, List<(TypeDefinition, ErrorHandlingStrategy)>>();
												Interfaces[text2] = value;
											}
											if (!value.TryGetValue(fullName, out var value2))
											{
												value2 = (value[fullName] = new List<(TypeDefinition, ErrorHandlingStrategy)>());
											}
											value2.Add((current, item));
										}
									}
								}
								finally
								{
									((IDisposable)enumerator).Dispose();
								}
							}
							catch (BadImageFormatException ex)
							{
								Log.LogWarning((object)("Skipping " + Path.GetRelativePath(Paths.BepInExRootPath, text) + " because it's not a valid .NET assembly. Full error: " + ex.Message));
							}
							catch (IOException ex2)
							{
								inError = ErrorLevel.Soft;
								Log.LogError((object)("Failed to open " + Path.GetRelativePath(Paths.BepInExRootPath, text) + ". Full error:\n" + ex2.Message));
							}
							catch (Exception arg)
							{
								inError = ErrorLevel.Hard;
								Log.LogFatal((object)$"Exception parsing {Path.GetRelativePath(Paths.BepInExRootPath, text)}:\n{arg}");
								break;
							}
						}
						Log.LogInfo((object)$"Found {LoadedAssemblies.Count} assemblies that require Injections");
						<>7__wrap1 = Interfaces.Keys.GetEnumerator();
						<>1__state = -3;
						break;
					}
					case 1:
						<>1__state = -3;
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						string current2 = <>7__wrap1.Current;
						if (inError <= ErrorLevel.Soft)
						{
							_targetAssembly = current2;
							<>2__current = current2;
							<>1__state = 1;
							return true;
						}
					}
					<>m__Finally1();
					<>7__wrap1 = default(Dictionary<string, Dictionary<string, List<(TypeDefinition, ErrorHandlingStrategy)>>>.KeyCollection.Enumerator);
					_targetAssembly = 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;
				((IDisposable)<>7__wrap1).Dispose();
			}

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

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <EnumerateTargetDlLs>d__25(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<string>)this).GetEnumerator();
			}
		}

		public const string GUID = "mattymatty.MonkeyInjectionLibrary";

		public const string NAME = "MonkeyInjectionLibrary";

		public const string VERSION = "1.0.2";

		internal static readonly BepInPlugin Plugin = new BepInPlugin("mattymatty.MonkeyInjectionLibrary", "MonkeyInjectionLibrary", "1.0.2");

		private static ReaderParameters _readerParameters;

		private static readonly string RequiresInjectionAttributeName = typeof(RequiresInjectionsAttribute).FullName;

		private static readonly string InjectInterfaceAttributeName = typeof(InjectInterfaceAttribute).FullName;

		private static readonly string HandleErrorsAttributeName = typeof(HandleErrorsAttribute).FullName;

		private static readonly string MainDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

		private static readonly Dictionary<string, Dictionary<string, List<(TypeDefinition @interface, ErrorHandlingStrategy strategy)>>> Interfaces = new Dictionary<string, Dictionary<string, List<(TypeDefinition, ErrorHandlingStrategy)>>>();

		private static readonly LinkedList<AssemblyDefinition> LoadedAssemblies = new LinkedList<AssemblyDefinition>();

		private static readonly HashSet<string> TargetTypes = new HashSet<string>();

		private static ErrorLevel _inError;

		private static string _targetAssembly;

		internal static ManualLogSource Log { get; } = Logger.CreateLogSource("InjectionLibrary");


		internal static ErrorLevel inError
		{
			get
			{
				return _inError;
			}
			set
			{
				if (value > _inError)
				{
					_inError = value;
				}
			}
		}

		public static IEnumerable<string> TargetDLLs => EnumerateTargetDlLs();

		public static void Patch(ref AssemblyDefinition assembly)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if (inError > ErrorLevel.Soft)
			{
				return;
			}
			try
			{
				if (Interfaces.TryGetValue(_targetAssembly, out Dictionary<string, List<(TypeDefinition, ErrorHandlingStrategy)>> value))
				{
					Log.LogInfo((object)("Patching " + _targetAssembly));
					Enumerator<ModuleDefinition> enumerator = assembly.Modules.GetEnumerator();
					try
					{
						while (enumerator.MoveNext())
						{
							ModuleDefinition current = enumerator.Current;
							current.assembly_resolver = Disposable.NotOwned<IAssemblyResolver>((IAssemblyResolver)(object)TypeLoader.Resolver);
							current.metadata_resolver = (IMetadataResolver)new MetadataResolver((IAssemblyResolver)(object)TypeLoader.Resolver);
							Enumerator<TypeDefinition> enumerator2 = current.Types.GetEnumerator();
							try
							{
								while (enumerator2.MoveNext())
								{
									TypeDefinition current2 = enumerator2.Current;
									if (!value.TryGetValue(((MemberReference)current2).FullName, out var value2))
									{
										continue;
									}
									TargetTypes.Remove(((MemberReference)current2).FullName + " from " + _targetAssembly);
									foreach (var (@interface, errorHandlingStrategy) in value2)
									{
										current2.ImplementInterface((TypeReference)(object)@interface, errorHandlingStrategy);
									}
								}
							}
							finally
							{
								((IDisposable)enumerator2).Dispose();
							}
						}
					}
					finally
					{
						((IDisposable)enumerator).Dispose();
					}
				}
			}
			catch (Exception ex)
			{
				inError = ErrorLevel.Hard;
				if (!(ex is TerminationException))
				{
					Log.LogFatal((object)$"Exception while patching {((AssemblyNameReference)assembly.Name).Name}:\n{ex}");
				}
			}
			if (DevelopConfig.Enabled.Value)
			{
				string text = DevelopConfig.OutputPath.Value + "/" + ((AssemblyNameReference)assembly.Name).Name + DevelopConfig.OutputExtension.Value;
				Log.LogWarning((object)("Saving modified Assembly to " + text));
				assembly.Write(text);
			}
		}

		public static void Initialize()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			Log.LogInfo((object)"Preloader Started");
			ModConfig.Init();
			DevelopConfig.Init();
			DefaultAssemblyResolver val = new DefaultAssemblyResolver();
			_readerParameters = new ReaderParameters
			{
				ReadWrite = false,
				ReadSymbols = false,
				ReadingMode = (ReadingMode)2,
				AssemblyResolver = (IAssemblyResolver)(object)val
			};
			object obj = <>c.<>9__23_0;
			if (obj == null)
			{
				AssemblyResolveEventHandler val2 = delegate(object _, AssemblyNameReference reference)
				{
					AssemblyName assemblyName2 = default(AssemblyName);
					if (!Utility.TryParseAssemblyName(reference.FullName, ref assemblyName2))
					{
						Log.LogWarning((object)("Could not parse assembly name: " + reference.FullName));
						return null;
					}
					AssemblyDefinition result2 = default(AssemblyDefinition);
					foreach (string item in new string[3]
					{
						Paths.BepInExAssemblyDirectory,
						Paths.PluginPath,
						Paths.PatcherPluginPath
					}.Concat(Paths.DllSearchPaths))
					{
						if (Utility.TryResolveDllAssembly(assemblyName2, item, _readerParameters, ref result2))
						{
							return result2;
						}
					}
					Log.LogWarning((object)$"Could not find assembly: {assemblyName2}");
					return null;
				};
				<>c.<>9__23_0 = val2;
				obj = (object)val2;
			}
			((BaseAssemblyResolver)val).ResolveFailure += (AssemblyResolveEventHandler)obj;
			if (!ModConfig.EnhancedCompatibility.Value)
			{
				return;
			}
			AppDomain.CurrentDomain.AssemblyResolve += delegate(object _, ResolveEventArgs args)
			{
				AssemblyName assemblyName = new AssemblyName(args.Name);
				Assembly result = default(Assembly);
				foreach (string item2 in new string[3]
				{
					Paths.BepInExAssemblyDirectory,
					Paths.PluginPath,
					Paths.PatcherPluginPath
				}.Concat(Paths.DllSearchPaths))
				{
					if (Utility.TryResolveDllAssembly(assemblyName, item2, ref result))
					{
						return result;
					}
				}
				return null;
			};
		}

		public static void Finish()
		{
			foreach (AssemblyDefinition loadedAssembly in LoadedAssemblies)
			{
				try
				{
					loadedAssembly.Dispose();
				}
				catch (Exception)
				{
				}
			}
			LoadedAssemblies.Clear();
			if (TargetTypes.Count > 0 && inError < ErrorLevel.Hard)
			{
				inError = ErrorLevel.Soft;
				Log.LogFatal((object)("Some Injection types have not been found:\n |- " + string.Join("\n |- ", TargetTypes)));
			}
			if (inError > ErrorLevel.None)
			{
				Log.LogWarning((object)"\r\n//////////////////////////////////////////////////////////////////\r\n\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\r\nAn Error Occurred while injecting code, \r\nthe game is most likely in a broken state and will probably crash!\r\n//////////////////////////////////////////////////////////////////\r\n\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\");
				if (ConsoleManager.ConsoleActive)
				{
					Log.LogWarning((object)"Pausing for 10s to let the user read the logs");
					Thread.Sleep(TimeSpan.FromSeconds(10.0));
				}
				if (inError >= ErrorLevel.Hard)
				{
					Harmony.CreateAndPatchAll(typeof(TerminationPatch), "mattymatty.MonkeyInjectionLibrary");
				}
			}
			Log.LogInfo((object)"Preloader Finished");
		}

		[IteratorStateMachine(typeof(<EnumerateTargetDlLs>d__25))]
		private static IEnumerable<string> EnumerateTargetDlLs()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnumerateTargetDlLs>d__25(-2);
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "mattymatty.MonkeyInjectionLibrary";

		public const string PLUGIN_NAME = "MonkeyInjectionLibrary";

		public const string PLUGIN_VERSION = "1.0.2";
	}
}
namespace InjectionLibrary.Utils
{
	internal static class InjectionHelper
	{
		private static class Interfaces
		{
			internal static void ImplementProperties(in TypeDefinition type, TypeDefinition @interface, in HashSet<IMemberDefinition> blacklist, ErrorHandlingStrategy errorHandlingStrategy)
			{
				//IL_0006: 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)
				Enumerator<PropertyDefinition> enumerator = @interface.Properties.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						PropertyDefinition current = enumerator.Current;
						ImplementProperty(in type, current, in blacklist, errorHandlingStrategy);
					}
				}
				finally
				{
					((IDisposable)enumerator).Dispose();
				}
			}

			internal static void ImplementEvents(in TypeDefinition type, TypeDefinition @interface, in HashSet<IMemberDefinition> blacklist, ErrorHandlingStrategy errorHandlingStrategy)
			{
				//IL_0006: 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)
				Enumerator<EventDefinition> enumerator = @interface.Events.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						EventDefinition current = enumerator.Current;
						ImplementEvent(in type, current, in blacklist, errorHandlingStrategy);
					}
				}
				finally
				{
					((IDisposable)enumerator).Dispose();
				}
			}

			internal static void ImplementMethods(in TypeDefinition type, TypeDefinition @interface, in HashSet<IMemberDefinition> blacklist, ErrorHandlingStrategy errorHandlingStrategy)
			{
				//IL_0006: 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)
				Enumerator<MethodDefinition> enumerator = @interface.Methods.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						MethodDefinition current = enumerator.Current;
						ImplementMethod(in type, current, in blacklist, errorHandlingStrategy);
					}
				}
				finally
				{
					((IDisposable)enumerator).Dispose();
				}
			}

			private static void ImplementProperty(in TypeDefinition type, PropertyDefinition property, in HashSet<IMemberDefinition> blacklist, ErrorHandlingStrategy errorHandlingStrategy)
			{
				//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fe: Expected O, but got Unknown
				//IL_021c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0228: Unknown result type (might be due to invalid IL or missing references)
				//IL_023a: Unknown result type (might be due to invalid IL or missing references)
				//IL_039c: Unknown result type (might be due to invalid IL or missing references)
				//IL_03a3: Expected O, but got Unknown
				//IL_03c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ce: Expected O, but got Unknown
				//IL_03de: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0408: Unknown result type (might be due to invalid IL or missing references)
				PropertyDefinition propertyImpl2 = null;
				FieldDefinition backingField = null;
				bool hasImplementation = false;
				if (!blacklist.Add((IMemberDefinition)(object)property))
				{
					return;
				}
				Preloader.Log.LogDebug((object)("Adding Property  '" + ((MemberReference)property).Name + "' to " + ((MemberReference)type).FullName + "'"));
				CustomAttribute val = ((IEnumerable<CustomAttribute>)property.CustomAttributes).FirstOrDefault((Func<CustomAttribute, bool>)((CustomAttribute a) => ((MemberReference)a.AttributeType).FullName == ErrorStrategyAttributeName));
				if (val != null)
				{
					errorHandlingStrategy = val.GetAttributeInstance<HandleErrorsAttribute>().Strategy;
				}
				TypeReference typeRef = ((MemberReference)type).Module.ImportReference(((PropertyReference)property).PropertyType);
				MethodDefinition getMethod = property.GetMethod;
				if (getMethod != null && getMethod.IsAbstract && blacklist.Add((IMemberDefinition)(object)property.GetMethod))
				{
					Preloader.Log.LogDebug((object)("Adding getter of '" + ((MemberReference)property).Name + "' to " + ((MemberReference)type).FullName + "'"));
					MethodDefinition val2 = Extensions.FindMethod(type, "get_" + ((MemberReference)property).Name, true);
					if (val2 != null)
					{
						HandleError("Method 'get_" + ((MemberReference)property).Name + "' is already defined in '" + ((MemberReference)type).FullName + "'", errorHandlingStrategy);
						val2.Attributes = (MethodAttributes)2502;
					}
					else
					{
						Init(in type, out propertyImpl2);
						val2 = new MethodDefinition("get_" + ((MemberReference)property).Name, (MethodAttributes)2502, typeRef);
						val2.MarkAsInjected<MethodDefinition>(((MemberReference)type).Module);
						ILProcessor iLProcessor = val2.Body.GetILProcessor();
						iLProcessor.Emit(OpCodes.Ldarg_0);
						iLProcessor.Emit(OpCodes.Ldfld, (FieldReference)(object)backingField);
						iLProcessor.Emit(OpCodes.Ret);
						type.Methods.Add(val2);
						propertyImpl2.GetMethod = val2;
					}
					val2.CopyCustomAttributes<MethodDefinition>(property.GetMethod);
				}
				getMethod = property.SetMethod;
				if (getMethod != null && getMethod.IsAbstract && blacklist.Add((IMemberDefinition)(object)property.SetMethod))
				{
					Preloader.Log.LogDebug((object)("Adding setter of '" + ((MemberReference)property).Name + "' to " + ((MemberReference)type).FullName + "'"));
					MethodDefinition val3 = Extensions.FindMethod(type, "set_" + ((MemberReference)property).Name, true);
					if (val3 != null)
					{
						HandleError("Method 'set_" + ((MemberReference)property).Name + "' is already defined in '" + ((MemberReference)type).FullName + "'", errorHandlingStrategy);
						val3.Attributes = (MethodAttributes)2502;
					}
					else
					{
						if (!hasImplementation)
						{
							Init(in type, out propertyImpl2);
						}
						val3 = new MethodDefinition("set_" + ((MemberReference)property).Name, (MethodAttributes)2502, ((MemberReference)type).Module.TypeSystem.Void);
						val3.MarkAsInjected<MethodDefinition>(((MemberReference)type).Module);
						((MethodReference)val3).Parameters.Add(new ParameterDefinition("value", (ParameterAttributes)0, typeRef));
						ILProcessor iLProcessor2 = val3.Body.GetILProcessor();
						iLProcessor2.Emit(OpCodes.Ldarg_0);
						iLProcessor2.Emit(OpCodes.Ldarg_1);
						iLProcessor2.Emit(OpCodes.Stfld, (FieldReference)(object)backingField);
						iLProcessor2.Emit(OpCodes.Ret);
						type.Methods.Add(val3);
						propertyImpl2.SetMethod = val3;
					}
					val3.CopyCustomAttributes<MethodDefinition>(property.SetMethod);
				}
				if (!hasImplementation)
				{
					Preloader.Log.LogDebug((object)("Default Property '" + ((MemberReference)property).Name + "' to " + ((MemberReference)type).FullName + "'"));
				}
				else
				{
					type.Fields.TryAdd<FieldDefinition>(backingField);
					type.Properties.TryAdd<PropertyDefinition>(propertyImpl2);
				}
				void Init(in TypeDefinition type, out PropertyDefinition propertyImpl)
				{
					//IL_0054: Unknown result type (might be due to invalid IL or missing references)
					//IL_005e: Expected O, but got Unknown
					//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
					//IL_00cf: Expected O, but got Unknown
					propertyImpl = null;
					backingField = Extensions.FindField(type, "<" + ((MemberReference)property).Name + ">k__BackingField");
					if (backingField == null)
					{
						backingField = new FieldDefinition("<" + ((MemberReference)property).Name + ">k__BackingField", (FieldAttributes)1, typeRef);
						backingField.MarkAsInjected<FieldDefinition>(((MemberReference)type).Module);
					}
					else
					{
						HandleError("Field '<" + ((MemberReference)property).Name + ">k__BackingField' already exists in " + ((MemberReference)type).FullName, errorHandlingStrategy);
					}
					propertyImpl = Extensions.FindProperty(type, ((MemberReference)property).Name);
					if (propertyImpl == null)
					{
						propertyImpl = new PropertyDefinition(((MemberReference)property).Name, (PropertyAttributes)0, typeRef);
						propertyImpl.CopyCustomAttributes<PropertyDefinition>(property);
						propertyImpl.MarkAsInjected<PropertyDefinition>(((MemberReference)type).Module);
					}
					else
					{
						HandleError("Property '" + ((MemberReference)property).Name + "' already exists in " + ((MemberReference)type).FullName, errorHandlingStrategy);
					}
					hasImplementation = true;
				}
			}

			private static void ImplementEvent(in TypeDefinition type, EventDefinition @event, in HashSet<IMemberDefinition> blacklist, ErrorHandlingStrategy errorHandlingStrategy)
			{
				//IL_0202: Unknown result type (might be due to invalid IL or missing references)
				//IL_0209: Expected O, but got Unknown
				//IL_022a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0234: Expected O, but got Unknown
				//IL_0244: Unknown result type (might be due to invalid IL or missing references)
				//IL_0250: Unknown result type (might be due to invalid IL or missing references)
				//IL_025c: Unknown result type (might be due to invalid IL or missing references)
				//IL_026e: Unknown result type (might be due to invalid IL or missing references)
				//IL_027a: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_0451: Unknown result type (might be due to invalid IL or missing references)
				//IL_0458: Expected O, but got Unknown
				//IL_0479: Unknown result type (might be due to invalid IL or missing references)
				//IL_0483: Expected O, but got Unknown
				//IL_0493: Unknown result type (might be due to invalid IL or missing references)
				//IL_049f: Unknown result type (might be due to invalid IL or missing references)
				//IL_04ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_04bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_04c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0515: Unknown result type (might be due to invalid IL or missing references)
				//IL_052c: Unknown result type (might be due to invalid IL or missing references)
				//IL_053e: Unknown result type (might be due to invalid IL or missing references)
				//IL_06a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_06a7: Expected O, but got Unknown
				//IL_06c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_06ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_06e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_06ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0709: Expected O, but got Unknown
				//IL_0732: Unknown result type (might be due to invalid IL or missing references)
				//IL_073e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0755: Unknown result type (might be due to invalid IL or missing references)
				//IL_077b: Unknown result type (might be due to invalid IL or missing references)
				//IL_07cc: Unknown result type (might be due to invalid IL or missing references)
				EventDefinition eventImpl2 = null;
				FieldDefinition backingField = null;
				bool hasImplementation = false;
				if (!blacklist.Add((IMemberDefinition)(object)@event))
				{
					return;
				}
				Preloader.Log.LogDebug((object)("Adding Event     '" + ((MemberReference)@event).Name + "' to " + ((MemberReference)type).FullName + "'"));
				CustomAttribute val = ((IEnumerable<CustomAttribute>)@event.CustomAttributes).FirstOrDefault((Func<CustomAttribute, bool>)((CustomAttribute a) => ((MemberReference)a.AttributeType).FullName == ErrorStrategyAttributeName));
				if (val != null)
				{
					errorHandlingStrategy = val.GetAttributeInstance<HandleErrorsAttribute>().Strategy;
				}
				TypeReference typeRef = ((MemberReference)type).Module.ImportReference(((EventReference)@event).EventType);
				MethodDefinition addMethod = @event.AddMethod;
				if (addMethod != null && addMethod.IsAbstract && blacklist.Add((IMemberDefinition)(object)@event.AddMethod))
				{
					Preloader.Log.LogDebug((object)("Adding add of    '" + ((MemberReference)@event).Name + "' to " + ((MemberReference)type).FullName + "'"));
					MethodDefinition val2 = Extensions.FindMethod(type, "add_" + ((MemberReference)@event).Name, true);
					if (val2 != null)
					{
						HandleError("Method 'add_" + ((MemberReference)@event).Name + "' is already defined in '" + ((MemberReference)type).FullName + "'", errorHandlingStrategy);
						val2.Attributes = (MethodAttributes)2502;
					}
					else
					{
						Init(in type, out eventImpl2);
						val2 = new MethodDefinition("add_" + ((MemberReference)@event).Name, (MethodAttributes)2502, ((MemberReference)type).Module.TypeSystem.Void);
						val2.MarkAsInjected<MethodDefinition>(((MemberReference)type).Module);
						((MethodReference)val2).Parameters.Add(new ParameterDefinition("value", (ParameterAttributes)0, typeRef));
						ILProcessor iLProcessor = val2.Body.GetILProcessor();
						iLProcessor.Emit(OpCodes.Ldarg_0);
						iLProcessor.Emit(OpCodes.Ldarg_0);
						iLProcessor.Emit(OpCodes.Ldfld, (FieldReference)(object)backingField);
						iLProcessor.Emit(OpCodes.Ldarg_1);
						iLProcessor.Emit(OpCodes.Call, ((MemberReference)type).Module.ImportReference((MethodBase)typeof(Delegate).GetMethod("Combine", new Type[2]
						{
							typeof(Delegate),
							typeof(Delegate)
						})));
						iLProcessor.Emit(OpCodes.Castclass, ((EventReference)@event).EventType);
						iLProcessor.Emit(OpCodes.Stfld, (FieldReference)(object)backingField);
						iLProcessor.Emit(OpCodes.Ret);
						type.Methods.Add(val2);
						eventImpl2.AddMethod = val2;
					}
					val2.CopyCustomAttributes<MethodDefinition>(@event.AddMethod);
				}
				addMethod = @event.RemoveMethod;
				if (addMethod != null && addMethod.IsAbstract && blacklist.Add((IMemberDefinition)(object)@event.RemoveMethod))
				{
					if (!hasImplementation)
					{
						Init(in type, out eventImpl2);
					}
					Preloader.Log.LogDebug((object)("Adding remove of '" + ((MemberReference)@event).Name + "' to " + ((MemberReference)type).FullName + "'"));
					MethodDefinition val3 = Extensions.FindMethod(type, "remove_" + ((MemberReference)@event).Name, true);
					if (val3 != null)
					{
						HandleError("Method 'remove_" + ((MemberReference)@event).Name + "' is already defined in '" + ((MemberReference)type).FullName + "'", errorHandlingStrategy);
						val3.Attributes = (MethodAttributes)2502;
					}
					else
					{
						val3 = new MethodDefinition("remove_" + ((MemberReference)@event).Name, (MethodAttributes)2502, ((MemberReference)type).Module.TypeSystem.Void);
						val3.MarkAsInjected<MethodDefinition>(((MemberReference)type).Module);
						((MethodReference)val3).Parameters.Add(new ParameterDefinition("value", (ParameterAttributes)0, typeRef));
						ILProcessor iLProcessor2 = val3.Body.GetILProcessor();
						iLProcessor2.Emit(OpCodes.Ldarg_0);
						iLProcessor2.Emit(OpCodes.Ldarg_0);
						iLProcessor2.Emit(OpCodes.Ldfld, (FieldReference)(object)backingField);
						iLProcessor2.Emit(OpCodes.Ldarg_1);
						iLProcessor2.Emit(OpCodes.Call, ((MemberReference)type).Module.ImportReference((MethodBase)typeof(Delegate).GetMethod("Remove", new Type[2]
						{
							typeof(Delegate),
							typeof(Delegate)
						})));
						iLProcessor2.Emit(OpCodes.Castclass, ((EventReference)@event).EventType);
						iLProcessor2.Emit(OpCodes.Stfld, (FieldReference)(object)backingField);
						iLProcessor2.Emit(OpCodes.Ret);
						type.Methods.Add(val3);
						eventImpl2.RemoveMethod = val3;
					}
					val3.CopyCustomAttributes<MethodDefinition>(@event.RemoveMethod);
				}
				addMethod = @event.InvokeMethod;
				if (addMethod != null && addMethod.IsAbstract && blacklist.Add((IMemberDefinition)(object)@event.InvokeMethod))
				{
					Preloader.Log.LogDebug((object)("Adding raise of  '" + ((MemberReference)@event).Name + "' to " + ((MemberReference)type).FullName + "'"));
					MethodDefinition val4 = Extensions.FindMethod(type, "raise_" + ((MemberReference)@event).Name, true);
					if (val4 != null)
					{
						HandleError("Method 'raise_" + ((MemberReference)@event).Name + "' is already defined in '" + ((MemberReference)type).FullName + "'", errorHandlingStrategy);
						val4.Attributes = (MethodAttributes)2502;
					}
					else
					{
						if (!hasImplementation)
						{
							Init(in type, out eventImpl2);
						}
						val4 = new MethodDefinition("raise_" + ((MemberReference)@event).Name, (MethodAttributes)2502, ((MemberReference)type).Module.TypeSystem.Void);
						val4.MarkAsInjected<MethodDefinition>(((MemberReference)type).Module);
						Enumerator<ParameterDefinition> enumerator = ((MethodReference)@event.InvokeMethod).Parameters.GetEnumerator();
						try
						{
							while (enumerator.MoveNext())
							{
								ParameterDefinition current = enumerator.Current;
								((MethodReference)val4).Parameters.Add(new ParameterDefinition(((ParameterReference)current).Name, current.Attributes, ((MemberReference)type).Module.ImportReference(((ParameterReference)current).ParameterType)));
							}
						}
						finally
						{
							((IDisposable)enumerator).Dispose();
						}
						ILProcessor iLProcessor3 = val4.Body.GetILProcessor();
						iLProcessor3.Emit(OpCodes.Ldarg_0);
						iLProcessor3.Emit(OpCodes.Ldfld, (FieldReference)(object)backingField);
						for (int i = 0; i < ((MethodReference)val4).Parameters.Count; i++)
						{
							iLProcessor3.Emit(OpCodes.Ldarg, i + 1);
						}
						iLProcessor3.Emit(OpCodes.Callvirt, ((MemberReference)type).Module.ImportReference((MethodReference)(object)((IEnumerable<MethodDefinition>)((EventReference)@event).EventType.Resolve().Methods).First((MethodDefinition m) => ((MemberReference)m).Name == "Invoke")));
						iLProcessor3.Emit(OpCodes.Ret);
						type.Methods.Add(val4);
						eventImpl2.InvokeMethod = val4;
					}
					val4.CopyCustomAttributes<MethodDefinition>(@event.InvokeMethod);
				}
				if (hasImplementation)
				{
					type.Fields.TryAdd<FieldDefinition>(backingField);
					type.Events.TryAdd<EventDefinition>(eventImpl2);
				}
				void Init(in TypeDefinition type, out EventDefinition eventImpl)
				{
					//IL_0036: Unknown result type (might be due to invalid IL or missing references)
					//IL_0040: 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
					eventImpl = null;
					backingField = Extensions.FindField(type, ((MemberReference)@event).Name);
					if (backingField == null)
					{
						backingField = new FieldDefinition(((MemberReference)@event).Name, (FieldAttributes)1, typeRef);
						backingField.MarkAsInjected<FieldDefinition>(((MemberReference)type).Module);
					}
					else
					{
						HandleError("Field '" + ((MemberReference)@event).Name + "' already exists in " + ((MemberReference)type).FullName, errorHandlingStrategy);
					}
					eventImpl = Extensions.FindEvent(type, ((MemberReference)@event).Name);
					if (eventImpl == null)
					{
						eventImpl = new EventDefinition(((MemberReference)@event).Name, (EventAttributes)0, typeRef);
						eventImpl.CopyCustomAttributes<EventDefinition>(@event);
						eventImpl.MarkAsInjected<EventDefinition>(((MemberReference)type).Module);
					}
					else
					{
						HandleError("Event '" + ((MemberReference)@event).Name + "' already exists in " + ((MemberReference)type).FullName, errorHandlingStrategy);
					}
					hasImplementation = true;
				}
			}

			private static void ImplementMethod(in TypeDefinition type, MethodDefinition method, in HashSet<IMemberDefinition> blacklist, ErrorHandlingStrategy errorHandlingStrategy)
			{
				//IL_010a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0110: Expected O, but got Unknown
				//IL_0116: Unknown result type (might be due to invalid IL or missing references)
				//IL_011b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: Unknown result type (might be due to invalid IL or missing references)
				//IL_014e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0158: Expected O, but got Unknown
				//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
				if (!blacklist.Add((IMemberDefinition)(object)method))
				{
					return;
				}
				Preloader.Log.LogDebug((object)("Adding Method    '" + ((MemberReference)method).Name + "' to " + ((MemberReference)type).FullName + "'"));
				if (!method.IsAbstract)
				{
					return;
				}
				CustomAttribute val = ((IEnumerable<CustomAttribute>)method.CustomAttributes).FirstOrDefault((Func<CustomAttribute, bool>)((CustomAttribute a) => ((MemberReference)a.AttributeType).FullName == ErrorStrategyAttributeName));
				if (val != null)
				{
					errorHandlingStrategy = val.GetAttributeInstance<HandleErrorsAttribute>().Strategy;
				}
				MethodDefinition val2 = Extensions.FindMethod(type, ((MemberReference)method).Name, true);
				if (val2 != null)
				{
					HandleError("Method '" + ((MemberReference)method).Name + "' is already defined in '" + ((MemberReference)type).FullName + "'", errorHandlingStrategy);
					val2.Attributes = (MethodAttributes)326;
				}
				else
				{
					val2 = new MethodDefinition(((MemberReference)method).Name, (MethodAttributes)326, ((MemberReference)type).Module.ImportReference(((MethodReference)method).ReturnType));
					Enumerator<ParameterDefinition> enumerator = ((MethodReference)method).Parameters.GetEnumerator();
					try
					{
						while (enumerator.MoveNext())
						{
							ParameterDefinition current = enumerator.Current;
							((MethodReference)val2).Parameters.Add(new ParameterDefinition(((ParameterReference)current).Name, current.Attributes, ((MemberReference)type).Module.ImportReference(((ParameterReference)current).ParameterType)));
						}
					}
					finally
					{
						((IDisposable)enumerator).Dispose();
					}
					ILProcessor iLProcessor = val2.Body.GetILProcessor();
					if (((MemberReference)((MethodReference)method).ReturnType).FullName != "System.Void")
					{
						ConstructorInfo constructor = typeof(NotImplementedException).GetConstructor(new Type[1] { typeof(string) });
						MethodReference val3 = ((MemberReference)type).Module.ImportReference((MethodBase)constructor);
						iLProcessor.Emit(OpCodes.Ldstr, "This is a Stub");
						iLProcessor.Emit(OpCodes.Newobj, val3);
						iLProcessor.Emit(OpCodes.Throw);
					}
					else
					{
						iLProcessor.Emit(OpCodes.Ret);
					}
					val2.MarkAsInjected<MethodDefinition>(((MemberReference)type).Module);
				}
				val2.CopyCustomAttributes<MethodDefinition>(method);
				type.Methods.TryAdd<MethodDefinition>(val2);
			}
		}

		private static readonly string ErrorStrategyAttributeName = typeof(HandleErrorsAttribute).FullName;

		private const MethodAttributes InterfaceMethodAttributes = 326;

		private const MethodAttributes InterfaceSpecialMethodAttributes = 2502;

		private const PropertyAttributes InterfacePropertyAttributes = 0;

		private const EventAttributes InterfaceEventAttributes = 0;

		public static T GetAttributeInstance<T>(this CustomAttribute attribute) where T : Attribute
		{
			Type typeFromHandle = typeof(T);
			object[] args = ((IEnumerable<CustomAttributeArgument>)attribute.ConstructorArguments).Select((CustomAttributeArgument ca) => ((CustomAttributeArgument)(ref ca)).Value).ToArray();
			return (T)Activator.CreateInstance(typeFromHandle, args);
		}

		private static void HandleError(string message, ErrorHandlingStrategy strategy)
		{
			switch (strategy)
			{
			default:
				Preloader.inError = ErrorLevel.Hard;
				Preloader.Log.LogFatal((object)message);
				throw new TerminationException("Fatal Injection error!");
			case ErrorHandlingStrategy.LogWarning:
				Preloader.Log.LogWarning((object)message);
				break;
			case ErrorHandlingStrategy.LogError:
				Preloader.inError = ErrorLevel.Soft;
				Preloader.Log.LogError((object)message);
				break;
			case ErrorHandlingStrategy.Ignore:
				break;
			}
		}

		internal static void ImplementInterface(this TypeDefinition self, TypeReference @interface, ErrorHandlingStrategy errorHandlingStrategy)
		{
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: 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_01b0: Expected O, but got Unknown
			TypeDefinition val = @interface.Resolve();
			CustomAttribute val2 = ((IEnumerable<CustomAttribute>)val.CustomAttributes).FirstOrDefault((Func<CustomAttribute, bool>)((CustomAttribute a) => ((MemberReference)a.AttributeType).FullName == ErrorStrategyAttributeName));
			if (val2 != null)
			{
				errorHandlingStrategy = val2.GetAttributeInstance<HandleErrorsAttribute>().Strategy;
			}
			if (!val.IsInterface)
			{
				HandleError("Type '" + ((MemberReference)@interface).FullName + "' is not an interface!", errorHandlingStrategy);
			}
			if (((TypeReference)val).HasGenericParameters)
			{
				HandleError("Type '" + ((MemberReference)@interface).FullName + "' is a Generic type!", errorHandlingStrategy);
			}
			Preloader.Log.LogDebug((object)("Injecting '" + ((MemberReference)@interface).FullName + "' into " + ((MemberReference)self).FullName + "'"));
			if (((IEnumerable<InterfaceImplementation>)self.Interfaces).Any((InterfaceImplementation i) => i.InterfaceType == @interface))
			{
				Preloader.Log.LogWarning((object)("Interface '" + ((MemberReference)@interface).FullName + "' is already implemented, SKIPPING!"));
				return;
			}
			Enumerator<InterfaceImplementation> enumerator = val.Interfaces.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					InterfaceImplementation current = enumerator.Current;
					self.ImplementInterface(current.InterfaceType, errorHandlingStrategy);
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
			TypeReference val3 = ((MemberReference)self).Module.ImportReference(@interface);
			HashSet<IMemberDefinition> blacklist = new HashSet<IMemberDefinition>();
			Interfaces.ImplementProperties(in self, val, in blacklist, errorHandlingStrategy);
			Interfaces.ImplementEvents(in self, val, in blacklist, errorHandlingStrategy);
			Interfaces.ImplementMethods(in self, val, in blacklist, errorHandlingStrategy);
			self.Interfaces.Add(new InterfaceImplementation(val3));
		}

		private static void MarkAsInjected<T>(this T target, ModuleDefinition module) where T : MemberReference, ICustomAttributeProvider
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			module.ImportReference(typeof(InjectedMemberAttribute));
			MethodReference val = module.ImportReference((MethodBase)typeof(InjectedMemberAttribute).GetConstructor(AccessTools.all, null, Array.Empty<Type>(), Array.Empty<ParameterModifier>()));
			CustomAttribute val2 = new CustomAttribute(val);
			((ICustomAttributeProvider)target).CustomAttributes.Add(val2);
		}

		private static void CopyCustomAttributes<T>(this T target, T source) where T : MemberReference, ICustomAttributeProvider
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: 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_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			ModuleDefinition module = ((MemberReference)target).Module;
			Enumerator<CustomAttribute> enumerator = ((ICustomAttributeProvider)source).CustomAttributes.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					CustomAttribute current = enumerator.Current;
					if (((MemberReference)current.AttributeType).FullName == ErrorStrategyAttributeName)
					{
						continue;
					}
					MethodReference val = module.ImportReference(current.Constructor);
					CustomAttribute val2 = new CustomAttribute(val);
					Enumerator<CustomAttributeArgument> enumerator2 = current.ConstructorArguments.GetEnumerator();
					try
					{
						while (enumerator2.MoveNext())
						{
							CustomAttributeArgument current2 = enumerator2.Current;
							val2.ConstructorArguments.Add(module.ImportCustomAttributeArgument(current2));
						}
					}
					finally
					{
						((IDisposable)enumerator2).Dispose();
					}
					Enumerator<CustomAttributeNamedArgument> enumerator3 = current.Properties.GetEnumerator();
					try
					{
						while (enumerator3.MoveNext())
						{
							CustomAttributeNamedArgument current3 = enumerator3.Current;
							val2.Properties.Add(new CustomAttributeNamedArgument(((CustomAttributeNamedArgument)(ref current3)).Name, module.ImportCustomAttributeArgument(((CustomAttributeNamedArgument)(ref current3)).Argument)));
						}
					}
					finally
					{
						((IDisposable)enumerator3).Dispose();
					}
					Enumerator<CustomAttributeNamedArgument> enumerator4 = current.Fields.GetEnumerator();
					try
					{
						while (enumerator4.MoveNext())
						{
							CustomAttributeNamedArgument current4 = enumerator4.Current;
							val2.Fields.Add(new CustomAttributeNamedArgument(((CustomAttributeNamedArgument)(ref current4)).Name, module.ImportCustomAttributeArgument(((CustomAttributeNamedArgument)(ref current4)).Argument)));
						}
					}
					finally
					{
						((IDisposable)enumerator4).Dispose();
					}
					((ICustomAttributeProvider)target).CustomAttributes.Add(val2);
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
		}

		private static CustomAttributeArgument ImportCustomAttributeArgument(this ModuleDefinition targetModule, CustomAttributeArgument arg)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			TypeReference val = targetModule.ImportReference(((CustomAttributeArgument)(ref arg)).Type);
			object value = ((CustomAttributeArgument)(ref arg)).Value;
			TypeReference val2 = (TypeReference)((value is TypeReference) ? value : null);
			if (val2 == null)
			{
				if (value is CustomAttributeArgument[] array)
				{
					CustomAttributeArgument[] array2 = (CustomAttributeArgument[])(object)new CustomAttributeArgument[array.Length];
					for (int i = 0; i < array.Length; i++)
					{
						array2[i] = targetModule.ImportCustomAttributeArgument(array[i]);
					}
					return new CustomAttributeArgument(val, (object)array2);
				}
				return new CustomAttributeArgument(val, ((CustomAttributeArgument)(ref arg)).Value);
			}
			return new CustomAttributeArgument(val, (object)targetModule.ImportReference(val2));
		}

		private static void TryAdd<T>(this Collection<T> collection, T newMember) where T : IMemberDefinition
		{
			if (!((IEnumerable<T>)collection).Any((T member) => ((IMemberDefinition)member).Name == ((IMemberDefinition)newMember).Name))
			{
				collection.Add(newMember);
			}
		}

		internal static string GetAssemblyQualifiedName(this TypeReference type)
		{
			IMetadataScope scope = type.Scope;
			AssemblyNameReference val = (AssemblyNameReference)(object)((scope is AssemblyNameReference) ? scope : null);
			string text;
			if (val == null)
			{
				ModuleDefinition val2 = (ModuleDefinition)(object)((scope is ModuleDefinition) ? scope : null);
				if (val2 != null)
				{
					AssemblyDefinition assembly = val2.Assembly;
					object obj;
					if (assembly == null)
					{
						obj = null;
					}
					else
					{
						AssemblyNameDefinition name = assembly.Name;
						obj = ((name != null) ? ((AssemblyNameReference)name).FullName : null);
					}
					text = (string)obj;
				}
				else
				{
					text = null;
				}
			}
			else
			{
				text = val.FullName;
			}
			string text2 = text;
			if (text2 == null)
			{
				return ((MemberReference)type).FullName;
			}
			return ((MemberReference)type).FullName + ", " + text2;
		}
	}
}
namespace InjectionLibrary.Patches
{
	[HarmonyPatch(typeof(Chainloader))]
	internal static class TerminationPatch
	{
		[HarmonyPatch("ReplayPreloaderLogs")]
		[HarmonyFinalizer]
		internal static void TerminateAfterLogging()
		{
			Preloader.Log.LogFatal((object)"An unrecoverable error occurred. Shutting down the process.");
			Environment.Exit(999);
		}
	}
}
namespace InjectionLibrary.Exceptions
{
	public class TerminationException : Exception
	{
		public TerminationException(string message)
			: base(message)
		{
		}
	}
}
namespace InjectionLibrary.Attributes
{
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Interface)]
	public class HandleErrorsAttribute : Attribute
	{
		public ErrorHandlingStrategy Strategy { get; }

		public HandleErrorsAttribute(ErrorHandlingStrategy strategy)
		{
			Strategy = strategy;
		}

		public HandleErrorsAttribute(int strategy)
		{
			Strategy = (ErrorHandlingStrategy)strategy;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event, AllowMultiple = true)]
	public class InjectedMemberAttribute : Attribute
	{
		internal InjectedMemberAttribute()
		{
		}
	}
	[AttributeUsage(AttributeTargets.Interface, AllowMultiple = true)]
	public sealed class InjectInterfaceAttribute : Attribute
	{
		[CompilerGenerated]
		private Type <targetType>P;

		public string AssemblyName => <targetType>P.Assembly.GetName().Name;

		public string TypeName => <targetType>P.FullName;

		public InjectInterfaceAttribute(Type targetType)
		{
			<targetType>P = targetType;
			base..ctor();
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	public sealed class RequiresInjectionsAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}