using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using AngryLevelLoader;
using AngryLevelLoader.Containers;
using AngryLevelLoader.DataTypes;
using AngryLevelLoader.DataTypes.MapVarHandlers;
using AngryLevelLoader.Extensions;
using AngryLevelLoader.Fields;
using AngryLevelLoader.Managers;
using AngryLevelLoader.Managers.BannedMods;
using AngryLevelLoader.Managers.LegacyPatches;
using AngryLevelLoader.Managers.ServerManager;
using AngryLevelLoader.Notifications;
using AngryLevelLoader.Patches;
using AngryLevelLoader.UserInterface;
using AngryLevelLoader.Utils;
using AngryUiComponents;
using BananaDifficulty;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using BillionDifficulty;
using Configgy;
using FasterPunch;
using HarmonyLib;
using Logic;
using LucasMeshCombine;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using PluginConfig;
using PluginConfig.API;
using PluginConfig.API.Decorators;
using PluginConfig.API.Fields;
using PluginConfig.API.Functionals;
using ProjectProphet;
using RudeLevelScript;
using RudeLevelScripts;
using RudeLevelScripts.Essentials;
using Steamworks;
using Steamworks.Data;
using TMPro;
using The_Timestopper;
using TimeStop;
using ULTRAKILL.Portal;
using Ultracoins;
using Ultrapain;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.AddressableAssets.ResourceLocators;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.Networking;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.ResourceManagement.ResourceProviders;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityExplorer.ObjectExplorer;
using UnityExplorer.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: AssemblyCompany("AngryLevelLoader")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Loads level made with Rude level editor")]
[assembly: AssemblyFileVersion("4.0.1.0")]
[assembly: AssemblyInformationalVersion("4.0.1+a718d8188edea69dce0c0053800abf75b2cda0ce")]
[assembly: AssemblyProduct("AngryLevelLoader")]
[assembly: AssemblyTitle("AngryLevelLoader")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("4.0.1.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;
		}
	}
}
internal class CrossThreadInvoker : ISynchronizeInvoke
{
	private class BackgroundUpdater : MonoBehaviour
	{
		public void Update()
		{
			ProcessQueue();
		}
	}

	private class AsyncResult : IAsyncResult
	{
		public Delegate method;

		public object[] args;

		public ManualResetEvent manualResetEvent;

		public Thread invokingThread;

		public bool IsCompleted { get; set; }

		public WaitHandle AsyncWaitHandle => manualResetEvent;

		public object AsyncState { get; set; }

		public bool CompletedSynchronously { get; set; }

		public void Invoke()
		{
			AsyncState = method.DynamicInvoke(args);
			IsCompleted = true;
			manualResetEvent.Set();
		}
	}

	private static CrossThreadInvoker instance;

	private static Thread mainThread;

	private static readonly Queue<AsyncResult> ToExecute = new Queue<AsyncResult>();

	public static CrossThreadInvoker Instance => instance;

	public bool InvokeRequired => mainThread.ManagedThreadId != Thread.CurrentThread.ManagedThreadId;

	public static void Init()
	{
		if (instance == null)
		{
			mainThread = Thread.CurrentThread;
			instance = new CrossThreadInvoker();
			((Component)Plugin.instance).gameObject.AddComponent<BackgroundUpdater>();
		}
	}

	private static void ProcessQueue()
	{
		if (Thread.CurrentThread != mainThread)
		{
			throw new Exception("must be called from the same thread it was created on (created on thread id: " + mainThread.ManagedThreadId + ", called from thread id: " + Thread.CurrentThread.ManagedThreadId);
		}
		AsyncResult asyncResult = null;
		while (true)
		{
			lock (ToExecute)
			{
				if (ToExecute.Count == 0)
				{
					break;
				}
				asyncResult = ToExecute.Dequeue();
			}
			asyncResult.Invoke();
		}
	}

	public IAsyncResult BeginInvoke(Delegate method, object[] args)
	{
		AsyncResult asyncResult = new AsyncResult
		{
			method = method,
			args = args,
			IsCompleted = false,
			manualResetEvent = new ManualResetEvent(initialState: false),
			invokingThread = Thread.CurrentThread
		};
		if (mainThread.ManagedThreadId != asyncResult.invokingThread.ManagedThreadId)
		{
			lock (ToExecute)
			{
				ToExecute.Enqueue(asyncResult);
			}
		}
		else
		{
			asyncResult.Invoke();
			asyncResult.CompletedSynchronously = true;
		}
		return asyncResult;
	}

	public object EndInvoke(IAsyncResult result)
	{
		if (!result.IsCompleted)
		{
			result.AsyncWaitHandle.WaitOne();
		}
		return result.AsyncState;
	}

	public object Invoke(Delegate method, object[] args)
	{
		if (InvokeRequired)
		{
			IAsyncResult result = BeginInvoke(method, args);
			return EndInvoke(result);
		}
		return method.DynamicInvoke(args);
	}
}
namespace AngryLevelLoader
{
	public static class AngryPaths
	{
		internal enum Repo
		{
			AngryLevelLoader,
			AngryLevels
		}

		public const string SERVER_ROOT_GLOBAL = "https://angry.dnzsoft.com";

		public const string SERVER_ROOT_LOCAL = "http://localhost:3000";

		public static string SERVER_ROOT
		{
			get
			{
				if (!ConfigManager.useLocalServer.value)
				{
					return "https://angry.dnzsoft.com";
				}
				return "http://localhost:3000";
			}
		}

		public static string ConfigFolderPath => Path.Combine(Paths.ConfigPath, "AngryLevelLoader");

		public static string OnlineCacheFolderPath => Path.Combine(ConfigFolderPath, "OnlineCache");

		public static string ThumbnailCachePath => Path.Combine(OnlineCacheFolderPath, "thumbnailCacheHashes.txt");

		public static string LevelCatalogCachePath => Path.Combine(OnlineCacheFolderPath, "V2", "LevelCatalog.json");

		public static string ScriptsPath => Path.Combine(Plugin.workingDir, "Scripts");

		public static string ScriptCatalogCachePath => Path.Combine(OnlineCacheFolderPath, "ScriptCatalog.json");

		public static string ThumbnailCacheFolderPath => Path.Combine(OnlineCacheFolderPath, "ThumbnailCache");

		public static string LastPlayedMapPath => Path.Combine(ConfigFolderPath, "lastPlayedMap.txt");

		public static string LastUpdateMapPath => Path.Combine(ConfigFolderPath, "lastUpdateMap.txt");

		internal static string GetGithubURL(Repo repo, string path)
		{
			string text = "release";
			if (ConfigManager.useDevelopmentBranch.value)
			{
				text = "dev";
			}
			string text2 = "AngryLevels";
			switch (repo)
			{
			case Repo.AngryLevels:
				text2 = "AngryLevels";
				break;
			case Repo.AngryLevelLoader:
				text2 = "AngryLevelLoader";
				break;
			}
			return "https://raw.githubusercontent.com/eternalUnion/" + text2 + "/" + text + "/" + path;
		}

