using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using UnityDebuggerAssistant.Components;
using UnityDebuggerAssistant.Filtering;
using UnityDebuggerAssistant.Patches;
using UnityDebuggerAssistant.Processing;
using UnityDebuggerAssistant.Utils;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyCompany("LethalCompanyModding")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("A BepinEx plugin that captures Harmony and Monomod (wip) hook information at\r\n      runtime to ease debugging")]
[assembly: AssemblyFileVersion("1.4.2.0")]
[assembly: AssemblyInformationalVersion("1.4.2+79a459d07838d68bc658c4def630236d2d21cdcd")]
[assembly: AssemblyProduct("UnityDebuggerAssistant")]
[assembly: AssemblyTitle("dev.mamallama.lcm.dbgasst")]
[assembly: AssemblyMetadata("RepositoryUrl", "gitgithub.com:RobynLlama/UnityDebuggerAssistant.git")]
[assembly: AssemblyVersion("1.4.2.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
[BepInPlugin("dev.mamallama.lcm.dbgasst", "UnityDebuggerAssistant", "1.4.2")]
public class UDAPlugin : BaseUnityPlugin
{
	internal static ManualLogSource? Log;

	internal static PluginConfiguration UDASettings;

	private void Awake()
	{
		//IL_014f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0155: Expected O, but got Unknown
		//IL_018a: Unknown result type (might be due to invalid IL or missing references)
		//IL_018f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0198: Expected O, but got Unknown
		Log = ((BaseUnityPlugin)this).Logger;
		UDASettings = new PluginConfiguration(((BaseUnityPlugin)this).Config);
		UDABlacklist.UpdateLists_Internal();
		StringBuilder stringBuilder = new StringBuilder("\r\n\r\n>------------------------------------------------------------------------<\r\n  Unity Debugger assistant is loaded and receiving exceptions!\r\n\r\n  Note: That UDA will catch ALL exceptions, even harmless ones\r\n  Please ONLY report logs to modders if you have an issue with their mod\r\n\r\n  Config:\r\n");
		stringBuilder.Append("    Using Per-Exception Whitelist: ");
		stringBuilder.AppendLine(UDASettings.EnableWhitelistPerException.Value.ToString());
		stringBuilder.Append("    Using Per-Exception Blacklist: ");
		stringBuilder.AppendLine(UDASettings.EnableBlacklistPerException.Value.ToString());
		stringBuilder.Append("    Using Per-Frame Whitelist: ");
		stringBuilder.AppendLine(UDASettings.EnableWhitelistPerFrame.Value.ToString());
		stringBuilder.Append("    Using Per-Frame Blacklist: ");
		stringBuilder.AppendLine(UDASettings.EnableBlacklistPerFrame.Value.ToString());
		stringBuilder.Append("    Total Filters: ");
		stringBuilder.AppendLine((UDABlacklist.ExceptionBlackList.Count() + UDABlacklist.FrameBlackList.Count()).ToString());
		stringBuilder.AppendLine(">------------------------------------------------------------------------<");
		Log.LogMessage((object)stringBuilder);
		ILHook.OnDetour = (Func<ILHook, MethodBase, Manipulator, bool>)Delegate.Combine(ILHook.OnDetour, new Func<ILHook, MethodBase, Manipulator, bool>(UDAPatchListener.ListenForPatch));
		Harmony val = new Harmony("dev.mamallama.lcm.dbgasst");
		val.PatchAll(typeof(ExceptionConstructorPatch));
		GameObject val2 = new GameObject("UDAMain", new Type[2]
		{
			typeof(UDAExceptionBroker),
			typeof(UDAPostChainloadRunner)
		})
		{
			hideFlags = (HideFlags)61
		};
		Object.DontDestroyOnLoad((Object)(object)val2);
	}
}
internal class PluginConfiguration
{
	public readonly ConfigEntry<bool> EnableWhitelistPerException = Config.Bind<bool>(new ConfigDefinition("ExceptionFilter", "WhitelistEnabled"), true, new ConfigDescription("The per-exception whitelist filters out exceptions that do not originate from common game assemblies or BepinEx plugins.\nDisable this to catch everything. Will increase the log file size.", (AcceptableValueBase)null, Array.Empty<object>()));

	public readonly ConfigEntry<bool> EnableWhitelistPerFrame = Config.Bind<bool>(new ConfigDefinition("FrameFilter", "WhitelistEnabled"), false, new ConfigDescription("The per-frame whitelist will remove frames inside of exceptions that do not originate from common game assemblies.\nEnable this to reduce log file size by cutting out less relevant frames", (AcceptableValueBase)null, Array.Empty<object>()));

	public readonly ConfigEntry<bool> EnableBlacklistPerException = Config.Bind<bool>(new ConfigDefinition("ExceptionFilter", "BlacklistEnabled"), false, new ConfigDescription("The per-exception blacklist filters out exceptions that match the given patterns.\nThis is useful if you know a specific assembly throws errors you can ignore", (AcceptableValueBase)null, Array.Empty<object>()));

	public readonly ConfigEntry<bool> EnableBlacklistPerFrame = Config.Bind<bool>(new ConfigDefinition("FrameFilter", "BlacklistEnabled"), false, new ConfigDescription("The per-frame blacklist filters out exceptions that match the given patterns.\nThis is useful if you know a specific assembly throws errors you can ignore", (AcceptableValueBase)null, Array.Empty<object>()));

	public readonly ConfigEntry<string> ExceptionBlacklist = Config.Bind<string>(new ConfigDefinition("ExceptionFilter", "Blacklist"), "UniverseLib.Mono, UnityExplorer.", new ConfigDescription("A comma-separated list of assembly names to ignore in exception processing\nThis will be matched against the beginning of each assembly name so e.g. `UnityEngine.` will match all UnityEngine assemblies", (AcceptableValueBase)null, Array.Empty<object>()));

	public readonly ConfigEntry<string> FrameBlacklist = Config.Bind<string>(new ConfigDefinition("FrameFilter", "Blacklist"), "mscorlib", new ConfigDescription("A comma-separated list of assembly names to ignore in individual frame processing\nThis will be matched against the beginning of each assembly name so e.g. `UnityEngine.` will match all UnityEngine assemblies", (AcceptableValueBase)null, Array.Empty<object>()));

	public PluginConfiguration(ConfigFile Config)
	{
	}//IL_000c: Unknown result type (might be due to invalid IL or missing references)
	//IL_001d: Unknown result type (might be due to invalid IL or missing references)
	//IL_0027: Expected O, but got Unknown
	//IL_0027: Expected O, but got Unknown
	//IL_0038: Unknown result type (might be due to invalid IL or missing references)
	//IL_0049: Unknown result type (might be due to invalid IL or missing references)
	//IL_0053: Expected O, but got Unknown
	//IL_0053: Expected O, but got Unknown
	//IL_0064: Unknown result type (might be due to invalid IL or missing references)
	//IL_0075: Unknown result type (might be due to invalid IL or missing references)
	//IL_007f: Expected O, but got Unknown
	//IL_007f: Expected O, but got Unknown
	//IL_0090: Unknown result type (might be due to invalid IL or missing references)
	//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
	//IL_00ab: Expected O, but got Unknown
	//IL_00ab: Expected O, but got Unknown
	//IL_00bc: 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_00db: Expected O, but got Unknown
	//IL_00db: Expected O, but got Unknown
	//IL_00ec: 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)
	//IL_010b: Expected O, but got Unknown
	//IL_010b: Expected O, but got Unknown

}
internal static class LCMPluginInfo
{
	public const string PLUGIN_GUID = "dev.mamallama.lcm.dbgasst";

	public const string PLUGIN_NAME = "UnityDebuggerAssistant";

	public const string PLUGIN_VERSION = "1.4.2";
}
namespace UnityDebuggerAssistant.Utils
{
	internal static class Helpers
	{
		internal static Assembly GetAssemblyByName(string name)
		{
			string name2 = name;
			return AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly assembly) => assembly.GetName().Name.Equals(name2, StringComparison.InvariantCultureIgnoreCase));
		}
	}
	public static class UDAPatchListener
	{
		internal static bool ListenForPatch(ILHook hook, MethodBase @base, Manipulator manipulator)
		{
			if ((object)@base == null || manipulator == null || hook == null || ((Delegate)(object)manipulator).Target == null)
			{
				ManualLogSource? log = UDAPlugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"Skipping a null/empty patch");
				}
				return true;
			}
			UDAPatchStorage.AddPatchInformation(@base, ((Delegate)(object)manipulator).Target.GetType().Assembly);
			return true;
		}
	}
	internal static class UDAPatchStorage
	{
		private static readonly Dictionary<MethodBase, List<Assembly>> Patches = new Dictionary<MethodBase, List<Assembly>>();

		private static readonly Assembly HarmonyAssembly = typeof(Harmony).Assembly;

		internal static bool AddPatchInformation(MethodBase method, Assembly assembly)
		{
			if ((object)assembly == null || assembly == HarmonyAssembly)
			{
				return false;
			}
			if (!Patches.TryGetValue(method, out List<Assembly> value))
			{
				value = (Patches[method] = new List<Assembly>());
			}
			if (value.Contains(assembly))
			{
				return false;
			}
			value.Add(assembly);
			ManualLogSource? log = UDAPlugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("blame " + assembly.GetName().Name + " for " + GeneralExtensions.FullDescription(method)));
			}
			return true;
		}

		internal static List<Assembly> GetPatchInformation(MethodBase method)
		{
			if (!Patches.TryGetValue(method, out List<Assembly> value))
			{
				return new List<Assembly>();
			}
			return value;
		}
	}
	public static class UDAPluginMarshal
	{
		internal static readonly Dictionary<Assembly, PluginInfo> InfoCache = new Dictionary<Assembly, PluginInfo>();

		public static void Run()
		{
			Stopwatch stopwatch = new Stopwatch();
			stopwatch.Start();
			Dictionary<string, PluginInfo>.KeyCollection keys = Chainloader.PluginInfos.Keys;
			foreach (string item in keys)
			{
				Assembly assembly = ((object)Chainloader.PluginInfos[item].Instance).GetType().Assembly;
				PluginInfo val = Chainloader.PluginInfos[item];
				if (val != null)
				{
					AddToInfoCache(assembly, val);
				}
			}
			stopwatch.Stop();
			ManualLogSource? log = UDAPlugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"BepinEx Plugins Marshaled in {stopwatch.ElapsedMilliseconds}ms");
			}
		}

		internal static bool AddToInfoCache(Assembly assembly, PluginInfo info)
		{
			if (InfoCache.ContainsKey(assembly))
			{
				return false;
			}
			InfoCache.Add(assembly, info);
			return true;
		}
	}
}
namespace UnityDebuggerAssistant.Processing
{
	public static class UDAExceptionHandler
	{
		public static void Handle(Exception ex)
		{
			int num = 0;
			MethodBase targetSite = ex.TargetSite;
			StackTrace stackTrace = new StackTrace(ex, fNeedFileInfo: true);
			Assembly assembly2 = targetSite?.DeclaringType.Assembly;
			bool flag = false;
			if ((object)assembly2 == null)
			{
				flag = true;
				_ = stackTrace.FrameCount;
				StackFrame[] frames = stackTrace.GetFrames();
				foreach (StackFrame stackFrame in frames)
				{
					if (stackFrame.HasMethod())
					{
						assembly2 = stackFrame.GetMethod().DeclaringType.Assembly;
						break;
					}
				}
				if ((object)assembly2 == null)
				{
					return;
				}
			}
			if (!UDAWhitelist.IsOnExceptionWhitelist(assembly2) || UDABlacklist.IsOnExceptionBlacklist(assembly2))
			{
				return;
			}
			StringBuilder stringBuilder = new StringBuilder("\n\n--- Exception Handler ---\n\n");
			stringBuilder.Append("Exception Caught: ");
			stringBuilder.AppendLine(ex.GetType().ToString());
			stringBuilder.Append("Assembly: ");
			stringBuilder.Append(assembly2.GetName().Name);
			if (flag)
			{
				stringBuilder.Append(" (Guess)");
			}
			stringBuilder.AppendLine();
			if (UDAPluginMarshal.InfoCache.TryGetValue(assembly2, out PluginInfo value))
			{
				WritePluginInfo(stringBuilder, value, 1);
			}
			stringBuilder.Append("Message: ");
			stringBuilder.AppendLine(ex.Message);
			if (ex.Source != null)
			{
				stringBuilder.Append("Source: ");
				stringBuilder.AppendLine(ex.Source);
			}
			stringBuilder.AppendLine();
			stringBuilder.Append(Tabs(1));
			stringBuilder.AppendLine("--- Begin Frames ---");
			stringBuilder.AppendLine();
			StackFrame[] frames2 = stackTrace.GetFrames();
			foreach (StackFrame frame2 in frames2)
			{
				StringBuilder stringBuilder2 = new StringBuilder();
				if (DumpFrame(stringBuilder2, frame2, 2))
				{
					stringBuilder.Append(Tabs(1));
					stringBuilder.Append("--FRAME ");
					num++;
					stringBuilder.Append(num);
					stringBuilder.AppendLine(":");
					stringBuilder.Append(stringBuilder2.ToString());
				}
			}
			stringBuilder.Append(Tabs(1));
			stringBuilder.AppendLine("--- End Frames ---");
			stringBuilder.AppendLine("\n--- End Exception Handler ---");
			if (num > 0)
			{
				ManualLogSource? log = UDAPlugin.Log;
				if (log != null)
				{
					log.LogError((object)stringBuilder);
				}
			}
			static void DoHarmonyBlames(StringBuilder sb, ReadOnlyCollection<Patch>? Patches, int Indent)
			{
				if (Patches == null)
				{
					return;
				}
				foreach (Patch Patch in Patches)
				{
					DumpPatch(sb, Patch.PatchMethod.DeclaringType.Assembly, Indent);
				}
			}
			static bool DumpFrame(StringBuilder sb, StackFrame frame, int Indent)
			{
				MethodBase method = frame.GetMethod();
				int iLOffset = frame.GetILOffset();
				bool result = false;
				if ((object)method != null)
				{
					Assembly assembly3 = method.DeclaringType.Assembly;
					if (UDAWhitelist.IsOnFrameWhitelist(assembly3) && !UDABlacklist.IsOnFrameBlacklist(assembly3))
					{
						result = true;
						sb.Append(Tabs(Indent));
						sb.Append("In Assembly: ");
						sb.AppendLine(assembly3.GetName().Name);
						if (frame.GetFileName() != null)
						{
							sb.Append(Tabs(Indent));
							sb.Append("Source: ");
							sb.Append(frame.GetFileName());
							sb.Append(':');
							sb.Append(frame.GetFileLineNumber());
							sb.Append(',');
							sb.AppendLine(frame.GetFileColumnNumber().ToString());
						}
						sb.Append(Tabs(Indent));
						sb.Append("Target Method: ");
						sb.Append(method.DeclaringType.Name);
						sb.Append('.');
						sb.AppendLine(method.Name);
						sb.AppendLine();
						List<Assembly> patchInformation = UDAPatchStorage.GetPatchInformation(method);
						Patches patchInfo = Harmony.GetPatchInfo(method);
						if (patchInformation.Count > 0 || patchInfo != null)
						{
							sb.Append(Tabs(Indent));
							sb.AppendLine("Patched By:");
						}
						foreach (Assembly item in patchInformation)
						{
							DumpPatch(sb, item, Indent + 1);
						}
						if (patchInfo != null)
						{
							DoHarmonyBlames(sb, patchInfo.Prefixes, Indent + 1);
							DoHarmonyBlames(sb, patchInfo.Postfixes, Indent + 1);
							DoHarmonyBlames(sb, patchInfo.Finalizers, Indent + 1);
						}
					}
				}
				return result;
			}
			static void DumpPatch(StringBuilder sb, Assembly assembly, int Indent)
			{
				sb.Append(Tabs(Indent));
				sb.AppendLine(assembly.GetName().Name);
				if (UDAPluginMarshal.InfoCache.TryGetValue(assembly, out PluginInfo value2))
				{
					WritePluginInfo(sb, value2, Indent);
				}
			}
			static string GetPluginDirSandboxed(PluginInfo info)
			{
				int num2 = info.Location.IndexOf($"{Path.DirectorySeparatorChar}plugins{Path.DirectorySeparatorChar}");
				if (num2 < 0)
				{
					return "Unknown";
				}
				int length = info.Location.Length - num2;
				return new string(info.Location.ToCharArray(), num2, length);
			}
			static string Tabs(int n)
			{
				return new string(' ', n * 2);
			}
			static void WritePluginInfo(StringBuilder sb, PluginInfo info, int Indent)
			{
				sb.AppendLine();
				sb.Append(Tabs(Indent));
				sb.AppendLine("Plugin Info");
				sb.Append(Tabs(Indent + 1));
				sb.Append("GUID:     ");
				sb.AppendLine(info.Metadata.GUID);
				sb.Append(Tabs(Indent + 1));
				sb.Append("NAME/VER: ");
				sb.Append(info.Metadata.Name);
				sb.Append("@");
				sb.AppendLine(info.Metadata.Version.ToString());
				sb.Append(Tabs(Indent + 1));
				sb.Append("LOCATION: ");
				sb.AppendLine(GetPluginDirSandboxed(info));
				sb.AppendLine();
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void DebugThrow()
		{
			throw new Exception("Debug throw");
		}
	}
	internal static class UDAExceptionProcessor
	{
		internal static readonly ConcurrentStack<Exception> Storage = new ConcurrentStack<Exception>();

		internal static readonly int[] LastInExceptions = new int[10];

		internal static int LastInPosition = 0;

		private static bool OperationUnderway = false;

		internal static void PushException(Exception ex)
		{
			int hashCode = ex.GetHashCode();
			int[] lastInExceptions = LastInExceptions;
			foreach (int num in lastInExceptions)
			{
				if (hashCode == num)
				{
					return;
				}
			}
			LastInExceptions[LastInPosition] = hashCode;
			LastInPosition++;
			LastInPosition %= LastInExceptions.Length;
			Storage.Push(ex);
		}

		internal static void Run(Exception __instance)
		{
			if (OperationUnderway)
			{
				ManualLogSource? log = UDAPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"Exception processor is busy");
				}
				return;
			}
			OperationUnderway = true;
			try
			{
				UDAExceptionHandler.Handle(__instance);
			}
			catch (Exception ex)
			{
				ManualLogSource? log2 = UDAPlugin.Log;
				if (log2 != null)
				{
					log2.LogError((object)"The exception handler failed while running. Please report the next line to Robyn:");
				}
				ManualLogSource? log3 = UDAPlugin.Log;
				if (log3 != null)
				{
					log3.LogError((object)ex);
				}
			}
			finally
			{
				OperationUnderway = false;
			}
		}
	}
}
namespace UnityDebuggerAssistant.Patches
{
	public static class ExceptionStackGetterPatch
	{
		private static bool LockRoot;

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		internal static void ExceptionStackGot(Exception __instance)
		{
			if (!LockRoot)
			{
				LockRoot = true;
				UDAExceptionProcessor.Run(__instance);
				LockRoot = false;
			}
		}
	}
	[HarmonyPatch]
	public static class ExceptionConstructorPatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			return typeof(Exception).GetConstructors(BindingFlags.Instance | BindingFlags.Public);
		}

		private static void Postfix(Exception __instance)
		{
			UDAExceptionProcessor.PushException(__instance);
		}
	}
}
namespace UnityDebuggerAssistant.Filtering
{
	internal static class UDABlacklist
	{
		internal static string[] ExceptionBlackList = Array.Empty<string>();

