using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
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 Archipelago.MultiClient.Net;
using Archipelago.MultiClient.Net.BounceFeatures.DeathLink;
using Archipelago.MultiClient.Net.Enums;
using Archipelago.MultiClient.Net.Helpers;
using Archipelago.MultiClient.Net.MessageLog.Messages;
using Archipelago.MultiClient.Net.Models;
using Archipelago.MultiClient.Net.Packets;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json.Linq;
using PulseLib;
using PulseLib.Extensions;
using PulseLib.Localization;
using RDLevelEditor;
using RhythmDoctor.Archipelago.Client;
using RhythmDoctor.Archipelago.Extensions;
using RhythmDoctor.Archipelago.Helpers;
using RhythmDoctor.Archipelago.Interfaces;
using RhythmDoctor.Archipelago.Patches;
using RhythmDoctor.Archipelago.Patches.Gameplay;
using RhythmDoctor.Archipelago.Patches.Gameplay.Powerups;
using RhythmDoctor.Archipelago.Patches.Gameplay.Traps;
using RhythmDoctor.Archipelago.Patches.Menu;
using RhythmDoctor.Archipelago.World;
using RhythmDoctor.Archipelago.World.Data;
using RhythmWeightlifter;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("gg.archipelago.rhythmdoctor")]
[assembly: AssemblyConfiguration("Release-BepInEx5")]
[assembly: AssemblyFileVersion("0.6.13.0")]
[assembly: AssemblyInformationalVersion("0.6.13+71162631dc2f6e169ab8e9362130d32633f21ee2")]
[assembly: AssemblyProduct("RhythmDoctor.Archipelago")]
[assembly: AssemblyTitle("gg.archipelago.rhythmdoctor")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.6.13.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[CompilerGenerated]
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Length;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => _items.Length;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Length;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyArray(T[] items)
	{
		_items = items;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return ((IEnumerable)_items).GetEnumerator();
	}

	void ICollection.CopyTo(Array array, int index)
	{
		((ICollection)_items).CopyTo(array, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return ((IList)_items).Contains(value);
	}

	int IList.IndexOf(object value)
	{
		return ((IList)_items).IndexOf(value);
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return ((IEnumerable<T>)_items).GetEnumerator();
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return ((ICollection<T>)_items).Contains(item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		((ICollection<T>)_items).CopyTo(array, arrayIndex);
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return ((IList<T>)_items).IndexOf(item);
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlySingleElementList<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	private sealed class Enumerator : IDisposable, IEnumerator, IEnumerator<T>
	{
		object IEnumerator.Current => _item;

		T IEnumerator<T>.Current => _item;

		public Enumerator(T item)
		{
			_item = item;
		}

		bool IEnumerator.MoveNext()
		{
			if (!_moveNextCalled)
			{
				return _moveNextCalled = true;
			}
			return false;
		}

		void IEnumerator.Reset()
		{
			_moveNextCalled = false;
		}

		void IDisposable.Dispose()
		{
		}
	}

	int ICollection.Count => 1;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => 1;

	T IReadOnlyList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
	}

	int ICollection<T>.Count => 1;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlySingleElementList(T item)
	{
		_item = item;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return new Enumerator(_item);
	}

	void ICollection.CopyTo(Array array, int index)
	{
		array.SetValue(_item, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return EqualityComparer<T>.Default.Equals(_item, (T)value);
	}

	int IList.IndexOf(object value)
	{
		if (!EqualityComparer<T>.Default.Equals(_item, (T)value))
		{
			return -1;
		}
		return 0;
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return new Enumerator(_item);
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return EqualityComparer<T>.Default.Equals(_item, item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		array[arrayIndex] = _item;
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		if (!EqualityComparer<T>.Default.Equals(_item, item))
		{
			return -1;
		}
		return 0;
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[Embedded]
	[AttributeUsage(AttributeTargets.All)]
	[ExcludeFromCodeCoverage]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace Archipelago.MultiClient.Net
{
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, Inherited = false, AllowMultiple = false)]
	internal sealed class DataStoragePropertyAttribute : Attribute
	{
		public string? SessionVariable { get; }

		public Scope Scope { get; }

		public string Key { get; }

		public DataStoragePropertyAttribute(string sessionVariable, Scope scope, string key)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			SessionVariable = sessionVariable;
			Scope = scope;
			Key = key;
		}

		public DataStoragePropertyAttribute(string sessionVariable, string key)
			: this(sessionVariable, (Scope)0, key)
		{
		}
	}
}
namespace RhythmDoctor.Archipelago
{
	internal static class Configuration
	{
		internal enum DeathLinkConfig
		{
			FollowSlot,
			On,
			Off
		}

		private static ConfigEntry<DeathLinkConfig> _deathLink;

		private static ConfigEntry<int> _autoReconnectMaxRetries;

		private static ConfigEntry<int> _remoteTrapClearsTimeout;

		private static ConfigEntry<int> _slotToUse;

		internal static void Bind(ConfigFile config)
		{
			Plugin.Logger.LogInfo((object)"Binding configuration");
			_deathLink = config.Bind<DeathLinkConfig>("Gameplay", "DeathLink", DeathLinkConfig.FollowSlot, "Whether to enable DeathLink when connected to an Archipelago slot.\nSee the respective Game Page in Archipelago for more info.");
			_autoReconnectMaxRetries = config.Bind<int>("zzzDebugDoNotTouchUnlessAsked", "AutoReconnectMaxRetries", 3, "How many times to attempt to reconnect to an Archipelago server before the client is considered unsalvagable and the Client is abandoned.");
			_remoteTrapClearsTimeout = config.Bind<int>("zzzDebugDoNotTouchUnlessAsked", "RemoteTrapClearsTimeout", 3000, "How long to wait in milliseconds until getting remote trap clear status times out and defaults to 0/last known good value.");
			_slotToUse = config.Bind<int>("zzzDebugDoNotTouchUnlessAsked", "SlotToUse", 0, "Slot to use for Archipelago.");
		}

		internal static async Task<DeathLinkConfig> GetDeathLink()
		{
			if (Plugin.Client == null || Plugin.Client.Session == null)
			{
				return _deathLink.Value;
			}
			return (!(await ((IDataStorageWrapper)Plugin.Client.Session.DataStorage).GetRaceModeAsync())) ? _deathLink.Value : DeathLinkConfig.FollowSlot;
		}

		internal static int GetSlotToUse()
		{
			return _slotToUse.Value;
		}

		internal static int GetAutoReconnectMaxRetries()
		{
			return _autoReconnectMaxRetries.Value;
		}

		internal static int GetRemoteTrapClearsTimeout()
		{
			return _remoteTrapClearsTimeout.Value;
		}
	}
	internal static class Paths
	{
		internal static string Assembly;

		internal static string Assets;

		internal static string Localization;

		internal static string WardIcons;

		internal static void PopulatePaths()
		{
			Assembly = Path.GetDirectoryName(((BaseUnityPlugin)Plugin.Instance).Info.Location);
			Assets = Path.Combine(Assembly, "Assets");
			Localization = Path.Combine(Assets, "Localization");
			WardIcons = Path.Combine(Assets, "WardIcons");
		}
	}
	[BepInPlugin("gg.archipelago.rhythmdoctor", "RhythmDoctor.Archipelago", "0.6.13")]
	[BepInDependency("io.github.nonperforming.pulse", "0.0.6")]
	[BepInProcess("Rhythm Doctor.exe")]
	public class Plugin : BaseUnityPlugin
	{
		internal static RhythmDoctor.Archipelago.Client.Client Client = null;

		internal static ManualLogSource Logger = null;

		internal static readonly Random Random = new Random();

		internal static readonly ConcurrentQueue<Action> ToExecuteOnMainThread = new ConcurrentQueue<Action>();

		internal static Plugin Instance = null;

		internal const string PATCH_ID_ALWAYS_ACTIVE = "gg.archipelago.rhythmdoctor";

		internal const string PATCH_ID_ARCHIPELAGO_MENU = "gg.archipelago.rhythmdoctor.cls";

		internal const string PATCH_ID_POST_LOGIN = "gg.archipelago.rhythmdoctor.post";

		internal const string PATCH_ID_TRAP = "gg.archipelago.rhythmdoctor.trap";

		internal const string PATCH_ID_SLEEVE_PAINT = "gg.archipelago.rhythmdoctor.sleevepaint";

		private static readonly Type[] AlwaysActivePatches = new Type[3]
		{
			typeof(ArchipelagoMainMenuOptionPatch),
			typeof(VersionTextPatch),
			typeof(scnGameExtensions)
		};

		private static readonly Type[] PostLoginPatches = new Type[15]
		{
			typeof(Act5Patch),
			typeof(ClearLocationPatch),
			typeof(DeathLinkPatch),
			typeof(LevelSelectVisualFixesPatch),
			typeof(RhythmDogtorLevelPatch),
			typeof(RhythmWeightlifterPatch),
			typeof(RunningCharactersPatch),
			typeof(SkipCutscenePatch),
			typeof(SkipTutorialPatch),
			typeof(StateReplicationPatch),
			typeof(TrapManagerPatch),
			typeof(UnlockItemPatch),
			typeof(WelcomeBackPatch),
			typeof(SavingPatch),
			typeof(UnapplyPatchesPatch)
		};

		private static readonly Type CustomLoginScreenPatch = typeof(ArchipelagoLoginPatch);

		private bool _quitting;

		private void Awake()
		{
			Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"gg.archipelago.rhythmdoctor v0.6.13 loading");
			Configuration.Bind(((BaseUnityPlugin)this).Config);
			Logger.LogInfo((object)"Setting up paths");
			Paths.PopulatePaths();
			Logger.LogInfo((object)("Registering custom localization (" + Paths.Localization + ")"));
			CustomLocalizationHelper.SearchAndRegisterDirectory(Paths.Localization);
			Logger.LogInfo((object)"Applying always active patches");
			ApplyPatches("gg.archipelago.rhythmdoctor", AlwaysActivePatches);
			Logger.LogInfo((object)"gg.archipelago.rhythmdoctor v0.6.13 loaded");
		}

		private void Start()
		{
			Version version = new Version("1.1.1");
			Version version2 = new Version(Application.version);
			if (Releases.releaseNumber < 42 || version2 < version)
			{
				Logger.LogWarning((object)"================================================================================");
				Logger.LogWarning((object)"|   ╭─╮╷  ╭─╴╭─╮╭─╮╭─╴   ╷ ╷╭─╮╶┬╮╭─╮╶┬╴╭─╴   ╷ ╷╭─╮╷ ╷╭─╮   ╭─╴╭─╮╭┬╮╭─╴╷╷╷   |");
				Logger.LogWarning((object)"|   ├─╯│  ├╴ ├─┤╰─╮├╴    │ │├─╯ ││├─┤ │ ├╴    ╰┬╯│ ││ │├┬╯   │╶╮├─┤│││├╴ ╵╵╵   |");
				Logger.LogWarning((object)"|   ╵  ╰─╴╰─╴╵ ╵╰─╯╰─╴   ╰─╯╵  ╶┴╯╵ ╵ ╵ ╰─╴    ╵ ╰─╯╰─╯╵╰╴   ╰─╯╵ ╵╵ ╵╰─╴╵╵╵   |");
				Logger.LogWarning((object)"================================================================================");
				Logger.LogWarning((object)string.Format("This version of the mod (v{0}) was built for: v{1} (release {2}, commit {3}, date {4})", "0.6.13", version, 42, "e43207b", "2026/06/15 12:42 AM"));
				Logger.LogWarning((object)$"Your version is: v{Application.version} (release {Releases.releaseNumber}, commit {Releases.buildCommit}, date {Releases.buildDate})");
				Logger.LogWarning((object)"================================================================================");
			}
			else if (Releases.releaseNumber > 42 || version2 > version)
			{
				Logger.LogWarning((object)"=================================================================================");
				Logger.LogWarning((object)"|         ╭─╮╷  ╭─╴╭─╮╭─╮╭─╴   ╭─╮╭─╮╭─╴╭╮╷   ╭─╮╭╮╷   ╷╭─╮╭─╮╷ ╷╭─╴╷╷╷         |");
				Logger.LogWarning((object)"|         ├─╯│  ├╴ ├─┤╰─╮├╴    │ │├─╯├╴ │╰┤   ├─┤│╰┤   │╰─╮╰─╮│ │├╴ ╵╵╵         |");
				Logger.LogWarning((object)"|         ╵  ╰─╴╰─╴╵ ╵╰─╯╰─╴   ╰─╯╵  ╰─╴╵ ╵   ╵ ╵╵ ╵   ╵╰─╯╰─╯╰─╯╰─╴╵╵╵         |");
				Logger.LogWarning((object)"=================================================================================");
				Logger.LogWarning((object)string.Format("This version of the mod (v{0}) was built for: v{1} (release {2}, commit {3}, date {4})", "0.6.13", version, 42, "e43207b", "2026/06/15 12:42 AM"));
				Logger.LogWarning((object)$"Your version is: v{Application.version} (release {Releases.releaseNumber}, commit {Releases.buildCommit}, date {Releases.buildDate})");
				Logger.LogWarning((object)null);
				Logger.LogWarning((object)"First, please check that there is an updated version here: https://github.com/nonperforming/RhythmDoctor.Archipelago/releases. Remember to update Pulse (https://github.com/nonperforming/Pulse/releases) as well.");
				Logger.LogWarning((object)$"If there is no update yet, please open an issue at https://github.com/nonperforming/RhythmDoctor.Archipelago/issues/new?labels=\"plugin outdated\"&title=v{Application.version}+support&body=Release:+{Releases.releaseNumber}+/+Commit:+{Releases.buildCommit}+/+Date:+{Releases.buildDate}&assignees=nonperforming");
				Logger.LogWarning((object)"=================================================================================");
			}
		}

		private void Update()
		{
			Action result;
			while (ToExecuteOnMainThread.TryDequeue(out result))
			{
				result();
			}
		}

		private static void ApplyPatches(string id, params Type[] patches)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			Logger.LogInfo((object)("Applying patches as " + id));
			Harmony val = new Harmony(id);
			foreach (Type type in patches)
			{
				Logger.LogInfo((object)("Applying " + type.Name));
				val.PatchAll(type);
			}
		}

		internal static void ApplyGameplayPatches()
		{
			Logger.LogInfo((object)"Applying gameplay patches");
			ApplyPatches("gg.archipelago.rhythmdoctor.post", PostLoginPatches);
			ApplyPatches("gg.archipelago.rhythmdoctor.sleevepaint", typeof(LockSleevePaintPatch));
		}

		internal static void UnapplyGameplayPatches()
		{
			Logger.LogInfo((object)"Unapplying gameplay patches");
			Harmony.UnpatchID("gg.archipelago.rhythmdoctor.post");
			Harmony.UnpatchID("gg.archipelago.rhythmdoctor.sleevepaint");
		}

		internal static void ApplyArchipelagoMenuPatch()
		{
			Logger.LogInfo((object)"Applying Archipelago menu patch");
			Harmony.CreateAndPatchAll(CustomLoginScreenPatch, "gg.archipelago.rhythmdoctor.cls");
		}

		internal static void UnapplyArchipelagoMenuPatch()
		{
			Logger.LogInfo((object)"Unapplying Archipelago menu patch");
			Harmony.UnpatchID("gg.archipelago.rhythmdoctor.cls");
		}

		private void OnApplicationQuit()
		{
			Logger.LogDebug((object)"Quitting...");
			_quitting = true;
		}

		private void OnDestroy()
		{
			if (!_quitting)
			{
				Logger.LogWarning((object)"Tearing down plugin. This is unsupported!");
				UnapplyPatchesPatch.TearDownClientPluginPatch();
				Harmony.UnpatchID("gg.archipelago.rhythmdoctor");
				Harmony.UnpatchID("gg.archipelago.rhythmdoctor.cls");
				Harmony.UnpatchID("gg.archipelago.rhythmdoctor.post");
				Harmony.UnpatchID("gg.archipelago.rhythmdoctor.trap");
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "gg.archipelago.rhythmdoctor";

		public const string PLUGIN_NAME = "RhythmDoctor.Archipelago";

		public const string PLUGIN_VERSION = "0.6.13";
	}
}
namespace RhythmDoctor.Archipelago.World
{
	internal enum Act
	{
		None,
		Act1,
		Act2,
		Act3,
		Act4,
		Act5,
		Act6,
		Act7
	}
	internal static class Bindings
	{
		internal const string GAME = "Rhythm Doctor";

		internal const long SLEEVE_PAINT_ITEM_ID = 56L;

		internal const Level RHYTHM_DOGTOR_LEVEL = (Level)84;

		internal static readonly Dictionary<Level, BaseStage> LevelToStage = new Dictionary<Level, BaseStage>
		{
			{
				(Level)2,
				new RegularStage(Act.Act1, 1L, 2L, 3L)
			},
			{
				(Level)3,
				new RegularStage(Act.Act1, 4L, 5L, 6L)
			},
			{
				(Level)4,
				new RegularStage(Act.Act1, 7L, 8L, 9L)
			},
			{
				(Level)5,
				new RegularStage(Act.Act1, 10L, 11L, 12L)
			},
			{
				(Level)53,
				new RegularStage(Act.Act1, 13L, 14L, 15L)
			},
			{
				(Level)54,
				new RegularStage(Act.Act1, 16L, 17L, 18L)
			},
			{
				(Level)18,
				new RegularStage(Act.Act3, 21L, 22L, 23L)
			},
			{
				(Level)19,
				new RegularStage(Act.Act3, 24L, 25L, 26L)
			},
			{
				(Level)20,
				new RegularStage(Act.Act3, 27L, 28L, 29L)
			},
			{
				(Level)21,
				new RegularStage(Act.Act3, 30L, 31L, 32L)
			},
			{
				(Level)22,
				new RegularStage(Act.Act3, 33L, 34L, 35L)
			},
			{
				(Level)23,
				new RegularStage(Act.Act3, 36L, 37L, 38L)
			},
			{
				(Level)26,
				new BossStage(Act.Act3, 39L, null, 40L)
			},
			{
				(Level)84,
				new BossStage(Act.Act3, 41L, null, 42L)
			},
			{
				(Level)8,
				new RegularStage(Act.Act2, 43L, 44L, 45L)
			},
			{
				(Level)9,
				new RegularStage(Act.Act2, 46L, 47L, 48L)
			},
			{
				(Level)10,
				new RegularStage(Act.Act2, 49L, 50L, 51L)
			},
			{
				(Level)11,
				new RegularStage(Act.Act2, 52L, 53L, 54L)
			},
			{
				(Level)12,
				new RegularStage(Act.Act2, 55L, 56L, 57L)
			},
			{
				(Level)13,
				new RegularStage(Act.Act2, 58L, 59L, 60L)
			},
			{
				(Level)14,
				new RegularStage(Act.Act2, 171L, 172L, 61L)
			},
			{
				(Level)15,
				new RegularStage(Act.Act2, 173L, 174L, 62L)
			},
			{
				(Level)17,
				new RegularStage(Act.Act2, 63L, 64L, 65L)
			},
			{
				(Level)48,
				new BossStage(Act.Act7, 66L, 67L, 68L)
			},
			{
				(Level)27,
				new RegularStage(Act.Act4, 71L, 72L, 73L)
			},
			{
				(Level)28,
				new RegularStage(Act.Act4, 74L, 75L, 76L)
			},
			{
				(Level)29,
				new RegularStage(Act.Act4, 77L, 78L, 79L)
			},
			{
				(Level)30,
				new RegularStage(Act.Act4, 80L, 81L, 82L)
			},
			{
				(Level)31,
				new RegularStage(Act.Act4, 83L, 84L, 85L)
			},
			{
				(Level)32,
				new RegularStage(Act.Act4, 86L, 87L, 88L)
			},
			{
				(Level)33,
				new RegularStage(Act.Act4, 89L, 90L, 91L)
			},
			{
				(Level)34,
				new RegularStage(Act.Act4, 92L, 93L, 94L)
			},
			{
				(Level)35,
				new RegularStage(Act.Act5, 97L, 98L, 99L)
			},
			{
				(Level)36,
				new RegularStage(Act.Act5, 100L, 101L, 102L)
			},
			{
				(Level)37,
				new RegularStage(Act.Act5, 103L, 104L, 105L)
			},
			{
				(Level)38,
				new RegularStage(Act.Act5, 106L, 107L, 108L)
			},
			{
				(Level)39,
				new RegularStage(Act.Act5, 175L, 176L, 109L)
			},
			{
				(Level)40,
				new RegularStage(Act.Act5, 110L, 111L, 112L)
			},
			{
				(Level)43,
				new RegularStage(Act.Act6, 126L, 127L, 128L)
			},
			{
				(Level)45,
				new RegularStage(Act.Act6, 129L, 130L, 131L)
			},
			{
				(Level)47,
				new RegularStage(Act.Act7, 135L, 136L, 137L)
			},
			{
				(Level)58,
				new RegularStage(Act.None, 144L, 145L, 146L)
			},
			{
				(Level)59,
				new RegularStage(Act.None, 147L, 148L, 149L)
			},
			{
				(Level)56,
				new RegularStage(Act.None, 150L, 151L, 152L)
			},
			{
				(Level)57,
				new RegularStage(Act.None, 153L, 154L, 155L)
			},
			{
				(Level)61,
				new RegularStage(Act.None, 156L, 157L, 158L)
			},
			{
				(Level)62,
				new RegularStage(Act.None, 159L, 160L, 161L)
			},
			{
				(Level)63,
				new RegularStage(Act.None, 162L, 163L, 164L)
			},
			{
				(Level)55,
				new RegularStage(Act.None, 165L, 166L, 167L)
			},
			{
				(Level)25,
				new RegularStage(Act.None, 168L, 169L, 170L)
			},
			{
				(Level)60,
				new RegularStage(Act.None, 177L, 178L, 179L)
			},
			{
				(Level)6,
				new BossStage(Act.Act1, 19L, null, 20L)
			},
			{
				(Level)16,
				new BossStage(Act.Act2, 69L, null, 70L)
			},
			{
				(Level)7,
				new BossStage(Act.Act4, 95L, null, 96L)
			},
			{
				(Level)42,
				new BossStage(Act.Act5, 123L, 124L, 125L)
			},
			{
				(Level)46,
				new BossStage(Act.Act6, 132L, null, 134L)
			},
			{
				(Level)49,
				new BossStage(Act.Act7, 138L, 139L, 140L)
			},
			{
				(Level)50,
				new BossStage(Act.Act7, 141L, 142L, 143L)
			}
		};

		internal static readonly Dictionary<long, Level> ItemIdToLevel = new Dictionary<long, Level>
		{
			{
				1L,
				(Level)2
			},
			{
				2L,
				(Level)3
			},
			{
				3L,
				(Level)4
			},
			{
				4L,
				(Level)5
			},
			{
				5L,
				(Level)53
			},
			{
				6L,
				(Level)54
			},
			{
				7L,
				(Level)18
			},
			{
				8L,
				(Level)19
			},
			{
				9L,
				(Level)20
			},
			{
				10L,
				(Level)21
			},
			{
				11L,
				(Level)22
			},
			{
				12L,
				(Level)23
			},
			{
				13L,
				(Level)8
			},
			{
				14L,
				(Level)9
			},
			{
				15L,
				(Level)10
			},
			{
				16L,
				(Level)11
			},
			{
				17L,
				(Level)12
			},
			{
				18L,
				(Level)13
			},
			{
				19L,
				(Level)14
			},
			{
				20L,
				(Level)15
			},
			{
				21L,
				(Level)17
			},
			{
				22L,
				(Level)48
			},
			{
				23L,
				(Level)27
			},
			{
				24L,
				(Level)28
			},
			{
				25L,
				(Level)29
			},
			{
				26L,
				(Level)30
			},
			{
				27L,
				(Level)31
			},
			{
				28L,
				(Level)32
			},
			{
				29L,
				(Level)33
			},
			{
				30L,
				(Level)34
			},
			{
				31L,
				(Level)35
			},
			{
				32L,
				(Level)36
			},
			{
				33L,
				(Level)37
			},
			{
				34L,
				(Level)38
			},
			{
				35L,
				(Level)39
			},
			{
				36L,
				(Level)40
			},
			{
				37L,
				(Level)41
			},
			{
				38L,
				(Level)43
			},
			{
				39L,
				(Level)45
			},
			{
				40L,
				(Level)47
			},
			{
				41L,
				(Level)58
			},
			{
				42L,
				(Level)59
			},
			{
				43L,
				(Level)56
			},
			{
				44L,
				(Level)57
			},
			{
				45L,
				(Level)61
			},
			{
				46L,
				(Level)62
			},
			{
				47L,
				(Level)63
			},
			{
				48L,
				(Level)55
			},
			{
				49L,
				(Level)25
			},
			{
				67L,
				(Level)60
			}
		};

		internal static readonly Dictionary<long, Type> TrapItemIdToLevel = new Dictionary<long, Type>
		{
			{
				60L,
				typeof(FragileHeartTrapPatch)
			},
			{
				61L,
				typeof(HardDifficultyTrapPatch)
			},
			{
				62L,
				typeof(ScrambleCharactersTrapPatch)
			},
			{
				63L,
				typeof(ScrambleBeatsoundsTrapPatch)
			},
			{
				64L,
				typeof(ScrambleHitsoundsTrapPatch)
			},
			{
				65L,
				typeof(ChilliSpeedTrapPatch)
			},
			{
				66L,
				typeof(GhostTapTrapPatch)
			},
			{
				57L,
				typeof(StrongHeartPowerupPatch)
			},
			{
				58L,
				typeof(EasyDifficultyPowerupPatch)
			},
			{
				59L,
				typeof(IceSpeedTrapPatch)
			}
		};

		internal static readonly Dictionary<long, Region> KeyItemIdToWard = new Dictionary<long, Region>
		{
			{
				50L,
				Region.SVTWard
			},
			{
				51L,
				Region.Train
			},
			{
				52L,
				Region.PhysiotherapyWard
			},
			{
				55L,
				Region.RecordsRoom
			},
			{
				53L,
				Region.Basement
			},
			{
				54L,
				Region.GardenRoom
			}
		};

		internal static readonly long[] RhythmWeightlifterStageToLocationID = new long[12]
		{
			113L, 114L, 115L, 116L, 117L, 118L, 119L, 120L, 121L, 122L,
			180L, 181L
		};

		internal static readonly IReadOnlyCollection<Type> Traps = TrapItemIdToLevel.Values;

		internal static readonly IReadOnlyCollection<Level> Levels = LevelToStage.Keys;

		internal static readonly Dictionary<Level, Act> LevelToAct = LevelToStage.ToDictionary<KeyValuePair<Level, BaseStage>, Level, Act>((KeyValuePair<Level, BaseStage> pair) => pair.Key, (KeyValuePair<Level, BaseStage> pair) => pair.Value.StageAct);

		internal static readonly Dictionary<Region, long> RegionToKeyID = KeyItemIdToWard.ToDictionary((KeyValuePair<long, Region> pair) => pair.Value, (KeyValuePair<long, Region> pair) => pair.Key);

		internal static readonly Dictionary<Act, IEnumerable<Level>> LevelsInAct = (from pair in LevelToStage
			group pair by pair.Value.StageAct).ToDictionary((IGrouping<Act, KeyValuePair<Level, BaseStage>> grouping) => grouping.Key, (IGrouping<Act, KeyValuePair<Level, BaseStage>> grouping) => grouping.Select((KeyValuePair<Level, BaseStage> c) => c.Key));

		internal static readonly Level[] LevelsThatDoNotUnlockBoss = (Level[])(object)new Level[1] { (Level)41 };

		internal static readonly Dictionary<Act, Level[]> ActBoss = new Dictionary<Act, Level[]>
		{
			{
				Act.Act1,
				(Level[])(object)new Level[1] { (Level)6 }
			},
			{
				Act.Act2,
				(Level[])(object)new Level[1] { (Level)16 }
			},
			{
				Act.Act3,
				(Level[])(object)new Level[2]
				{
					(Level)26,
					(Level)84
				}
			},
			{
				Act.Act4,
				(Level[])(object)new Level[1] { (Level)7 }
			},
			{
				Act.Act5,
				(Level[])(object)new Level[1] { (Level)42 }
			},
			{
				Act.Act6,
				(Level[])(object)new Level[1] { (Level)46 }
			},
			{
				Act.Act7,
				(Level[])(object)new Level[2]
				{
					(Level)49,
					(Level)50
				}
			}
		};
	}
	internal enum Region
	{
		MainWard,
		SVTWard,
		Train,
		PhysiotherapyWard,
		RecordsRoom,
		Basement,
		GardenRoom
	}
}
namespace RhythmDoctor.Archipelago.World.Data
{
	internal abstract class BaseStage
	{
		internal Act StageAct { get; init; }

		internal abstract IEnumerable<long> GetLocationsToClear(Rank rank);
	}
	internal class BossStage : BaseStage
	{
		internal long ClearLocation { get; init; }

		internal long? CompletePlusLocation { get; init; }

		internal long PerfectLocation { get; init; }

		internal BossStage(Act act, long clearLocation, long? completePlusLocation, long perfectLocation)
		{
			base.StageAct = act;
			ClearLocation = clearLocation;
			CompletePlusLocation = completePlusLocation;
			PerfectLocation = perfectLocation;
		}

		internal override IEnumerable<long> GetLocationsToClear(Rank rank)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Logger.LogDebug((object)$"Getting locations to clear for rank {rank.internalValue}");
			List<long> list = new List<long>();
			if (((Rank)(ref rank)).perfected)
			{
				list.Add(PerfectLocation);
			}
			if (CompletePlusLocation.HasValue && (((Rank)(ref rank)).perfected || scnGame.instance.GetPassedLevelWithoutCheckpoints()))
			{
				list.Add(CompletePlusLocation.Value);
			}
			list.Add(ClearLocation);
			return list.AsReadOnly();
		}
	}
	internal class RegularStage : BaseStage
	{
		internal long? BRankLocation { get; init; }

		internal long? ARankLocation { get; init; }

		internal long SRankLocation { get; init; }

		internal RegularStage(Act act, long? bRankLocation, long? aRankLocation, long sRankLocation)
		{
			base.StageAct = act;
			BRankLocation = bRankLocation;
			ARankLocation = aRankLocation;
			SRankLocation = sRankLocation;
		}

		internal override IEnumerable<long> GetLocationsToClear(Rank rank)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Logger.LogDebug((object)$"Getting locations to clear for rank {rank.internalValue}");
			List<long> list = new List<long>();
			switch (Rank.op_Implicit(rank))
			{
			case -15:
			case 5:
			case 15:
				list.Add(SRankLocation);
				goto case -14;
			case -14:
			case 4:
			case 14:
				if (ARankLocation.HasValue)
				{
					list.Add(ARankLocation.Value);
				}
				goto case -13;
			case -13:
			case 3:
			case 13:
				if (BRankLocation.HasValue)
				{
					list.Add(BRankLocation.Value);
				}
				break;
			}
			return list.AsReadOnly();
		}
	}
}
namespace RhythmDoctor.Archipelago.Patches
{
	[HarmonyPatch(typeof(ArmSkin))]
	internal static class LockSleevePaintPatch
	{
		[HarmonyPatch("Load")]
		[HarmonyPrefix]
		private static void LoadDefaultSleevePatch(ref ArmSkin __instance, ref bool __runOriginal)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			__runOriginal = false;
			int num = Plugin.Random.Next(0, 2);
			RDPlayer player = __instance.player;
			if ((int)player != 0)
			{
				if ((int)player == 1)
				{
					__instance.skinColor = RDConstants.data.skinColors[RDConstants.data.defaultP2SkinColor[num]];
					__instance.sleeveColor = RDConstants.data.sleeveColors[RDConstants.data.defaultP2SleeveColor[num]];
					__instance.nailsColor = RDConstants.data.nailColors[RDConstants.data.defaultP2NailColor[num]];
					__instance.palmLightness = RDConstants.data.defaultP2PalmLightness[num];
					__instance.drawing = RDConstants.data.emptyTexture;
				}
			}
			else
			{
				__instance.skinColor = RDConstants.data.skinColors[RDConstants.data.defaultP1SkinColor[num]];
				__instance.sleeveColor = RDConstants.data.sleeveColors[RDConstants.data.defaultP1SleeveColor[num]];
				__instance.nailsColor = RDConstants.data.nailColors[RDConstants.data.defaultP1NailColor[num]];
				__instance.palmLightness = RDConstants.data.defaultP1PalmLightness[num];
				__instance.drawing = RDConstants.data.emptyTexture;
			}
		}
	}
	[HarmonyPatch(typeof(RDVersionText))]
	internal static class VersionTextPatch
	{
		[HarmonyPatch("SetPage")]
		[HarmonyPostfix]
		private static void AppendClientVersionPatch(RDVersionText __instance)
		{
			Text text = __instance.text;
			string text2 = (text.text += " / Archipelago v0.6.13");
			string text4 = text2;
			__instance.text.text = text4;
		}
	}
	[HarmonyPatch]
	internal static class SavingPatch
	{
		[HarmonyPatch(typeof(PlayerPrefsJson), "Save")]
		[HarmonyPatch(typeof(PlayerPrefsJson), "SaveBackup")]
		[HarmonyPrefix]
		private static void DisableSavingToFilePatch(ref bool __runOriginal, ref PlayerPrefsJson __instance)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			__runOriginal = (int)__instance.fileType == 0;
		}

		[HarmonyPatch(typeof(ArmSkin), "GetDrawingPath")]
		[HarmonyPrefix]
		private unsafe static void RedirectSleevePaintFilePatch(RDPlayer player, ref string __result, ref bool __runOriginal)
		{
			__runOriginal = false;
			__result = Path.Combine(PlayerPrefsJson.GetFileFolderPath(), "scribble" + ((object)(*(RDPlayer*)(&player))/*cast due to .constrained prefix*/).ToString() + "_AP.png");
		}
	}
	[HarmonyPatch]
	internal static class UnapplyPatchesPatch
	{
		[HarmonyPatch(typeof(scnMenu), "Awake")]
		[HarmonyPatch(typeof(scnBase), "GoToMainMenu")]
		[HarmonyPrefix]
		internal static void TearDownClientPluginPatch()
		{
			Plugin.Logger.LogInfo((object)"Tearing down client plugin");
			Plugin.UnapplyGameplayPatches();
			Persistence.Load();
			try
			{
				scnMenu.instance.slots[Configuration.GetSlotToUse()].LoadSlotData();
				Plugin.Logger.LogDebug((object)"Reloaded slot data");
			}
			catch (NullReferenceException)
			{
				Plugin.Logger.LogDebug((object)"Not in main menu, could not load slot data");
			}
			Plugin.Client?.Dispose();
			Plugin.Client = null;
		}
	}
}
namespace RhythmDoctor.Archipelago.Patches.Menu
{
	[HarmonyPatch]
	internal static class ArchipelagoLoginPatch
	{
		[HarmonyPatch(typeof(scnCLS), "Start")]
		[HarmonyPostfix]
		private static void ConstructArchipelagoMenuPatch(scnCLS __instance)
		{
			Plugin.Logger.LogInfo((object)"Renaming custom level ward items");
			Plugin.Logger.LogInfo((object)"Renaming LED sign");
			GameObject.Find("Canvas/Ward Container/LEDSign Container/WardTitle Text").GetComponent<Text>().text = RDString.Get("archipelago.connectScreenTitle");
			Plugin.Logger.LogInfo((object)"Renaming ward options");
			WardOption val = __instance.wardOptions.Find((WardOption wardOption) => (int)wardOption.name == 0);
			WardOption val2 = __instance.wardOptions.Find((WardOption wardOption) => (int)wardOption.name == 1);
			WardOption? obj = __instance.wardOptions.Find((WardOption wardOption) => (int)wardOption.name == 2);
			__instance.ChangeToImportOption();
			if (val != null)
			{
				RectTransform rect = val.rect;
				if (rect != null)
				{
					Transform parent = ((Component)rect).transform.parent;
					if (parent != null)
					{
						((Component)parent).gameObject.SetActive(false);
					}
				}
				__instance.wardOptions.Remove(val);
			}
			if (val2 != null)
			{
				RectTransform rect2 = val2.rect;
				if (rect2 != null)
				{
					Transform parent2 = ((Component)rect2).transform.parent;
					if (parent2 != null)
					{
						((Component)parent2).gameObject.SetActive(false);
					}
				}
				__instance.wardOptions.Remove(val2);
			}
			Plugin.Logger.LogInfo((object)"Renaming Import to Archipelago option");
			Transform obj2 = ((Transform)obj.rect).Find("Button");
			((Component)obj2.Find("Icon Image")).GetComponent<Image>().sprite = AssetHelper.LoadSprite("WardIcons", "Archipelago.png");
			((Component)obj2.Find("Text")).GetComponent<Text>().text = RDString.Get("archipelago.loginButton");
			Plugin.Logger.LogInfo((object)"Disabling DragAndDrop");
			__instance.levelImporter.dragAndDrop.SetActive(false);
			__instance._currentWardOptionIndex = 0;
		}