		internal static void TryCreateAllPaths()
		{
			AngryIOUtils.TryCreateDirectory(ConfigFolderPath);
			AngryIOUtils.TryCreateDirectory(OnlineCacheFolderPath);
			AngryIOUtils.TryCreateDirectory(ThumbnailCacheFolderPath);
			AngryIOUtils.TryCreateDirectory(ScriptsPath);
		}
	}
	internal class SpaceField : CustomConfigField
	{
		public SpaceField(ConfigPanel parentPanel, float space)
			: base(parentPanel, 60f, space)
		{
		}
	}
	[BepInPlugin("com.eternalUnion.angryLevelLoader", "AngryLevelLoader", "4.0.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <<InitializeFileWatcher>g__LoadLevelInstantly|26_5>d : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private <>c__DisplayClass26_0 <>8__1;

			private BundleContainer <bundle>5__2;

			private LevelContainer <level>5__3;

			private Transform <optionsMenu>5__4;

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

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

			[DebuggerHidden]
			public <<InitializeFileWatcher>g__LoadLevelInstantly|26_5>d(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<bundle>5__2 = null;
				<level>5__3 = null;
				<optionsMenu>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Expected O, but got Unknown
				//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_0322: Unknown result type (might be due to invalid IL or missing references)
				//IL_032c: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass26_0();
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!TryGetAngryBundleByGuid(InternalConfigManager.instantLoadLevelGuid.value, out <bundle>5__2))
					{
						logger.LogInfo((object)"Bundle not found");
						return false;
					}
					<>8__1.handler = <bundle>5__2.ReloadBundle(forceReload: false, lazyLoad: false);
					<>2__current = (object)new WaitUntil((Func<bool>)(() => <>8__1.handler.IsCompleted));
					<>1__state = 2;
					return true;
				case 2:
				{
					<>1__state = -1;
					if (!<bundle>5__2.TryGetLevelContainer(InternalConfigManager.instantLoadLevelId.value, out <level>5__3))
					{
						logger.LogInfo((object)"Level not found");
						return false;
					}
					Scene activeScene = SceneManager.GetActiveScene();
					GameObject val = (from obj in ((Scene)(ref activeScene)).GetRootGameObjects()
						where ((Object)obj).name == "Canvas"
						select obj).FirstOrDefault();
					if ((Object)(object)val == (Object)null)
					{
						logger.LogWarning((object)"Angry tried to create main menu buttons, but root canvas was not found!");
						return false;
					}
					<optionsMenu>5__4 = val.transform.Find("OptionsMenu");
					if ((Object)(object)<optionsMenu>5__4 == (Object)null)
					{
						logger.LogError((object)"Angry tried to find the options menu but failed!");
						return false;
					}
					((Component)<optionsMenu>5__4).gameObject.SetActive(true);
					<>2__current = null;
					<>1__state = 3;
					return true;
				}
				case 3:
				{
					<>1__state = -1;
					Transform val2 = ((Component)<optionsMenu>5__4).transform.Find("Navigation Rail/PluginConfiguratorButton(Clone)");
					if ((Object)(object)val2 == (Object)null)
					{
						val2 = ((Component)<optionsMenu>5__4).transform.Find("Navigation Rail/PluginConfiguratorButton");
					}
					if ((Object)(object)val2 == (Object)null)
					{
						logger.LogError((object)"Angry tried to find the plugin configurator button but failed!");
						return false;
					}
					Transform val3 = <optionsMenu>5__4.Find("Navigation Rail");
					ButtonHighlightParent val4 = default(ButtonHighlightParent);
					if ((Object)(object)val3 != (Object)null && ((Component)val3).gameObject.TryGetComponent<ButtonHighlightParent>(ref val4) && (val4.buttons == null || val4.buttons.Length == 0))
					{
						val4.Start();
						val4.targetOnStart = null;
					}
					((UnityEvent)((Component)val2).gameObject.GetComponent<Button>().onClick).Invoke();
					<>2__current = null;
					<>1__state = 4;
					return true;
				}
				case 4:
					<>1__state = -1;
					if ((Object)(object)PluginConfiguratorController.activePanel != (Object)null)
					{
						PluginConfiguratorController.activePanel.SetActive(false);
					}
					<>2__current = null;
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					((Component)PluginConfiguratorController.mainPanel).gameObject.SetActive(false);
					<>2__current = null;
					<>1__state = 6;
					return true;
				case 6:
					<>1__state = -1;
					ConfigManager.config.rootPanel.OpenPanelInternally(false);
					<>2__current = null;
					<>1__state = 7;
					return true;
				case 7:
					<>1__state = -1;
					if (!<bundle>5__2.Loaded)
					{
						<>2__current = (object)new WaitUntil((Func<bool>)new <>c__DisplayClass26_1
						{
							reloadTask = <bundle>5__2.ReloadBundle(forceReload: false, lazyLoad: false)
						}.<InitializeFileWatcher>b__9);
						<>1__state = 8;
						return true;
					}
					goto IL_033c;
				case 8:
					<>1__state = -1;
					goto IL_033c;
				case 9:
					{
						<>1__state = -1;
						AngrySceneManager.LevelButtonPressed(<level>5__3);
						return false;
					}
					IL_033c:
					<>2__current = null;
					<>1__state = 9;
					return true;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <>c__DisplayClass26_0
		{
			public Task<bool> handler;

			internal bool <InitializeFileWatcher>b__7()
			{
				return handler.IsCompleted;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass26_1
		{
			public Task reloadTask;

			internal bool <InitializeFileWatcher>b__9()
			{
				return reloadTask.IsCompleted;
			}
		}

		public const string PLUGIN_NAME = "AngryLevelLoader";

		public const string PLUGIN_GUID = "com.eternalUnion.angryLevelLoader";

		public const string PLUGIN_VERSION = "4.0.1";

		public const string PLUGIN_CONFIG_MIN_VERSION = "1.8.0";

		internal static string workingDir;

		public static string tempFolderPath;

		internal static string dataPath;

		internal static string levelsPath;

		internal static string mapVarsFolderPath;

		public static string angryCatalogPath;

		internal static Plugin instance;

		internal static Harmony harmony;

		internal static ManualLogSource logger;

		private static readonly Dictionary<string, BundleContainer> angryBundles = new Dictionary<string, BundleContainer>();

		private static int numOfOldBundles = 0;

		internal static FileSystemWatcher levelsWatcher;

		internal static FileSystemWatcher scriptsWatcher;

		private float lastPress;

		public static IEnumerable<BundleContainer> GetAllBundleContainers()
		{
			return angryBundles.Values;
		}

		public static bool TryGetAngryBundleByGuid(string guid, out BundleContainer bundleContainer)
		{
			bundleContainer = angryBundles.Values.Where((BundleContainer bundle) => bundle.bundleGuid == guid).FirstOrDefault();
			return bundleContainer != null;
		}

		public static bool TryGetAngryLevel(string id, out LevelContainer level)
		{
			level = null;
			foreach (BundleContainer allBundleContainer in GetAllBundleContainers())
			{
				foreach (LevelContainer allLevelContainer in allBundleContainer.GetAllLevelContainers())
				{
					if (allLevelContainer.levelId == id)
					{
						level = allLevelContainer;
						return true;
					}
				}
			}
			return false;
		}

		private static void ProcessPath(string path, FolderButtonField folder)
		{
			if (AngryFileUtils.TryGetAngryBundleData(path, out var data, out var error))
			{
				if (angryBundles.TryGetValue(data.bundleGuid, out var value))
				{
					if (value.HasValidAngryFile && !AngryIOUtils.PathEquals(path, value.pathToAngryBundle))
					{
						logger.LogError((object)("Duplicate angry files. Original: " + Path.GetFileName(value.pathToAngryBundle) + ". Duplicate: " + Path.GetFileName(path)));
						if (!string.IsNullOrEmpty(ConfigManager.errorText.text))
						{
							ConfigHeader errorText = ConfigManager.errorText;
							errorText.text += "\n";
						}
						ConfigHeader errorText2 = ConfigManager.errorText;
						errorText2.text = errorText2.text + "<color=red>Error loading " + Path.GetFileName(path) + "</color> Duplicate file, original is " + Path.GetFileName(value.pathToAngryBundle);
						return;
					}
					folder.bundles.Add(value);
					if (data.bundleVersion < 6)
					{
						numOfOldBundles++;
					}
					value.pathToAngryBundle = path;
					if (value.LazyLoaded && value.BuildHash != data.buildHash)
					{
						if (value.Loaded && AngrySceneManager.isInCustomLevel && AngrySceneManager.currentBundleContainer == value)
						{
							value.FileChanged();
						}
						else
						{
							value.ReloadBundle(forceReload: false, lazyLoad: true);
						}
					}
					return;
				}
				value = new BundleContainer(path, data);
				angryBundles[data.bundleGuid] = value;
				folder.bundles.Add(value);
				try
				{
					value.ReloadBundle(forceReload: false, lazyLoad: true);
				}
				catch (Exception arg)
				{
					logger.LogWarning((object)$"Exception thrown while loading level bundle: {arg}");
					if (!string.IsNullOrEmpty(ConfigManager.errorText.text))
					{
						ConfigHeader errorText3 = ConfigManager.errorText;
						errorText3.text += "\n";
					}
					ConfigHeader errorText4 = ConfigManager.errorText;
					errorText4.text = errorText4.text + "<color=red>Error loading " + Path.GetFileNameWithoutExtension(path) + "</color>. Check the logs for more information";
				}
				if (data.bundleVersion < 6)
				{
					numOfOldBundles++;
				}
			}
			else if (AngryFileUtils.IsV1LegacyFile(path))
			{
				if (!string.IsNullOrEmpty(ConfigManager.errorText.text))
				{
					ConfigHeader errorText5 = ConfigManager.errorText;
					errorText5.text += "\n";
				}
				ConfigHeader errorText6 = ConfigManager.errorText;
				errorText6.text = errorText6.text + "<color=yellow>" + Path.GetFileName(path) + " is a V1 legacy file. Support for legacy files were dropped after 2.5.0</color>";
			}
			else
			{
				logger.LogError((object)$"Could not load the bundle at {path}\n{error}");
				if (!string.IsNullOrEmpty(ConfigManager.errorText.text))
				{
					ConfigHeader errorText7 = ConfigManager.errorText;
					errorText7.text += "\n";
				}
				ConfigHeader errorText8 = ConfigManager.errorText;
				errorText8.text = errorText8.text + "<color=yellow>Failed to load " + Path.GetFileNameWithoutExtension(path) + "</color>";
			}
		}

		private static void ScanForLevelsRecursive(string folderPath, FolderButtonField folder)
		{
			string[] files = Directory.GetFiles(folderPath);
			foreach (string text in files)
			{
				if (text.EndsWith(".angry"))
				{
					ProcessPath(Path.Combine(folderPath, text), folder);
				}
			}
			files = Directory.GetDirectories(folderPath);
			foreach (string obj in files)
			{
				string fileName = Path.GetFileName(obj);
				ScanForLevelsRecursive(obj, folder.GetOrCreateFolder(fileName));
			}
		}

		public static void ScanForLevels()
		{
			numOfOldBundles = 0;
			ConfigManager.errorText.text = "";
			ConfigManager.searchBar.value = "";
			if (!Directory.Exists(levelsPath))
			{
				logger.LogWarning((object)("Could not find the Levels folder at " + levelsPath));
				ConfigManager.errorText.text = "<color=red>Error: </color>Levels folder not found";
				return;
			}
			AngryBundleList.ResetFolders();
			ScanForLevelsRecursive(levelsPath, AngryBundleList.rootFolder);
			AngryBundleList.SortBundles();
			AngryBundleList.UpdateFolderIcons();
			if (numOfOldBundles != 0)
			{
				if (!string.IsNullOrEmpty(ConfigManager.errorText.text))
				{
					ConfigHeader errorText = ConfigManager.errorText;
					errorText.text += "\n";
				}
				ConfigHeader errorText2 = ConfigManager.errorText;
				errorText2.text += $"<color=yellow>Hidden {numOfOldBundles} old angry file(s). These files can be deleted at the bottom of the settings page.</color>";
			}
			AngryBundleList.DisplayFolder(AngryBundleList.rootFolder);
			OnlineLevelsList.UpdateUI();
		}

		private static bool LoadEssentialScripts()
		{
			bool result = true;
			switch (ScriptManager.AttemptLoadScriptWithCertificate("AngryLoaderAPI.dll"))
			{
			case ScriptManager.LoadScriptResult.NotFound:
				logger.LogError((object)"Required script AngryLoaderAPI.dll not found");
				result = false;
				break;
			case ScriptManager.LoadScriptResult.NoCertificate:
				logger.LogError((object)"Required script AngryLoaderAPI.dll is not signed");
				result = false;
				break;
			case ScriptManager.LoadScriptResult.InvalidCertificate:
				logger.LogError((object)"Required script AngryLoaderAPI.dll signature is invalid");
				result = false;
				break;
			default:
				logger.LogError((object)"Required script AngryLoaderAPI.dll could not be loaded");
				result = false;
				break;
			case ScriptManager.LoadScriptResult.Loaded:
				break;
			}
			switch (ScriptManager.AttemptLoadScriptWithCertificate("RudeLevelScripts.dll"))
			{
			case ScriptManager.LoadScriptResult.NotFound:
				logger.LogError((object)"Required script RudeLevelScripts.dll not found");
				result = false;
				break;
			case ScriptManager.LoadScriptResult.NoCertificate:
				logger.LogError((object)"Required script RudeLevelScripts.dll is not signed");
				result = false;
				break;
			case ScriptManager.LoadScriptResult.InvalidCertificate:
				logger.LogError((object)"Required script RudeLevelScripts.dll signature is invalid");
				result = false;
				break;
			default:
				logger.LogError((object)"Required script RudeLevelScripts.dll could not be loaded");
				result = false;
				break;
			case ScriptManager.LoadScriptResult.Loaded:
				break;
			}
			return result;
		}

		private void ForceLoadAddressableDependencies()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_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_0064: 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_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			Addressables.LoadAssetAsync<GameObject>((object)"Assets/Prefabs/Attacks and Projectiles/Projectile Decorative.prefab").WaitForCompletion();
			Addressables.LoadAssetAsync<GameObject>((object)"FirstRoom").WaitForCompletion();
			Addressables.LoadAssetAsync<GameObject>((object)"FirstRoom Secret").WaitForCompletion();
			Addressables.LoadAssetAsync<GameObject>((object)"FirstRoom Prime").WaitForCompletion();
			Addressables.LoadAssetAsync<GameObject>((object)"Assets/Prefabs/Levels/Special Rooms/FirstRoom Encore.prefab").WaitForCompletion();
			Addressables.LoadAssetAsync<Font>((object)"Assets/Fonts/VCR_OSD_MONO_1.001.ttf").WaitForCompletion();
			Addressables.LoadAssetAsync<Sprite>((object)"Assets/Textures/UI/meter.png").WaitForCompletion();
			Addressables.LoadAssetAsync<Sprite>((object)"Assets/Textures/UI/arrow.png").WaitForCompletion();
			Addressables.LoadAssetAsync<Material>((object)"Assets/Materials/Environment/Metal/Metal Decoration 20.mat").WaitForCompletion();
		}

		private static void RefreshCatalogOnMainMenu(Scene newScene, LoadSceneMode mode)
		{
			if (!(SceneHelper.CurrentScene != "Main Menu"))
			{
				if (ConfigManager.refreshCatalogOnBoot.value)
				{
					OnlineLevelsList.RefreshAsync();
				}
				SceneManager.sceneLoaded -= RefreshCatalogOnMainMenu;
			}
		}

		private static void InitializeFileWatcher()
		{
			if (levelsWatcher != null)
			{
				return;
			}
			levelsWatcher = new FileSystemWatcher(levelsPath);
			levelsWatcher.SynchronizingObject = CrossThreadInvoker.Instance;
			levelsWatcher.Changed += delegate(object sender, FileSystemEventArgs e)
			{
				string fullPath4 = e.FullPath;
				foreach (BundleContainer value2 in angryBundles.Values)
				{
					if (AngryIOUtils.PathEquals(fullPath4, value2.pathToAngryBundle))
					{
						logger.LogWarning((object)("Bundle " + fullPath4 + " was updated, container notified"));
						value2.FileChanged();
						break;
					}
				}
			};
			levelsWatcher.Renamed += delegate(object sender, RenamedEventArgs e)
			{
				string oldFullPath = e.OldFullPath;
				foreach (BundleContainer value3 in angryBundles.Values)
				{
					if (AngryIOUtils.PathEquals(oldFullPath, value3.pathToAngryBundle))
					{
						logger.LogWarning((object)("Bundle " + oldFullPath + " was renamed, path updated"));
						value3.pathToAngryBundle = e.FullPath;
						break;
					}
				}
			};
			levelsWatcher.Deleted += delegate(object sender, FileSystemEventArgs e)
			{
				string fullPath3 = e.FullPath;
				foreach (BundleContainer value4 in angryBundles.Values)
				{
					if (AngryIOUtils.PathEquals(fullPath3, value4.pathToAngryBundle))
					{
						logger.LogWarning((object)("Bundle " + fullPath3 + " was deleted, unlinked"));
						value4.pathToAngryBundle = "";
						break;
					}
				}
			};
			levelsWatcher.Created += delegate(object sender, FileSystemEventArgs e)
			{
				string fullPath2 = e.FullPath;
				if (AngryFileUtils.TryGetAngryBundleData(fullPath2, out var data, out var _) && angryBundles.TryGetValue(data.bundleGuid, out var value) && value.bundleGuid == data.bundleGuid && !value.HasValidAngryFile)
				{
					logger.LogWarning((object)("Bundle " + fullPath2 + " was just added, and a container with the same guid had no file linked. Linked, container notified"));
					value.pathToAngryBundle = fullPath2;
					value.FileChanged();
				}
			};
			levelsWatcher.Filter = "*";
			levelsWatcher.IncludeSubdirectories = true;
			levelsWatcher.EnableRaisingEvents = true;
			scriptsWatcher = new FileSystemWatcher(AngryPaths.ScriptsPath);
			scriptsWatcher.SynchronizingObject = CrossThreadInvoker.Instance;
			scriptsWatcher.Changed += delegate(object sender, FileSystemEventArgs e)
			{
				string fullPath = e.FullPath;
				if (fullPath.EndsWith(".dll") && ScriptManager.ScriptChanged(Path.GetFileName(fullPath)))
				{
					logger.LogMessage((object)("Detected script change " + Path.GetFileName(fullPath)));
					AngryUI.UpdatedScript = Path.GetFileName(fullPath);
				}
			};
			scriptsWatcher.Filter = "*";
			scriptsWatcher.IncludeSubdirectories = false;
			scriptsWatcher.EnableRaisingEvents = true;
			SceneManager.sceneLoaded += CheckForInstantLoad;
			static void CheckForInstantLoad(Scene scene, LoadSceneMode mode)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				if ((int)mode != 1 && !AngrySceneManager.isInCustomLevel && !(SceneHelper.CurrentScene != "Main Menu"))
				{
					if (!InternalConfigManager.instantLoadLevel.value)
					{
						SceneManager.sceneLoaded -= CheckForInstantLoad;
					}
					else
					{
						InternalConfigManager.instantLoadLevel.value = false;
						logger.LogInfo((object)"Starting custom level instantly");
						((MonoBehaviour)instance).StartCoroutine(LoadLevelInstantly());
					}
				}
			}
			[IteratorStateMachine(typeof(<<InitializeFileWatcher>g__LoadLevelInstantly|26_5>d))]
			static IEnumerator LoadLevelInstantly()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <<InitializeFileWatcher>g__LoadLevelInstantly|26_5>d(0);
			}
		}

		private void DisplayPluginConfigVersionError()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			PluginConfigurator obj = PluginConfigurator.Create("Angry Level Loader", "com.eternalUnion.angryLevelLoader");
			obj.SetIconWithURL("file://" + Path.Combine(workingDir, "plugin-icon.png"));
			new ConfigHeader(obj.rootPanel, "<color=red>Plugin config version too low, 1.8.0 or above needed</color>", 24);
		}

