using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
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.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using DoomahLevelLoader.UnityComponents;
using EnvyLevelLoader;
using EnvyLevelLoader.Loaders;
using EnvyLevelLoader.Parsers;
using EnvyLevelLoader.UI;
using EnvyLevelLoader.UnityComponents;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using ScriptableObjects;
using Steamworks;
using Steamworks.Data;
using TMPro;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.AddressableAssets.ResourceLocators;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.Networking;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.ResourceManagement.ResourceLocations;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("Unity.TextMeshPro")]
[assembly: AssemblyCompany("DoomahLevelLoader")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Now called EnvyLevelLoader. This is a custom level loader for ULTRAKILL.")]
[assembly: AssemblyFileVersion("1.8.0.0")]
[assembly: AssemblyInformationalVersion("1.8.0+0d7d1220a1e9f4a4aa3ca1a0029dcec3405f3646")]
[assembly: AssemblyProduct("DoomahLevelLoader")]
[assembly: AssemblyTitle("DoomahLevelLoader")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.8.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public class TriggerZoneBehavior : MonoBehaviour
{
	public float delay = 2f;

	public float activationDelay = 0.1f;

	private bool hasActivated;

	private List<Transform> ignoreList = new List<Transform>();

	private void Start()
	{
		Collider component = ((Component)this).GetComponent<Collider>();
		if ((Object)(object)component != (Object)null)
		{
			component.isTrigger = true;
		}
		DelayedInitialization();
	}

	private void DelayedInitialization()
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		foreach (Transform item in ((Component)this).transform)
		{
			((Component)item).gameObject.SetActive(false);
		}
	}

	private IEnumerator ActivateChildrenWithDelay()
	{
		bool allChildrenActivated;
		do
		{
			allChildrenActivated = true;
			foreach (Transform item in ((Component)this).transform)
			{
				Transform child = item;
				if ((Object)(object)child == (Object)null)
				{
					continue;
				}
				if (!ignoreList.Contains(child) && !((Object)child).name.Contains("Gore Zone") && !((Component)child).gameObject.activeSelf)
				{
					allChildrenActivated = false;
					if (((Object)child).name != null && (((Object)child).name != "NoPass(Clone)" || (Object)(object)((Component)child).GetComponent<AddressableReplacer>() == (Object)null))
					{
						yield return (object)new WaitForSeconds(activationDelay);
					}
					((Component)child).gameObject.SetActive(true);
					EnvyLevelLoader.Debugger.Log("Trigger Activated child:  " + ((Object)child).name);
				}
				else
				{
					ignoreList.Add(child);
				}
			}
		}
		while (!allChildrenActivated);
		hasActivated = true;
	}

	private void OnTriggerEnter(Collider other)
	{
		if (((Object)((Component)other).gameObject).name == "Player" && !hasActivated)
		{
			((MonoBehaviour)this).StartCoroutine(ActivateChildrenWithDelay());
		}
	}
}
public class WaveComponent : MonoBehaviour
{
	public float checkInterval = 1f;

	private float timer;

	private float activationDelay = 0.1f;

	private bool hasActivated;

	private List<Transform> activatedChildren = new List<Transform>();

	private List<Transform> ignoreList = new List<Transform>();

	private void Start()
	{
		DisableAllChildren();
	}

	private void DisableAllChildren()
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		foreach (Transform item in ((Component)this).transform)
		{
			((Component)item).gameObject.SetActive(false);
		}
	}

	private void Update()
	{
		timer += Time.deltaTime;
		if (timer >= checkInterval)
		{
			timer = 0f;
			CheckChildren();
		}
	}

	private IEnumerator ActivateChildrenWithDelay(Transform[] childrenToActivate)
	{
		foreach (Transform val in childrenToActivate)
		{
			if (((Object)val).name != "NoPass(Clone)" || (Object)(object)((Component)val).GetComponent<AddressableReplacer>() == (Object)null)
			{
				((Component)val).gameObject.SetActive(true);
				yield return (object)new WaitForSeconds(activationDelay);
			}
			else
			{
				((Component)val).gameObject.SetActive(true);
			}
		}
	}

	private void CheckChildren()
	{
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Expected O, but got Unknown
		GameObject gameObject = ((Component)((Component)this).transform.parent).gameObject;
		List<GameObject> list = new List<GameObject>();
		foreach (Transform item in ((Component)this).transform)
		{
			Transform val = item;
			list.Add(((Component)val).gameObject);
		}
		List<Transform> list2 = new List<Transform>();
		list2.AddRange(gameObject.GetComponentsInChildren<Transform>());
		list2.Remove(((Component)this).transform);
		List<Transform> list3 = new List<Transform>();
		foreach (Transform item2 in list2)
		{
			EnemyIdentifier component = ((Component)item2).GetComponent<EnemyIdentifier>();
			if ((Object)(object)component != (Object)null && !component.dead)
			{
				list3.Add(item2);
			}
			else if ((Object)(object)component != (Object)null && component.dead && list3.Contains(item2))
			{
				list3.Remove(item2);
			}
		}
		Transform[] array = (Transform[])(object)new Transform[list.Count];
		for (int i = 0; i < list.Count; i++)
		{
			array[i] = list[i].transform;
		}
		if (list3.Count == 0 && !hasActivated)
		{
			hasActivated = true;
			((MonoBehaviour)this).StartCoroutine(ActivateChildrenWithDelay(array));
		}
	}
}
public class UIUtility : MonoBehaviour
{
	private const int loadingSize = 24;

	public void OpenDiscord()
	{
		Application.OpenURL("https://discord.gg/RY8J67neJ9");
	}

	public void OpenLevelsFolder()
	{
		if (!Directory.Exists(EnvyUtility.ConfigPath))
		{
			Directory.CreateDirectory(EnvyUtility.ConfigPath);
		}
		Application.OpenURL("file://" + EnvyUtility.ConfigPath.Replace("\\", "/"));
	}

	private static IEnumerator OpenCreditsLoadingScreen(AsyncOperation asyncOp, LoadingLevelsBlocker info)
	{
		while (!asyncOp.isDone)
		{
			yield return null;
			if ((Object)(object)info != (Object)null)
			{
				((TMP_Text)info.Text).text = "[";
				for (int i = 0; (float)i < 24f * asyncOp.progress; i++)
				{
					TextMeshProUGUI text = info.Text;
					((TMP_Text)text).text = ((TMP_Text)text).text + "*";
				}
				for (int j = 0; (float)j < 24f * (1f - asyncOp.progress); j++)
				{
					TextMeshProUGUI text2 = info.Text;
					((TMP_Text)text2).text = ((TMP_Text)text2).text + "-";
				}
				TextMeshProUGUI text3 = info.Text;
				((TMP_Text)text3).text = ((TMP_Text)text3).text + "]";
			}
		}
		if ((Object)(object)info != (Object)null)
		{
			Object.Destroy((Object)(object)((Component)((Component)info).GetComponentInParent<Transform>()).gameObject);
		}
	}

	public void OpenCredits()
	{
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		if (!Directory.Exists(EnvyUtility.ConfigPath))
		{
			Directory.CreateDirectory(EnvyUtility.ConfigPath);
		}
		if (!File.Exists(EnvyUtility.CreditsLevelPath))
		{
			if ((int)Application.internetReachability == 0)
			{
				return;
			}
			UnityWebRequest wwr = UnityWebRequest.Get("https://file.garden/Z5hylsSV6nNdNxZi/creditsE%26S.doomah");
			GameObject val = Plugin.menu.LoadAsset<GameObject>("LoadingALevelBlocker");
			LoadingLevelsBlocker loadingLevelsBlocker = null;
			if ((Object)(object)val != (Object)null)
			{
				GameObject val2 = Object.Instantiate<GameObject>(Plugin.canvasForEnvy, (Transform)null);
				GameObject obj = Object.Instantiate<GameObject>(val, val2.transform);
				obj.SetActive(true);
				loadingLevelsBlocker = obj.GetComponentInChildren<LoadingLevelsBlocker>();
				((TMP_Text)loadingLevelsBlocker.Title).text = "Downloading credits level";
			}
			UnityWebRequestAsyncOperation val3 = wwr.SendWebRequest();
			((MonoBehaviour)this).StartCoroutine(OpenCreditsLoadingScreen((AsyncOperation)(object)val3, loadingLevelsBlocker));
			((AsyncOperation)val3).completed += delegate
			{
				if (!wwr.isNetworkError && !wwr.isHttpError)
				{
					File.WriteAllBytes(EnvyUtility.CreditsLevelPath, wwr.downloadHandler.data);
					EnvyUtility.RunOnMainThread(delegate
					{
						EnvyLevelLoader.Debugger.Log("Credits level downloaded, now trying to open...");
						OpenCredits();
					}, 0.125f);
				}
			};
			return;
		}
		using ZipArchive archive = ZipFile.OpenRead(EnvyUtility.CreditsLevelPath);
		EnvyLevel envyLevel = null;
		try
		{
			envyLevel = DoomahParser.ParseLevelInfo(archive);
			envyLevel.FilePath = EnvyUtility.CreditsLevelPath;
		}
		catch (Exception)
		{
			return;
		}
		SceneHelper.LoadScene(LevelLoader.GetLevelKey(envyLevel), false);
	}

	public void SetDate(TextMeshProUGUI dateTarget)
	{
		string shortDatePattern = CultureInfo.CurrentCulture.DateTimeFormat.ShortDatePattern;
		string text = DateTime.Now.ToString(shortDatePattern);
		((TMP_Text)dateTarget).text = text.ToUpper();
	}
}
public static class UniGif
{
	public class GifTexture
	{
		public Texture2D m_texture2d;

		public float m_delaySec;

		public GifTexture(Texture2D texture2d, float delaySec)
		{
			m_texture2d = texture2d;
			m_delaySec = delaySec;
		}
	}

	private struct GifData
	{
		public byte m_sig0;

		public byte m_sig1;

		public byte m_sig2;

		public byte m_ver0;

		public byte m_ver1;

		public byte m_ver2;

		public ushort m_logicalScreenWidth;

		public ushort m_logicalScreenHeight;

		public bool m_globalColorTableFlag;

		public int m_colorResolution;

		public bool m_sortFlag;

		public int m_sizeOfGlobalColorTable;

		public byte m_bgColorIndex;

		public byte m_pixelAspectRatio;

		public List<byte[]> m_globalColorTable;

		public List<ImageBlock> m_imageBlockList;

		public List<GraphicControlExtension> m_graphicCtrlExList;

		public List<CommentExtension> m_commentExList;

		public List<PlainTextExtension> m_plainTextExList;

		public ApplicationExtension m_appEx;

		public byte m_trailer;

		public string signature => new string(new char[3]
		{
			(char)m_sig0,
			(char)m_sig1,
			(char)m_sig2
		});

		public string version => new string(new char[3]
		{
			(char)m_ver0,
			(char)m_ver1,
			(char)m_ver2
		});

		public void Dump()
		{
			Debug.Log((object)("GIF Type: " + signature + "-" + version));
			Debug.Log((object)("Image Size: " + m_logicalScreenWidth + "x" + m_logicalScreenHeight));
			Debug.Log((object)("Animation Image Count: " + m_imageBlockList.Count));
			Debug.Log((object)("Animation Loop Count (0 is infinite): " + m_appEx.loopCount));
			if (m_graphicCtrlExList != null && m_graphicCtrlExList.Count > 0)
			{
				StringBuilder stringBuilder = new StringBuilder("Animation Delay Time (1/100sec)");
				for (int i = 0; i < m_graphicCtrlExList.Count; i++)
				{
					stringBuilder.Append(", ");
					stringBuilder.Append(m_graphicCtrlExList[i].m_delayTime);
				}
				Debug.Log((object)stringBuilder.ToString());
			}
			Debug.Log((object)("Application Identifier: " + m_appEx.applicationIdentifier));
			Debug.Log((object)("Application Authentication Code: " + m_appEx.applicationAuthenticationCode));
		}
	}

	private struct ImageBlock
	{
		public struct ImageDataBlock
		{
			public byte m_blockSize;

			public byte[] m_imageData;
		}

		public byte m_imageSeparator;

		public ushort m_imageLeftPosition;

		public ushort m_imageTopPosition;

		public ushort m_imageWidth;

		public ushort m_imageHeight;

		public bool m_localColorTableFlag;

		public bool m_interlaceFlag;

		public bool m_sortFlag;

		public int m_sizeOfLocalColorTable;

		public List<byte[]> m_localColorTable;

		public byte m_lzwMinimumCodeSize;

		public List<ImageDataBlock> m_imageDataList;
	}

	private struct GraphicControlExtension
	{
		public byte m_extensionIntroducer;

		public byte m_graphicControlLabel;

		public byte m_blockSize;

		public ushort m_disposalMethod;

		public bool m_transparentColorFlag;

		public ushort m_delayTime;

		public byte m_transparentColorIndex;

		public byte m_blockTerminator;
	}

	private struct CommentExtension
	{
		public struct CommentDataBlock
		{
			public byte m_blockSize;