		[HarmonyPatch(typeof(LevelImporter), "Install")]
		[HarmonyPostfix]
		private static IEnumerator OverrideInstallButtonPatch(IEnumerator result, LevelImporter __instance)
		{
			Plugin.Logger.LogInfo((object)"Locking input");
			((RDBase)__instance).cls.CLSPlaySound("sndImportInstallButtonClick", 1f, "CustomLevelSelect", 1f, 0f);
			__instance.ToggleInsertUrlContainer(false, true, false);
			__instance.CurrentContentName = (ContentName)2;
			__instance.stoppedInstallCoroutine = false;
			__instance.CanToggleClearButton = false;
			__instance.levelsToInstall = new List<ImportLevel>(__instance.toInstallIS.levels);
			foreach (ImportLevel item in __instance.levelsToInstall)
			{
				item.canToggleRemoveButton = false;
			}
			yield return null;
			((Selectable)__instance.stopButton).interactable = false;
			string text = ((Component)((Component)__instance).transform.Find("screen/Contents/InsertURL Container/URL InputField/Text")).GetComponent<Text>().text;
			string[] array = (from text2 in text.Split('\n')
				select text2.Trim()).ToArray();
			Plugin.Logger.LogInfo((object)("Input: '" + GeneralExtensions.Join<string>((IEnumerable<string>)array, (Func<string, string>)null, ", ") + "' (raw: " + Convert.ToBase64String(Encoding.UTF8.GetBytes(text))));
			if (array.Length < 2)
			{
				Plugin.Logger.LogError((object)"URL or Name not input, bailing out");
				__instance.CurrentContentName = (ContentName)3;
				((RDBase)__instance).cls.CLSPlaySound("sndImportInstallFinish", 1f, "CustomLevelSelect", 1f, 0f);
				__instance.AddLevelToErrorSection(__instance.levelsToInstall[0], RDString.Get("archipelago.login.fail.missingInformation"));
				yield break;
			}
			string url = array[0];
			string name = array[1];
			string password = null;
			try
			{
				password = array[2];
			}
			catch (IndexOutOfRangeException)
			{
			}
			Plugin.Logger.LogInfo((object)("URL: " + url + ", Slot Name: " + name));
			if (Utility.IsNullOrWhiteSpace(url) || Utility.IsNullOrWhiteSpace(name))
			{
				Plugin.Logger.LogError((object)"Invalid information, bailing out");
			}
			else
			{
				Plugin.Logger.LogInfo((object)"Creating client");
				Plugin.Client = new RhythmDoctor.Archipelago.Client.Client();
				Task<LoginResult> login = Task.Run(() => Plugin.Client.CreateSessionAndConnect(url, name, password));
				yield return (object)new WaitUntil((Func<bool>)(() => login.IsCompleted));
				if (login.IsCanceled || login.IsFaulted)
				{
					string arg = (login.IsFaulted ? login.Exception.ToString() : "false");
					Plugin.Logger.LogError((object)$"Login has cancelled or faulted (cancel: {login.IsCanceled} / fault: {arg})");
				}
				else
				{
					LoginResult result2 = login.Result;
					if (result2 is LoginSuccessful)
					{
						Plugin.Logger.LogInfo((object)"Logged in!");
						((RDBase)__instance).cls.CLSPlaySound("sndImportInstallFinish", 1f, "CustomLevelSelect", 1f, 0f);
						yield return null;
						UnpatchMenuPatch();
						while (!Plugin.Client.Setup)
						{
							yield return (object)new WaitForSecondsRealtime(1f);
						}
						Plugin.Logger.LogInfo((object)"Heading to Level Select...");
						scnBase.GoToScene("scnLevelSelect");
						yield break;
					}
					LoginFailure val = (LoginFailure)(object)((result2 is LoginFailure) ? result2 : null);
					if (val == null)
					{
						Plugin.Logger.LogWarning((object)"Got to the end of OverrideInstallButtonPatch - this should never happen!");
						yield break;
					}
					Plugin.Logger.LogError((object)("Got LoginFailure: " + string.Join(", ", val.ErrorCodes) + " / " + string.Join(", ", val.Errors)));
				}
				Plugin.Logger.LogError((object)"Login failed (Login)");
				UnapplyPatchesPatch.TearDownClientPluginPatch();
				Plugin.Client?.Dispose();
				Plugin.Client = null;
			}
			__instance.CurrentContentName = (ContentName)3;
			((RDBase)__instance).cls.CLSPlaySound("sndImportInstallFinish", 1f, "CustomLevelSelect", 1f, 0f);
			((Component)((Component)__instance).transform.Find("screen/Contents/Top Panel/Title Text")).GetComponent<Text>().text = RDString.Get("archipelago.login.fail.title");
		}