		private void Start()
		{
			instance = this;
			logger = ((BaseUnityPlugin)this).Logger;
			workingDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			if (Chainloader.PluginInfos.TryGetValue("com.eternalUnion.pluginConfigurator", out var value))
			{
				if (!(value.Metadata.Version < new Version("1.8.0")))
				{
					try
					{
						PostAwake();
						return;
					}
					catch (Exception ex)
					{
						logger.LogError((object)ex);
						ConfigManager.InitializeErrorConfig("Encountered an unknown error, cannot recover!", ex);
						((Behaviour)this).enabled = false;
						return;
					}
				}
				logger.LogError((object)"Angry level loader needs Plugin Configurator minimum version 1.8.0 to work properly. Disabled.");
				DisplayPluginConfigVersionError();
				((Behaviour)this).enabled = false;
			}
			else
			{
				logger.LogError((object)"Angry level loader needs Plugin Configurator minimum version 1.8.0 to work properly. Disabled.");
				((Behaviour)this).enabled = false;
			}
		}

		private void PostAwake()
		{
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//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_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Expected O, but got Unknown
			InternalConfigManager.InitializeInternalConfig();
			if (!InternalConfigManager.askedPermissionForLeaderboards.value)
			{
				NotificationPanel.Open((Notification)(object)new LeaderboardPermissionNotification());
			}
			dataPath = InternalConfigManager.configDataPath.value;
			try
			{
				AngryIOUtils.TryCreateDirectory(dataPath);
			}
			catch (IOException ex)
			{
				logger.LogError((object)("Failed to create data path at '" + dataPath + "'! Overwriting with the default value '" + InternalConfigManager.configDataPath.defaultValue + "'"));
				logger.LogError((object)ex);
				InternalConfigManager.configDataPath.value = InternalConfigManager.configDataPath.defaultValue;
				dataPath = InternalConfigManager.configDataPath.defaultValue;
				try
				{
					AngryIOUtils.TryCreateDirectory(dataPath);
				}
				catch (IOException ex2)
				{
					logger.LogError((object)("Failed to create data path at '" + dataPath + "'! Cannot recover, disabling plugin."));
					ConfigManager.InitializeErrorConfig("Error! Failed to create plugin's data folder at '" + dataPath + "'", ex2);
					((Behaviour)this).enabled = false;
					return;
				}
			}
			levelsPath = Path.Combine(dataPath, "Levels");
			AngryIOUtils.TryCreateDirectory(levelsPath);
			tempFolderPath = Path.Combine(dataPath, "LevelsUnpacked");
			AngryIOUtils.TryCreateDirectory(tempFolderPath);
			mapVarsFolderPath = Path.Combine(dataPath, "MapVars");
			AngryIOUtils.TryCreateDirectory(mapVarsFolderPath);
			AngryPaths.TryCreateAllPaths();
			CrossThreadInvoker.Init();
			InitializeFileWatcher();
			Addressables.InitializeAsync().WaitForCompletion();
			ForceLoadAddressableDependencies();
			angryCatalogPath = Path.Combine(workingDir, "Assets");
			Addressables.LoadContentCatalogAsync(Path.Combine(angryCatalogPath, "catalog.json"), true, (string)null).WaitForCompletion();
			AssetManager.Init();
			LegacyPatchManager.Init();
			if (!LoadEssentialScripts())
			{
				logger.LogError((object)"Disabling AngryLevelLoader because one or more of its dependencies have failed to load");
				((Behaviour)this).enabled = false;
				return;
			}
			LastPlayedMapManager.LoadLastPlayedMap();
			LastPlayedMapManager.LoadLastUpdateMap();
			harmony = new Harmony("com.eternalUnion.angryLevelLoader");
			harmony.PatchAll();
			AngrySceneManager.Init();
			SceneManager.sceneLoaded += RefreshCatalogOnMainMenu;
			ConfigManager.InitializeConfig();
			BannedModsManager.Init();
			MeshCombineManagerPatches.Initialize();
			PluginUpdateHandler.Check();
			ScanForLevels();
			AngryUser.Init();
			AngryUser.GetPermissionsTask().ContinueWith(delegate(Task<AngryUser.GetPermissionsResult> res)
			{
				if (!res.IsCompletedSuccessfully || !res.Result.completedSuccessfully)
				{
					logger.LogError((object)"Could not obtain user permissions");
				}
				else
				{
					AngryUser.GetPermissionsResult result = res.Result;
					if (result.status != 0)
					{
						logger.LogError((object)("Could not obtain user permissions: " + result.message));
					}
					else
					{
						AngryUser.hasLeaderboardPermissions = result.response.hasLeaderboardModificationPermission;
					}
				}
			}, TaskScheduler.FromCurrentSynchronizationContext());
			AngryCustomLevelButton.Init();
			AngryUI.Init();
			AngryBundleList.Init();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin com.eternalUnion.angryLevelLoader is loaded!");
		}