			public byte[] m_commentData;
		}

		public byte m_extensionIntroducer;

		public byte m_commentLabel;

		public List<CommentDataBlock> m_commentDataList;
	}

	private struct PlainTextExtension
	{
		public struct PlainTextDataBlock
		{
			public byte m_blockSize;

			public byte[] m_plainTextData;
		}

		public byte m_extensionIntroducer;

		public byte m_plainTextLabel;

		public byte m_blockSize;

		public List<PlainTextDataBlock> m_plainTextDataList;
	}

	private struct ApplicationExtension
	{
		public struct ApplicationDataBlock
		{
			public byte m_blockSize;

			public byte[] m_applicationData;
		}

		public byte m_extensionIntroducer;

		public byte m_extensionLabel;

		public byte m_blockSize;

		public byte m_appId1;

		public byte m_appId2;

		public byte m_appId3;

		public byte m_appId4;

		public byte m_appId5;

		public byte m_appId6;

		public byte m_appId7;

		public byte m_appId8;

		public byte m_appAuthCode1;

		public byte m_appAuthCode2;

		public byte m_appAuthCode3;

		public List<ApplicationDataBlock> m_appDataList;

		public string applicationIdentifier => new string(new char[8]
		{
			(char)m_appId1,
			(char)m_appId2,
			(char)m_appId3,
			(char)m_appId4,
			(char)m_appId5,
			(char)m_appId6,
			(char)m_appId7,
			(char)m_appId8
		});

		public string applicationAuthenticationCode => new string(new char[3]
		{
			(char)m_appAuthCode1,
			(char)m_appAuthCode2,
			(char)m_appAuthCode3
		});

		public int loopCount
		{
			get
			{
				if (m_appDataList == null || m_appDataList.Count < 1 || m_appDataList[0].m_applicationData.Length < 3 || m_appDataList[0].m_applicationData[0] != 1)
				{
					return 0;
				}
				return BitConverter.ToUInt16(m_appDataList[0].m_applicationData, 1);
			}
		}
	}