		[HarmonyPatch(typeof(scnCLS), "Exit")]
		[HarmonyPostfix]
		private static void UnpatchMenuPatch()
		{
			Plugin.UnapplyArchipelagoMenuPatch();
		}

		[HarmonyPatch(typeof(scnCLS), "SelectWardOption")]
		[HarmonyPostfix]
		private static void CustomSelectOptionPatch(ref bool __runOriginal, scnCLS __instance)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			__runOriginal = false;
			WardOptionName name = __instance.CurrentWardOption.name;
			if ((int)name <= 1)
			{
				Plugin.Logger.LogWarning((object)"Library/Steam Workshop selected in Archipelago login screen");
			}
			else
			{
				__runOriginal = true;
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		private static void ArchipelagoImportScreenPatch()
		{
			GameObject gameObject = ((Component)((Component)((Component)scnCLS.instance.levelImporter).gameObject.transform.Find("screen")).gameObject.transform.Find("Contents")).gameObject;
			GameObject gameObject2 = ((Component)gameObject.transform.Find("InsertURL Container")).gameObject;
			GameObject gameObject3 = ((Component)gameObject2.transform.Find("Add Button")).gameObject;
			Text component = ((Component)((Component)gameObject2.transform.Find("URL InputField")).gameObject.transform.Find("Placeholder")).gameObject.GetComponent<Text>();
			Text component2 = ((Component)gameObject2.transform.Find("Instructions")).GetComponent<Text>();
			Text component3 = ((Component)gameObject3.transform.Find("Text")).GetComponent<Text>();
			((UnityEvent)((Component)gameObject.transform.Find("Draggable Content/AddURL Button")).GetComponent<Button>().onClick).Invoke();
			((Component)gameObject.transform.Find("Top Panel/Title Text")).GetComponent<Text>().text = RDString.Get("archipelago.login.menu.title");
			((Component)gameObject2.transform.Find("Cancel Button")).gameObject.SetActive(false);
			component2.text = RDString.Get("archipelago.login.menu.instructions");
			component.text = RDString.Get("archipelago.login.menu.hint");
			component3.text = RDString.Get("archipelago.login.menu.connectButton");
		}

		[HarmonyPatch(typeof(LevelImporter), "ValidateUrl")]
		[HarmonyPrefix]
		private static void StubValidateUrlPatch(ref bool __runOriginal, LevelImporter __instance)
		{
			__runOriginal = false;
			__instance.Install_Public();
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		private static void DisableDragAndDropInstallGetPatch(ref bool __result, ref bool __runOriginal)
		{
			__runOriginal = false;
			__result = false;
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		private static void DisableDragAndDropInstallSetPatch(ref bool __runOriginal)
		{
			__runOriginal = false;
		}
	}
	[HarmonyPatch(typeof(scnMenu))]
	internal static class ArchipelagoMainMenuOptionPatch
	{
		private const string ARCHIPELAGO_OBJECT_NAME = "archipelago";

		[HarmonyPatch("Awake")]
		[HarmonyPrefix]
		private static void RenameMusicOptionPatch(scnMenu __instance)
		{
			((Object)((Component)((Component)__instance).transform.Find("mainMenu/options/optionsContainer/music")).gameObject).name = "archipelago";
		}

		[HarmonyPatch("SelectOption")]
		[HarmonyPrefix]
		private static void HandleArchipelagoOptionSelectedPatch(ref bool __runOriginal, scnMenu __instance)
		{
			if (((Object)((Component)__instance.optionsText[__instance.currentOption]).gameObject).name == "archipelago")
			{
				__runOriginal = false;
				Plugin.ApplyArchipelagoMenuPatch();
				__instance.PlayConfirmSound();
				__instance.TransitionToScene("scnCLS");
			}
		}
	}
}
namespace RhythmDoctor.Archipelago.Patches.Gameplay
{
	[HarmonyPatch(typeof(scnLevelSelect))]
	internal static class Act5Patch
	{
		[HarmonyPatch("PerformEntityAction")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> NicoleBlockageInteractionPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(true, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldstr, (object)"GoToAthleteWard", (string)null)
			}).Advance(3).RemoveInstructions(8)
				.SetOpcodeAndAdvance(OpCodes.Ldc_I4_0)
				.InstructionEnumeration();
		}

		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void DematerializeNicolePatch(scnLevelSelect __instance)
		{
			((Entity)__instance.nicoleAct5Blockage).visible = false;
		}

		[HarmonyPatch("PrepareAthleteWardTransition")]
		[HarmonyPrefix]
		private static void DoNotShowDreamBubblesPatch(ref bool __runOriginal)
		{
			__runOriginal = false;
		}
	}
	[HarmonyPatch]
	internal static class ClearLocationPatch
	{
		private static Dictionary<long, ScoutedItemInfo> ItemsToSend = new Dictionary<long, ScoutedItemInfo>();