		private void OnGUI()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Invalid comparison between Unknown and I4
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: 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_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			if (((int)ConfigManager.reloadFileKeybind.value == 0 && (int)ConfigManager.reloadScriptKeybind.value == 0) || !AngrySceneManager.isInCustomLevel)
			{
				return;
			}
			Event current = Event.current;
			KeyCode val = (KeyCode)0;
			if ((int)current.keyCode == 27)
			{
				return;
			}
			if (current.isKey || current.isMouse || current.button > 2 || current.shift)
			{
				if (current.isKey)
				{
					val = current.keyCode;
				}
				else if (Input.GetKey((KeyCode)304))
				{
					val = (KeyCode)304;
				}
				else if (Input.GetKey((KeyCode)303))
				{
					val = (KeyCode)303;
				}
				else if (current.button <= 6)
				{
					val = (KeyCode)(323 + current.button);
				}
			}
			else if (Input.GetKey((KeyCode)326) || Input.GetKey((KeyCode)327) || Input.GetKey((KeyCode)328) || Input.GetKey((KeyCode)329))
			{
				val = (KeyCode)326;
				if (Input.GetKey((KeyCode)327))
				{
					val = (KeyCode)327;
				}
				else if (Input.GetKey((KeyCode)328))
				{
					val = (KeyCode)328;
				}
				else if (Input.GetKey((KeyCode)329))
				{
					val = (KeyCode)329;
				}
			}
			else if (Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303))
			{
				val = (KeyCode)304;
				if (Input.GetKey((KeyCode)303))
				{
					val = (KeyCode)303;
				}
			}
			if ((int)val == 0)
			{
				return;
			}
			if (val == ConfigManager.reloadFileKeybind.value)
			{
				if (Time.time - lastPress < 3f)
				{
					return;
				}
				lastPress = Time.time;
				if (NotificationPanel.CurrentNotificationCount() == 0 && AngrySceneManager.currentBundleContainer != null)
				{
					AngrySceneManager.currentBundleContainer.ReloadBundle(forceReload: false, lazyLoad: false);
				}
			}
			if (val == ConfigManager.reloadScriptKeybind.value)
			{
				AngryUI.ReloadScript();
			}
		}
	}
	public static class RudeLevelInterface
	{
		public static char INCOMPLETE_LEVEL_CHAR = '-';

		public static char GetLevelRank(string levelId)
		{
			if (Plugin.TryGetAngryLevel(levelId, out var level))
			{
				return level.FinalRank;
			}
			return INCOMPLETE_LEVEL_CHAR;
		}

		public static bool GetLevelChallenge(string levelId)
		{
			if (Plugin.TryGetAngryLevel(levelId, out var level))
			{
				return level.ChallengeDone;
			}
			return false;
		}

		public static bool GetLevelSecret(string levelId, int secretIndex)
		{
			if (secretIndex < 0)
			{
				return false;
			}
			if (Plugin.TryGetAngryLevel(levelId, out var level))
			{
				return level.SecretDiscovered(secretIndex);
			}
			return false;
		}

		public static string GetCurrentLevelId()
		{
			if (!AngrySceneManager.isInCustomLevel)
			{
				return "";
			}
			return AngrySceneManager.currentLevelData.uniqueIdentifier;
		}
	}
	public static class RudeBundleInterface
	{
		public static bool BundleExists(string bundleGuid)
		{
			return (from bundle in Plugin.GetAllBundleContainers()
				where bundle.bundleGuid == bundleGuid
				select bundle).FirstOrDefault() != null;
		}

		public static string GetBundleBuildHash(string bundleGuid)
		{
			BundleContainer bundleContainer = (from bundle in Plugin.GetAllBundleContainers()
				where bundle.bundleGuid == bundleGuid
				select bundle).FirstOrDefault();
			if (bundleContainer != null)
			{
				return bundleContainer.BuildHash;
			}
			return "";
		}
	}
	public static class RudeGamemodeInterface
	{
		public static AngryGamemodeManager.Gamemode GetCurrentGamemode()
		{
			return AngryGamemodeManager.SelectedGamemode;
		}
	}
	internal static class PluginUpdateHandler
	{
		public static async Task CheckPluginUpdate(bool userRequested = true)
		{
			UnityWebRequest infoReq = new UnityWebRequest(AngryPaths.GetGithubURL(AngryPaths.Repo.AngryLevelLoader, "AngryLevelLoader/PluginInfo.json"));
			infoReq.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
			await (AsyncOperation)(object)infoReq.SendWebRequest();
			if ((int)infoReq.result != 1)
			{
				Plugin.logger.LogError((object)"Could not download plugin data");
				infoReq.Dispose();
				ConfigManager.openButtons.SetButtonInteractable(1, true);
				return;
			}
			string text = infoReq.downloadHandler.text;
			int num = text.IndexOf('{');
			if (num > 0)
			{
				text = text.Substring(num);
			}
			PluginInfoJson pluginInfoJson = JsonConvert.DeserializeObject<PluginInfoJson>(text);
			ConfigManager.openButtons.SetButtonInteractable(1, true);
			infoReq.Dispose();
			if (!userRequested)
			{
				bool num2 = InternalConfigManager.lastVersion.value != "4.0.1";
				bool flag = new Version("4.0.1") < new Version(pluginInfoJson.latestVersion) && !InternalConfigManager.ignoreUpdates.value;
				bool flag2 = pluginInfoJson.latestVersion != InternalConfigManager.updateLastVersion.value;
				if (!(num2 || flag || flag2))
				{
					return;
				}
			}
			NotificationPanel.Open((Notification)(object)new PluginUpdateNotification(pluginInfoJson));
		}

		public static void Check()
		{
			string path = Path.Combine(Plugin.workingDir, "Levels");
			if (Directory.Exists(path) && !Path.GetFullPath(InternalConfigManager.configDataPath.value).StartsWith(Path.GetFullPath(Plugin.workingDir)))
			{
				Plugin.logger.LogWarning((object)"Version 2.3.0 migration: Moving levels from working dir to data folder");
				string[] files = Directory.GetFiles(path);
				foreach (string text in files)
				{
					string text2 = Path.Combine(Plugin.levelsPath, Path.GetFileName(text));
					if (File.Exists(text2))
					{
						File.Delete(text);
						continue;
					}
					Plugin.logger.LogInfo((object)(text + " => " + text2));
					File.Move(text, text2);
				}
				Directory.Delete(path, recursive: true);
				string path2 = Path.Combine(Plugin.workingDir, "LevelsUnpacked");
				if (Directory.Exists(path2))
				{
					files = Directory.GetDirectories(path2);
					foreach (string text3 in files)
					{
						string text4 = Path.Combine(Plugin.tempFolderPath, Path.GetFileName(text3));
						if (Directory.Exists(text4))
						{
							Directory.Delete(text3, recursive: true);
							continue;
						}
						Plugin.logger.LogInfo((object)(text3 + " => " + text4));
						AngryIOUtils.DirectoryCopy(text3, text4, copySubDirs: true, deleteSource: true);
					}
					Directory.Delete(path2, recursive: true);
				}
			}
			string text5 = Path.Combine(Plugin.workingDir, "OnlineCache");
			if (Directory.Exists(text5))
			{
				Plugin.logger.LogWarning((object)"Moving online cache folder to config (update 2.5.x)");
				string onlineCacheFolderPath = AngryPaths.OnlineCacheFolderPath;
				if (!Directory.Exists(onlineCacheFolderPath))
				{
					AngryIOUtils.TryCreateDirectoryForFile(onlineCacheFolderPath);
					AngryIOUtils.DirectoryCopy(text5, onlineCacheFolderPath, copySubDirs: true, deleteSource: true);
				}
				else
				{
					Directory.Delete(text5, recursive: true);
				}
			}
			string text6 = Path.Combine(Plugin.workingDir, "lastPlayedMap.txt");
			if (File.Exists(text6))
			{
				Plugin.logger.LogWarning((object)"Moving last played map to config (update 2.5.x)");
				string lastPlayedMapPath = AngryPaths.LastPlayedMapPath;
				if (!File.Exists(lastPlayedMapPath))
				{
					AngryIOUtils.TryCreateDirectoryForFile(lastPlayedMapPath);
					File.Move(text6, lastPlayedMapPath);
				}
				else
				{
					File.Delete(text6);
				}
				LastPlayedMapManager.LoadLastPlayedMap();
			}
			if (string.IsNullOrEmpty(InternalConfigManager.lastVersion.value) || new Version(InternalConfigManager.lastVersion.value) <= new Version("2.7.3"))
			{
				ConfigManager.defaultLeaderboardDifficulty.value = ConfigManager.DefaultLeaderboardDifficulty.Any;
			}
			if ("4.0.1" != InternalConfigManager.lastVersion.value)
			{
				InternalConfigManager.ignoreUpdates.value = false;
			}
			if (ConfigManager.checkForUpdates.value)
			{
				CheckPluginUpdate(userRequested: false);
			}
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "AngryLevelLoader";

		public const string PLUGIN_NAME = "AngryLevelLoader";

		public const string PLUGIN_VERSION = "4.0.1";
	}
}
namespace AngryLevelLoader.Utils
{
	internal static class AngryCryptographyUtils
	{
		public static byte[] Encrypt(string data, string keyXml)
		{
			RSA rSA = RSA.Create();
			rSA.FromXmlString(keyXml);
			return rSA.Encrypt(Encoding.UTF8.GetBytes(data), RSAEncryptionPadding.Pkcs1);
		}

		public static byte[] Encrypt(byte[] data, string keyXml)
		{
			RSA rSA = RSA.Create();
			rSA.FromXmlString(keyXml);
			return rSA.Encrypt(data, RSAEncryptionPadding.Pkcs1);
		}

		public static bool VerifyFileCertificate(string filePath, string certificatePath)
		{
			RSA rSA = RSA.Create();
			rSA.FromXmlString("<RSAKeyValue><Modulus>+/ueeOpso05dA+5GjKbjQ0VpM+JAHmRRgYRw36G4dXqmpCGfVDNVdjjBBkVWO+6lJoSNaaG4Yprn4uQVslUQ7OYWAw6Y+9E0Ezvr1quWE7i0KGxG6weplRTsu9aO0/9gJgP/gWQxC0Cf83NwyvMPsThtCruAQFT+cW0LGghtFgrBr++aknI06SJI5ydrbZgEtU5i4FfjrV1ms4CRRojhydJglfGQfG8W3pTDge4jVdND+RGB6F01QGi0+Bnq5DfKdjvb3/Zh1ko7WocWgavDaIgLYj88AgbGdC0lidLMIgzdnGxkLyxbTzsgi/mvUpB2foy4uHoV22EaWMj+6H+oXQ==</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>");
			return rSA.VerifyData(signature: File.ReadAllBytes(certificatePath), data: File.ReadAllBytes(filePath), hashAlgorithm: HashAlgorithmName.SHA256, padding: RSASignaturePadding.Pkcs1);
		}

		private static string ByteArrayToString(byte[] ba)
		{
			return BitConverter.ToString(ba).Replace("-", "");
		}

		public static string GetSHA256Hash(string filePath)
		{
			SHA256 sHA = SHA256.Create();
			sHA.Initialize();
			return ByteArrayToString(sHA.ComputeHash(File.ReadAllBytes(filePath))).ToLower();
		}

		public static string GetMD5String(string text)
		{
			return ByteArrayToString(MD5.Create().ComputeHash(Encoding.ASCII.GetBytes(text))).ToLower();
		}

		public static string GetMD5String(byte[] data)
		{
			return ByteArrayToString(MD5.Create().ComputeHash(data)).ToLower();
		}
	}
	public static class AngryFileUtils
	{
		public static bool TryGetAngryBundleData(string filePath, out AngryBundleData data, out Exception error)
		{
			error = null;
			data = null;
			try
			{
				data = GetAngryBundleData(filePath);
				return true;
			}
			catch (Exception ex)
			{
				error = ex;
			}
			return false;
		}

		private static AngryBundleData GetAngryBundleData(string filePath)
		{
			using FileStream stream = File.Open(filePath, FileMode.Open, FileAccess.Read);
			using ZipArchive zipArchive = new ZipArchive(stream);
			ZipArchiveEntry entry = zipArchive.GetEntry("data.json");
			if (entry == null)
			{
				return null;
			}
			using StreamReader streamReader = new StreamReader(entry.Open());
			return JsonConvert.DeserializeObject<AngryBundleData>(streamReader.ReadToEnd());
		}

		public static bool IsV1LegacyFile(string pathToAngryBundle)
		{
			try
			{
				using FileStream fileStream = File.Open(pathToAngryBundle, FileMode.Open, FileAccess.Read);
				try
				{
					BinaryReader binaryReader = new BinaryReader(fileStream);
					fileStream.Seek(0L, SeekOrigin.Begin);
					int num = binaryReader.ReadInt32();
					if (num * 4 + 4 >= fileStream.Length)
					{
						return false;
					}
					int num2 = 4 + num * 4;
					for (int i = 0; i < num; i++)
					{
						if (num2 >= fileStream.Length)
						{
							break;
						}
						num2 += binaryReader.ReadInt32();
					}
					if (num2 == fileStream.Length)
					{
						return true;
					}
				}
				catch (Exception)
				{
					return false;
				}
			}
			catch (Exception ex2)
			{
				Plugin.logger.LogError((object)ex2);
				return false;
			}
			return false;
		}
	}
	internal static class AngryIOUtils
	{
		private static string _AppData;