	public static IEnumerator GetTextureListCoroutine(byte[] bytes, Action<List<GifTexture>, int, int, int> callback, FilterMode filterMode = 1, TextureWrapMode wrapMode = 1, bool debugLog = false)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		int loopCount2 = -1;
		int width2 = 0;
		int height2 = 0;
		GifData gifData = default(GifData);
		if (!SetGifData(bytes, ref gifData, debugLog))
		{
			Debug.LogError((object)"GIF file data set error.");
			callback?.Invoke(null, loopCount2, width2, height2);
			yield break;
		}
		List<GifTexture> gifTexList = null;
		yield return DecodeTextureCoroutine(gifData, delegate(List<GifTexture> result)
		{
			gifTexList = result;
		}, filterMode, wrapMode);
		if (gifTexList == null || gifTexList.Count <= 0)
		{
			Debug.LogError((object)"GIF texture decode error.");
			callback?.Invoke(null, loopCount2, width2, height2);
			yield break;
		}
		loopCount2 = gifData.m_appEx.loopCount;
		width2 = gifData.m_logicalScreenWidth;
		height2 = gifData.m_logicalScreenHeight;
		callback?.Invoke(gifTexList, loopCount2, width2, height2);
	}

	private static IEnumerator DecodeTextureCoroutine(GifData gifData, Action<List<GifTexture>> callback, FilterMode filterMode, TextureWrapMode wrapMode)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		if (gifData.m_imageBlockList == null || gifData.m_imageBlockList.Count < 1)
		{
			yield break;
		}
		List<GifTexture> gifTexList = new List<GifTexture>(gifData.m_imageBlockList.Count);
		List<ushort> disposalMethodList = new List<ushort>(gifData.m_imageBlockList.Count);
		int imgIndex = 0;
		for (int i = 0; i < gifData.m_imageBlockList.Count; i++)
		{
			byte[] decodedData = GetDecodedData(gifData.m_imageBlockList[i]);
			GraphicControlExtension? graphicCtrlEx = GetGraphicCtrlExt(gifData, imgIndex);
			int transparentIndex = GetTransparentIndex(graphicCtrlEx);
			disposalMethodList.Add(GetDisposalMethod(graphicCtrlEx));
			Color32 bgColor;
			List<byte[]> colorTable = GetColorTableAndSetBgColor(gifData, gifData.m_imageBlockList[i], transparentIndex, out bgColor);
			yield return 0;
			bool filledTexture;
			Texture2D tex = CreateTexture2D(gifData, gifTexList, imgIndex, disposalMethodList, bgColor, filterMode, wrapMode, out filledTexture);
			yield return 0;
			int dataIndex = 0;
			for (int num = ((Texture)tex).height - 1; num >= 0; num--)
			{
				SetTexturePixelRow(tex, num, gifData.m_imageBlockList[i], decodedData, ref dataIndex, colorTable, bgColor, transparentIndex, filledTexture);
			}
			tex.Apply();
			yield return 0;
			float delaySec = GetDelaySec(graphicCtrlEx);
			gifTexList.Add(new GifTexture(tex, delaySec));
			imgIndex++;
			bgColor = default(Color32);
		}
		callback?.Invoke(gifTexList);
	}

	private static byte[] GetDecodedData(ImageBlock imgBlock)
	{
		List<byte> list = new List<byte>();
		for (int i = 0; i < imgBlock.m_imageDataList.Count; i++)
		{
			for (int j = 0; j < imgBlock.m_imageDataList[i].m_imageData.Length; j++)
			{
				list.Add(imgBlock.m_imageDataList[i].m_imageData[j]);
			}
		}
		int needDataSize = imgBlock.m_imageHeight * imgBlock.m_imageWidth;
		byte[] array = DecodeGifLZW(list, imgBlock.m_lzwMinimumCodeSize, needDataSize);
		if (imgBlock.m_interlaceFlag)
		{
			array = SortInterlaceGifData(array, imgBlock.m_imageWidth);
		}
		return array;
	}

	private static List<byte[]> GetColorTableAndSetBgColor(GifData gifData, ImageBlock imgBlock, int transparentIndex, out Color32 bgColor)
	{
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//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_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		List<byte[]> list = (imgBlock.m_localColorTableFlag ? imgBlock.m_localColorTable : (gifData.m_globalColorTableFlag ? gifData.m_globalColorTable : null));
		if (list != null)
		{
			byte[] array = list[gifData.m_bgColorIndex];
			bgColor = new Color32(array[0], array[1], array[2], (byte)((transparentIndex != gifData.m_bgColorIndex) ? 255u : 0u));
		}
		else
		{
			bgColor = Color32.op_Implicit(Color.black);
		}
		return list;
	}

	private static GraphicControlExtension? GetGraphicCtrlExt(GifData gifData, int imgBlockIndex)
	{
		if (gifData.m_graphicCtrlExList != null && gifData.m_graphicCtrlExList.Count > imgBlockIndex)
		{
			return gifData.m_graphicCtrlExList[imgBlockIndex];
		}
		return null;
	}

	private static int GetTransparentIndex(GraphicControlExtension? graphicCtrlEx)
	{
		int result = -1;
		if (graphicCtrlEx.HasValue && graphicCtrlEx.Value.m_transparentColorFlag)
		{
			result = graphicCtrlEx.Value.m_transparentColorIndex;
		}
		return result;
	}

	private static float GetDelaySec(GraphicControlExtension? graphicCtrlEx)
	{
		float num = (graphicCtrlEx.HasValue ? ((float)(int)graphicCtrlEx.Value.m_delayTime / 100f) : (1f / 60f));
		if (num <= 0f)
		{
			num = 0.1f;
		}
		return num;
	}

	private static ushort GetDisposalMethod(GraphicControlExtension? graphicCtrlEx)
	{
		if (!graphicCtrlEx.HasValue)
		{
			return 2;
		}
		return graphicCtrlEx.Value.m_disposalMethod;
	}

	private static Texture2D CreateTexture2D(GifData gifData, List<GifTexture> gifTexList, int imgIndex, List<ushort> disposalMethodList, Color32 bgColor, FilterMode filterMode, TextureWrapMode wrapMode, out bool filledTexture)
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Expected O, but got Unknown
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: 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_0070: Unknown result type (might be due to invalid IL or missing references)
		filledTexture = false;
		Texture2D val = new Texture2D((int)gifData.m_logicalScreenWidth, (int)gifData.m_logicalScreenHeight, (TextureFormat)5, false);
		((Texture)val).filterMode = filterMode;
		((Texture)val).wrapMode = wrapMode;
		ushort num = (ushort)((imgIndex > 0) ? disposalMethodList[imgIndex - 1] : 2);
		int num2 = -1;
		switch (num)
		{
		case 1:
			num2 = imgIndex - 1;
			break;
		case 2:
		{
			filledTexture = true;
			Color32[] array = (Color32[])(object)new Color32[((Texture)val).width * ((Texture)val).height];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = bgColor;
			}
			val.SetPixels32(array);
			val.Apply();
			break;
		}
		case 3:
		{
			for (int num3 = imgIndex - 1; num3 >= 0; num3--)
			{
				if (disposalMethodList[num3] == 0 || disposalMethodList[num3] == 1)
				{
					num2 = num3;
					break;
				}
			}
			break;
		}
		}
		if (num2 >= 0)
		{
			filledTexture = true;
			Color32[] pixels = gifTexList[num2].m_texture2d.GetPixels32();
			val.SetPixels32(pixels);
			val.Apply();
		}
		return val;
	}

	private static void SetTexturePixelRow(Texture2D tex, int y, ImageBlock imgBlock, byte[] decodedData, ref int dataIndex, List<byte[]> colorTable, Color32 bgColor, int transparentIndex, bool filledTexture)
	{
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_010d: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: 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_01ab: Unknown result type (might be due to invalid IL or missing references)
		int num = ((Texture)tex).height - 1 - y;
		Color32 val = default(Color32);
		for (int i = 0; i < ((Texture)tex).width; i++)
		{
			int num2 = i;
			if (num < imgBlock.m_imageTopPosition || num >= imgBlock.m_imageTopPosition + imgBlock.m_imageHeight || num2 < imgBlock.m_imageLeftPosition || num2 >= imgBlock.m_imageLeftPosition + imgBlock.m_imageWidth)
			{
				if (!filledTexture)
				{
					tex.SetPixel(i, y, Color32.op_Implicit(bgColor));
				}
				continue;
			}
			if (dataIndex >= decodedData.Length)
			{
				if (!filledTexture)
				{
					tex.SetPixel(i, y, Color32.op_Implicit(bgColor));
					if (dataIndex == decodedData.Length)
					{
						Debug.LogError((object)("dataIndex exceeded the size of decodedData. dataIndex:" + dataIndex + " decodedData.Length:" + decodedData.Length + " y:" + y + " x:" + i));
					}
				}
				dataIndex++;
				continue;
			}
			byte b = decodedData[dataIndex];
			if (colorTable == null || colorTable.Count <= b)
			{
				if (!filledTexture)
				{
					tex.SetPixel(i, y, Color32.op_Implicit(bgColor));
					if (colorTable == null)
					{
						Debug.LogError((object)("colorIndex exceeded the size of colorTable. colorTable is null. colorIndex:" + b));
					}
					else
					{
						Debug.LogError((object)("colorIndex exceeded the size of colorTable. colorTable.Count:" + colorTable.Count + " colorIndex:" + b));
					}
				}
				dataIndex++;
			}
			else
			{
				byte[] array = colorTable[b];
				byte b2 = (byte)((transparentIndex < 0 || transparentIndex != b) ? byte.MaxValue : 0);
				if (!filledTexture || b2 != 0)
				{
					((Color32)(ref val))..ctor(array[0], array[1], array[2], b2);
					tex.SetPixel(i, y, Color32.op_Implicit(val));
				}
				dataIndex++;
			}
		}
	}

	private static byte[] DecodeGifLZW(List<byte> compData, int lzwMinimumCodeSize, int needDataSize)
	{
		int clearCode = 0;
		int finishCode = 0;
		Dictionary<int, string> dictionary = new Dictionary<int, string>();
		int lzwCodeSize = 0;
		InitDictionary(dictionary, lzwMinimumCodeSize, out lzwCodeSize, out clearCode, out finishCode);
		BitArray bitArray = new BitArray(compData.ToArray());
		byte[] array = new byte[needDataSize];
		int num = 0;
		string text = null;
		bool flag = false;
		int num2 = 0;
		while (num2 < bitArray.Length)
		{
			if (flag)
			{
				InitDictionary(dictionary, lzwMinimumCodeSize, out lzwCodeSize, out clearCode, out finishCode);
				flag = false;
			}
			int numeral = bitArray.GetNumeral(num2, lzwCodeSize);
			string text2 = null;
			if (numeral == clearCode)
			{
				flag = true;
				num2 += lzwCodeSize;
				text = null;
				continue;
			}
			if (numeral == finishCode)
			{
				Debug.LogWarning((object)("early stop code. bitDataIndex:" + num2 + " lzwCodeSize:" + lzwCodeSize + " key:" + numeral + " dic.Count:" + dictionary.Count));
				break;
			}
			if (dictionary.ContainsKey(numeral))
			{
				text2 = dictionary[numeral];
			}
			else
			{
				if (numeral < dictionary.Count)
				{
					Debug.LogWarning((object)("It is strange that come here. bitDataIndex:" + num2 + " lzwCodeSize:" + lzwCodeSize + " key:" + numeral + " dic.Count:" + dictionary.Count));
					num2 += lzwCodeSize;
					continue;
				}
				if (text == null)
				{
					Debug.LogWarning((object)("It is strange that come here. bitDataIndex:" + num2 + " lzwCodeSize:" + lzwCodeSize + " key:" + numeral + " dic.Count:" + dictionary.Count));
					num2 += lzwCodeSize;
					continue;
				}
				text2 = text + text[0];
			}
			byte[] bytes = Encoding.Unicode.GetBytes(text2);
			for (int i = 0; i < bytes.Length; i++)
			{
				if (i % 2 == 0)
				{
					array[num] = bytes[i];
					num++;
				}
			}
			if (num >= needDataSize)
			{
				break;
			}
			if (text != null)
			{
				dictionary.Add(dictionary.Count, text + text2[0]);
			}
			text = text2;
			num2 += lzwCodeSize;
			if (lzwCodeSize == 3 && dictionary.Count >= 8)
			{
				lzwCodeSize = 4;
			}
			else if (lzwCodeSize == 4 && dictionary.Count >= 16)
			{
				lzwCodeSize = 5;
			}
			else if (lzwCodeSize == 5 && dictionary.Count >= 32)
			{
				lzwCodeSize = 6;
			}
			else if (lzwCodeSize == 6 && dictionary.Count >= 64)
			{
				lzwCodeSize = 7;
			}
			else if (lzwCodeSize == 7 && dictionary.Count >= 128)
			{
				lzwCodeSize = 8;
			}
			else if (lzwCodeSize == 8 && dictionary.Count >= 256)
			{
				lzwCodeSize = 9;
			}
			else if (lzwCodeSize == 9 && dictionary.Count >= 512)
			{
				lzwCodeSize = 10;
			}
			else if (lzwCodeSize == 10 && dictionary.Count >= 1024)
			{
				lzwCodeSize = 11;
			}
			else if (lzwCodeSize == 11 && dictionary.Count >= 2048)
			{
				lzwCodeSize = 12;
			}
			else if (lzwCodeSize == 12 && dictionary.Count >= 4096 && bitArray.GetNumeral(num2, lzwCodeSize) != clearCode)
			{
				flag = true;
			}
		}
		return array;
	}

	private static void InitDictionary(Dictionary<int, string> dic, int lzwMinimumCodeSize, out int lzwCodeSize, out int clearCode, out int finishCode)
	{
		int num = (clearCode = (int)Math.Pow(2.0, lzwMinimumCodeSize));
		finishCode = clearCode + 1;
		dic.Clear();
		for (int i = 0; i < num + 2; i++)
		{
			dic.Add(i, ((char)i).ToString());
		}
		lzwCodeSize = lzwMinimumCodeSize + 1;
	}

	private static byte[] SortInterlaceGifData(byte[] decodedData, int xNum)
	{
		int num = 0;
		int num2 = 0;
		byte[] array = new byte[decodedData.Length];
		for (int i = 0; i < array.Length; i++)
		{
			if (num % 8 == 0)
			{
				array[i] = decodedData[num2];
				num2++;
			}
			if (i != 0 && i % xNum == 0)
			{
				num++;
			}
		}
		num = 0;
		for (int j = 0; j < array.Length; j++)
		{
			if (num % 8 == 4)
			{
				array[j] = decodedData[num2];
				num2++;
			}
			if (j != 0 && j % xNum == 0)
			{
				num++;
			}
		}
		num = 0;
		for (int k = 0; k < array.Length; k++)
		{
			if (num % 4 == 2)
			{
				array[k] = decodedData[num2];
				num2++;
			}
			if (k != 0 && k % xNum == 0)
			{
				num++;
			}
		}
		num = 0;
		for (int l = 0; l < array.Length; l++)
		{
			if (num % 8 != 0 && num % 8 != 4 && num % 4 != 2)
			{
				array[l] = decodedData[num2];
				num2++;
			}
			if (l != 0 && l % xNum == 0)
			{
				num++;
			}
		}
		return array;
	}

	private static bool SetGifData(byte[] gifBytes, ref GifData gifData, bool debugLog)
	{
		if (debugLog)
		{
			Debug.Log((object)"SetGifData Start.");
		}
		if (gifBytes == null || gifBytes.Length == 0)
		{
			Debug.LogError((object)"bytes is nothing.");
			return false;
		}
		int byteIndex = 0;
		if (!SetGifHeader(gifBytes, ref byteIndex, ref gifData))
		{
			Debug.LogError((object)"GIF header set error.");
			return false;
		}
		if (!SetGifBlock(gifBytes, ref byteIndex, ref gifData))
		{
			Debug.LogError((object)"GIF block set error.");
			return false;
		}
		if (debugLog)
		{
			gifData.Dump();
			Debug.Log((object)"SetGifData Finish.");
		}
		return true;
	}

	private static bool SetGifHeader(byte[] gifBytes, ref int byteIndex, ref GifData gifData)
	{
		if (gifBytes[0] != 71 || gifBytes[1] != 73 || gifBytes[2] != 70)
		{
			Debug.LogError((object)"This is not GIF image.");
			return false;
		}
		gifData.m_sig0 = gifBytes[0];
		gifData.m_sig1 = gifBytes[1];
		gifData.m_sig2 = gifBytes[2];
		if ((gifBytes[3] != 56 || gifBytes[4] != 55 || gifBytes[5] != 97) && (gifBytes[3] != 56 || gifBytes[4] != 57 || gifBytes[5] != 97))
		{
			Debug.LogError((object)"GIF version error.\nSupported only GIF87a or GIF89a.");
			return false;
		}
		gifData.m_ver0 = gifBytes[3];
		gifData.m_ver1 = gifBytes[4];
		gifData.m_ver2 = gifBytes[5];
		gifData.m_logicalScreenWidth = BitConverter.ToUInt16(gifBytes, 6);
		gifData.m_logicalScreenHeight = BitConverter.ToUInt16(gifBytes, 8);
		gifData.m_globalColorTableFlag = (gifBytes[10] & 0x80) == 128;
		switch (gifBytes[10] & 0x70)
		{
		case 112:
			gifData.m_colorResolution = 8;
			break;
		case 96:
			gifData.m_colorResolution = 7;
			break;
		case 80:
			gifData.m_colorResolution = 6;
			break;
		case 64:
			gifData.m_colorResolution = 5;
			break;
		case 48:
			gifData.m_colorResolution = 4;
			break;
		case 32:
			gifData.m_colorResolution = 3;
			break;
		case 16:
			gifData.m_colorResolution = 2;
			break;
		default:
			gifData.m_colorResolution = 1;
			break;
		}
		gifData.m_sortFlag = (gifBytes[10] & 8) == 8;
		int num = (gifBytes[10] & 7) + 1;
		gifData.m_sizeOfGlobalColorTable = (int)Math.Pow(2.0, num);
		gifData.m_bgColorIndex = gifBytes[11];
		gifData.m_pixelAspectRatio = gifBytes[12];
		byteIndex = 13;
		if (gifData.m_globalColorTableFlag)
		{
			gifData.m_globalColorTable = new List<byte[]>();
			for (int i = byteIndex; i < byteIndex + gifData.m_sizeOfGlobalColorTable * 3; i += 3)
			{
				gifData.m_globalColorTable.Add(new byte[3]
				{
					gifBytes[i],
					gifBytes[i + 1],
					gifBytes[i + 2]
				});
			}
			byteIndex += gifData.m_sizeOfGlobalColorTable * 3;
		}
		return true;
	}

	private static bool SetGifBlock(byte[] gifBytes, ref int byteIndex, ref GifData gifData)
	{
		try
		{
			int num = 0;
			while (true)
			{
				int num2 = byteIndex;
				if (gifBytes[num2] == 44)
				{
					SetImageBlock(gifBytes, ref byteIndex, ref gifData);
				}
				else if (gifBytes[num2] == 33)
				{
					switch (gifBytes[num2 + 1])
					{
					case 249:
						SetGraphicControlExtension(gifBytes, ref byteIndex, ref gifData);
						break;
					case 254:
						SetCommentExtension(gifBytes, ref byteIndex, ref gifData);
						break;
					case 1:
						SetPlainTextExtension(gifBytes, ref byteIndex, ref gifData);
						break;
					case byte.MaxValue:
						SetApplicationExtension(gifBytes, ref byteIndex, ref gifData);
						break;
					}
				}
				else if (gifBytes[num2] == 59)
				{
					break;
				}
				if (num == num2)
				{
					Debug.LogError((object)"Infinite loop error.");
					return false;
				}
				num = num2;
			}
			gifData.m_trailer = gifBytes[byteIndex];
			byteIndex++;
		}
		catch (Exception ex)
		{
			Debug.LogError((object)ex.Message);
			return false;
		}
		return true;
	}

	private static void SetImageBlock(byte[] gifBytes, ref int byteIndex, ref GifData gifData)
	{
		ImageBlock item = default(ImageBlock);
		item.m_imageSeparator = gifBytes[byteIndex];
		byteIndex++;
		item.m_imageLeftPosition = BitConverter.ToUInt16(gifBytes, byteIndex);
		byteIndex += 2;
		item.m_imageTopPosition = BitConverter.ToUInt16(gifBytes, byteIndex);
		byteIndex += 2;
		item.m_imageWidth = BitConverter.ToUInt16(gifBytes, byteIndex);
		byteIndex += 2;
		item.m_imageHeight = BitConverter.ToUInt16(gifBytes, byteIndex);
		byteIndex += 2;
		item.m_localColorTableFlag = (gifBytes[byteIndex] & 0x80) == 128;
		item.m_interlaceFlag = (gifBytes[byteIndex] & 0x40) == 64;
		item.m_sortFlag = (gifBytes[byteIndex] & 0x20) == 32;
		int num = (gifBytes[byteIndex] & 7) + 1;
		item.m_sizeOfLocalColorTable = (int)Math.Pow(2.0, num);
		byteIndex++;
		if (item.m_localColorTableFlag)
		{
			item.m_localColorTable = new List<byte[]>();
			for (int i = byteIndex; i < byteIndex + item.m_sizeOfLocalColorTable * 3; i += 3)
			{
				item.m_localColorTable.Add(new byte[3]
				{
					gifBytes[i],
					gifBytes[i + 1],
					gifBytes[i + 2]
				});
			}
			byteIndex += item.m_sizeOfLocalColorTable * 3;
		}
		item.m_lzwMinimumCodeSize = gifBytes[byteIndex];
		byteIndex++;
		while (true)
		{
			byte b = gifBytes[byteIndex];
			byteIndex++;
			if (b == 0)
			{
				break;
			}
			ImageBlock.ImageDataBlock item2 = default(ImageBlock.ImageDataBlock);
			item2.m_blockSize = b;
			item2.m_imageData = new byte[item2.m_blockSize];
			for (int j = 0; j < item2.m_imageData.Length; j++)
			{
				item2.m_imageData[j] = gifBytes[byteIndex];
				byteIndex++;
			}
			if (item.m_imageDataList == null)
			{
				item.m_imageDataList = new List<ImageBlock.ImageDataBlock>();
			}
			item.m_imageDataList.Add(item2);
		}
		if (gifData.m_imageBlockList == null)
		{
			gifData.m_imageBlockList = new List<ImageBlock>();
		}
		gifData.m_imageBlockList.Add(item);
	}

	private static void SetGraphicControlExtension(byte[] gifBytes, ref int byteIndex, ref GifData gifData)
	{
		GraphicControlExtension item = default(GraphicControlExtension);
		item.m_extensionIntroducer = gifBytes[byteIndex];
		byteIndex++;
		item.m_graphicControlLabel = gifBytes[byteIndex];
		byteIndex++;
		item.m_blockSize = gifBytes[byteIndex];
		byteIndex++;
		switch (gifBytes[byteIndex] & 0x1C)
		{
		case 4:
			item.m_disposalMethod = 1;
			break;
		case 8:
			item.m_disposalMethod = 2;
			break;
		case 12:
			item.m_disposalMethod = 3;
			break;
		default:
			item.m_disposalMethod = 0;
			break;
		}
		item.m_transparentColorFlag = (gifBytes[byteIndex] & 1) == 1;
		byteIndex++;
		item.m_delayTime = BitConverter.ToUInt16(gifBytes, byteIndex);
		byteIndex += 2;
		item.m_transparentColorIndex = gifBytes[byteIndex];
		byteIndex++;
		item.m_blockTerminator = gifBytes[byteIndex];
		byteIndex++;
		if (gifData.m_graphicCtrlExList == null)
		{
			gifData.m_graphicCtrlExList = new List<GraphicControlExtension>();
		}
		gifData.m_graphicCtrlExList.Add(item);
	}

	private static void SetCommentExtension(byte[] gifBytes, ref int byteIndex, ref GifData gifData)
	{
		CommentExtension item = default(CommentExtension);
		item.m_extensionIntroducer = gifBytes[byteIndex];
		byteIndex++;
		item.m_commentLabel = gifBytes[byteIndex];
		byteIndex++;
		while (true)
		{
			byte b = gifBytes[byteIndex];
			byteIndex++;
			if (b == 0)
			{
				break;
			}
			CommentExtension.CommentDataBlock item2 = default(CommentExtension.CommentDataBlock);
			item2.m_blockSize = b;
			item2.m_commentData = new byte[item2.m_blockSize];
			for (int i = 0; i < item2.m_commentData.Length; i++)
			{
				item2.m_commentData[i] = gifBytes[byteIndex];
				byteIndex++;
			}
			if (item.m_commentDataList == null)
			{
				item.m_commentDataList = new List<CommentExtension.CommentDataBlock>();
			}
			item.m_commentDataList.Add(item2);
		}
		if (gifData.m_commentExList == null)
		{
			gifData.m_commentExList = new List<CommentExtension>();
		}
		gifData.m_commentExList.Add(item);
	}

	private static void SetPlainTextExtension(byte[] gifBytes, ref int byteIndex, ref GifData gifData)
	{
		PlainTextExtension item = default(PlainTextExtension);
		item.m_extensionIntroducer = gifBytes[byteIndex];
		byteIndex++;
		item.m_plainTextLabel = gifBytes[byteIndex];
		byteIndex++;
		item.m_blockSize = gifBytes[byteIndex];
		byteIndex++;
		byteIndex += 2;
		byteIndex += 2;
		byteIndex += 2;
		byteIndex += 2;
		byteIndex++;
		byteIndex++;
		byteIndex++;
		byteIndex++;
		while (true)
		{
			byte b = gifBytes[byteIndex];
			byteIndex++;
			if (b == 0)
			{
				break;
			}
			PlainTextExtension.PlainTextDataBlock item2 = default(PlainTextExtension.PlainTextDataBlock);
			item2.m_blockSize = b;
			item2.m_plainTextData = new byte[item2.m_blockSize];
			for (int i = 0; i < item2.m_plainTextData.Length; i++)
			{
				item2.m_plainTextData[i] = gifBytes[byteIndex];
				byteIndex++;
			}
			if (item.m_plainTextDataList == null)
			{
				item.m_plainTextDataList = new List<PlainTextExtension.PlainTextDataBlock>();
			}
			item.m_plainTextDataList.Add(item2);
		}
		if (gifData.m_plainTextExList == null)
		{
			gifData.m_plainTextExList = new List<PlainTextExtension>();
		}
		gifData.m_plainTextExList.Add(item);
	}

	private static void SetApplicationExtension(byte[] gifBytes, ref int byteIndex, ref GifData gifData)
	{
		gifData.m_appEx.m_extensionIntroducer = gifBytes[byteIndex];
		byteIndex++;
		gifData.m_appEx.m_extensionLabel = gifBytes[byteIndex];
		byteIndex++;
		gifData.m_appEx.m_blockSize = gifBytes[byteIndex];
		byteIndex++;
		gifData.m_appEx.m_appId1 = gifBytes[byteIndex];
		byteIndex++;
		gifData.m_appEx.m_appId2 = gifBytes[byteIndex];
		byteIndex++;
		gifData.m_appEx.m_appId3 = gifBytes[byteIndex];
		byteIndex++;
		gifData.m_appEx.m_appId4 = gifBytes[byteIndex];
		byteIndex++;
		gifData.m_appEx.m_appId5 = gifBytes[byteIndex];
		byteIndex++;
		gifData.m_appEx.m_appId6 = gifBytes[byteIndex];
		byteIndex++;
		gifData.m_appEx.m_appId7 = gifBytes[byteIndex];
		byteIndex++;
		gifData.m_appEx.m_appId8 = gifBytes[byteIndex];
		byteIndex++;
		gifData.m_appEx.m_appAuthCode1 = gifBytes[byteIndex];
		byteIndex++;
		gifData.m_appEx.m_appAuthCode2 = gifBytes[byteIndex];
		byteIndex++;
		gifData.m_appEx.m_appAuthCode3 = gifBytes[byteIndex];
		byteIndex++;
		while (true)
		{
			byte b = gifBytes[byteIndex];
			byteIndex++;
			if (b != 0)
			{
				ApplicationExtension.ApplicationDataBlock item = default(ApplicationExtension.ApplicationDataBlock);
				item.m_blockSize = b;
				item.m_applicationData = new byte[item.m_blockSize];
				for (int i = 0; i < item.m_applicationData.Length; i++)
				{
					item.m_applicationData[i] = gifBytes[byteIndex];
					byteIndex++;
				}
				if (gifData.m_appEx.m_appDataList == null)
				{
					gifData.m_appEx.m_appDataList = new List<ApplicationExtension.ApplicationDataBlock>();
				}
				gifData.m_appEx.m_appDataList.Add(item);
				continue;
			}
			break;
		}
	}
}
public static class UniGifExtension
{
	public static int GetNumeral(this BitArray array, int startIndex, int bitLength)
	{
		BitArray bitArray = new BitArray(bitLength);
		for (int i = 0; i < bitLength; i++)
		{
			if (array.Length <= startIndex + i)
			{
				bitArray[i] = false;
				continue;
			}
			bool value = array.Get(startIndex + i);
			bitArray[i] = value;
		}
		return bitArray.ToNumeral();
	}