		internal static string[] FrameBlackList = Array.Empty<string>();

		internal static bool IsOnExceptionBlacklist(Assembly assembly)
		{
			if (!UDAPlugin.UDASettings.EnableBlacklistPerException.Value)
			{
				return false;
			}
			return IsOnList_Internal(assembly.GetName().Name, in ExceptionBlackList);
		}

		internal static bool IsOnFrameBlacklist(Assembly assembly)
		{
			if (!UDAPlugin.UDASettings.EnableBlacklistPerException.Value)
			{
				return false;
			}
			return IsOnList_Internal(assembly.GetName().Name, in FrameBlackList);
		}

		internal static bool IsOnList_Internal(string name, in string[] blacklist)
		{
			string[] array = blacklist;
			foreach (string value in array)
			{
				if (name.StartsWith(value))
				{
					return true;
				}
			}
			return false;
		}

		internal static void UpdateLists_Internal()
		{
			ExceptionBlackList = UDAPlugin.UDASettings.ExceptionBlacklist.Value.Split(new char[1] { ',' });
			FrameBlackList = UDAPlugin.UDASettings.FrameBlacklist.Value.Split(new char[1] { ',' });
			for (int i = 0; i < ExceptionBlackList.Length; i++)
			{
				ExceptionBlackList[i] = ExceptionBlackList[i].Trim();
			}
			for (int j = 0; j < FrameBlackList.Length; j++)
			{
				FrameBlackList[j] = FrameBlackList[j].Trim();
			}
		}
	}
	internal static class UDAWhitelist
	{
		internal static readonly List<Assembly> AssemblyWhiteList = new List<Assembly>(2)
		{
			Helpers.GetAssemblyByName("Assembly-CSharp"),
			Helpers.GetAssemblyByName("MMHOOK_Assembly-CSharp")
		};