		public static string AppData
		{
			get
			{
				if (_AppData != null)
				{
					return _AppData;
				}
				_AppData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
				Regex regex = new Regex("^[^:]+:\\\\Users\\\\User\\\\AppData\\\\Roaming");
				if (regex.IsMatch(_AppData))
				{
					Plugin.logger.LogWarning((object)("Bad username for AppData (got '" + _AppData + "', expected user '" + Environment.UserName + "'), falling back to local AppData"));
					_AppData = Path.Combine(Directory.GetParent(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData)).FullName, "Roaming");
					if (regex.IsMatch(_AppData) && Environment.UserName != "User")
					{
						Plugin.logger.LogWarning((object)("Bad username for local AppData (got '" + Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData) + "', expected user '" + Environment.UserName + "'), falling back to absolute path"));
						char c = ((_AppData.Length > 0) ? _AppData[0] : 'C');
						_AppData = $"{c}:\\Users\\{Environment.UserName}\\AppData\\Roaming";
					}
				}
				return _AppData;
			}
		}

		public static string GetUniqueFileName(string folder, string name)
		{
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(name);
			string text = fileNameWithoutExtension;
			string extension = Path.GetExtension(name);
			int num = 0;
			while (File.Exists(Path.Combine(folder, text + extension)))
			{
				text = $"{fileNameWithoutExtension}_{num++}";
			}
			return text + extension;
		}

		public static string GetUniqueFileName(string path)
		{
			return Path.Combine(Path.GetDirectoryName(path), GetUniqueFileName(Path.GetDirectoryName(path), Path.GetFileName(path)));
		}

		public static string GetPathSafeName(string name)
		{
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < name.Length; i++)
			{
				char c = name[i];
				if (!char.IsLetterOrDigit(c))
				{
					switch (c)
					{
					case '-':
					case '_':
						break;
					case ' ':
						if (i > 0 && name[i - 1] != ' ')
						{
							stringBuilder.Append('_');
						}
						continue;
					default:
						continue;
					}
				}
				stringBuilder.Append(c);
			}
			string text = stringBuilder.ToString();
			if (string.IsNullOrEmpty(text))
			{
				return "file";
			}
			return text;
		}

		public static bool TryCreateDirectory(string path)
		{
			if (Directory.Exists(path))
			{
				return false;
			}
			Directory.CreateDirectory(path);
			return true;
		}

		public static bool TryCreateDirectoryForFile(string path)
		{
			return TryCreateDirectory(Path.GetDirectoryName(path));
		}

		public static void DirectoryCopy(string sourceDirName, string destDirName, bool copySubDirs, bool deleteSource)
		{
			DirectoryInfo directoryInfo = new DirectoryInfo(sourceDirName);
			DirectoryInfo[] directories = directoryInfo.GetDirectories();
			if (!directoryInfo.Exists)
			{
				throw new DirectoryNotFoundException("Source directory does not exist or could not be found: " + sourceDirName);
			}
			if (!Directory.Exists(destDirName))
			{
				Directory.CreateDirectory(destDirName);
			}
			FileInfo[] files = directoryInfo.GetFiles();
			foreach (FileInfo fileInfo in files)
			{
				string destFileName = Path.Combine(destDirName, fileInfo.Name);
				if (deleteSource)
				{
					fileInfo.MoveTo(destFileName);
				}
				else
				{
					fileInfo.CopyTo(destFileName, overwrite: false);
				}
			}
			if (copySubDirs)
			{
				DirectoryInfo[] array = directories;
				foreach (DirectoryInfo directoryInfo2 in array)
				{
					string destDirName2 = Path.Combine(destDirName, directoryInfo2.Name);
					DirectoryCopy(directoryInfo2.FullName, destDirName2, copySubDirs, deleteSource);
				}
			}
		}

		public static bool PathEquals(string path1, string path2)
		{
			if (string.IsNullOrEmpty(path1))
			{
				return string.IsNullOrEmpty(path2);
			}
			if (string.IsNullOrEmpty(path2))
			{
				return false;
			}
			return Path.GetFullPath(path1) == Path.GetFullPath(path2);
		}
	}
	public static class AngryRankUtils
	{
		private static Dictionary<char, Color> rankColors = new Dictionary<char, Color>
		{
			{
				'D',
				new Color(0f, 0.5803922f, 1f)
			},
			{
				'C',
				new Color(0.29803923f, 1f, 0f)
			},
			{
				'B',
				new Color(1f, 72f / 85f, 0f)
			},
			{
				'A',
				new Color(1f, 0.41568628f, 0f)
			},
			{
				'S',
				Color.red
			},
			{
				'P',
				Color.white
			},
			{
				'-',
				Color.gray
			},
			{
				' ',
				Color.gray
			}
		};

		public static int GetRankScore(char rank)
		{
			return rank switch
			{
				'D' => 1, 
				'C' => 2, 
				'B' => 3, 
				'A' => 4, 
				'S' => 5, 
				'P' => 6, 
				'-' => -1, 
				' ' => 0, 
				_ => -1, 
			};
		}

		public static char GetRankChar(int score)
		{
			return score switch
			{
				1 => 'D', 
				2 => 'C', 
				3 => 'B', 
				4 => 'A', 
				5 => 'S', 
				6 => 'P', 
				-1 => '-', 
				0 => ' ', 
				_ => '-', 
			};
		}

		public static Color GetRankColor(char rank, Color fallback)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (rankColors.TryGetValue(rank, out var value))
			{
				return value;
			}
			return fallback;
		}

		public static string GetFormattedRankText(char rank)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (!rankColors.TryGetValue(rank, out var value))
			{
				value = Color.gray;
			}
			return $"<color=#{ColorUtility.ToHtmlStringRGB(value)}>{rank}</color>";
		}
	}
	internal static class AngryUIUtils
	{
		public static void AddMouseEvents(GameObject field, Button btn, Action<BaseEventData> mouseOnEvent, Action<BaseEventData> mouseOffEvent)
		{
			//IL_003c: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			EventTrigger val = field.GetComponent<EventTrigger>();
			if ((Object)(object)val == (Object)null)
			{
				val = field.AddComponent<EventTrigger>();
				Utils.AddScrollEvents(val, Utils.GetComponentInParent<ScrollRect>(((Component)btn).transform));
			}
			Entry val2 = new Entry
			{
				eventID = (EventTriggerType)0
			};
			((UnityEvent<BaseEventData>)(object)val2.callback).AddListener((UnityAction<BaseEventData>)delegate(BaseEventData e)
			{
				mouseOnEvent(e);
			});
			Entry val3 = new Entry
			{
				eventID = (EventTriggerType)1
			};
			((UnityEvent<BaseEventData>)(object)val3.callback).AddListener((UnityAction<BaseEventData>)delegate(BaseEventData e)
			{
				mouseOffEvent(e);
			});
			val.triggers.Add(val2);
			val.triggers.Add(val3);
		}
	}
	internal class CachedTask
	{
		private Func<Task> task;

		private Task currentTask;

		public bool Running
		{
			get
			{
				if (currentTask != null)
				{
					return !currentTask.IsCompleted;
				}
				return false;
			}
		}

		public CachedTask(Func<Task> task)
		{
			this.task = task;
		}

		public async Task GetTask(CancellationToken cancellationToken = default(CancellationToken))
		{
			if (!Running)
			{
				currentTask = task();
			}
			await Task.Run(async delegate
			{
				await currentTask;
			}, cancellationToken);
		}
	}
	internal class CachedTask<T>
	{
		private Func<Task<T>> task;

		private Task<T> currentTask;

		public bool Running
		{
			get
			{
				if (currentTask != null)
				{
					return !currentTask.IsCompleted;
				}
				return false;
			}
		}

		public CachedTask(Func<Task<T>> task)
		{
			this.task = task;
		}

		public async Task<T> GetTask(CancellationToken cancellationToken = default(CancellationToken))
		{
			if (!Running)
			{
				currentTask = task();
			}
			return await Task.Run(async () => await currentTask, cancellationToken);
		}
	}
	internal class WordHighlighter
	{
		public List<(int, int)> highlights = new List<(int, int)>();

		public string rawText { get; private set; }

		public WordHighlighter(string text)
		{
			rawText = text;
		}

		public void Highlight(int index, int endIndex)
		{
			int i;
			for (i = 0; i < highlights.Count && index > highlights[i].Item1; i++)
			{
			}
			bool flag = false;
			if (i > 0 && highlights[i - 1].Item2 >= index - 1)
			{
				if (highlights[i - 1].Item2 >= endIndex)
				{
					return;
				}
				index = highlights[i - 1].Item1;
				flag = true;
			}
			int j;
			for (j = 0; i < highlights.Count - j && endIndex >= highlights[i + j].Item1 - 1; j++)
			{
				endIndex = Mathf.Max(endIndex, highlights[i + j].Item2);
			}
			highlights.Insert(i, (index, endIndex));
			for (int k = 0; k < j; k++)
			{
				highlights.RemoveAt(i + 1);
			}
			if (flag)
			{
				highlights.RemoveAt(i - 1);
			}
		}

		public string GenerateFormattedText(string prefix, string postfix)
		{
			if (rawText.Length == 0)
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder();
			string text = rawText;
			int num = 0;
			foreach (var (num2, num3) in highlights)
			{
				if (num < num2)
				{
					stringBuilder.Append(text.Substring(num, num2 - num));
				}
				stringBuilder.Append(prefix);
				stringBuilder.Append(text.Substring(num2, num3 - num2 + 1));
				stringBuilder.Append(postfix);
				num = num3 + 1;
			}
			if (num < text.Length)
			{
				stringBuilder.Append(text.Substring(num));
			}
			return stringBuilder.ToString();
		}
	}
}
namespace AngryLevelLoader.UserInterface
{
	internal static class AngryBundleList
	{
		private class BundleNameComparer : IComparer<BundleContainer>
		{
			public static readonly BundleNameComparer Instance = new BundleNameComparer();

			public int Compare(BundleContainer b1, BundleContainer b2)
			{
				if (ConfigManager.bundleFavSort.value)
				{
					if (b1.Favourite && !b2.Favourite)
					{
						return -1;
					}
					if (!b1.Favourite && b2.Favourite)
					{
						return 1;
					}
				}
				return StringComparer.OrdinalIgnoreCase.Compare(richText.Replace(b1.BundleName, string.Empty), richText.Replace(b2.BundleName, string.Empty));
			}
		}

		private class BundleAuthorComparer : IComparer<BundleContainer>
		{
			public static readonly BundleAuthorComparer Instance = new BundleAuthorComparer();

			public int Compare(BundleContainer b1, BundleContainer b2)
			{
				if (ConfigManager.bundleFavSort.value)
				{
					if (b1.Favourite && !b2.Favourite)
					{
						return -1;
					}
					if (!b1.Favourite && b2.Favourite)
					{
						return 1;
					}
				}
				return StringComparer.OrdinalIgnoreCase.Compare(richText.Replace(b1.BundleAuthor, string.Empty), richText.Replace(b2.BundleAuthor, string.Empty));
			}
		}