		private static long[] JustSentLocations = Array.Empty<long>();

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		private static void ScoutItemsSentPatch(LevelBase __instance)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Invalid comparison between Unknown and I4
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Logger.LogDebug((object)("Scouting locations to send for " + scnGame.internalIdentifier));
			ItemsToSend.Clear();
			JustSentLocations = Array.Empty<long>();
			if (!Enum.TryParse<Level>(scnGame.internalIdentifier, out Level result))
			{
				Plugin.Logger.LogError((object)("Couldn't find Level. Level identifier: " + scnGame.internalIdentifier));
				Plugin.Client.TrapManager.ClearActiveTraps(returnToQueue: false);
				return;
			}
			if ((int)result == 26 && (__instance.dogMode || scnGame.loadDogMode))
			{
				result = (Level)84;
			}
			IEnumerable<long> locationsToClear = Bindings.LevelToStage[result].GetLocationsToClear(Rank.op_Implicit(5));
			((MonoBehaviour)Plugin.Instance).StartCoroutine(ScoutLocationChecks(locationsToClear.ToArray()));
		}

		[HarmonyPatch(typeof(Rankscreen), "ShowAndSaveRank")]
		[HarmonyPrefix]
		private static void CustomClearLocationPatch(bool bossLevelFailed, bool onlySavePersistence, Rankscreen __instance)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			Level currentLevel = GetCurrentLevel();
			Rank rankFromMistakes = scnGame.instance.currentLevel.GetRankFromMistakes();
			SendLocations(currentLevel, rankFromMistakes, bossLevelFailed);
		}