	public static int ToNumeral(this BitArray array)
	{
		if (array == null)
		{
			Debug.LogError((object)"array is nothing.");
			return 0;
		}
		if (array.Length > 32)
		{
			Debug.LogError((object)"must be at most 32 bits long.");
			return 0;
		}
		int[] array2 = new int[1];
		array.CopyTo(array2, 0);
		return array2[0];
	}
}
namespace DoomahLevelLoader
{
	public class SetChallengeStatus : MonoBehaviour
	{
		public bool Active;

		public void Awake()
		{
			if (Active)
			{
				MonoSingleton<ChallengeManager>.Instance.challengeFailed = false;
				MonoSingleton<ChallengeManager>.Instance.challengeDone = true;
			}
			else
			{
				MonoSingleton<ChallengeManager>.Instance.challengeFailed = true;
				MonoSingleton<ChallengeManager>.Instance.challengeDone = false;
			}
		}
	}
}
namespace DoomahLevelLoader.UnityComponents
{
	public class AddressableReplacer : MonoBehaviour
	{
		public string targetAddress;

		public bool oneTime = true;

		public bool moveToParent = true;

		public bool destroyThis = true;

		public bool IsBoss;

		public string BossName;

		public bool IsSanded;

		public bool IsPuppet;

		public bool IsRadient;

		public float RadienceTier;

		public float DamageTier;

		public float SpeedTier;

		public float HealthTier;

		internal EnemyIdentifier eid;

		private bool _activated;

		private void OnEnable()
		{
			EnvyLevelLoader.Debugger.Log("HIIIIIIII SDASD ASD " + ((Object)((Component)this).transform).name + "-> " + targetAddress);
			Activate();
		}

		private void HandleInstantiatedObject(GameObject instantiatedObject)
		{
			eid = instantiatedObject.GetComponent<EnemyIdentifier>();
			if ((Object)(object)eid == (Object)null && instantiatedObject.transform.childCount > 0)
			{
				eid = ((Component)instantiatedObject.transform.GetChild(0)).GetComponent<EnemyIdentifier>();
			}
			if (moveToParent)
			{
				instantiatedObject.transform.SetParent(((Component)this).transform.parent, true);
			}
			PostInstantiate(instantiatedObject);
			if ((Object)(object)eid != (Object)null && IsBoss)
			{
				BossHealthBar val = ((Component)eid).gameObject.AddComponent<BossHealthBar>();
				if (!string.IsNullOrEmpty(BossName))
				{
					val.bossName = BossName;
				}
			}
			if ((Object)(object)eid != (Object)null && IsSanded)
			{
				eid.Sandify(false);
			}
			if ((Object)(object)eid != (Object)null && IsPuppet)
			{
				eid.PuppetSpawn();
				eid.puppet = true;
			}
			if ((Object)(object)eid != (Object)null && IsRadient)
			{
				eid.radianceTier = RadienceTier;
				eid.healthBuffModifier = HealthTier;
				eid.speedBuffModifier = SpeedTier;
				eid.damageBuffModifier = DamageTier;
				eid.BuffAll();
			}
			if (destroyThis)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				((Component)this).gameObject.SetActive(false);
			}
			((Behaviour)this).enabled = false;
		}

		public void Activate()
		{
			//IL_0085: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			EnvyLevelLoader.Debugger.Log("HIIIIIIII SDASD ASD " + ((Object)((Component)this).transform).name + "-> " + targetAddress);
			if (oneTime && _activated)
			{
				return;
			}
			_activated = true;
			if (ResourceLoader.IsGameobjectPreloaded(targetAddress))
			{
				GameObject instantiatedObject = Object.Instantiate<GameObject>(ResourceLoader.LoadGameobjectAtAddress(targetAddress), ((Component)this).transform.position, ((Component)this).transform.rotation, ((Component)this).transform);
				HandleInstantiatedObject(instantiatedObject);
				return;
			}
			AsyncOperationHandle<GameObject> val = Addressables.LoadAssetAsync<GameObject>((object)targetAddress);
			val.Completed += delegate(AsyncOperationHandle<GameObject> a)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Invalid comparison between Unknown and I4
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				GameObject result = a.Result;
				if ((Object)(object)result == (Object)null || (int)a.Status != 1)
				{
					EnvyLevelLoader.Debugger.LogWarn("Tried to load asset at address " + targetAddress + ", but it does not exist");
					((Behaviour)this).enabled = false;
				}
				else
				{
					GameObject instantiatedObject2 = Object.Instantiate<GameObject>(result, ((Component)this).transform.position, ((Component)this).transform.rotation, ((Component)this).transform);
					HandleInstantiatedObject(instantiatedObject2);
				}
			};
		}

		protected virtual void PostInstantiate(GameObject instantiatedObject)
		{
		}
	}
	public class CheckpointReplacer : AddressableReplacer
	{
		protected override void PostInstantiate(GameObject instantiatedObject)
		{
			EnvyLevelLoader.Debugger.Log("Replacing checkpoint");
			CheckPoint componentInParent = ((Component)this).GetComponentInParent<CheckPoint>();
			CheckPoint component = instantiatedObject.GetComponent<CheckPoint>();
			foreach (Collider item in from col in instantiatedObject.GetComponentsInChildren<Collider>()
				where col.isTrigger
				select col)
			{
				Object.Destroy((Object)(object)((Component)item).gameObject);
			}
			Transform[] array = (from i in Enumerable.Range(0, instantiatedObject.transform.childCount)
				select instantiatedObject.transform.GetChild(i)).ToArray();
			foreach (Transform obj in array)
			{
				EnvyLevelLoader.Debugger.Log(((Object)obj).name);
				obj.SetParent(((Component)this).transform.parent, true);
			}
			componentInParent.graphic = component.graphic;
			componentInParent.activateEffect = component.activateEffect;
		}
	}
	public class FinalDoorFixer : MonoBehaviour
	{
		public bool oneTime = true;

		public bool moveToParent = true;

		public BoxCollider OpenTrigger;

		private FinalDoor FD;

		private GameObject instantiatedObject;

		private bool isOpened;

		private bool _activated;

		private void OnEnable()
		{
			Activate();
		}

		public void Activate()
		{
			//IL_0046: 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)
			if (oneTime && _activated)
			{
				return;
			}
			_activated = true;
			GameObject val = ResourceLoader.LoadGameobjectAtAddress("Assets/Prefabs/Levels/Special Rooms/FinalRoom.prefab");
			if ((Object)(object)val == (Object)null)
			{
				EnvyLevelLoader.Debugger.LogWarn("Tried to load asset, but it does not exist");
				((Behaviour)this).enabled = false;
				return;
			}
			instantiatedObject = Object.Instantiate<GameObject>(val, ((Component)this).transform.position, ((Component)this).transform.rotation, ((Component)this).transform);
			if (moveToParent)
			{
				instantiatedObject.transform.SetParent(((Component)this).transform.parent, true);
			}
			EnvyLevelLoader.Debugger.Log("FinalDoorFixer: Final door game object loaded successfully.");
			Transform obj = instantiatedObject.transform.Find("FinalDoor");
			FinalDoor val2 = ((obj != null) ? ((Component)obj).GetComponent<FinalDoor>() : null);
			if ((Object)(object)val2 != (Object)null)
			{
				FD = val2;
				EnvyLevelLoader.Debugger.Log("FinalDoorFixer: Final door component found successfully.");
			}
			else
			{
				EnvyLevelLoader.Debugger.LogWarn("FinalDoorFixer: Final door component not found.");
			}
			PostInstantiate(instantiatedObject);
		}

		protected virtual void PostInstantiate(GameObject instantiatedObject)
		{
		}

		private void OnTriggerEnter(Collider other)
		{
			if (!isOpened && ((Component)other).CompareTag("Player") && (Object)(object)FD != (Object)null)
			{
				FD.Open();
				isOpened = true;
			}
		}
	}
	public class IdolAssigner : MonoBehaviour
	{
		public AddressableReplacer Target;

		public bool oneTime = true;

		public bool moveToParent = true;

		public bool destroyThis = true;

		private bool _activated;

		private void OnEnable()
		{
			Activate();
		}

		public void Activate()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if (oneTime && _activated)
			{
				return;
			}
			_activated = true;
			GameObject val = Addressables.LoadAssetAsync<GameObject>((object)"Assets/Prefabs/Enemies/Idol.prefab").WaitForCompletion();
			if ((Object)(object)val == (Object)null)
			{
				EnvyLevelLoader.Debugger.LogWarn("Tried to load asset, but it does not exist");
				((Behaviour)this).enabled = false;
				return;
			}
			GameObject val2 = Object.Instantiate<GameObject>(val, ((Component)this).transform.position, ((Component)this).transform.rotation, ((Component)this).transform);
			if (moveToParent)
			{
				val2.transform.SetParent(((Component)this).transform.parent, true);
			}
			Idol component = val2.GetComponent<Idol>();
			if ((Object)(object)component != (Object)null && (Object)(object)Target != (Object)null && (Object)(object)Target.eid != (Object)null)
			{
				component.overrideTarget = Target.eid;
			}
			PostInstantiate(val2);
			if (destroyThis)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				((Component)this).gameObject.SetActive(false);
			}
			((Behaviour)this).enabled = false;
		}

		protected virtual void PostInstantiate(GameObject instantiatedObject)
		{
		}
	}
	public class TipOfTheDay : MonoBehaviour
	{
		public string Tip;

		[HideInInspector]
		public GameObject TipBox;

		public async void Awake()
		{
			StockMapInfo instance = StockMapInfo.Instance;
			if ((Object)(object)((MapInfoBase)(instance?)).tipOfTheDay == (Object)null)
			{
				((MapInfoBase)instance).tipOfTheDay = ScriptableObject.CreateInstance<TipOfTheDay>();
				((MapInfoBase)instance).tipOfTheDay.tip = Tip;
			}
			await Task.Delay(150);
			try
			{
				TipBox = EnvyUtility.FindObjectEvenIfDisabled("FirstRoom(Clone)", "Room/Shop/Canvas/TipBox/Panel/TipText");
			}
			catch (Exception)
			{
				EnvyLevelLoader.Debugger.LogError("This level does not have Tip of the Day setup correctly, please make sure you are using the addressable replacer version of the FirstRoom (the one with no children inside of it, do not take that out of context please) Attempting to deploy temporary fix.");
				TipBox = EnvyUtility.FindObjectEvenIfDisabled("FirstRoom", "Room/Shop/Canvas/TipBox/Panel/TipText");
			}
			if ((Object)(object)TipBox == (Object)null)
			{
				ShopZone[] array = Object.FindObjectsOfType<ShopZone>();
				foreach (ShopZone val in array)
				{
					if ((Object)(object)val.tipOfTheDay != (Object)null)
					{
						val.tipOfTheDay.text = Tip;
					}
				}
				EnvyLevelLoader.Debugger.LogWarn("(TOTD) Temporary fix failed.");
			}
			else
			{
				((TMP_Text)TipBox.GetComponent<TextMeshProUGUI>()).text = Tip;
			}
		}
	}
}
namespace EnvyLevelLoader
{
	public class AddPlayerVelocity : MonoBehaviour
	{
		public bool FireOnce = true;