		private class BundleLastUpdateComparer : IComparer<BundleContainer>
		{
			public static readonly BundleLastUpdateComparer Instance = new BundleLastUpdateComparer();

			public int Compare(BundleContainer b1, BundleContainer b2)
			{
				if (ConfigManager.bundleFavSort.value)
				{
					if (b1.Favourite && !b2.Favourite)
					{
						return -1;
					}
					if (!b1.Favourite && b2.Favourite)
					{
						return 1;
					}
				}
				if (!LastPlayedMapManager.lastUpdate.TryGetValue(b1.bundleGuid, out var value))
				{
					value = 0L;
				}
				if (!LastPlayedMapManager.lastUpdate.TryGetValue(b2.bundleGuid, out var value2))
				{
					value2 = 0L;
				}
				return (int)(value2 - value);
			}
		}

		private class BundleLastPlayedComparer : IComparer<BundleContainer>
		{
			public static readonly BundleLastPlayedComparer Instance = new BundleLastPlayedComparer();

			public int Compare(BundleContainer b1, BundleContainer b2)
			{
				if (ConfigManager.bundleFavSort.value)
				{
					if (b1.Favourite && !b2.Favourite)
					{
						return -1;
					}
					if (!b1.Favourite && b2.Favourite)
					{
						return 1;
					}
				}
				if (!LastPlayedMapManager.lastPlayed.TryGetValue(b1.bundleGuid, out var value))
				{
					value = 0L;
				}
				if (!LastPlayedMapManager.lastPlayed.TryGetValue(b2.bundleGuid, out var value2))
				{
					value2 = 0L;
				}
				return (int)(value2 - value);
			}
		}

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

			public static Func<BundleContainer, BundleContainer> <>9__5_0;

			public static Func<string, bool> <>9__17_0;

			public static Func<string, string> <>9__20_0;

			public static OpenPanelEventDelegate <>9__21_0;

			public static Action <>9__21_2;

			public static Action<bool> <>9__21_3;

			internal BundleContainer <SortBundles>b__5_0(BundleContainer b)
			{
				return b;
			}

			internal bool <UpdateFolderIcons>b__17_0(string path)
			{
				return validImageExts.Contains<string>(Path.GetExtension(path));
			}

			internal string <UpdateBundleSearch>b__20_0(string keyword)
			{
				return keyword.ToLower();
			}

			internal void <Init>b__21_0(bool externally)
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Expected O, but got Unknown
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Expected O, but got Unknown
				<>c__DisplayClass21_0 CS$<>8__locals0 = new <>c__DisplayClass21_0
				{
					backButtonEvent = PluginConfiguratorController.backButton.onClick
				};
				PluginConfiguratorController.backButton.onClick = new ButtonClickedEvent();
				((UnityEvent)PluginConfiguratorController.backButton.onClick).AddListener((UnityAction)delegate
				{
					if (displayedFolder == null || displayedFolder == rootFolder || !string.IsNullOrEmpty(ConfigManager.searchBar.value))
					{
						((UnityEvent)CS$<>8__locals0.backButtonEvent).Invoke();
					}
					else
					{
						PopFolder();
					}
				});
			}

			internal void <Init>b__21_2()
			{
				ConfigManager.searchBar.value = "";
			}

			internal void <Init>b__21_3(bool wasCanceled)
			{
				if (wasCanceled)
				{
					if (!string.IsNullOrWhiteSpace(ConfigManager.searchBar.value))
					{
						ConfigManager.searchBar.value = "";
					}
					else if (displayedFolder == null || displayedFolder == rootFolder)
					{
						ConfigManager.config.rootPanel.ClosePanel();
					}
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass21_0
		{
			public ButtonClickedEvent backButtonEvent;

			internal void <Init>b__1()
			{
				if (displayedFolder == null || displayedFolder == rootFolder || !string.IsNullOrEmpty(ConfigManager.searchBar.value))
				{
					((UnityEvent)backButtonEvent).Invoke();
				}
				else
				{
					PopFolder();
				}
			}
		}

		[CompilerGenerated]
		private sealed class <GetAllFolders>d__12 : IEnumerable<FolderButtonField>, IEnumerable, IEnumerator<FolderButtonField>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private FolderButtonField <>2__current;

			private int <>l__initialThreadId;

			private Stack<FolderButtonField> <folders>5__2;

			private FolderButtonField <folder>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<folders>5__2 = null;
				<folder>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<folders>5__2 = new Stack<FolderButtonField>();
					<folders>5__2.Push(rootFolder);
					break;
				case 1:
					<>1__state = -1;
					foreach (FolderButtonField allSubfolder in <folder>5__3.GetAllSubfolders())
					{
						<folders>5__2.Push(allSubfolder);
					}
					<folder>5__3 = null;
					break;
				}
				if (<folders>5__2.Count != 0)
				{
					<folder>5__3 = <folders>5__2.Pop();
					<>2__current = <folder>5__3;
					<>1__state = 1;
					return true;
				}
				return false;
			}

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

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

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

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

		private static Regex richText;

		internal static readonly FolderButtonField rootFolder;

		private static string[] validImageExts;

		private static string[] currentSearchKeywords;

		private static char[] whitespaceSeparator;

		internal static FolderButtonField displayedFolder { get; private set; }

		internal static void SortBundles()
		{
			IComparer<BundleContainer> comparer = ConfigManager.bundleSortingMode.value switch
			{
				ConfigManager.BundleSorting.Author => BundleAuthorComparer.Instance, 
				ConfigManager.BundleSorting.LastUpdate => BundleLastUpdateComparer.Instance, 
				ConfigManager.BundleSorting.LastPlayed => BundleLastPlayedComparer.Instance, 
				_ => BundleNameComparer.Instance, 
			};
			int num = 0;
			foreach (BundleContainer item in Plugin.GetAllBundleContainers().OrderBy((BundleContainer b) => b, comparer))
			{
				item.SiblingIndex = num++;
			}
		}

		static AngryBundleList()
		{
			richText = new Regex("<[^>]*>");
			displayedFolder = null;
			validImageExts = new string[3] { ".jpg", ".jpeg", ".png" };
			currentSearchKeywords = new string[0];
			whitespaceSeparator = new char[1] { ' ' };
			ConfigManager.InitializeConfig();
			rootFolder = new FolderButtonField(string.Empty, null);
			((ConfigField)rootFolder).hidden = true;
		}