		[HarmonyPatch(typeof(Level), "GetRank")]
		[HarmonyPostfix]
		private static void RhythmWeightlifterClearLocationPatch(string __result)
		{
			if (!(__result == "-"))
			{
				Plugin.Client.Session.Locations.CompleteLocationChecks(new long[1] { Bindings.RhythmWeightlifterStageToLocationID[scnRhythmWeightlifter.gameInstance.LevelIndex] });
			}
		}

		[HarmonyPatch(typeof(Rankscreen), "ShowRankDescription")]
		[HarmonyPostfix]
		private static void ShowSentItemsPatch(Rankscreen __instance)
		{
			//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)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			if (!ItemsToSend.Any())
			{
				Plugin.Logger.LogWarning((object)"Couldn't get items sent, possibly due to a network issue.");
				__instance.description.text = "<color=red>" + RDString.Get("archipelago.rankscreen.error") + "</color>";
			}
			else
			{
				Rank rankFromMistakes = scnGame.instance.currentLevel.GetRankFromMistakes();
				IEnumerable<long> stageLocationIDsToClear = GetStageLocationIDsToClear(GetCurrentLevel(), rankFromMistakes);
				long[] array = stageLocationIDsToClear.Where((long id) => !Plugin.Client.Session.Locations.AllLocationsChecked.Contains(id) || JustSentLocations.Contains(id)).ToArray();
				Plugin.Logger.LogDebug((object)("IDs: " + string.Join(", ", stageLocationIDsToClear) + " (of which " + string.Join(", ", array) + " are new)"));
				if (!stageLocationIDsToClear.Any())
				{
					__instance.description.text = RDString.Get("archipelago.rankscreen.nothing");
					return;
				}
				if (array.Length == 0)
				{
					__instance.description.text = RDString.Get("archipelago.rankscreen.nothingNew");
					return;
				}
				__instance.description.text = "";
				__instance.description.fontSize = 10;
				long[] array2 = array;
				foreach (long num2 in array2)
				{
					if (!ItemsToSend.TryGetValue(num2, out ScoutedItemInfo value))
					{
						Plugin.Logger.LogWarning((object)($"Could not get scouted item information for location ID {num2}. " + "This is normal if this ID is tied to a Perfect rank, and Perfect locations are disabled."));
						continue;
					}
					string text = "silver";
					if (((Enum)((ItemInfo)value).Flags).HasFlag((Enum)(object)(ItemFlags)1) || ((Enum)((ItemInfo)value).Flags).HasFlag((Enum)(object)(ItemFlags)2))
					{
						text = "yellow";
					}
					else if (((Enum)((ItemInfo)value).Flags).HasFlag((Enum)(object)(ItemFlags)4))
					{
						text = "red";
					}
					if (value.IsReceiverRelatedToActivePlayer)
					{
						Text description = __instance.description;
						description.text += RDStringExtensions.GetWithSubstitution("archipelago.rankscreen.found", new KeyValuePair<string, string>[1]
						{
							new KeyValuePair<string, string>("item", "<color=" + text + ">" + ((ItemInfo)value).ItemDisplayName + "</color>")
						});
					}
					else
					{
						Text description2 = __instance.description;
						description2.text += RDStringExtensions.GetWithSubstitution("archipelago.rankscreen.sentTo", new KeyValuePair<string, string>[2]
						{
							new KeyValuePair<string, string>("item", "<color=" + text + ">" + ((ItemInfo)value).ItemDisplayName + "</color>"),
							new KeyValuePair<string, string>("player", value.Player.Alias)
						});
					}
				}
			}
			ItemsToSend.Clear();
			JustSentLocations = Array.Empty<long>();
		}