		public bool ManualOnly;

		public Vector3 force = Vector3.zero;

		public void Update()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (!ManualOnly && !FireOnce)
			{
				MonoSingleton<NewMovement>.Instance.rb.AddForce(force);
			}
		}

		public void OnEnable()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (!ManualOnly)
			{
				MonoSingleton<NewMovement>.Instance.rb.AddForce(force);
			}
		}

		public void ManualFire()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			MonoSingleton<NewMovement>.Instance.rb.AddForce(force);
		}
	}
	public class AddToPauseMenu : MonoBehaviour
	{
		public void Start()
		{
			((Component)this).transform.parent = EnvyUtility.FindObjectEvenIfDisabled("Canvas", "PauseMenu").transform;
		}
	}
	[Serializable]
	public enum CompareTypes
	{
		Equal,
		NotEqual,
		Greater,
		Less,
		GreaterOrEqual,
		LessOrEqual
	}
	public class Compare : MonoBehaviour
	{
		[Header("Events")]
		public UnityEvent onSuccess;

		public UnityEvent onFailure;

		[Header("Comparison")]
		public Object a;

		public Object b;

		public string property_a;

		public string property_b;

		public CompareTypes operation;

		public void CompareValues()
		{
			object value = ((object)a).GetType().GetProperty(property_a).GetValue(a);
			object value2 = ((object)b).GetType().GetProperty(property_b).GetValue(b);
			Debug.Log(value);
			Debug.Log(value2);
			Debug.Log((object)(value == value2));
			bool flag = false;
			switch (operation)
			{
			case CompareTypes.Equal:
				flag = value.Equals(value2);
				break;
			case CompareTypes.NotEqual:
				flag = !value.Equals(value2);
				break;
			case CompareTypes.Greater:
				flag = (double)value > (double)value2;
				break;
			case CompareTypes.GreaterOrEqual:
				flag = (double)value >= (double)value2;
				break;
			case CompareTypes.Less:
				flag = (double)value < (double)value2;
				break;
			case CompareTypes.LessOrEqual:
				flag = (double)value <= (double)value2;
				break;
			}
			if (flag)
			{
				onSuccess.Invoke();
			}
			else
			{
				onFailure.Invoke();
			}
		}
	}
	[Serializable]
	public struct MaterialProperty
	{
		public string name;

		public int int_value;

		public float float_value;

		public Color color_value;

		public Vector4 vector4_value;

		public Texture2D texture_value;
	}
	[RequireComponent(typeof(MeshRenderer))]
	public class LocalMaterialProperties : MonoBehaviour
	{
		public List<MaterialProperty> properties;

		public bool auto = true;

		public bool remove_ondisable = true;

		private void Start()
		{
			if (auto)
			{
				SetValues();
			}
		}

		public void SetValues()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			MeshRenderer component = ((Component)this).GetComponent<MeshRenderer>();
			MaterialPropertyBlock val = new MaterialPropertyBlock();
			foreach (MaterialProperty property in properties)
			{
				val.SetInt(property.name, property.int_value);
				val.SetFloat(property.name, property.float_value);
				val.SetColor(property.name, property.color_value);
				val.SetVector(property.name, property.vector4_value);
				val.SetTexture(property.name, (Texture)(object)property.texture_value);
			}
			((Renderer)component).SetPropertyBlock(val);
		}

		public void ResetValues()
		{
			((Renderer)((Component)this).GetComponent<MeshRenderer>()).SetPropertyBlock((MaterialPropertyBlock)null);
		}

		private void OnDisable()
		{
			if (remove_ondisable)
			{
				ResetValues();
			}
		}
	}
	public class LockCamera : MonoBehaviour
	{
		public bool inverse;

		public void Update()
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			if (inverse)
			{
				try
				{
					((Component)this).transform.position = ((Component)Camera.main).transform.position;
					((Component)this).transform.rotation = ((Component)Camera.main).transform.rotation;
					return;
				}
				catch (Exception)
				{
					try
					{
						((Component)this).transform.position = ((Component)Camera.current).transform.position;
						((Component)this).transform.rotation = ((Component)Camera.current).transform.rotation;
						return;
					}
					catch (Exception)
					{
						((Component)this).transform.position = ((Component)MonoSingleton<CameraController>.Instance.cam).transform.position;
						((Component)this).transform.rotation = ((Component)MonoSingleton<CameraController>.Instance.cam).transform.rotation;
						return;
					}
				}
			}
			try
			{
				((Component)Camera.main).transform.position = ((Component)this).transform.position;
				((Component)Camera.main).transform.rotation = ((Component)this).transform.rotation;
			}
			catch (Exception)
			{
				try
				{
					((Component)Camera.current).transform.position = ((Component)this).transform.position;
					((Component)Camera.current).transform.rotation = ((Component)this).transform.rotation;
				}
				catch (Exception)
				{
					((Component)MonoSingleton<CameraController>.Instance.cam).transform.position = ((Component)this).transform.position;
					((Component)MonoSingleton<CameraController>.Instance.cam).transform.rotation = ((Component)this).transform.rotation;
				}
			}
		}
	}
	public class LockPlayer : MonoBehaviour
	{
		public bool includeScale;

		public bool inverse;

		public void Update()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			if (inverse)
			{
				try
				{
					((Component)this).transform.position = ((Component)MonoSingleton<NewMovement>.Instance).transform.position;
					((Component)this).transform.rotation = ((Component)MonoSingleton<NewMovement>.Instance).transform.rotation;
					if (includeScale)
					{
						((Component)this).transform.localScale = ((Component)MonoSingleton<NewMovement>.Instance).transform.localScale;
					}
				}
				catch (Exception)
				{
				}
			}
			try
			{
				((Component)MonoSingleton<NewMovement>.Instance).transform.position = ((Component)this).transform.position;
				((Component)MonoSingleton<NewMovement>.Instance).transform.rotation = ((Component)this).transform.rotation;
				if (includeScale)
				{
					((Component)MonoSingleton<NewMovement>.Instance).transform.localScale = ((Component)this).transform.localScale;
				}
			}
			catch (Exception)
			{
			}
		}
	}
	public class PlayerSpawnpoint : MonoBehaviour
	{
		private Transform plr;

		public UnityEvent onSpawn;

		public bool overrideStats;

		public float walkSpeed = 750f;

		public float jumpPower = 90f;

		public float airAccel = 6000f;

		public float wallJumpPower = 150f;

		public int hp = 100;

		public float antiHP;

		private void Awake()
		{
			//IL_0012: 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_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = ResourceLoader.LoadGameobjectAtAddress("FirstRoom");
			val = Object.Instantiate<GameObject>(val, ((Component)this).transform.position, ((Component)this).transform.rotation, ((Component)this).transform);
			Object.Destroy((Object)(object)((Component)val.transform.Find("Room")).gameObject);
			plr = val.transform.Find("Player");
			if ((Object)(object)plr == (Object)null)
			{
				plr = GameObject.Find("Player").transform;
			}
			((Component)plr).transform.position = ((Component)this).transform.position;
			((Component)plr).transform.rotation = ((Component)this).transform.rotation;
			onSpawn.Invoke();
			if (overrideStats)
			{
				NewMovement component = ((Component)plr).GetComponent<NewMovement>();
				component.walkSpeed = walkSpeed;
				component.jumpPower = jumpPower;
				component.wallJumpPower = wallJumpPower;
				component.hp = hp;
				component.antiHp = antiHP;
			}
		}

		private void Update()
		{
			NewMovement component = ((Component)plr).GetComponent<NewMovement>();
			component.walkSpeed = walkSpeed;
			component.jumpPower = jumpPower;
			component.wallJumpPower = wallJumpPower;
			component.hp = hp;
			component.antiHp = antiHP;
			Object.Destroy((Object)(object)this);
		}
	}
	public class SpiteHellmap : MonoBehaviour
	{
	}
	[HarmonyPatch(typeof(FinalRank))]
	[HarmonyPatch("Appear")]
	public static class FinalRank_Leaderboard_Patch
	{
		private static void Prefix(FinalRank __instance)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			if (!LevelLoader.IsCustomLevel || !LevelLoader.IsOnlineLevel)
			{
				Debugger.Log("Not a custom/online level so not doing leaderboards");
				return;
			}
			Object? obj = Object.FindObjectsOfTypeAll(typeof(LevelEndLeaderboard)).FirstOrDefault();
			LevelEndLeaderboard val = (LevelEndLeaderboard)(object)((obj is LevelEndLeaderboard) ? obj : null);
			if ((Object)(object)val != (Object)null && ((Component)val).gameObject.scene == SceneManager.GetActiveScene())
			{
				((Component)val).gameObject.AddComponent<EnvyLeaderboard>().auto = true;
				Object.Destroy((Object)(object)val);
			}
			else if ((Object)(object)val != (Object)null && ((Component)val).gameObject.scene != SceneManager.GetActiveScene())
			{
				Debugger.LogError("LEVEL END LEADERBOARD FOUND IN RESOURCES OH FUCK THIS IS BAD");
			}
		}
	}
	public class EnvyLeaderboard : MonoBehaviour
	{
		private struct LeaderboardResponse
		{
			public LeaderboardSubmission[] submissive;
		}

		private struct LeaderboardSubmission
		{
			public int run_id;

			public ulong uid;

			public string difficulty;

			public bool is_prank;

			public ulong time;
		}

		public TextMeshProUGUI connectingText;

		public TextMeshProUGUI settingsReminder;

		public TextMeshProUGUI inputReminder;

		public TextMeshProUGUI rankType;

		public GameObject EntryTemplate;

		public bool auto;

		private List<EnvyLeaderboardEntry> envyLeaderboardEntries = new List<EnvyLeaderboardEntry>();

		private bool prank_mode;

		public void Start()
		{
			connectingText = ((Component)((Component)this).transform.Find("Connecting")).GetComponent<TextMeshProUGUI>();
			settingsReminder = ((Component)((Component)this).transform.Find("SettingsReminder")).GetComponent<TextMeshProUGUI>();
			inputReminder = ((Component)((Component)this).transform.Find("Mode Switch Input")).GetComponent<TextMeshProUGUI>();
			rankType = ((Component)((Component)this).transform.Find("Text")).GetComponent<TextMeshProUGUI>();
			((TMP_Text)inputReminder).text = "[Q]";
			((TMP_Text)rankType).text = "ANYTHING IG";
			((TMP_Text)settingsReminder).text = ((TMP_Text)settingsReminder).text + "\n<color=green>SERVERS COOL?</color>";
			((TMP_Text)connectingText).text = "CONNECTING TO ENVY SERVERS...";
			((Component)connectingText).gameObject.SetActive(true);
			EntryTemplate = ((Component)((Component)this).transform.Find("Container/Entry Template")).gameObject;
			if (auto)
			{
				LoadLeaderboardEntries();
			}
		}

		public void LoadLeaderboardEntries()
		{
			envyLeaderboardEntries = new List<EnvyLeaderboardEntry>();
			Task.Run(delegate
			{
				Task<string> leaderboardsJson = EnvyUtility.GetLeaderboardsJson("cool");
				leaderboardsJson.Wait();
				LeaderboardSubmission[] array = JsonConvert.DeserializeObject<LeaderboardSubmission[]>(leaderboardsJson.Result);
				for (int i = 0; i < array.Length; i++)
				{
					LeaderboardSubmission submission = array[i];
					EnvyUtility.RunOnMainThread(delegate
					{
						Debugger.Log($"Got submission from {submission.uid}");
						switch (submission.difficulty)
						{
						default:
							Debugger.LogError("Invalid submission! Difficulty was " + submission.difficulty);
							break;
						case "HARMLESS":
						case "LENIENT":
						case "STANDARD":
						case "VIOLENT":
						case "BRUTAL":
						{
							GameObject obj = Object.Instantiate<GameObject>(EntryTemplate);
							EnvyLeaderboardEntry envyLeaderboardEntry = obj.AddComponent<EnvyLeaderboardEntry>();
							envyLeaderboardEntries.Add(envyLeaderboardEntry);
							envyLeaderboardEntry.Time = submission.time;
							envyLeaderboardEntry.Difficulty = submission.difficulty;
							envyLeaderboardEntry.PRank = submission.is_prank;
							envyLeaderboardEntry.TargetUserID = submission.uid;
							((Component)envyLeaderboardEntry).transform.SetSiblingIndex((int)envyLeaderboardEntry.Time);
							obj.transform.SetParent(EntryTemplate.transform.parent, false);
							obj.SetActive(true);
							break;
						}
						}
					});
				}
				EnvyUtility.RunOnMainThread(delegate
				{
					((Component)connectingText).gameObject.SetActive(false);
					((Component)EntryTemplate.transform.parent).gameObject.SetActive(true);
				});
			});
		}

		public void Update()
		{
			if (Input.GetKeyDown((KeyCode)113))
			{
				prank_mode = !prank_mode;
			}
			foreach (EnvyLeaderboardEntry envyLeaderboardEntry in envyLeaderboardEntries)
			{
				if (envyLeaderboardEntry.PRank != prank_mode)
				{
					((Component)envyLeaderboardEntry).gameObject.SetActive(false);
				}
				else
				{
					((Component)envyLeaderboardEntry).gameObject.SetActive(true);
				}
			}
			if (prank_mode)
			{
				((TMP_Text)rankType).text = "P RANK";
			}
			else
			{
				((TMP_Text)rankType).text = "ANY RANK";
			}
		}
	}
	public static class Debugger
	{
		public static void Log(object message)
		{
		}

		public static void LogWarn(object message)
		{
		}

		public static void LogError(object message)
		{
		}

		public static void LogLine(string uuid_for_session, string note = "")
		{
		}
	}
	public static class EnvyUtility
	{
		private class MainThreadDispatcher : MonoBehaviour
		{
			private static MainThreadDispatcher Instance;

			private static readonly ConcurrentQueue<Action> _actions = new ConcurrentQueue<Action>();

			public static void RunOnMainThread(Action action)
			{
				_actions.Enqueue(action);
			}

			private void Awake()
			{
				if ((Object)(object)Instance == (Object)null)
				{
					Instance = this;
				}
				if ((Object)(object)Instance != (Object)(object)this)
				{
					Object.Destroy((Object)(object)this);
				}
				else
				{
					Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
				}
			}

			private void Update()
			{
				Action result;
				while (_actions.TryDequeue(out result))
				{
					result?.Invoke();
				}
			}
		}

		private static SynchronizationContext mainThreadContext;

		public static bool IsMainThread
		{
			get
			{
				return SynchronizationContext.Current == mainThreadContext;
			}
			set
			{
			}
		}

		public static string ConfigPath
		{
			get
			{
				return Path.Combine(Paths.ConfigPath + Path.DirectorySeparatorChar + "EnvyLevels");
			}
			private set
			{
			}
		}

		public static string PluginPath
		{
			get
			{
				return Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			}
			private set
			{
			}
		}

		public static string CreditsLevelPath
		{
			get
			{
				return Path.Combine(ConfigPath, "creditslevel.donotdelete.doomah");
			}
			private set
			{
			}
		}

		public static string SaveFolderPath
		{
			get
			{
				return Path.Combine(GameProgressSaver.SavePath, "Envy");
			}
			private set
			{
			}
		}

		public static string UnknownScene
		{
			get
			{
				return "__envy_unknown_scene__";
			}
			private set
			{
			}
		}

		public static string EnvyScenePrefix
		{
			get
			{
				return "__envylevel__";
			}
			private set
			{
			}
		}

		public static string EnvyLeaderboardsServer
		{
			get
			{
				return "not implemented";
			}
			set
			{
			}
		}

		public static void CaptureMainThread()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (mainThreadContext == null)
			{
				mainThreadContext = SynchronizationContext.Current;
				new GameObject("Envy MainThreadDispatcher").AddComponent<MainThreadDispatcher>();
			}
		}

		public static void RunOnMainThread(Action action)
		{
			MainThreadDispatcher.RunOnMainThread(action);
		}

		public static void RunOnMainThread(Action action, float delay)
		{
			Task.Run(async delegate
			{
				await Task.Delay((int)(delay * 1000f));
				MainThreadDispatcher.RunOnMainThread(action);
			});
		}

		public static byte[] ReadFully(Stream input)
		{
			using MemoryStream memoryStream = new MemoryStream();
			input.CopyTo(memoryStream);
			return memoryStream.ToArray();
		}

		public static GameObject FindObjectEvenIfDisabled(string rootName, string path = "")
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			GameObject val = (from go in ((Scene)(ref activeScene)).GetRootGameObjects()
				where ((Object)go).name == rootName
				select go).FirstOrDefault();
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			if (string.IsNullOrEmpty(path))
			{
				return val;
			}
			string[] array = path.Split('/');
			foreach (string name in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				val = FindChildEvenIfDisabled(val.transform, name);
			}
			return val;
		}

		private static GameObject FindChildEvenIfDisabled(Transform parent, string name)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			foreach (Transform item in parent)
			{
				Transform val = item;
				if (((Object)val).name == name)
				{
					return ((Component)val).gameObject;
				}
			}
			return null;
		}

		public static async Task<string> GetUserJson(ulong user)
		{
			Debugger.Log("GetUserJson");
			string text = EnvyLeaderboardsServer + "getSteamProfiles/steamids=" + user;
			UnityWebRequest request = UnityWebRequest.Get(text);
			try
			{
				Debugger.Log("SendWebRequest");
				UnityWebRequestAsyncOperation operation = request.SendWebRequest();
				while (!((AsyncOperation)operation).isDone)
				{
					await Task.Yield();
				}
				Debugger.Log("return request.downloadHandler.text");
				return request.downloadHandler.text;
			}
			finally
			{
				((IDisposable)request)?.Dispose();
			}
		}

		public static async Task<string> GetLeaderboardsJson(string levelName)
		{
			Debugger.Log("GetLeaderboardsJson");
			string text = EnvyLeaderboardsServer + "getLeaderboard/level=" + levelName;
			UnityWebRequest request = UnityWebRequest.Get(text);
			try
			{
				Debugger.Log("SendWebRequest");
				UnityWebRequestAsyncOperation operation = request.SendWebRequest();
				while (!((AsyncOperation)operation).isDone)
				{
					await Task.Yield();
				}
				Debugger.Log("return request.downloadHandler.text");
				return request.downloadHandler.text;
			}
			finally
			{
				((IDisposable)request)?.Dispose();
			}
		}

		public static async Task<Texture2D> GetTextureFromUrl(string url)
		{
			UnityWebRequest request = UnityWebRequestTexture.GetTexture(url);
			try
			{
				UnityWebRequestAsyncOperation operation = request.SendWebRequest();
				while (!((AsyncOperation)operation).isDone)
				{
					await Task.Yield();
				}
				return DownloadHandlerTexture.GetContent(request);
			}
			finally
			{
				((IDisposable)request)?.Dispose();
			}
		}
	}
	[HarmonyPatch(typeof(GameProgressSaver))]
	[HarmonyPatch("LevelProgressPath")]
	public static class LevelProgress_Patch
	{
		public static bool Prefix(ref string __result, int lvl)
		{
			Debugger.Log($"Getting level path for {lvl} and is playing custom is {LevelLoader.IsCustomLevel} and level path as {LevelLoader.CurrentLevel}");
			if (LevelLoader.IsCustomLevel && lvl == -1)
			{
				if (!Directory.Exists(EnvyUtility.SaveFolderPath))
				{
					Directory.CreateDirectory(EnvyUtility.SaveFolderPath);
				}
				__result = Path.Combine(EnvyUtility.SaveFolderPath, "lvl" + Path.GetFileName(LevelLoader.CurrentLevel.FilePath) + "progress.bepis");
				Debugger.Log("returning " + __result);
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch]
	public static class GetRank_Patch
	{
		[HarmonyTargetMethod]
		public static MethodBase TargetMethod()
		{
			return AccessTools.Method(typeof(GameProgressSaver), "GetRankData", new Type[3]
			{
				typeof(string).MakeByRefType(),
				typeof(int),
				typeof(bool)
			}, (Type[])null);
		}

		[HarmonyPrefix]
		public static bool Prefix(ref RankData __result, out string path, int lvl = -1, bool returnNull = false)
		{
			if (!LevelLoader.IsCustomLevel || lvl != -1)
			{
				GameProgressSaver.PrepareFs();
				path = GameProgressSaver.LevelProgressPath(lvl);
				return true;
			}
			path = "";
			__result = GetRank(out path, out var didChange, lvl, returnNull);
			if (didChange)
			{
				return false;
			}
			return true;
		}

		public static RankData GetRank(out string path, out bool didChange, int lvl = -1, bool returnNull = false)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			Debugger.Log($"Getting level rank for {lvl} and is playing custom is {LevelLoader.IsCustomLevel} and level path as {LevelLoader.CurrentLevel}");
			didChange = false;
			path = "";
			if (LevelLoader.IsCustomLevel && lvl == -1)
			{
				GameProgressSaver.PrepareFs();
				path = GameProgressSaver.LevelProgressPath(lvl);
				object obj = GameProgressSaver.ReadFile(path);
				RankData val;
				if ((val = (RankData)((obj is RankData) ? obj : null)) == null)
				{
					val = (returnNull ? ((RankData)null) : new RankData(MonoSingleton<StatsManager>.Instance));
				}
				Debugger.Log(val);
				didChange = true;
				return val;
			}
			if (!returnNull)
			{
				return new RankData(MonoSingleton<StatsManager>.Instance);
			}
			return null;
		}
	}
	[HarmonyPatch(typeof(StatsManager))]
	[HarmonyPatch("Awake")]
	public static class StatsManager_Awake_Patch
	{
		[HarmonyPostfix]
		private static void Postfix(StatsManager __instance)
		{
			if (LevelLoader.IsCustomLevel)
			{
				Debugger.Log($"Replacing {__instance.levelNumber} to -1");
				__instance.levelNumber = -1;
			}
		}
	}
	[HarmonyPatch(typeof(ItemPlaceZone))]
	[HarmonyPatch("Awake")]
	public static class ItemPlaceZone_Patch
	{
		[HarmonyPrefix]
		private static void Prefix(ItemPlaceZone __instance)
		{
			if (LevelLoader.IsCustomLevel && __instance.altarElements == null)
			{
				__instance.altarElements = Array.Empty<InstantiateObject>();
			}
		}
	}
	[HarmonyPatch(typeof(StatueFake))]
	[HarmonyPatch("Done")]
	public static class StatueFake_Patch
	{
		[HarmonyPrefix]
		private static void Prefix(StatueFake __instance)
		{
			if (!LevelLoader.IsCustomLevel)
			{
				return;
			}
			Transform parent = ((Component)__instance).transform.parent;
			if (parent != null)
			{
				Transform obj = parent.Find("StatueEnemy");
				if (obj != null)
				{
					((Component)obj).gameObject.SetActive(true);
				}
			}
			Transform parent2 = ((Component)__instance).transform.parent;
			if (parent2 != null)
			{
				Transform obj2 = parent2.Find("StatueBoss");
				if (obj2 != null)
				{
					((Component)obj2).gameObject.SetActive(true);
				}
			}
			Transform parent3 = ((Component)__instance).transform.parent;
			if (parent3 != null)
			{
				StatueBoss componentInChildren = ((Component)parent3).GetComponentInChildren<StatueBoss>();
				if (componentInChildren != null)
				{
					((Component)componentInChildren).gameObject.SetActive(true);
				}
			}
			((Component)__instance).gameObject.SetActive(false);
		}
	}
	[HarmonyPatch(typeof(FinalRank))]
	[HarmonyPatch("LevelChange")]
	public static class FinalRank_Patch
	{
		private static void Prefix(FinalRank __instance)
		{
			if (LevelLoader.IsCustomLevel && string.IsNullOrWhiteSpace(__instance.targetLevelName))
			{
				__instance.targetLevelName = "Main Menu";
			}
		}
	}
	[HarmonyPatch(typeof(FinalRank))]
	[HarmonyPatch("Start")]
	public static class FinalRank_Patch_MN
	{
		private static void Prefix(FinalRank __instance)
		{
			if (LevelLoader.IsCustomLevel)
			{
				LevelNameFinder val = Object.FindObjectOfType<LevelNameFinder>();
				Debugger.Log(string.Format("{0} and {1}", val?.txt2, ((MapInfoBase)(StockMapInfo.Instance?)).levelName ?? "UNABLE TO FIND MISSION NAME"));
				val.txt2.text = ((MapInfoBase)(StockMapInfo.Instance?)).levelName ?? "UNABLE TO FIND MISSION NAME";
				((Behaviour)val).enabled = false;
				Object.DestroyImmediate((Object)(object)val);
			}
		}
	}
	[HarmonyPatch(typeof(AdvancedOptions))]
	[HarmonyPatch("ResetCyberGrind")]
	public static class AdvOpt_Patch
	{
		private static bool Prefix(AdvancedOptions __instance)
		{
			return !LevelLoader.IsCustomLevel;
		}
	}
	[HarmonyPatch(typeof(ShopZone))]
	[HarmonyPatch("Start")]
	public static class ShopReplacer_Patch
	{
		private static bool Prefix(ShopZone __instance)
		{
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			if (!LevelLoader.IsCustomLevel)
			{
				return true;
			}
			if ((Object)(object)__instance.tipOfTheDay == (Object)null && ((Object)((Component)__instance).gameObject).name.ToLower() != "shop")
			{
				return true;
			}
			if ((Object)(object)((Component)__instance).gameObject.transform.Find("Jingle Music") == (Object)null)
			{
				Debugger.Log("Found OLD shop (" + ((Object)((Component)__instance).gameObject).name + ") ! Replacing it...");
				string text = "The tip of the day could not be loaded.";
				try
				{
					Transform transform = ((Component)__instance).transform;
					Transform obj = ((transform != null) ? transform.Find("Canvas") : null);
					Transform val = ((obj != null) ? obj.Find("Border") : null);
					object obj2;
					if (val == null)
					{
						obj2 = null;
					}
					else
					{
						Transform obj3 = val.Find("TipBox");
						if (obj3 == null)
						{
							obj2 = null;
						}
						else
						{
							Transform obj4 = obj3.Find("Panel");
							if (obj4 == null)
							{
								obj2 = null;
							}
							else
							{
								Transform obj5 = obj4.Find("Text");
								obj2 = ((obj5 != null) ? ((Component)obj5).GetComponentInChildren<TextMeshProUGUI>() : null);
							}
						}
					}
					TextMeshProUGUI val2 = (TextMeshProUGUI)obj2;
					object obj6;
					if (obj == null)
					{
						obj6 = null;
					}
					else
					{
						Transform obj7 = obj.Find("TipBox");
						if (obj7 == null)
						{
							obj6 = null;
						}
						else
						{
							Transform obj8 = obj7.Find("Panel");
							if (obj8 == null)
							{
								obj6 = null;
							}
							else
							{
								Transform obj9 = obj8.Find("Text");
								obj6 = ((obj9 != null) ? ((Component)obj9).GetComponentInChildren<TextMeshProUGUI>() : null);
							}
						}
					}
					TextMeshProUGUI val3 = (TextMeshProUGUI)obj6;
					object obj10;
					if (val == null)
					{
						obj10 = null;
					}
					else
					{
						Transform obj11 = val.Find("TipBox");
						if (obj11 == null)
						{
							obj10 = null;
						}
						else
						{
							Transform obj12 = obj11.Find("Panel");
							if (obj12 == null)
							{
								obj10 = null;
							}
							else
							{
								Transform obj13 = obj12.Find("TipText");
								obj10 = ((obj13 != null) ? ((Component)obj13).GetComponentInChildren<TextMeshProUGUI>() : null);
							}
						}
					}
					TextMeshProUGUI val4 = (TextMeshProUGUI)obj10;
					object obj14;
					if (obj == null)
					{
						obj14 = null;
					}
					else
					{
						Transform obj15 = obj.Find("TipBox");
						if (obj15 == null)
						{
							obj14 = null;
						}
						else
						{
							Transform obj16 = obj15.Find("Panel");
							if (obj16 == null)
							{
								obj14 = null;
							}
							else
							{
								Transform obj17 = obj16.Find("TipText");
								obj14 = ((obj17 != null) ? ((Component)obj17).GetComponentInChildren<TextMeshProUGUI>() : null);
							}
						}
					}
					TextMeshProUGUI val5 = (TextMeshProUGUI)obj14;
					if ((Object)(object)__instance.tipOfTheDay != (Object)null)
					{
						text = __instance.tipOfTheDay.text;
					}
					if ((Object)(object)val2 != (Object)null)
					{
						text = ((TMP_Text)val2).text;
					}
					if ((Object)(object)val3 != (Object)null)
					{
						text = ((TMP_Text)val3).text;
					}
					if ((Object)(object)val4 != (Object)null)
					{
						text = ((TMP_Text)val4).text;
					}
					if ((Object)(object)val5 != (Object)null)
					{
						text = ((TMP_Text)val5).text;
					}
				}
				catch (Exception)
				{
				}
				StockMapInfo instance = StockMapInfo.Instance;
				if ((Object)(object)((MapInfoBase)(instance?)).tipOfTheDay == (Object)null)
				{
					((MapInfoBase)instance).tipOfTheDay = ScriptableObject.CreateInstance<TipOfTheDay>();
					((MapInfoBase)instance).tipOfTheDay.tip = text;
				}
				GameObject val6 = ResourceLoader.LoadGameobjectAtAddress("Assets/Prefabs/Levels/Shop.prefab");
				if ((Object)(object)val6 != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)__instance).gameObject);
					Object.Instantiate<GameObject>(val6, ((Component)__instance).transform.position, ((Component)__instance).transform.rotation, ((Component)__instance).transform.parent).GetComponentInChildren<ShopZone>().tipOfTheDay.text = text;
					return false;
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(PlayerActivator))]
	[HarmonyPatch("Activate")]
	public static class PlayerActivator_Patch
	{
		private static bool Prefix(PlayerActivator __instance)
		{
			if (!LevelLoader.IsCustomLevel)
			{
				return true;
			}
			if (((Object)((Component)__instance).gameObject.transform.parent).name.ToLower() == "firstroom player only")
			{
				__instance.activated = true;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(MusicManager))]
	[HarmonyPatch("OnEnable")]
	public static class MusicMan_Patch
	{
		private static void Postfix(MusicManager __instance)
		{
			((MonoBehaviour)__instance).StartCoroutine(waitForCustom(__instance));
		}

		private static IEnumerator waitForCustom(MusicManager __instance)
		{
			yield return (object)new WaitForSeconds(0.25f);
			if (!LevelLoader.IsCustomLevel)
			{
				yield break;
			}
			try
			{
				__instance.cleanTheme.outputAudioMixerGroup = MonoSingleton<AudioMixerController>.Instance.musicGroup;
			}
			catch
			{
			}
			try
			{
				__instance.battleTheme.outputAudioMixerGroup = MonoSingleton<AudioMixerController>.Instance.musicGroup;
			}
			catch
			{
			}
			try
			{
				__instance.bossTheme.outputAudioMixerGroup = MonoSingleton<AudioMixerController>.Instance.musicGroup;
			}
			catch
			{
			}
			try
			{
				__instance.targetTheme.outputAudioMixerGroup = MonoSingleton<AudioMixerController>.Instance.musicGroup;
			}
			catch
			{
			}
			Scene activeScene = SceneManager.GetActiveScene();
			AudioSource[] array = (AudioSource[])(object)Resources.FindObjectsOfTypeAll(typeof(AudioSource));
			foreach (AudioSource val in array)
			{
				if (((Component)val).gameObject.scene != activeScene)
				{
					continue;
				}
				Scene scene = ((Component)val).gameObject.scene;
				if (((Scene)(ref scene)).name != ((Scene)(ref activeScene)).name)
				{
					continue;
				}
				try
				{
					if (((Object)val.outputAudioMixerGroup.audioMixer).name == "MusicAudio" || ((Object)val.outputAudioMixerGroup.audioMixer).name == "MusicAudio_0")
					{
						val.outputAudioMixerGroup = MonoSingleton<AudioMixerController>.Instance.musicGroup;
					}
				}
				catch
				{
				}
			}
		}
	}
	[HarmonyPatch(typeof(MusicManager))]
	[HarmonyPatch("Update")]
	public static class MusicMan_Patch2
	{
		private static bool Prefix(MusicManager __instance)
		{
			if ((Object)(object)__instance.targetTheme == (Object)null)
			{
				__instance.targetTheme = __instance.cleanTheme;
				if ((Object)(object)__instance.targetTheme == (Object)null)
				{
					__instance.targetTheme = __instance.battleTheme;
				}
				if ((Object)(object)__instance.targetTheme == (Object)null)
				{
					__instance.targetTheme = __instance.bossTheme;
				}
				if ((Object)(object)__instance.targetTheme == (Object)null)
				{
					return false;
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Material))]
	internal static class MaterialPatches
	{
		public static void Process(Material material)
		{
			if (!((Object)(object)material.shader == (Object)null) && ShaderManager.shaderDictionary.TryGetValue(((Object)material.shader).name, out var value) && !((Object)(object)material.shader == (Object)(object)value))
			{
				material.shader = value;
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		public static void CtorPatch1(Material __instance)
		{
			Process(__instance);
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		public static void CtorPatch2(Material __instance)
		{
			Process(__instance);
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		public static void CtorPatch3(Material __instance)
		{
			Process(__instance);
		}
	}
	[HarmonyPatch]
	public static class AddressablesScene_Patch
	{
		[HarmonyPatch(typeof(Addressables), "LoadSceneAsync", new Type[]
		{
			typeof(object),
			typeof(LoadSceneMode),
			typeof(bool),
			typeof(int)
		})]
		[HarmonyPrefix]
		public static bool Prefix_Overload1(object key, LoadSceneMode loadMode, bool activateOnLoad, int priority)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return PrefixCommon(key, new LoadSceneParameters(loadMode), activateOnLoad, priority);
		}

		[HarmonyPatch(typeof(Addressables), "LoadSceneAsync", new Type[]
		{
			typeof(object),
			typeof(LoadSceneParameters),
			typeof(bool),
			typeof(int)
		})]
		[HarmonyPrefix]
		public static bool Prefix_Overload2(object key, LoadSceneParameters loadSceneParameters, bool activateOnLoad, int priority)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return PrefixCommon(key, loadSceneParameters, activateOnLoad, priority);
		}

		public static bool PrefixCommon(object key, LoadSceneParameters loadSceneParameters, bool activateOnLoad, int priority)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			Debugger.Log($"Harmony patch: Loading scene with key: {key}, loadMode: {((LoadSceneParameters)(ref loadSceneParameters)).loadSceneMode}");
			string text = key.ToString();
			if (!text.StartsWith(EnvyUtility.EnvyScenePrefix))
			{
				return true;
			}
			try
			{
				string text2 = text.Substring(EnvyUtility.EnvyScenePrefix.Length);
				Debugger.Log("Got envy level query as " + text2);
				string[] array = text2.Split('~');
				string text3 = array[0];
				string targetScene = array[1];
				if (text3 == "?")
				{
					LevelLoader.LoadLevel(LevelLoader.CurrentLevel, targetScene);
					return false;
				}
				EnvyLevel envyLevel = null;
				foreach (EnvyLevel loadedLevel in LevelsList.LoadedLevels)
				{
					if (Path.GetFileName(loadedLevel.FilePath) == Path.GetFileName(text3))
					{
						envyLevel = loadedLevel;
					}
				}
				if (envyLevel == null)
				{
					envyLevel = LevelLoader.GetLevelFromFile(Path.Combine(EnvyUtility.ConfigPath, text3));
				}
				if (envyLevel != null)
				{
					LevelLoader.LoadLevel(envyLevel, targetScene);
				}
			}
			catch (Exception ex)
			{
				Debugger.LogError($"Failed to load level {key} because {ex.Message}");
			}
			return false;
		}
	}
	public static class ShaderManager
	{
		public static Dictionary<string, Shader> shaderDictionary = new Dictionary<string, Shader>();

		private static HashSet<Material> modifiedMaterials = new HashSet<Material>();

		public static string ModPath()
		{
			return Assembly.GetExecutingAssembly().Location.Substring(0, Assembly.GetExecutingAssembly().Location.LastIndexOf(Path.DirectorySeparatorChar));
		}

		public static IEnumerator ApplyShadersAsync(GameObject[] allGameObjects)
		{
			if (allGameObjects == null)
			{
				yield break;
			}
			foreach (GameObject val in allGameObjects)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Renderer[] componentsInChildren = val.GetComponentsInChildren<Renderer>(true);
				foreach (Renderer val2 in componentsInChildren)
				{
					if ((Object)(object)val2 == (Object)null)
					{
						continue;
					}
					Material[] array = (Material[])(object)new Material[val2.sharedMaterials.Length];
					for (int k = 0; k < val2.sharedMaterials.Length; k++)
					{
						Material val3 = (array[k] = val2.sharedMaterials[k]);
						if (!((Object)(object)val3 == (Object)null) && !((Object)(object)val3.shader == (Object)null) && !modifiedMaterials.Contains(val3) && !(((Object)val3.shader).name == "ULTRAKILL/PostProcessV2") && shaderDictionary.TryGetValue(((Object)val3.shader).name, out var value))
						{
							Debugger.Log($"Swapping shader {array[k].shader} with {((Object)value).name}");
							array[k].shader = value;
							modifiedMaterials.Add(val3);
						}
					}
					val2.materials = array;
				}
				yield return null;
			}
		}

		public static IEnumerator ApplyShadersAsyncContinuously()
		{
			new GameObject("ShaderManagerObject").AddComponent<ShaderManagerRunner>().StartApplyingShaders();
			yield return null;
		}

		public static void CreateShaderDictionary(bool force = false)
		{
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			if (shaderDictionary.Count > 1 && !force)
			{
				Debugger.LogWarn("A shader dictionary is already created.");
				return;
			}
			Debugger.Log("Building shader dictionary...");
			shaderDictionary = new Dictionary<string, Shader>();
			List<string> list = new List<string>();
			IList<IResourceLocation> list2 = default(IList<IResourceLocation>);
			foreach (IResourceLocator resourceLocator in Addressables.ResourceLocators)
			{
				foreach (object key in resourceLocator.Keys)
				{
					if (!resourceLocator.Locate(key, typeof(object), ref list2))
					{
						continue;
					}
					foreach (IResourceLocation item in list2)
					{
						if (!(Path.GetExtension(item.PrimaryKey) != ".shader"))
						{
							Debugger.Log("Loading " + item.PrimaryKey + " as shader");
							list.Add(item.PrimaryKey);
						}
					}
				}
			}
			Debugger.Log("Loading shaders please wait...");
			((MonoBehaviour)new GameObject("tmp shader loader").AddComponent<LevelLoader.Dummy>()).StartCoroutine(LoadShadersAsync(list));
		}

		private static IEnumerator LoadShadersAsync(List<string> allShaders)
		{
			foreach (string shaderKey in allShaders)
			{
				AsyncOperationHandle<Shader> req = Addressables.LoadAssetAsync<Shader>((object)shaderKey);
				yield return req;
				if ((int)req.Status != 1)
				{
					Debugger.LogError("Failed to load shader: " + shaderKey);
					continue;
				}
				Shader result = req.Result;
				shaderDictionary[((Object)result).name] = result;
				Debugger.Log("Got shader " + ((Object)result).name);
			}
			Debugger.Log("Loaded shaders!");
		}
	}
	public class ShaderManagerRunner : MonoBehaviour
	{
		public void StartApplyingShaders()
		{
			((MonoBehaviour)this).StartCoroutine(ApplyShadersContinuously());
		}

		private IEnumerator ApplyShadersContinuously()
		{
			Scene activeScene = SceneManager.GetActiveScene();
			yield return ShaderManager.ApplyShadersAsync(((Scene)(ref activeScene)).GetRootGameObjects());
			while (true)
			{
				yield return (object)new WaitForFixedUpdate();
				activeScene = SceneManager.GetActiveScene();
				yield return ShaderManager.ApplyShadersAsync(((Scene)(ref activeScene)).GetRootGameObjects());
			}
		}

		private GameObject[] GetInspectorReferencedObjects()
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			List<GameObject> list = new List<GameObject>();
			Object[] array = Object.FindObjectsOfTypeAll(typeof(MonoBehaviour));
			foreach (Object val in array)
			{
				FieldInfo[] fields = ((object)val).GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (FieldInfo fieldInfo in fields)
				{
					if (fieldInfo.IsPublic || fieldInfo.GetCustomAttributes(typeof(SerializeField), inherit: false).Length != 0)
					{
						object value = fieldInfo.GetValue(val);
						if (value != null && value is GameObject)
						{
							list.Add((GameObject)value);
						}
					}
				}
			}
			return list.ToArray();
		}
	}
	public static class Merger
	{
		private static string PartsPath => EnvyUtility.ConfigPath;

		public static async Task MergeFiles()
		{
			string[] files = Directory.GetFiles(PartsPath, "*.part*");
			Regex filePattern = new Regex("^(?<basename>.+)\\.part(?<part>\\d+)$");
			Dictionary<string, List<string>> dictionary = new Dictionary<string, List<string>>();
			string[] array = files;
			foreach (string text in array)
			{
				Match match = filePattern.Match(Path.GetFileName(text));
				if (match.Success)
				{
					string value = match.Groups["basename"].Value;
					if (!dictionary.ContainsKey(value))
					{
						dictionary[value] = new List<string>();
					}
					dictionary[value].Add(text);
				}
			}
			foreach (KeyValuePair<string, List<string>> item in dictionary)
			{
				string baseName = item.Key;
				List<string> sortedParts = item.Value.OrderBy((string f) => int.Parse(filePattern.Match(Path.GetFileName(f)).Groups["part"].Value)).ToList();
				string path = Path.Combine(PartsPath, baseName);
				using (FileStream outputStream = File.Create(path))
				{
					foreach (string item2 in sortedParts)
					{
						using FileStream inputStream = File.OpenRead(item2);
						await inputStream.CopyToAsync(outputStream);
					}
				}
				foreach (string item3 in sortedParts)
				{
					File.Delete(item3);
				}
				Debugger.Log("Merged and deleted parts for: " + baseName + ", created file: " + baseName + ".doomah");
			}
		}
	}
	[BepInPlugin("envyandspite.ultrakill.envylevelloader", "envylevelloader", "1.8.1")]
	public class Plugin : BaseUnityPlugin
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Action <>9__14_1;

			public static UnityAction <>9__15_0;

			internal void <Awake>b__14_1()
			{
				Debugger.LogError("Action a failed to setup??");
			}

			internal void <LoadEnvyMenu>b__15_0()
			{
				Debugger.Log("opening envy menu");
				currentMenuInstance.SetActive(true);
			}
		}

		private const string modGUID = "envyandspite.ultrakill.envylevelloader";

		private const string modName = "envylevelloader";

		private const string modVersion = "1.8.1";

		private static readonly Harmony Harmony = new Harmony("envyandspite.ultrakill.envylevelloader");

		public static AssetBundle menu;

		public static GameObject menuPrefab;

		public static GameObject iconPrefab;

		public static GameObject canvasForEnvy;

		public static GameObject currentMenuInstance;

		public static GameObject currentIconInstance;

		public static Plugin Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
			Debug.Log((object)"Loading envy level loader...");
			menu = ResourceLoader.GetBundle("envymenu");
			Debugger.Log("Testing bundle integrity...");
			Object[] array = menu.LoadAllAssets();
			foreach (Object val in array)
			{
				Debugger.Log("Found " + val.name + " [" + ((object)val).GetType().FullName + "] in bundle " + ((Object)menu).name + ".");
			}
			Debugger.Log("____________________");
			menuPrefab = menu.LoadAsset<GameObject>("EnvyMenu");
			iconPrefab = menu.LoadAsset<GameObject>("EnvyIcon");
			canvasForEnvy = menu.LoadAsset<GameObject>("CanvasForEnvy");
			if ((Object)(object)canvasForEnvy != (Object)null)
			{
				canvasForEnvy.GetComponentInChildren<Canvas>().sortingOrder = 9999;
			}
			SceneManager.sceneLoaded += delegate(Scene s, LoadSceneMode lcm)
			{
				EnvyUtility.CaptureMainThread();
				if (SceneHelper.CurrentScene != "Bootstrap")
				{
					_ = SceneHelper.CurrentScene != "Intro";
				}
				else
					_ = 0;
				bool flag = SceneHelper.CurrentScene == "Main Menu";
				if (!Directory.Exists(EnvyUtility.ConfigPath))
				{
					Directory.CreateDirectory(EnvyUtility.ConfigPath);
				}
				if (((Scene)(ref s)).name != (LevelLoader.CurrentLevel?.Name ?? ""))
				{
					LevelLoader.IsCustomLevel = false;
					Debug.Log((object)"Not envy level");
				}
				if (flag)
				{
					ShaderManager.CreateShaderDictionary();
					ResourceLoader.PreloadGameobjectAtAddressAsync("FirstRoom");
					ResourceLoader.PreloadGameobjectAtAddressAsync("FirstRoom Player Only");
					ResourceLoader.PreloadGameobjectAtAddressAsync("FirstRoom Prime");
					ResourceLoader.PreloadGameobjectAtAddressAsync("FirstRoom Secret");
					ResourceLoader.PreloadGameobjectAtAddressAsync("Assets/Prefabs/Levels/Shop.prefab");
					ResourceLoader.PreloadGameobjectAtAddressAsync("Assets/Prefabs/Levels/Special Rooms/FinalRoom.prefab");
				}
				if ((Object)(object)menuPrefab == (Object)null)
				{
					Debugger.LogWarn("menuPrefab is null");
				}
				else if ((Object)(object)iconPrefab == (Object)null)
				{
					Debugger.LogWarn("iconPrefab is null");
				}
				else if ((Object)(object)canvasForEnvy == (Object)null)
				{
					Debugger.LogWarn("canvasForEnvy is null");
				}
				else if (flag)
				{
					GameObject target = EnvyUtility.FindObjectEvenIfDisabled("Canvas", "Chapter Select");
					LoadEnvyMenu(target);
				}
				else
				{
					Action a = delegate
					{
						Debugger.LogError("Action a failed to setup??");
					};
					a = delegate
					{
						//IL_0021: Unknown result type (might be due to invalid IL or missing references)
						//IL_0026: 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_003d: Unknown result type (might be due to invalid IL or missing references)
						//IL_004c: Unknown result type (might be due to invalid IL or missing references)
						//IL_0051: Unknown result type (might be due to invalid IL or missing references)
						GameObject val2 = EnvyUtility.FindObjectEvenIfDisabled("Canvas", "PauseMenu");
						if ((Object)(object)val2 == (Object)null)
						{
							PauseMenu[] array2 = Resources.FindObjectsOfTypeAll<PauseMenu>();
							Scene activeScene = SceneManager.GetActiveScene();
							PauseMenu[] array3 = array2;
							foreach (PauseMenu val3 in array3)
							{
								if (!(((Component)val3).gameObject.scene != activeScene))
								{
									Scene scene = ((Component)val3).gameObject.scene;
									if (!(((Scene)(ref scene)).name != ((Scene)(ref activeScene)).name))
									{
										Transform parent = ((Component)val3).transform.parent;
										if ((((parent != null) ? ((Object)parent).name : null) ?? "").ToLower().Contains("canvas"))
										{
											val2 = ((Component)val3).gameObject;
										}
									}
								}
							}
						}
						if ((Object)(object)val2 == (Object)null)
						{
							EnvyUtility.RunOnMainThread(a, 0.25f);
						}
						LoadEnvyMenu(val2);
					};
					EnvyUtility.RunOnMainThread(a, 0.25f);
				}
			};
			Harmony.PatchAll();
			Debug.Log((object)"Loaded envy level loader!");
		}

		private void LoadEnvyMenu(GameObject target)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			if ((Object)(object)target == (Object)null)
			{
				Debugger.LogWarn("target is null");
				return;
			}
			GameObject val = Object.Instantiate<GameObject>(canvasForEnvy, (Transform)null);
			cu