		internal static bool IsOnExceptionWhitelist(Assembly assembly)
		{
			return Whitelist(UDAPlugin.UDASettings.EnableWhitelistPerException.Value, assembly);
		}

		internal static bool IsOnFrameWhitelist(Assembly assembly)
		{
			return Whitelist(UDAPlugin.UDASettings.EnableWhitelistPerFrame.Value, assembly);
		}

		private static bool Whitelist(bool Setting, Assembly assembly)
		{
			if (UDAPluginMarshal.InfoCache.ContainsKey(assembly))
			{
				return true;
			}
			if (Setting)
			{
				if (Setting)
				{
					return AssemblyWhiteList.Contains(assembly);
				}
				return false;
			}
			return true;
		}
	}
}
namespace UnityDebuggerAssistant.Components
{
	public class UDAExceptionBroker : MonoBehaviour
	{
		private readonly Exception[] popped = new Exception[3];

		private void Awake()
		{
			ManualLogSource? log = UDAPlugin.Log;
			if (log != null)
			{
				log.LogInfo((object)"UDAExceptionBroker active");
			}
		}

		private void Update()
		{
			ConcurrentStack<Exception> storage = UDAExceptionProcessor.Storage;
			int num = storage.TryPopRange(popped);
			if (num > 0)
			{
				for (int i = 0; i < num; i++)
				{
					UDAExceptionProcessor.Run(popped[i]);
				}
			}
		}
	}
	public class UDAPostChainloadRunner : MonoBehaviour
	{
		private void Start()
		{
			ManualLogSource? log = UDAPlugin.Log;
			if (log != null)
			{
				log.LogInfo((object)"UDAPostChainloadRunner Starting");
			}
			UDAPluginMarshal.Run();
		}
	}
}