		[IteratorStateMachine(typeof(<GetAllFolders>d__12))]
		private static IEnumerable<FolderButtonField> GetAllFolders()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetAllFolders>d__12(-2);
		}

		internal static void DisplayFolder(FolderButtonField folderField)
		{
			if (folderField == null)
			{
				folderField = rootFolder;
			}
			foreach (BundleContainer allBundleContainer in Plugin.GetAllBundleContainers())
			{
				allBundleContainer.Hidden = true;
			}
			foreach (FolderButtonField allFolder in GetAllFolders())
			{
				((ConfigField)allFolder).hidden = true;
			}
			foreach (BundleContainer bundle in folderField.bundles)
			{
				if (bundle.LazyLoaded)
				{
					bundle.Hidden = false;
				}
			}
			foreach (FolderButtonField allSubfolder in folderField.GetAllSubfolders())
			{
				if (allSubfolder.Any())
				{
					((ConfigField)allSubfolder).hidden = false;
				}
			}
			if (folderField == rootFolder)
			{
				ConfigManager.levelBundlesHeader.text = "Level Bundles";
			}
			else
			{
				ConfigManager.levelBundlesHeader.text = "Level Bundles <color=grey>" + folderField.GetRelativeFolderPath() + "</color>";
			}
			displayedFolder = folderField;
		}

		internal static void ResetFolders()
		{
			foreach (FolderButtonField allFolder in GetAllFolders())
			{
				allFolder.bundles.Clear();
			}
		}

		internal static bool PopFolder()
		{
			if (displayedFolder == null || displayedFolder == rootFolder)
			{
				return false;
			}
			DisplayFolder(displayedFolder.parent ?? rootFolder);
			return true;
		}

		internal static void UpdateFolderIcons()
		{
			foreach (FolderButtonField allFolder in GetAllFolders())
			{
				if (allFolder == rootFolder)
				{
					continue;
				}
				string absoluteFolderPath = allFolder.GetAbsoluteFolderPath(Plugin.levelsPath);
				if (Directory.Exists(absoluteFolderPath))
				{
					string text = (from path in Directory.GetFiles(absoluteFolderPath)
						where validImageExts.Contains<string>(Path.GetExtension(path))
						select path).FirstOrDefault();
					if (!string.IsNullOrEmpty(text))
					{
						allFolder.CreateIcon(text);
						continue;
					}
				}
				allFolder.CreateIcon(allFolder);
			}
		}

		private static void UpdateBundleSearch(string newVal)
		{
			string[] array = (from keyword in newVal.Split(whitespaceSeparator, StringSplitOptions.RemoveEmptyEntries)
				select keyword.ToLower()).ToArray();
			if (array.Length == currentSearchKeywords.Length && array.SequenceEqual(currentSearchKeywords))
			{
				return;
			}
			currentSearchKeywords = array;
			if (currentSearchKeywords.Length == 0)
			{
				((ConfigField)ConfigManager.folderDivision).hidden = false;
				((ConfigField)ConfigManager.searchInfo).hidden = true;
				foreach (BundleContainer allBundleContainer in Plugin.GetAllBundleContainers())
				{
					allBundleContainer.SearchKeywords = new string[0];
				}
				DisplayFolder(displayedFolder);
				return;
			}
			((ConfigField)ConfigManager.folderDivision).hidden = true;
			((ConfigField)ConfigManager.searchInfo).hidden = false;
			int num = 0;
			int num2 = 0;
			foreach (BundleContainer allBundleContainer2 in Plugin.GetAllBundleContainers())
			{
				allBundleContainer2.SearchKeywords = currentSearchKeywords;
				if (allBundleContainer2.HasValidAngryFile)
				{
					num2++;
					if (allBundleContainer2.SearchMatch)
					{
						num++;
					}
				}
			}
			ConfigManager.levelBundlesHeader.text = "Level Bundles";
			ConfigManager.searchInfo.text = $"Showing {num} of {num2} bundles";
		}

		internal static void Init()
		{
			//IL_0023: 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_002e: Expected O, but got Unknown
			ConfigManager.InitializeConfig();
			ConfigPanel rootPanel = ConfigManager.config.rootPanel;
			object obj = <>c.<>9__21_0;
			if (obj == null)
			{
				OpenPanelEventDelegate val = delegate
				{
					//IL_001b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0025: Expected O, but got Unknown
					//IL_0036: Unknown result type (might be due to invalid IL or missing references)
					//IL_0040: Expected O, but got Unknown
					ButtonClickedEvent backButtonEvent = PluginConfiguratorController.backButton.onClick;
					PluginConfiguratorController.backButton.onClick = new ButtonClickedEvent();
					((UnityEvent)PluginConfiguratorController.backButton.onClick).AddListener((UnityAction)delegate
					{
						if (displayedFolder == null || displayedFolder == rootFolder || !string.IsNullOrEmpty(ConfigManager.searchBar.value))
						{
							((UnityEvent)backButtonEvent).Invoke();
						}
						else
						{
							PopFolder();
						}
					});
				};
				<>c.<>9__21_0 = val;
				obj = (object)val;
			}
			rootPanel.onPannelOpenEvent += (OpenPanelEventDelegate)obj;
			SearchBarField searchBar = ConfigManager.searchBar;
			searchBar.onValueChange = (Action<string>)Delegate.Combine(searchBar.onValueChange, new Action<string>(UpdateBundleSearch));
			SearchBarField searchBar2 = ConfigManager.searchBar;
			searchBar2.onReset = (Action)Delegate.Combine(searchBar2.onReset, (Action)delegate
			{
				ConfigManager.searchBar.value = "";
			});
			SearchBarField searchBar3 = ConfigManager.searchBar;
			searchBar3.onEndEdit = (Action<bool>)Delegate.Combine(searchBar3.onEndEdit, (Action<bool>)delegate(bool wasCanceled)
			{
				if (wasCanceled)
				{
					if (!string.IsNullOrWhiteSpace(ConfigManager.searchBar.value))
					{
						ConfigManager.searchBar.value = "";
					}
					else if (displayedFolder == null || displayedFolder == rootFolder)
					{
						ConfigManager.config.rootPanel.ClosePanel();
					}
				}
			});
		}
	}
	internal static class AngryCustomLevelButton
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<GameObject, bool> <>9__4_0;

			public static UnityAction<Scene, LoadSceneMode> <>9__5_0;

			public static PostEnumValueChangeEvent<ConfigManager.CustomLevelButtonPosition> <>9__5_1;

			public static PostColorValueChangeEvent <>9__5_2;

			public static PostColorValueChangeEvent <>9__5_3;

			internal bool <CreateCustomLevelButtonOnMainMenuAsync>b__4_0(GameObject obj)
			{
				return ((Object)obj).name == "Canvas";
			}

			internal void <Init>b__5_0(Scene scene, LoadSceneMode mode)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				if ((int)mode != 1 && SceneHelper.CurrentScene == "Main Menu")
				{
					CreateCustomLevelButtonOnMainMenu();
				}
			}

			internal void <Init>b__5_1(ConfigManager.CustomLevelButtonPosition pos)
			{
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: 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_005e: 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_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0195: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_0212: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0130: Unknown result type (might be due to invalid IL or missing references)
				//IL_013a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0153: Unknown result type (might be due to invalid IL or missing references)
				//IL_0176: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)currentCustomLevelButton == (Object)null)
				{
					return;
				}
				((Component)currentCustomLevelButton).gameObject.SetActive(true);
				switch (pos)
				{
				case ConfigManager.CustomLevelButtonPosition.Disabled:
					((Component)currentCustomLevelButton).gameObject.SetActive(false);
					break;
				case ConfigManager.CustomLevelButtonPosition.Bottom:
					((Component)currentCustomLevelButton).transform.localPosition = new Vector3(((Component)currentCustomLevelButton).transform.localPosition.x, -303f, ((Component)currentCustomLevelButton).transform.localPosition.z);
					break;
				case ConfigManager.CustomLevelButtonPosition.Top:
					((Component)currentCustomLevelButton).transform.localPosition = new Vector3(((Component)currentCustomLevelButton).transform.localPosition.x, 192f, ((Component)currentCustomLevelButton).transform.localPosition.z);
					break;
				}
				if ((Object)(object)bossRushButton != (Object)null)
				{
					if (pos == ConfigManager.CustomLevelButtonPosition.Bottom)
					{
						currentCustomLevelButton.rect.sizeDelta = new Vector2(187.5f, 50f);
						((Component)currentCustomLevelButton).transform.localPosition = new Vector3(-96.25f, ((Component)currentCustomLevelButton).transform.localPosition.y, ((Component)currentCustomLevelButton).transform.localPosition.z);
						bossRushButton.sizeDelta = new Vector2(187.5f, 50f);
						((Component)bossRushButton).transform.localPosition = new Vector3(96.25f, -303f, 0f);
					}
					else
					{
						currentCustomLevelButton.rect.sizeDelta = new Vector2(380f, 50f);
						((Component)currentCustomLevelButton).transform.localPosition = new Vector3(0f, ((Component)currentCustomLevelButton).transform.localPosition.y, ((Component)currentCustomLevelButton).transform.localPosition.z);
						bossRushButton.sizeDelta = new Vector2(380f, 50f);
						((Component)bossRushButton).transform.localPosition = new Vector3(0f, -303f, 0f);
					}
				}
			}

			internal void <Init>b__5_2(Color clr)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)currentCustomLevelButton == (Object)null))
				{
					ColorBlock colors = default(ColorBlock);
					((ColorBlock)(ref colors)).colorMultiplier = 1f;
					((ColorBlock)(ref colors)).fadeDuration = 0.1f;
					((ColorBlock)(ref colors)).normalColor = clr;
					((ColorBlock)(ref colors)).selectedColor = clr * 0.8f;
					((ColorBlock)(ref colors)).highlightedColor = clr * 0.8f;
					((ColorBlock)(ref colors)).pressedColor = clr * 0.5f;
					((ColorBlock)(ref colors)).disabledColor = Color.gray;
					((Selectable)currentCustomLevelButton.button).colors = colors;
				}
			}

			internal void <Init>b__5_3(Color clr)
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)currentCustomLevelButton == (Object)null))
				{
					((Graphic)currentCustomLevelButton.text).color = clr;
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass4_0
		{
			public GameObject canvasObj;

			public Transform chapterSelect;

			internal void <CreateCustomLevelButtonOnMainMenuAsync>b__1()
			{
				//IL_013d: Unknown result type (might be due to invalid IL or missing references)
				Transform val = canvasObj.transform.Find("OptionsMenu");
				if ((Object)(object)val == (Object)null)
				{
					Plugin.logger.LogError((object)"Angry tried to find the options menu but failed!");
					return;
				}
				((Component)chapterSelect).gameObject.SetActive(false);
				((Component)val).gameObject.SetActive(true);
				Transform val2 = ((Component)val).transform.Find("Navigation Rail/PluginConfiguratorButton(Clone)");
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = ((Component)val).transform.Find("Navigation Rail/PluginConfiguratorButton");
				}
				if ((Object)(object)val2 == (Object)null)
				{
					Plugin.logger.LogError((object)"Angry tried to find the plugin configurator button but failed!");
					return;
				}
				Transform val3 = val.Find("Navigation Rail");
				ButtonHighlightParent val4 = default(ButtonHighlightParent);
				if ((Object)(object)val3 != (Object)null && ((Component)val3).gameObject.TryGetComponent<ButtonHighlightParent>(ref val4) && (val4.buttons == null || val4.buttons.Length == 0))
				{
					val4.Start();
					val4.targetOnStart = null;
				}
				((UnityEvent)((Component)val2).gameObject.GetComponent<Button>().onClick).Invoke();
				if ((Object)(object)PluginConfiguratorController.activePanel != (Object)null)
				{
					PluginConfiguratorController.activePanel.SetActive(false);
				}
				((Component)PluginConfiguratorController.mainPanel).gameObject.SetActive(false);
				ConfigManager.config.rootPanel.OpenPanelInternally(false);
				ConfigManager.config.rootPanel.currentPanel.rect.normalizedPosition = new Vector2(0f, 1f);
				AngryDifficultyManager.SetDifficultyFromPrefs();
			}
		}

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

			private object <>2__current;

			private <>c__DisplayClass4_0 <>8__1;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_003f: 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_00f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0139: Unknown result type (might be due to invalid IL or missing references)
				//IL_0143: Expected O, but got Unknown
				//IL_015e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0168: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass4_0();
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					<>c__DisplayClass4_0 <>c__DisplayClass4_ = <>8__1;
					Scene activeScene = SceneManager.GetActiveScene();
					<>c__DisplayClass4_.canvasObj = (from obj in ((Scene)(ref activeScene)).GetRootGameObjects()
						where ((Object)obj).name == "Canvas"
						select obj).FirstOrDefault();
					if ((Object)(object)<>8__1.canvasObj == (Object)null)
					{
						Plugin.logger.LogWarning((object)"Angry tried to create main menu buttons, but root canvas was not found!");
						return false;
					}
					Transform val = <>8__1.canvasObj.transform.Find("Chapter Select/Chapters");
					if ((Object)(object)val != (Object)null)
					{
						<>8__1.chapterSelect = <>8__1.canvasObj.transform.Find("Chapter Select");
						GameObject obj2 = Addressables.InstantiateAsync((object)"AngryLevelLoader/UI/CustomLevels.prefab", val, false, true).WaitForCompletion();
						Transform val2 = val.Find("Boss Rush Button");
						if ((Object)(object)val2 != (Object)null)
						{
							bossRushButton = ((Component)val2).gameObject.GetComponent<RectTransform>();
						}
						currentCustomLevelButton = obj2.GetComponent<AngryCustomLevelButtonComponent>();
						currentCustomLevelButton.button.onClick = new ButtonClickedEvent();
						((UnityEvent)currentCustomLevelButton.button.onClick).AddListener((UnityAction)delegate
						{
							//IL_013d: Unknown result type (might be due to invalid IL or missing references)
							Transform val3 = <>8__1.canvasObj.transform.Find("OptionsMenu");
							if ((Object)(object)val3 == (Object)null)
							{
								Plugin.logger.LogError((object)"Angry tried to find the options menu but failed!");
							}
							else
							{
								((Component)<>8__1.chapterSelect).gameObject.SetActive(false);
								((Component)val3).gameObject.SetActive(true);
								Transform val4 = ((Component)val3).transform.Find("Navigation Rail/PluginConfiguratorButton(Clone)");
								if ((Object)(object)val4 == (Object)null)
								{
									val4 = ((Component)val3).transform.Find("Navigation Rail/PluginConfiguratorButton");
								}
								if ((Object)(object)val4 == (Object)null)
								{
									Plugin.logger.LogError((object)"Angry tried to find the plugin configurator button but failed!");
								}
								else
								{
									Transform val5 = val3.Find("Navigation Rail");
									ButtonHighlightParent val6 = default(ButtonHighlightParent);
									if ((Object)(object)val5 != (Object)null && ((Component)val5).gameObject.TryGetComponent<ButtonHighlightParent>(ref val6) && (val6.buttons == null || val6.buttons.Length == 0))
									{
										val6.Start();
										val6.targetOnStart = null;
									}
									((UnityEvent)((Component)val4).gameObject.GetComponent<Button>().onClick).Invoke();
									if ((Object)(object)PluginConfiguratorController.activePanel != (Object)null)
									{
										PluginConfiguratorController.activePanel.SetActive(false);
									}
									((Component)PluginConfiguratorController.mainPanel).gameObject.SetActive(false);
									ConfigManager.config.rootPanel.OpenPanelInternally(false);
									ConfigManager.config.rootPanel.currentPanel.rect.normalizedPosition = new Vector2(0f, 1f);
									AngryDifficultyManager.SetDifficultyFromPrefs();
								}
							}
						});
						ConfigManager.customLevelButtonPosition.TriggerPostValueChangeEvent();
						ConfigManager.customLevelButtonFrameColor.TriggerPostValueChangeEvent();
						ConfigManager.customLevelButtonTextColor.TriggerPostValueChangeEvent();
					}
					else
					{
						Plugin.logger.LogWarning((object)"Angry tried to find chapter select menu, but root canvas was not found!");
					}
					return false;
				}
				}
			}

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

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

		internal const string CUSTOM_LEVEL_BUTTON_ASSET_PATH = "AngryLevelLoader/UI/CustomLevels.prefab";

		internal static AngryCustomLevelButtonComponent currentCustomLevelButton;

		internal static RectTransform bossRushButton;

		private static void CreateCustomLevelButtonOnMainMenu()
		{
			((MonoBehaviour)Plugin.instance).StartCoroutine(CreateCustomLevelButtonOnMainMenuAsync());
		}

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

		internal static void Init()
		{
			//IL_006b: 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)
			//IL_0076: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			SceneManager.sceneLoaded += delegate(Scene scene, LoadSceneMode mode)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				if ((int)mode != 1 && SceneHelper.CurrentScene == "Main Menu")
				{
					CreateCustomLevelButtonOnMainMenu();
				}
			};
			ConfigManager.InitializeConfig();
			ConfigManager.customLevelButtonPosition.postValueChangeEvent += delegate(ConfigManager.CustomLevelButtonPosition pos)
			{
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: 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_005e: 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_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0195: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_0212: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0130: Unknown result type (might be due to invalid IL or missing references)
				//IL_013a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0153: Unknown result type (might be due to invalid IL or missing references)
				//IL_0176: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)currentCustomLevelButton == (Object)null))
				{
					((Component)currentCustomLevelButton).gameObject.SetActive(true);
					switch (pos)
					{
					case ConfigManager.CustomLevelButtonPosition.Disabled:
						((Component)currentCustomLevelButton).gameObject.SetActive(false);
						break;
					case ConfigManager.CustomLevelButtonPosition.Bottom:
						((Component)currentCustomLevelButton).transform.localPosition = new Vector3(((Component)currentCustomLevelButton).transform.localPosition.x, -303f, ((Component)currentCustomLevelButton).transform.localPosition.z);
						break;
					case ConfigManager.CustomLevelButtonPosition.Top:
						((Component)currentCustomLevelButton).transform.localPosition = new Vector3(((Component)currentCustomLevelButton).transform.localPosition.x, 192f, ((Component)currentCustomLevelButton).transform.localPosition.z);
						break;
					}
					if ((Object)(object)bossRushButton != (Object)null)
					{
						if (pos == ConfigManager.CustomLevelButtonPosition.Bottom)
						{
							currentCustomLevelButton.rect.sizeDelta = new Vector2(187.5f, 50f);
							((Component)currentCustomLevelButton).transform.localPosition = new Vector3(-96.25f, ((Component)currentCustomLevelButton).transform.localPosition.y, ((Component)currentCustomLevelButton).transform.localPosition.z);
							bossRushButton.sizeDelta = new Vector2(187.5f, 50f);
							((Component)bossRushButton).transform.localPosition = new Vector3(96.25f, -303f, 0f);
						}
						else
						{
							currentCustomLevelButton.rect.sizeDelta = new Vector2(380f, 50f);
							((Component)currentCustomLevelButton).transform.localPosition = new Vector3(0f, ((Component)currentCustomLevelButton).transform.localPosition.y, ((Component)currentCustomLevelButton).transform.localPosition.z);
							bossRushButton.sizeDelta = new Vector2(380f, 50f);
							((Component)bossRushButton).transform.localPosition = new Vector3(0f, -303f, 0f);
						}
					}
				}
			};
			ColorField customLevelButtonFrameColor = ConfigManager.customLevelButtonFrameColor;
			object obj = <>c.<>9__5_2;
			if (obj == null)
			{
				PostColorValueChangeEvent val = delegate(Color clr)
				{
					//IL_0010: Unknown result type (might be due to invalid IL or missing references)
					//IL_0030: Unknown result type (might be due to invalid IL or missing references)
					//IL_0038: Unknown result type (might be due to invalid IL or missing references)
					//IL_003e: Unknown result type (might be due to invalid IL or missing references)
					//IL_004a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0050: Unknown result type (might be due to invalid IL or missing references)
					//IL_005c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0062: Unknown result type (might be due to invalid IL or missing references)
					//IL_006e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0082: Unknown result type (might be due to invalid IL or missing references)
					if (!((Object)(object)currentCustomLevelButton == (Object)null))
					{
						ColorBlock colors = default(ColorBlock);
						((ColorBlock)(ref colors)).colorMultiplier = 1f;
						((ColorBlock)(ref colors)).fadeDuration = 0.1f;
						((ColorBlock)(ref colors)).normalColor = clr;
						((ColorBlock)(ref colors)).selectedColor = clr * 0.8f;
						((ColorBlock)(ref colors)).highlightedColor = clr * 0.8f;
						((ColorBlock)(ref colors)).pressedColor = clr * 0.5f;
						((ColorBlock)(ref colors)).disabledColor = Color.gray;
						((Selectable)currentCustomLevelButton.button).colors = colors;
					}
				};
				<>c.<>9__5_2 = val;
				obj = (object)val;
			}
			customLevelButtonFrameColor.postValueChangeEvent += (PostColorValueChangeEvent)obj;
			ColorField customLevelButtonTextColor = ConfigManager.customLevelButtonTextColor;
			object obj2 = <>c.<>9__5_3;
			if (obj2 == null)
			{
				PostColorValueChangeEvent val2 = delegate(Color clr)
				{
					//IL_0018: Unknown result type (might be due to invalid IL or missing references)
					if (!((Object)(object)currentCustomLevelButton == (Object)null))
					{
						((Graphic)currentCustomLevelButton.text).color = clr;
					}
				};
				<>c.<>9__5_3 = val2;
				obj2 = (object)val2;
			}
			customLevelButtonTextColor.postValueChangeEvent += (PostColorValueChangeEvent)obj2;
		}
	}
	internal static class AngryUI
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<GameObject, bool> <>9__3_0;

			public static UnityAction <>9__5_0;

			public static UnityAction <>9__5_1;

			public static UnityAction <>9__6_0;

			public static UnityAction <>9__6_1;

			public static UnityAction<Scene, LoadSceneMode> <>9__12_0;

			internal bool <CreateAngryUIAsync>b__3_0(GameObject obj)
			{
				return ((Object)obj).name == "Canvas";
			}

			internal void <ShowReloadScriptPrompt>b__5_0()
			{
				ReloadScript();
			}

			internal void <ShowReloadScriptPrompt>b__5_1()
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Expected O, but got Unknown
				currentPanel.reloadScriptPrompt.reloadButton.onClick = new ButtonClickedEvent();
				((Component)currentPanel.reloadScriptPrompt).gameObject.SetActive(false);
				UpdatedScript = string.Empty;
			}

			internal void <ShowReloadBundlePrompt>b__6_0()
			{
				AngrySceneManager.currentBundleContainer.ReloadBundle(forceReload: false, lazyLoad: false);
			}

			internal void <ShowReloadBundlePrompt>b__6_1()
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Expected O, but got Unknown
				AngrySceneManager.currentBundleContainer.IgnoreFileChange = true;
				currentPanel.reloadBundlePrompt.reloadButton.onClick = new ButtonClickedEvent();
				((Component)currentPanel.reloadBundlePrompt).gameObject.SetActive(false);
			}

			internal void <Init>b__12_0(Scene scene, LoadSceneMode mode)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				if ((int)mode != 1 && AngrySceneManager.isInCustomLevel)
				{
					Plugin.logger.LogInfo((object)"Creating UI panel");
					CreateAngryUI();
				}
			}
		}

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

			private object <>2__current;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_003d: 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_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					if ((Object)(object)currentPanel != (Object)null)
					{
						return false;
					}
					Scene activeScene = SceneManager.GetActiveScene();
					GameObject val = (from obj in ((Scene)(ref activeScene)).GetRootGameObjects()
						where ((Object)obj).name == "Canvas"
						select obj).FirstOrDefault();
					if ((Object)(object)val == (Object)null)
					{
						Plugin.logger.LogWarning((object)"Angry tried to create main menu buttons, but root canvas was not found!");
						return false;
					}
					currentPanel = Addressables.InstantiateAsync((object)"AngryLevelLoader/UI/AngryUIPanel.prefab", val.transform, false, true).WaitForCompletion().GetComponent<AngryUIPanelComponent>();
					currentPanel.reloadBundlePrompt.MakeTransparent(true);
					currentPanel.reloadScriptPrompt.MakeTransparent(true);
					if (AngrySceneManager.currentBundleContainer.FileChangeDetected && !AngrySceneManager.currentBundleContainer.IgnoreFileChange)
					{
						ShowReloadBundlePrompt();
						return false;
					}
					if (!string.IsNullOrEmpty(UpdatedScript))
					{
						ShowReloadScriptPrompt();
						return false;
					}
					return false;
				}
				}
			}

			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 const string ANGRY_UI_PANEL_ASSET_PATH = "AngryLevelLoader/UI/AngryUIPanel.prefab";

		private static AngryUIPanelComponent currentPanel;

		private static string _updatedScript = string.Empty;

		internal static string UpdatedScript
		{
			get
			{
				return _updatedScript;
			}
			set
			{
				_updatedScript = value;
				if ((Object)(object)currentPanel != (Object)null && !string.IsNullOrEmpty(_updatedScript))
				{
					ShowReloadScriptPrompt();
				}
			}
		}

		private static void CreateAngryUI()
		{
			((MonoBehaviour)Plugin.instance).StartCoroutine(CreateAngryUIAsync());
		}

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

		internal static void ReloadScript()
		{
			if (string.IsNullOrEmpty(UpdatedScript))
			{
				return;
			}
			if (AngrySceneManager.isInCustomLevel)
			{
				InternalConfigManager.instantLoadLevel.value = true;
				InternalConfigManager.instantLoadLevelGuid.value = AngrySceneManager.currentBundleContainer.bundleGuid;
				InternalConfigManager.instantLoadLevelId.value = AngrySceneManager.currentLevelContainer.levelId;
			}
			PluginConfiguratorController.FlushAllConfigs();
			ProcessStartInfo processStartInfo = new ProcessStartInfo
			{
				FileName = Path.Combine(Directory.GetParent(Application.dataPath).FullName, "ULTRAKILL.exe"),
				WorkingDirectory = Directory.GetParent(Application.dataPath).FullName,
				UseShellExecute = false,
				RedirectStandardError = true,
				RedirectStandardOutput = true
			};
			string[] array = new string[7] { "DOORSTOP_DISABLE", "DOORSTOP_DLL_SEARCH_DIRS", "DOORSTOP_INITIALIZED", "DOORSTOP_INVOKE_DLL_PATH", "DOORSTOP_MANAGED_FOLDER_DIR", "DOORSTOP_MONO_LIB_PATH", "DOORSTOP_PROCESS_PATH" };
			foreach (string key in array)
			{
				if (processStartInfo.EnvironmentVariables.ContainsKey(key))
				{
					processStartInfo.EnvironmentVariables.Remove(key);
				}
				if (processStartInfo.Environment.ContainsKey(key))
				{
					processStartInfo.Environment.Remove(key);
				}
			}
			Process.Start(processStartInfo);
			Application.Quit();
		}

		private static void ShowReloadScriptPrompt()
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected O, but got Unknown
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Expected O, but got Unknown
			if ((Object)(object)currentPanel == (Object)null || !AngrySceneManager.isInCustomLevel || string.IsNullOrEmpty(UpdatedScript) || ((Component)currentPanel.reloadScriptPrompt).gameObject.activeSe