		[HarmonyPatch(typeof(Level_Montage), "SetLevelAsPassed")]
		[HarmonyPostfix]
		private static void MiracleDefibrillatorClearLocationPatch(Level_Montage __instance)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			bool flag = Plugin.Client.TrapManager.IsTrapActive(ScrambleCharactersTrapPatch.name);
			int num = ((!__instance.missedOnce && !((RDClass)__instance).game.GetPassedLevelWithoutCheckpoints()) ? 5 : ((!((RDClass)__instance).game.GetPassedLevelWithoutCheckpoints()) ? 4 : 14));
			IEnumerable<long> enumerable = SendLocations((Level)49, Rank.op_Implicit(num));
			if (!ItemsToSend.Any())
			{
				Plugin.Logger.LogWarning((object)"Couldn't get items sent, possibly due to a network issue.");
				((RDClass)__instance).game.statusText.SetStatusText("Couldn't get items sent.", (Color?)Color.red, 10f, false, true);
			}
			else
			{
				long[] array = enumerable.Where((long id) => !Plugin.Client.Session.Locations.AllLocationsChecked.Contains(id) || JustSentLocations.Contains(id)).ToArray();
				Plugin.Logger.LogDebug((object)("IDs: " + string.Join(", ", enumerable) + " (of which " + string.Join(", ", array) + " are new)"));
				if (!enumerable.Any())
				{
					((RDClass)__instance).game.statusText.SetStatusText(RDString.Get("archipelago.rankscreen.nothing"), (Color?)null, 4f, false, false);
					return;
				}
				if (array.Length == 0)
				{
					((RDClass)__instance).game.statusText.SetStatusText(RDString.Get("archipelago.rankscreen.nothingNew"), (Color?)null, 4f, false, false);
					return;
				}
				IEnumerable<string> values = array.Select((long id) => ((ItemInfo)ItemsToSend[id]).ItemDisplayName);
				((RDClass)__instance).game.statusText.SetStatusText("Found " + string.Join(", ", values), (Color?)null, 10f, false, true);
			}
			if (flag)
			{
				Plugin.Logger.LogInfo((object)"Setting Room 1, Row 2 to Cole");
				((RDClass)__instance).game.rows[1].ent.character.ChangeCharacter((Character)13, (string)null);
			}
		}

		private static IEnumerable<long> SendLocations(Level level, Rank rank, bool bossLevelFailed = false)
		{
			//IL_0020: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Invalid comparison between Unknown and I4
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			if (bossLevelFailed)
			{
				Plugin.Client.TrapManager.ClearActiveTraps(returnToQueue: false);
				return Array.Empty<long>();
			}
			IEnumerable<long> ids = GetStageLocationIDsToClear(level, rank);
			if (Plugin.Client.Slot.endGoal == SlotData.EndGoal.HelpingHands && (int)level == 55 && ((Rank)(ref rank)).passed)
			{
				Plugin.Logger.LogInfo((object)"Setting goal achieved - Helping Hands");
				Plugin.Client.Session.SetGoalAchieved();
			}
			else if (Plugin.Client.Slot.endGoal != SlotData.EndGoal.HelpingHands)
			{
				bool flag = true;
				Rank val = Rank.op_Implicit(Plugin.Client.Slot.endGoal switch
				{
					SlotData.EndGoal.PerfectAll => 5, 
					SlotData.EndGoal.ARankAll => 4, 
					SlotData.EndGoal.BRankAll => 3, 
					_ => throw new ArgumentOutOfRangeException($"End Goal ({Plugin.Client.Slot.endGoal}) not valid value."), 
				});
				foreach (Level level2 in Bindings.Levels)
				{
					Rank levelRank = Persistence.GetLevelRank(level2, false, -1);
					if (Rank.op_Implicit(val) > Rank.op_Implicit(((Rank)(ref levelRank)).ToNormal()))
					{
						flag = false;
						break;
					}
				}
				if (flag)
				{
					Plugin.Logger.LogInfo((object)"Setting goal achieved - Cleared all");
					Plugin.Client.Session.SetGoalAchieved();
				}
			}
			if (ids.Any((long id) => !Plugin.Client.Session.Locations.AllLocationsChecked.Contains(id)))
			{
				JustSentLocations = ids.Where((long id) => !Plugin.Client.Session.Locations.AllLocationsChecked.Contains(id)).ToArray();
				Task.Run(() => Plugin.Client.Session.Locations.CompleteLocationChecksAsync(ids.ToArray()));
				Plugin.Client.TrapManager.ClearActiveTraps(returnToQueue: false);
			}
			else
			{
				Plugin.Client.TrapManager.ClearActiveTraps(returnToQueue: true);
			}
			return ids;
		}

		private static IEnumerator ScoutLocationChecks(long[] ids, int retries = 0)
		{
			Plugin.Logger.LogInfo((object)string.Format("Scouting location checks for ids {0}... (try {1})", string.Join(", ", ids), retries));
			Task<Dictionary<long, ScoutedItemInfo>> scout = Task.Run(() => Plugin.Client.Session.Locations.ScoutLocationsAsync((HintCreationPolicy)0, ids));
			yield return (object)new WaitUntil((Func<bool>)(() => scout.IsCompleted));
			Plugin.Logger.LogInfo((object)"Completed scouting");
			if (!scout.IsCompletedSuccessfully)
			{
				if (retries >= 3)
				{
					Plugin.Logger.LogError((object)$"Couldn't scout locations - on try #{retries}, retrying");
					((MonoBehaviour)Plugin.Instance).StartCoroutine(ScoutLocationChecks(ids, retries + 1));
				}
				else
				{
					Plugin.Logger.LogError((object)"Couldn't scout locations");
				}
			}
			else
			{
				ItemsToSend = scout.Result;
			}
		}

		private static Level GetCurrentLevel()
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Invalid comparison between Unknown and I4
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			if (!Enum.TryParse<Level>(scnGame.internalIdentifier, out Level result))
			{
				Plugin.Logger.LogError((object)("Couldn't find Level. Level identifier: " + scnGame.internalIdentifier));
				Plugin.Client.TrapManager.ClearActiveTraps(returnToQueue: false);
				throw new ArgumentOutOfRangeException("Couldn't find level " + scnGame.internalIdentifier);
			}
			if (scnGame.instance.currentLevel.dogMode && (int)result == 26)
			{
				return (Level)84;
			}
			return result;
		}

		private static IEnumerable<long> GetStageLocationIDsToClear(Level level, Rank rank)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Logger.LogDebug((object)"Getting locations to clear");
			IEnumerable<long> locationsToClear = Bindings.LevelToStage[level].GetLocationsToClear(rank);
			Plugin.Logger.LogDebug((object)string.Format("Stage to clear: {0} with rank {1} ({2})", level, rank.internalValue, string.Join(", ", locationsToClear)));
			return locationsToClear;
		}
	}
	[HarmonyPatch]
	internal static class DeathLinkPatch
	{
		internal static bool enabled = true;

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		private static void ResetDeathLinkPatch()
		{
			Plugin.Logger.LogDebug((object)"Enabling DeathLink patch");
			enabled = true;
		}

		[HarmonyPatch(typeof(RowEntity), "CrackAdvance")]
		[HarmonyPostfix]
		private static void SendDeathLinkOnCrackedHeartPatch(RowEntity __instance)
		{
			if (Plugin.Client.DeathLink != null && enabled && !(__instance.rowMisses < ((RDBase)__instance).game.currentLevel.missesToCrackHeart))
			{
				Plugin.Logger.LogInfo((object)"Sending CrackAdvance death");
				enabled = false;
				Plugin.Client.SendDeathLink();
			}
		}

		[HarmonyPatch(typeof(scnGame), "FailLevel")]
		[HarmonyPostfix]
		private static void SendDeathLinkOnLevelFailPatch()
		{
			if (enabled)
			{
				Plugin.Logger.LogInfo((object)"Sending FailLevel death");
				enabled = false;
				Plugin.Client.SendDeathLink();
			}
		}

		[HarmonyPatch(typeof(scnGame), "FailLevelLite")]
		[HarmonyPostfix]
		private static void SendDeathLinkOnLevelFailLitePatch(scnGame __instance)
		{
			if (enabled && !(__instance.levelIdentifier == "Montage"))
			{
				Plugin.Logger.LogInfo((object)"Sending FailLevelLite death");
				enabled = false;
				Plugin.Client.SendDeathLink();
			}
		}

		[HarmonyPatch(typeof(LevelBase), "RunTag")]
		[HarmonyPostfix]
		private static void SendDeathLinkOnBeansHopperLossPatch(string tag)
		{
			if (enabled && scnGame.internalIdentifier == "BeansHopper" && tag == "miss" && scnGame.instance.currentLevel.i1 < 30)
			{
				Plugin.Logger.LogInfo((object)"Sending Beans Hopper death");
				enabled = false;
				Plugin.Client.SendDeathLink();
			}
		}
	}
	[HarmonyPatch(typeof(scnLevelSelect))]
	internal static class JanitorPatch
	{
		[HarmonyPatch("PerformEntityAction")]
		[HarmonyPrefix]
		private static void InteractJanitorPatch(scnLevelSelect __instance, ref bool __runOriginal)
		{
			SelectableEntity selectedEntity = __instance.selectedEntity;
			SelectableObject val = (SelectableObject)(object)((selectedEntity is SelectableObject) ? selectedEntity : null);
			if (val == null)
			{
				Plugin.Logger.LogWarning((object)"Current selectable object is null");
			}
			else if (val.action != "talkToJanitor")
			{
				Plugin.Logger.LogDebug((object)"Current selectable object's action is not talkToJanitor");
			}
			else
			{
				Plugin.Logger.LogError((object)"TODO: Implement janitor menu patch");
			}
		}

		[HarmonyPatch("ShowRanksText")]
		[HarmonyPrefix]
		private static void TextJanitorPatch(int index, scnLevelSelect __instance, ref bool __runOriginal)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			SelectableEntity obj = __instance.selectableEntities[index];
			SelectableObject val = (SelectableObject)(object)((obj is SelectableObject) ? obj : null);
			if (val == null)
			{
				Plugin.Logger.LogDebug((object)"Selectable entities is null");
				return;
			}
			if (!((SelectableEntity)val).id.StartsWith("TalkToJanitor"))
			{
				Plugin.Logger.LogDebug((object)"Selected object is not Janitor, doing nothing");
				return;
			}
			Plugin.Logger.LogDebug((object)"Overriding Janitor text");
			__runOriginal = false;
			__instance.ChangeTextOutline(RDConstants.data.levelSelect_notPassedLevelTextOutline);
			__instance.SetDifficultyArrowsVisible(false);
			__instance.description.text = RDString.Get("mainMenu.Archipelago");
		}

		[HarmonyPatch("PlaceJanitor")]
		[HarmonyPrefix]
		private static void PlaceJanitorPatch(ref bool __runOriginal)
		{
			Plugin.Logger.LogDebug((object)"Bypassing PlaceJanitor");
			__runOriginal = false;
		}

		[HarmonyPatch("HideJanitor")]
		[HarmonyPrefix]
		private static void HideJanitorPatch(ref bool __runOriginal)
		{
			Plugin.Logger.LogWarning((object)"Bypassing HideJanitor. This should never be called assuming PlaceJanitor was bypassed!");
			__runOriginal = false;
		}
	}
	[HarmonyPatch(typeof(scnLevelSelect))]
	internal static class LevelSelectVisualFixesPatch
	{
		private static readonly Level[] ForceDisplayAsRegularLevel;

		private static readonly Level[] ForceDisplayAsBossLevel;

		[HarmonyPatch("ShowRanksText")]
		[HarmonyPrefix]
		private static void ModifyLabelVisibilitiesPatch(int index, scnLevelSelect __instance)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			SelectableEntity obj = __instance.selectableEntities[index];
			SelectableCharacter val = (SelectableCharacter)(object)((obj is SelectableCharacter) ? obj : null);
			if (val != null && val.levels.TryGetValue(__instance.currentDifficulty, out var value))
			{
				if (ForceDisplayAsRegularLevel.Contains(value))
				{
					((SelectableEntity)val).levelType = (LevelType)1;
				}
				else if (ForceDisplayAsBossLevel.Contains(value))
				{
					((SelectableEntity)val).levelType = (LevelType)2;
				}
			}
		}

		[HarmonyPatch("ShowRanksText")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> DoNotShowUnlockHintsPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldstr, (object)"levelSelect.condition.{0}", (string)null)
			}).SetOpcodeAndAdvance(OpCodes.Nop).SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(scnLevelSelect), "currentDifficulty"), (string)null)
				})
				.Advance(-1)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Br_S)
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Ldstr, (object)"", (string)null)
				})
				.InstructionEnumeration();
		}

		static LevelSelectVisualFixesPatch()
		{
			Level[] array = new Level[6];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			ForceDisplayAsRegularLevel = (Level[])(object)array;
			ForceDisplayAsBossLevel = (Level[])(object)new Level[1] { (Level)16 };
		}
	}
	[HarmonyPatch]
	internal static class RhythmDogtorLevelPatch
	{
		[HarmonyPatch(typeof(scnLevelSelect), "LoadLevelData")]
		[HarmonyPostfix]
		private static void AddRhythmDogtorPatch(scnLevelSelect __instance)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: 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_00d9: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Expected O, but got Unknown
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Logger.LogDebug((object)"Creating Rhythm Dogtor entity");
			SelectableCharacter val = (SelectableCharacter)__instance.FindSelectableEntity("3-X");
			val.bpmHard = val.bpmNormal;
			((SelectableEntity)val).hardEnabled = true;
			val.charactersHard = (Character[])(object)new Character[1] { (Character)22 };
			val.levels[(Difficulty)2] = (Level)84;
			val.portraitsHard = (Character[])(object)new Character[2]
			{
				(Character)23,
				(Character)22
			};
			if (!GC.levelMetadata.ContainsKey((Level)84))
			{
				Plugin.Logger.LogDebug((object)"Creating Rhythm Dogtor metadata");
				LevelMetadata val2 = GC.levelMetadata[(Level)26];
				GuestData guest = new GuestData
				{
					link = val2.guest1.link,
					linkType = val2.guest1.linkType,
					name = val2.guest1.name,
					type = "Mix"
				};
				GuestData guest2 = new GuestData
				{
					link = "https://x.com/Morphious86",
					linkType = "Twitter",
					name = "Morphious86",
					type = "VocalsAndArt"
				};
				LevelMetadata val3 = new LevelMetadata();
				val3.id = "3-DOG";
				val3.type = val2.type;
				val3.portraits = (Character[])(object)new Character[2]
				{
					(Character)23,
					(Character)22
				};
				val3.characters = (Character[])(object)new Character[1] { (Character)22 };
				val3.guest1 = guest;
				val3.guest2 = guest2;
				val3.guest3 = null;
				val3.guest4 = null;
				LevelMetadata value = val3;
				GC.levelMetadata.Add((Level)84, value);
			}
		}

		[HarmonyPatch(typeof(scnLevelSelect), "GoToLevelSequence")]
		[HarmonyPrefix]
		private static void GoToRhythmDogtorPatch(ref string levelToGo, scnLevelSelect __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			if ((int)__instance.currentDifficulty == 2 && (int)RDUtils.ParseEnum<Level>(levelToGo, (Level)0) == 84)
			{
				Plugin.Logger.LogInfo((object)"Going to Rhythm Dogtor...");
				Persistence.SetLastPlayedLevel((Level)84);
				levelToGo = "Lesmis";
				scnGame.loadDogMode = true;
			}
		}

		[HarmonyPatch(typeof(Rankscreen), "ShowAndSaveRank")]
		[HarmonyPrefix]
		private static void SaveRhythmDogtorRankPatch(bool bossLevelFailed, Rankscreen __instance)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (!bossLevelFailed && !(((RDBase)__instance).game.levelIdentifier != "Lesmis") && ((RDBase)__instance).game.currentLevel.dogMode)
			{
				Plugin.Logger.LogInfo((object)"Saving Rhythm Dogtor rank...");
				Persistence.SetLevelRank((Level)84, ((RDBase)__instance).game.currentLevel.GetRankFromMistakes(), false, true);
			}
		}

		[HarmonyPatch(typeof(scnLevelSelect), "SetDifficulty")]
		[HarmonyPrefix]
		private static void ShowAdogPatch(Difficulty newDifficulty, scnLevelSelect __instance)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			Rank levelRank = Persistence.GetLevelRank((Level)26, false, -1);
			bool passed = ((Rank)(ref levelRank)).passed;
			if ((int)newDifficulty != 1)
			{
				if ((int)newDifficulty == 2)
				{
					__instance.FindSelectableEntity("3-X").gameObject.SetActive(true);
					HideSleepingPaige();
				}
			}
			else if (passed)
			{
				__instance.FindSelectableEntity("3-X").gameObject.SetActive(false);
				HideSleepingPaige();
			}
			void HideSleepingPaige()
			{
				if (((InvisibleEntity)__instance.sleepingPaige).shaderRenderer != null)
				{
					((Entity)__instance.sleepingPaige).visible = false;
				}
				else
				{
					Plugin.Logger.LogWarning((object)"[RhythmDogtorLevelPatch] Sleeping Paige shader renderer is null");
				}
			}
		}
	}
	[HarmonyPatch(typeof(scnRhythmWeightlifter))]
	internal static class RhythmWeightlifterPatch
	{
		[HarmonyPatch("PlayLevelDialogue")]
		[HarmonyPrefix]
		private static void DoNotShowDialoguePatch(ref bool __runOriginal)
		{
			__runOriginal = false;
		}
	}
	[HarmonyPatch(typeof(WalkingSelectableCharacter))]
	internal static class RunningCharactersPatch
	{
		[HarmonyPatch("UpdateCharacter")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> WalkingSelectableCharacterOverLockedLevelsPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
			foreach (CodeInstruction item in val.Instructions())
			{
				if (item.opcode == OpCodes.Call && (MethodInfo)item.operand == AccessTools.Method(typeof(RDUtils), "Locked", new Type[1] { typeof(Level) }, (Type[])null))
				{
					item.opcode = OpCodes.Ldc_I4_0;
				}
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch]
	internal static class SkipCutscenePatch
	{
		[HarmonyPatch(typeof(Persistence), "GetPlayedPassedLevelCutscene")]
		[HarmonyPatch(typeof(Persistence), "GetPlayedPostAct2Cutscene")]
		[HarmonyPatch(typeof(Persistence), "GetPlayedPostAct3Cutscene")]
		[HarmonyPatch(typeof(Persistence), "GetPlayedPostAct4Cutscene")]
		[HarmonyPatch(typeof(Persistence), "GetPlayedPreAct5Cutscene")]
		[HarmonyPatch(typeof(Persistence), "GetPlayedPreAct6Cutscene")]
		[HarmonyPatch(typeof(Persistence), "GetPlayedHaileyDuetIntroduction")]
		[HarmonyPatch(typeof(Persistence), "GetPlayedPreBitternessCutscene")]
		[HarmonyPatch(typeof(Persistence), "GetPlayedRooftopCutscene")]
		[HarmonyPrefix]
		private static void PersistenceDoNotPlayCutscenePatch(ref bool __result, ref bool __runOriginal)
		{
			__result = true;
			__runOriginal = false;
		}

		[HarmonyPatch(typeof(scnLevelSelect), "MovePaigeToVendingMachine")]
		[HarmonyPatch(typeof(scnLevelSelect), "PlayAct5Intro")]
		[HarmonyPatch(typeof(scnLevelSelect), "CheckForCutscene")]
		[HarmonyPatch(typeof(scnBase), "GoToCutscene")]
		[HarmonyPrefix]
		private static void LevelSelectDoNotPlayCutscenePatch(ref bool __runOriginal)
		{
			__runOriginal = false;
		}

		[HarmonyPatch(typeof(scnLevelSelect), "Start")]
		[HarmonyPostfix]
		private static void SkipStoryAndCutscenePatch(scnLevelSelect __instance)
		{
			scnLevelSelect.bitternessWarningPlayed = true;
			__instance.voidItemProgress = 3;
			__instance.selectableEntities.Find((SelectableEntity entity) => entity.id == "VoidItem1").normalEnabled = true;
			__instance.selectableEntities.Find((SelectableEntity entity) => entity.id == "VoidItem2").normalEnabled = true;
			__instance.selectableEntities.Find((SelectableEntity entity) => entity.id == "VoidItem3").normalEnabled = true;
		}
	}
	[HarmonyPatch(typeof(scnGame))]
	internal static class SkipTutorialPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> FixLesmisPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldstr, (object)"Level_", (string)null)
			}).Advance(3).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
			{
				new CodeInstruction(OpCodes.Ldstr, (object)", Assembly-CSharp"),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method("System.String:Concat", new Type[2]
				{
					typeof(string),
					typeof(string)
				}, (Type[])null))
			})
				.InstructionEnumeration();
		}

		[HarmonyPatch("Start")]
		[HarmonyPrefix]
		private static void DoNotLoadTutorialPatch()
		{
			if (scnGame.internalIdentifier == "Montage")
			{
				Plugin.Logger.LogDebug((object)"Level is 7-X, not skipping tutorial");
				return;
			}
			Plugin.Logger.LogDebug((object)$"Level {scnGame.internalIdentifier}: Forcing attemptToLoadTutorial from {scnGame.attemptToLoadTutorial} to false");
			scnGame.attemptToLoadTutorial = false;
		}

		[HarmonyPatch(typeof(Persistence), "GetFirstTimePlaying")]
		[HarmonyPrefix]
		private static void DoNotLoadIntroPatch(ref bool __result, ref bool __runOriginal)
		{
			Plugin.Logger.LogDebug((object)"Forcing first_time to false");
			__runOriginal = false;
			__result = false;
		}
	}
	[HarmonyPatch(typeof(Persistence))]
	internal static class StateReplicationPatch
	{
		[HarmonyPatch("SetPaigeEnding")]
		[HarmonyPostfix]
		private static void ReplicatePaigeStaysPatch(bool paigeStays)
		{
			Plugin.Logger.LogInfo((object)string.Format("Replicating {0} to {1}", "paige_stays", paigeStays));
			Plugin.Client.Session.DataStorage[(Scope)3, "paige_stays"] = DataStorageElement.op_Implicit(paigeStays);
		}

		[HarmonyPatch("SetIanDesktopLogin")]
		[HarmonyPostfix]
		private static void ReplicateIansDesktopUnlockedPatch(bool ianDesktopLogin)
		{
			Plugin.Logger.LogInfo((object)string.Format("Replicating {0} to {1}", "ian_desktop_login", ianDesktopLogin));
			Plugin.Client.Session.DataStorage[(Scope)3, "ian_desktop_login"] = DataStorageElement.op_Implicit(ianDesktopLogin);
		}

		internal static async Task InitializeSync()
		{
			Task task = InitializeKey<bool>("paige_stays", Persistence.SetPaigeEnding, delegate
			{
				bool flag = Plugin.Random.Next() % 2 == 1;
				Plugin.Client.Session.DataStorage[(Scope)3, "paige_stays"] = DataStorageElement.op_Implicit(flag);
				return flag;
			});
			Task task2 = InitializeKey<bool>("ian_desktop_login", Persistence.SetIanDesktopLogin, delegate
			{
				Plugin.Client.Session.DataStorage[(Scope)3, "ian_desktop_login"] = DataStorageElement.op_Implicit(false);
				return false;
			});
			Plugin.Logger.LogInfo((object)"Waiting for initialization to complete...");
			await Task.WhenAll(task, task2);
			Plugin.Logger.LogInfo((object)"Initialization completed!");
			static async Task InitializeKey<T>(string key, Action<T> executeExisting, Func<T> valueDoesntExist) where T : notnull
			{
				JToken val = await Plugin.Client.Session.DataStorage[(Scope)3, key].GetAsync();
				if ((int)val.Type != 10 && (int)val.Type != 11)
				{
					T val2 = val.ToObject<T>();
					Plugin.Logger.LogInfo((object)$"Found {key} state: {val2}");
					executeExisting(val2);
				}
				else
				{
					T val3 = valueDoesntExist();
					Plugin.Logger.LogInfo((object)$"Setting initial {key} state to {val3}");
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class TrapManagerPatch
	{
		[HarmonyPatch(typeof(scnLevelSelect), "SelectCharacter")]
		[HarmonyPrefix]
		private static void ApplyApplicableTrapPreviewPatch(scnLevelSelect __instance)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			SelectableEntity selectedEntity = __instance.selectedEntity;
			SelectableCharacter val = (SelectableCharacter)(object)((selectedEntity is SelectableCharacter) ? selectedEntity : null);
			if (val != null)
			{
				Level level = val.levels[__instance.currentDifficulty];
				Plugin.Client.TrapManager.ApplyApplicableTraps(level);
			}
		}

		[HarmonyPatch(typeof(HeartMonitor), "Show")]
		[HarmonyPostfix]
		private static void ShowTrapNameOnPhonePatch(HeartMonitor __instance)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			IEnumerable<string> previewTrapNames = Plugin.Client.TrapManager.GetPreviewTrapNames();
			if (!previewTrapNames.Any())
			{
				return;
			}
			Plugin.Logger.LogDebug((object)"Instantiating guest credit for preview traps");
			__instance.isGuestCreditShown = true;
			foreach (string item in previewTrapNames)
			{
				Plugin.Logger.LogDebug((object)("Creating guest credit for " + item));
				GuestData val = new GuestData
				{
					type = null,
					link = null,
					linkType = "other-unused",
					name = item
				};
				GameObject val2 = Object.Instantiate<GameObject>(__instance.guestPrefab, (Transform)(object)__instance.creditsContainer);
				HeartMonitorGuest component = val2.GetComponent<HeartMonitorGuest>();
				component.Setup(val);
				__instance.creditStrings.Add(val.name);
				__instance.links.Add(val.link);
				__instance.creditsElements.Add(val2);
				component.nameText.text = item;
			}
		}

		[HarmonyPatch(typeof(scnLevelSelect), "GoToLevelSequence")]
		[HarmonyPostfix]
		private static void ApplyApplicableTrapsPatch(string levelToGo, scnLevelSelect __instance)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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)
			Plugin.Logger.LogInfo((object)"Promoting preview traps to active traps");
			if ((levelToGo == "Lesmis" || levelToGo == "RhythmWeightlifter") ? true : false)
			{
				Plugin.Logger.LogInfo((object)"Going to Rhythm Dogtor/Rhythm Weightlifter (dog) - applying preview traps now");
				Level level = RDUtils.ParseEnum<Level>(levelToGo, (Level)0);
				Plugin.Client.TrapManager.ApplyApplicableTraps(level);
			}
			Plugin.Client.TrapManager.PromotePreviewTrapsToActiveTraps();
		}

		[HarmonyPatch(typeof(scnBase), "GoToLevel")]
		[HarmonyPostfix]
		private static void ApplyApplicableTrapsOnLevelChangePatch(string path)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			Level val = RDUtils.ParseEnum<Level>(path, (Level)0);
			if ((int)val == 50)
			{
				Plugin.Logger.LogWarning((object)$"Applying traps for {val} immediately");
				Plugin.Client.TrapManager.ApplyApplicableTraps(val);
				Plugin.Client.TrapManager.PromotePreviewTrapsToActiveTraps();
			}
		}

		[HarmonyPatch(typeof(scnGame), "Quit")]
		[HarmonyPostfix]
		private static void RestoreActiveTrapsOnAbandonPatch()
		{
			Plugin.Logger.LogInfo((object)"Clearing active traps (returning to queue)");
			Plugin.Client.TrapManager.ClearActiveTraps(returnToQueue: true);
		}
	}
	[HarmonyPatch(typeof(scnLevelSelect))]
	internal static class UnlockItemPatch
	{
		[HarmonyPatch("LoadLevelData")]
		[HarmonyPostfix]
		private static void UnlockEntitiesWithItemsPatch(scnLevelSelect __instance)
		{
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_057f: Unknown result type (might be due to invalid IL or missing references)
			//IL_05aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0604: Unknown result type (might be due to invalid IL or missing references)
			//IL_0609: Unknown result type (might be due to invalid IL or missing references)
			//IL_0628: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d3: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Logger.LogInfo((object)"Checking for extra unlocks");
			Plugin.Logger.LogInfo((object)"Checking for regions to unlock");
			bool flag = false;
			foreach (ItemInfo item in Plugin.Client.Session.Items.AllItemsReceived)
			{
				Plugin.Logger.LogDebug((object)$"Processing item {item.ItemName} ({item.ItemId})");
				Level value2;
				if (Bindings.KeyItemIdToWard.TryGetValue(item.ItemId, out var value))
				{
					if (value == Region.Basement)
					{
						flag = true;
					}
					Plugin.Logger.LogInfo((object)$"Unlocking entrance {value}");
					scnLevelSelect.instance.UnlockEntrance(value);
				}
				else if (Bindings.ItemIdToLevel.TryGetValue(item.ItemId, out value2))
				{
					Plugin.Logger.LogInfo((object)string.Format("[{0}] Unlocking stage item {1} ({2}, {3})", "UnlockItemPatch", item.ItemName, item.ItemId, value2));
					Persistence.SetLevelRank(value2, Rank.op_Implicit(-1), false, false);
				}
			}
			if (!flag)
			{
				Plugin.Logger.LogInfo((object)"Locking basement");
				__instance.LockEntrance("GoToBasement");
			}
			Plugin.Logger.LogInfo((object)"Moving 1-CNY");
			__instance.FindSelectableEntity("1-CNY").gamePosition.x = -564f;
			if (Plugin.Client.Slot.endGoal == SlotData.EndGoal.HelpingHands)
			{
				Plugin.Logger.LogInfo((object)"Moving X-1 to the basement");
				SelectableEntity val = __instance.FindSelectableEntity("X-1");
				val.group = 3;
				int index = __instance.selectableEntities.FindIndex((SelectableEntity entity) => ((Object)entity.gameObject).name == "BasementComputer") + 1;
				val.gamePosition = new Vector2(2480f, 53f);
				__instance.selectableEntities.Remove(val);
				__instance.selectableEntities.Insert(index, val);
				if (Bindings.ActBoss.Values.All((Level[] levels) => levels.All(delegate(Level level)
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					//IL_0003: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Unknown result type (might be due to invalid IL or missing references)
					Rank levelRank2 = Persistence.GetLevelRank(level, false, -1);
					return ((Rank)(ref levelRank2)).passed;
				})))
				{
					Plugin.Logger.LogInfo((object)"Unlocking Art Room and X-0 - Helping Hands");
					__instance.UnlockEntrance(__instance.FindSelectableEntity("GoToArtRoom"));
					Persistence.SetLevelRank((Level)55, Rank.op_Implicit(-1), false, false);
				}
			}
			GameObject.Find("/Scene/Corridor/VendingMachinePaige").gameObject.SetActive(false);
			foreach (SelectableEntity item2 in __instance.selectableEntities.Where((SelectableEntity entity) => entity.id.StartsWith("X-") && !Regex.IsMatch(entity.id, "/[0-9]/")))
			{
				item2.normalEnabled = true;
			}
			__instance.GetSelectableEntity("2-B1").normalEnabled = true;
			__instance.GetSelectableEntity("5-B1").normalEnabled = true;
			foreach (SelectableEntity item3 in __instance.selectableEntities.Where((SelectableEntity entity) => entity.id.StartsWith("3-")))
			{
				item3.normalEnabled = true;
				if (item3.id != "3-X")
				{
					item3.hardEnabled = true;
				}
			}
			foreach (SelectableEntity item4 in __instance.selectableEntities.Where((SelectableEntity entity) => entity.id.StartsWith("5-")))
			{
				item4.normalEnabled = true;
				bool flag2;
				switch (item4.id)
				{
				case "5-1":
				case "5-2":
				case "5-3":
					flag2 = true;
					break;
				default:
					flag2 = false;
					break;
				}
				if (flag2)
				{
					item4.hardEnabled = true;
				}
			}
			GameObject.Find("/Scene/Levels Container/Vertical Movement/5-2").SetActive(true);
			GameObject.Find("/Scene/Levels Container/Vertical Movement/5-3").SetActive(true);
			GameObject.Find("/Scene/Levels Container/Vertical Movement/5-X").SetActive(true);
			SelectableEntity selectableEntity = __instance.GetSelectableEntity("1-CNY");
			selectableEntity.normalEnabled = true;
			selectableEntity.gameObject.SetActive(true);
			SelectableEntity selectableEntity2 = __instance.GetSelectableEntity("1-BOO");
			selectableEntity2.normalEnabled = true;
			selectableEntity2.gameObject.SetActive(true);
			__instance.GetSelectableEntity("MD-1").normalEnabled = true;
			__instance.GetSelectableEntity("1-X").hardEnabled = true;
			SelectableEntity selectableEntity3 = __instance.GetSelectableEntity("2-X");
			selectableEntity3.normalEnabled = true;
			selectableEntity3.hardEnabled = true;
			SelectableEntity selectableEntity4 = __instance.GetSelectableEntity("5-1");
			selectableEntity4.normalEnabled = true;
			selectableEntity4.hardEnabled = true;
			SelectableEntity[] array = (SelectableEntity[])(object)new SelectableEntity[3]
			{
				__instance.FindSelectableEntity("6-2"),
				__instance.FindSelectableEntity("6-X"),
				__instance.FindSelectableEntity("7-1")
			};
			for (int num = 0; num < array.Length; num++)
			{
				array[num].normalEnabled = true;
			}
			GameObject.Find("/Scene/Levels Container/Vertical Movement/6-2").SetActive(true);
			__instance.GetSelectableEntity("VoidItem1").normalEnabled = true;
			__instance.GetSelectableEntity("VoidItem2").normalEnabled = true;
			__instance.GetSelectableEntity("VoidItem3").normalEnabled = true;
			((tk2dBaseSprite)__instance.abandonedWard.voidItems[0]).color = new Color(1f, 1f, 1f, 1f);
			((tk2dBaseSprite)__instance.abandonedWard.voidItems[1]).color = new Color(1f, 1f, 1f, 1f);
			((tk2dBaseSprite)__instance.abandonedWard.voidItems[2]).color = new Color(1f, 1f, 1f, 1f);
			__instance.GetSelectableEntity("7-X").normalEnabled = true;
			Persistence.SetLevelRank((Level)49, Rank.op_Implicit(-1), false, true);
			Rank levelRank = Persistence.GetLevelRank((Level)49, false, -1);
			if (((Rank)(ref levelRank)).passed)
			{
				__instance.GetSelectableEntity("7-X2").normalEnabled = true;
				Persistence.SetLevelRank((Level)50, Rank.op_Implicit(-1), false, true);
			}
			SelectableEntity selectableEntity5 = __instance.GetSelectableEntity("X-0");
			selectableEntity5.normalEnabled = true;
			selectableEntity5.gameObject.SetActive(true);
			SelectableEntity selectableEntity6 = __instance.GetSelectableEntity("X-1");
			selectableEntity6.normalEnabled = true;
			selectableEntity6.gameObject.SetActive(true);
			foreach (Act value3 in Enum.GetValues(typeof(Act)))
			{
				if (!HasUnlockedBossSong(value3))
				{
					continue;
				}
				Plugin.Logger.LogDebug((object)$"Unlocking act {value3}");
				Level[] array2 = Bindings.ActBoss[value3];
				for (int num = 0; num < array2.Length; num++)
				{
					int num2 = (int)array2[num];
					Persistence.SetLevelRank((Level)num2, Rank.op_Implicit(-1), false, false);
					if (num2 == 49)
					{
						__instance.UnlockEntrance(Region.RecordsRoom);
					}
				}
			}
		}

		[HarmonyPatch("LoadLevelData")]
		[HarmonyPatch("LevelJustPassedSequenceCo")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> DoNotUnlockEntrancesPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
			foreach (CodeInstruction item in val.Instructions())
			{
				if (item.opcode == OpCodes.Call && (MethodInfo)item.operand == AccessTools.Method(typeof(scnLevelSelect), "UnlockEntrance", new Type[1] { typeof(SelectableEntity) }, (Type[])null))
				{
					item.opcode = OpCodes.Nop;
				}
			}
			return val.InstructionEnumeration();
		}

		[HarmonyPatch("UnlockNightShiftLevel")]
		[HarmonyPrefix]
		private static void DoNotUnlockNightShiftLevelPatch(ref bool __runOriginal)
		{
			__runOriginal = false;
		}

		[HarmonyPatch("LoadLevelData")]
		[HarmonyPatch("Awake")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> DoNotUnlockLevelsPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
			List<CodeInstruction> list = val.Instructions();
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val2 = list[i];
				if (!(val2.opcode == OpCodes.Call))
				{
					continue;
				}
				int num;
				if ((MethodInfo)val2.operand == AccessTools.Method(typeof(Persistence), "SetLevelRank", new Type[4]
				{
					typeof(string),
					typeof(Rank),
					typeof(bool),
					typeof(bool)
				}, (Type[])null))
				{
					num = -9;
				}
				else
				{
					if (!((MethodInfo)val2.operand == AccessTools.Method(typeof(Persistence), "SetLevelRank", new Type[4]
					{
						typeof(Level),
						typeof(Rank),
						typeof(bool),
						typeof(bool)
					}, (Type[])null)))
					{
						continue;
					}
					num = -5;
				}
				for (int j = num; j <= 1; j++)
				{
					list[i + j].opcode = OpCodes.Nop;
				}
			}
			return val.InstructionEnumeration();
		}

		[HarmonyPatch("ShowRanksText")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> CustomPopulateSelectedVerticalDestinationsPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			int match = 0;
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(true, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Stfld, (object)AccessTools.Field(typeof(scnLevelSelect), "selectedVerticalDestinations"), (string)null)
			}).Repeat((Action<CodeMatcher>)delegate(CodeMatcher codeMatcher)
			{
				codeMatcher.Advance(1);
				switch (match)
				{
				case 0:
					codeMatcher.Insert((CodeInstruction[])(object)new CodeInstruction[1] { Transpilers.EmitDelegate<Action>((Action)delegate
					{
						//IL_008a: Unknown result type (might be due to invalid IL or missing references)
						//IL_0094: Expected O, but got Unknown
						//IL_00db: Unknown result type (might be due to invalid IL or missing references)
						//IL_00e5: Expected O, but got Unknown
						Plugin.Logger.LogInfo((object)"Setting Ian's laptop vertical destinations");
						scnLevelSelect.instance.selectedVerticalDestinations = new List<LevelSelectDestination>();
						if (Plugin.Client.Session.Items.AllItemsReceived.Any((ItemInfo item) => item.ItemId == 56))
						{
							Plugin.Logger.LogInfo((object)"Adding sleevePaint");
							scnLevelSelect.instance.selectedVerticalDestinations.Add(new LevelSelectDestination("sleevePaint", RDString.Get("levelSelect.SleevePaint"), RDString.Get("levelSelect.SleevePaint.details")));
						}
						Plugin.Logger.LogInfo((object)"Adding IanDesktop");
						scnLevelSelect.instance.selectedVerticalDestinations.Add(new LevelSelectDestination("IanDesktop", RDString.Get("levelSelect.IanDesktop"), RDString.Get($"levelSelect.IanDesktop.details.{((!Persistence.GetIanDesktopLogin()) ? 1 : 2)}")));
					}) });
					break;
				case 1:
					codeMatcher.Insert((CodeInstruction[])(object)new CodeInstruction[1] { Transpilers.EmitDelegate<Action>((Action)delegate
					{
						//IL_008a: Unknown result type (might be due to invalid IL or missing references)
						//IL_0094: Expected O, but got Unknown
						//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
						//IL_00d8: Expected O, but got Unknown
						Plugin.Logger.LogInfo((object)"Setting main elevator vertical destinations");
						scnLevelSelect.instance.selectedVerticalDestinations = new List<LevelSelectDestination>();
						if (Plugin.Client.Session.Items.AllItemsReceived.Any((ItemInfo item) => item.ItemId == Bindings.RegionToKeyID[Region.RecordsRoom]))
						{
							Plugin.Logger.LogInfo((object)"Adding ExitRecordsRoom");
							scnLevelSelect.instance.selectedVerticalDestinations.Add(new LevelSelectDestination("ExitRecordsRoom", RDString.Get("levelSelect.act6"), RDString.Get("levelSelect.GoToRecordsRoom.day")));
						}
						if (HasUnlockedBossSong(Act.Act7))
						{
							Plugin.Logger.LogInfo((object)"Adding ExitVoid");
							scnLevelSelect.instance.selectedVerticalDestinations.Add(new LevelSelectDestination("ExitVoid", RDString.Get("levelSelect.finale"), RDString.Get("levelSelect.GoToVoid.day")));
						}
					}) });
					break;
				default:
					Plugin.Logger.LogWarning((object)"Matched more than two vertical destinations - plugin may need update!!");
					break;
				}
				match++;
			}, (Action<string>)null).Start()
				.MatchForward(true, (CodeMatch[])(object)new CodeMatch[3]
				{
					new CodeMatch((OpCode?)OpCodes.Ldc_I4_S, (object)(sbyte)48, (string)null),
					new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(RDUtils), "Passed", (Type[])null, (Type[])null), (string)null),
					new CodeMatch((OpCode?)OpCodes.Brfalse, (object)null, (string)null)
				})
				.ThrowIfInvalid("Couldn't find Level.Bitterness.Passed()")
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Pop, (object)null)
				})
				.SetOpcodeAndAdvance(OpCodes.Br)
				.InstructionEnumeration();
		}

		[HarmonyPatch("UpdateCharacters")]
		[HarmonyPostfix]
		private static void UpdateCharactersPatch(scnLe