using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
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.MessageLog.Parts;
using Archipelago.MultiClient.Net.Models;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using POKModManager;
using PeaksOfArchipelago;
using Rewired;
using Steamworks;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("PeaksOfArchipelago")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.7.1.0")]
[assembly: AssemblyInformationalVersion("1.7.1+23f497084d3ea430ef0e5a98eea83574e8b771da")]
[assembly: AssemblyProduct("Peaks Of Archipelago")]
[assembly: AssemblyTitle("PeaksOfArchipelago")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.7.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
internal class Traps : MonoBehaviour
{
	private enum Trap
	{
		Birds,
		Night,
		Holds,
		Gravity,
		OneTime
	}

	private enum SingleTimeTrap
	{
		Ropes,
		Chalk,
		Coffee,
		Seeds
	}

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

		private object <>2__current;

		public Traps <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				if ((Object)(object)<>4__this.hunter != (Object)null && (Object)(object)<>4__this.crow != (Object)null)
				{
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				}
				UIHandler.instance.AddChatMessage("Something went wrong, please report this to the dev :) \n (you can keep playing)");
				logger.LogInfo((object)"birds are null?");
				break;
			case 1:
				<>1__state = -1;
				UIHandler.instance.Notify("You've awakened the birds's wrath");
				logger.LogInfo((object)"activating birds");
				((Component)<>4__this.hunter).gameObject.SetActive(true);
				((Component)<>4__this.crow).gameObject.SetActive(true);
				<>4__this.birdTrapRunning = true;
				<>4__this.hunter.InitiateBird();
				<>4__this.crow.InitiateBird();
				<>2__current = <>4__this.StartTimer("Birds!", 30f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<>4__this.birdTrapRunning = false;
				logger.LogInfo((object)"deactivating birds");
				((Component)<>4__this.hunter).gameObject.SetActive(false);
				((Component)<>4__this.crow).gameObject.SetActive(false);
				break;
			}
			return false;
		}

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

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

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

		private object <>2__current;

		public Traps <>4__this;

		private GameObject[] <array>5__1;

		private int <i>5__2;

		private int <i>5__3;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForEndOfFrame();
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.holdsTrapRunning = true;
				<array>5__1 = GameObject.FindGameObjectsWithTag("Climbable");
				UIHandler.instance.Notify("All the holds seem so small today");
				<i>5__2 = 0;
				while (<i>5__2 < <array>5__1.Length)
				{
					if (((Object)<array>5__1[<i>5__2]).name != "ClimbableSloper_Normal" && ((Object)<array>5__1[<i>5__2]).name != "ClimbableSloper_Slippery" && ((Object)<array>5__1[<i>5__2]).name != "ClimbableSloper_Easy" && ((Object)<array>5__1[<i>5__2]).name != "ClimbableSloper_Rain" && ((Object)<array>5__1[<i>5__2]).name != "ClimbableSloper_Rain_Brick")
					{
						<array>5__1[<i>5__2].tag = "ClimbableMicroHold";
					}
					<i>5__2++;
				}
				<>2__current = <>4__this.StartTimer("Oops, all crimps!", 30f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<>2__current = (object)new WaitForEndOfFrame();
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				<i>5__3 = 0;
				while (<i>5__3 < <array>5__1.Length)
				{
					if (((Object)<array>5__1[<i>5__3]).name != "ClimbableSloper_Normal" && ((Object)<array>5__1[<i>5__3]).name != "ClimbableSloper_Slippery" && ((Object)<array>5__1[<i>5__3]).name != "ClimbableSloper_Easy" && ((Object)<array>5__1[<i>5__3]).name != "ClimbableSloper_Rain" && ((Object)<array>5__1[<i>5__3]).name != "ClimbableSloper_Rain_Brick")
					{
						<array>5__1[<i>5__3].tag = "Climbable";
					}
					<i>5__3++;
				}
				<>4__this.holdsTrapRunning = false;
				return false;
			}
		}

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

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

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

		private object <>2__current;

		public Traps <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForEndOfFrame();
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				UIHandler.instance.Notify("How much porridge did ye have for breakfast?");
				<>4__this.gravityTrapRunning = true;
				Physics.gravity = new Vector3(0f, -10.692901f, 0f);
				<>2__current = <>4__this.StartTimer("Feeling Heavy", 30f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				Physics.gravity = new Vector3(0f, -9.81f, 0f);
				<>4__this.gravityTrapRunning = false;
				return false;
			}
		}

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

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

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

		private object <>2__current;

		public Traps <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForEndOfFrame();
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				UIHandler.instance.Notify("Sudden Eclipse");
				logger.LogInfo((object)"Starting Night Trap");
				GameManager.control.alps_statue_sundown_InUse = true;
				Object.FindObjectOfType<EnterPeakScene>().PublicSetSundown();
				GameManager.control.alps_statue_sundown_InUse = false;
				if (playerData.items.lamp)
				{
					<>4__this.oilLamp.lampObj.SetActive(true);
					((MonoBehaviour)<>4__this.oilLamp).StartCoroutine("StartOilLamp", (object)false);
				}
				<>4__this.nightTrapRunning = true;
				<>2__current = <>4__this.StartTimer("Eclipse", 60f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<>4__this.nightTrapRunning = false;
				if (playerData.items.lamp)
				{
					<>4__this.oilLamp.lampObj.SetActive(false);
				}
				Object.FindObjectOfType<EnterPeakScene>().PublicSetSundown();
				return false;
			}
		}

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

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

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

		private object <>2__current;

		public Traps <>4__this;

		private GameObject[] <array>5__1;

		private int <j>5__2;

		private int <j>5__3;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForEndOfFrame();
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				UIHandler.instance.Notify("You seem to tire quicker than usual");
				<>4__this.holdsTrapRunning = true;
				<array>5__1 = GameObject.FindGameObjectsWithTag("Climbable");
				<j>5__2 = 0;
				while (<j>5__2 < <array>5__1.Length)
				{
					<array>5__1[<j>5__2].tag = "ClimbablePitch";
					<j>5__2++;
				}
				<>2__current = <>4__this.StartTimer("Oops, all pitches!", 30f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<>2__current = (object)new WaitForEndOfFrame();
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				<j>5__3 = 0;
				while (<j>5__3 < <array>5__1.Length)
				{
					<array>5__1[<j>5__3].tag = "Climbable";
					<j>5__3++;
				}
				<>4__this.holdsTrapRunning = false;
				return false;
			}
		}

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

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

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

		private object <>2__current;

		public Traps <>4__this;

		private GameObject[] <array>5__1;

		private string[] <array2>5__2;

		private int <j>5__3;

		private int <j>5__4;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForEndOfFrame();
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				UIHandler.instance.Notify("Your hands feel greasy");
				<>4__this.holdsTrapRunning = true;
				<array>5__1 = GameObject.FindGameObjectsWithTag("Climbable");
				<array2>5__2 = new string[<array>5__1.Length];
				<j>5__3 = 0;
				while (<j>5__3 < <array>5__1.Length)
				{
					<array2>5__2[<j>5__3] = ((Object)<array>5__1[<j>5__3]).name;
					((Object)<array>5__1[<j>5__3]).name = "ClimbableSloper_Easy";
					<j>5__3++;
				}
				<>2__current = <>4__this.StartTimer("Oops, all slopers!", 15f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<>2__current = (object)new WaitForEndOfFrame();
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				<j>5__4 = 0;
				while (<j>5__4 < <array>5__1.Length)
				{
					((Object)<array>5__1[<j>5__4]).name = <array2>5__2[<j>5__4];
					<j>5__4++;
				}
				<>4__this.holdsTrapRunning = false;
				return false;
			}
		}

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

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

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

		private object <>2__current;

		public string name;

		public float duration;

		public Traps <>4__this;

		private GameObject <p>5__1;

		private Text <t>5__2;

		private GameObject <c>5__3;

		private Image <i>5__4;

		private float <timer>5__5;

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

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

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

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<p>5__1 = null;
			<t>5__2 = null;
			<c>5__3 = null;
			<i>5__4 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: 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)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForEndOfFrame();
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.trapList.SetActive(true);
				<p>5__1 = UIHandler.CreatePanel(name + " clock", new Color(0f, 0f, 0f, 0.8f), <>4__this.trapList.transform, Vector2.zero, 0.5f, 0.5f, -1f, -1f, (TextAnchor)4, vertical: false);
				<t>5__2 = UIHandler.CreateTextElem("name", 32, <p>5__1.transform, (TextAnchor)4);
				<t>5__2.text = name;
				<c>5__3 = UIHandler.CreateClock("clock", Color.white, <p>5__1.transform, Vector2.zero, 36f);
				<i>5__4 = <c>5__3.GetComponent<Image>();
				<>2__current = null;
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<timer>5__5 = 0f;
				break;
			case 3:
				<>1__state = -1;
				break;
			}
			if (<timer>5__5 <= 1f)
			{
				<timer>5__5 += Time.deltaTime / duration;
				<i>5__4.fillAmount = 1f - <timer>5__5;
				<>2__current = null;
				<>1__state = 3;
				return true;
			}
			Object.Destroy((Object)(object)<p>5__1);
			if (<>4__this.trapList.transform.childCount == 0)
			{
				<>4__this.trapList.SetActive(false);
			}
			return false;
		}

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

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

	private Bird hunter = null;

	private Bird crow = null;

	public static ManualLogSource logger;

	private GameObject trapList;

	public static Traps instance;

	public static PlayerData playerData;

	private bool birdTrapRunning = false;

	private bool nightTrapRunning;

	private bool holdsTrapRunning;

	private bool gravityTrapRunning;

	private OilLamp oilLamp;

	public void Awake()
	{
		oilLamp = Object.FindObjectOfType<OilLamp>();
		if (!Object.op_Implicit((Object)(object)oilLamp))
		{
			logger.LogError((object)"Didn't find Oil Lamp!");
		}
		hunter = GameObject.Find("SeaBird_Hunter").GetComponent<Bird>();
		if (!Object.op_Implicit((Object)(object)hunter))
		{
			logger.LogError((object)"Didn't find Hunter!");
		}
		crow = GameObject.Find("CrowBird_Hunter").GetComponent<Bird>();
		if (!Object.op_Implicit((Object)(object)crow))
		{
			logger.LogError((object)"Didn't find Crow!");
		}
	}

	public void Start()
	{
		//IL_001b: 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)
		Color color = new Color(0f, 0f, 0f, 0.8f);
		Canvas obj = Object.FindObjectOfType<Canvas>();
		trapList = UIHandler.CreatePanel("trap list", color, (obj != null) ? ((Component)obj).transform : null, new Vector2(10f, 10f), 0f, 0f, -1f, -1f, (TextAnchor)4);
		trapList.SetActive(false);
	}

	public void StartTrap()
	{
		List<Trap> list = new List<Trap>(new <>z__ReadOnlySingleElementList<Trap>(Trap.OneTime));
		if (!birdTrapRunning)
		{
			list.Add(Trap.Birds);
		}
		if (!nightTrapRunning)
		{
			list.Add(Trap.Night);
		}
		if (!holdsTrapRunning)
		{
			list.Add(Trap.Holds);
		}
		if (!gravityTrapRunning)
		{
			list.Add(Trap.Gravity);
		}
		switch (list[Random.Range(0, list.Count)])
		{
		case Trap.Birds:
			StartBirdTrap();
			break;
		case Trap.Night:
			StartNightTrap();
			break;
		case Trap.Holds:
			StartHoldsTrap();
			break;
		case Trap.Gravity:
			StartGravityTrap();
			break;
		case Trap.OneTime:
			StartOneTimeTrap();
			break;
		}
	}

	public void StartGravityTrap()
	{
		((MonoBehaviour)this).StartCoroutine(GravityTrap());
	}

	public void StartBirdTrap()
	{
		((MonoBehaviour)this).StartCoroutine(BirdsTrap());
	}

	public void StartNightTrap()
	{
		((MonoBehaviour)this).StartCoroutine(NightTrap());
	}

	public void StartOneTimeTrap()
	{
		List<SingleTimeTrap> list = new List<SingleTimeTrap>();
		if (playerData.items.rope)
		{
			list.Add(SingleTimeTrap.Ropes);
		}
		if (playerData.items.coffee)
		{
			list.Add(SingleTimeTrap.Coffee);
		}
		if (playerData.items.chalkbag)
		{
			list.AddRange(new <>z__ReadOnlyArray<SingleTimeTrap>(new SingleTimeTrap[2]
			{
				SingleTimeTrap.Chalk,
				SingleTimeTrap.Seeds
			}));
		}
		if (list.Count == 0)
		{
			UIHandler.instance.Notify("Nothing Happened...");
			return;
		}
		SingleTimeTrap singleTimeTrap = list[Random.Range(0, list.Count)];
		switch ((SingleTimeTrap)Random.Range(0, 4))
		{
		case SingleTimeTrap.Ropes:
		{
			RopeAnchor val3 = Object.FindObjectOfType<RopeAnchor>();
			if (!((Object)(object)val3 == (Object)null) && val3.anchorsInBackpack > 0)
			{
				val3.anchorsInBackpack--;
				((MonoBehaviour)val3).StartCoroutine("RopesLeftTooltip");
				UIHandler.instance.Notify("You dropped a rope");
			}
			break;
		}
		case SingleTimeTrap.Coffee:
		{
			CoffeeDrink val2 = Object.FindObjectOfType<CoffeeDrink>();
			if (!((Object)(object)val2 == (Object)null) && val2.coffeeSipsLeft > 0)
			{
				val2.coffeeSipsLeft--;
				((MonoBehaviour)val2).StartCoroutine("CoffeeLeftToolTip");
				UIHandler.instance.Notify("Your coffee spilled");
			}
			break;
		}
		case SingleTimeTrap.Chalk:
		{
			ChalkBag val4 = Object.FindObjectOfType<ChalkBag>();
			if (!((Object)(object)val4 == (Object)null) && val4.chalkBagUsesLeft > 0)
			{
				val4.chalkBagUsesLeft--;
				((MonoBehaviour)val4).StartCoroutine("ChalkLeftToolTip", (object)false);
				UIHandler.instance.Notify("You found a hole in your chalk bag");
			}
			break;
		}
		case SingleTimeTrap.Seeds:
		{
			ChalkBag val = Object.FindObjectOfType<ChalkBag>();
			if (!((Object)(object)val == (Object)null) && val.birdseedsUsesLeft > 0)
			{
				val.birdseedsUsesLeft--;
				((MonoBehaviour)val).StartCoroutine("ChalkLeftToolTip", (object)true);
				UIHandler.instance.Notify("You realise you forgot a portion of bird seeds");
			}
			break;
		}
		}
	}

	public void StartHoldsTrap()
	{
		string[] array = new string[3] { "CrimpsTrap", "SlopersTrap", "PitchesTrap" };
		((MonoBehaviour)this).StartCoroutine(array[Random.Range(0, array.Length)]);
	}

	[IteratorStateMachine(typeof(<NightTrap>d__21))]
	private IEnumerator NightTrap()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <NightTrap>d__21(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<BirdsTrap>d__22))]
	private IEnumerator BirdsTrap()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <BirdsTrap>d__22(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<CrimpsTrap>d__23))]
	private IEnumerator CrimpsTrap()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <CrimpsTrap>d__23(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<SlopersTrap>d__24))]
	private IEnumerator SlopersTrap()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <SlopersTrap>d__24(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<PitchesTrap>d__25))]
	private IEnumerator PitchesTrap()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PitchesTrap>d__25(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<GravityTrap>d__26))]
	private IEnumerator GravityTrap()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <GravityTrap>d__26(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<StartTimer>d__27))]
	private IEnumerator StartTimer(string name, float duration)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <StartTimer>d__27(0)
		{
			<>4__this = this,
			name = name,
			duration = duration
		};
	}
}
internal class UIHandler : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <FadeAndShowText>d__16 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public CanvasGroup cg;

		public float fadeInTime;

		public float stayTime;

		public float fadeOutTime;

		public UIHandler <>4__this;

		private float <timer>5__1;

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

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

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

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

		private bool MoveNext()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForEndOfFrame();
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				cg.alpha = 0f;
				<timer>5__1 = 0f;
				goto IL_00c6;
			case 2:
				<>1__state = -1;
				goto IL_00c6;
			case 3:
				<>1__state = -1;
				<timer>5__1 = 0f;
				goto IL_0160;
			case 4:
				<>1__state = -1;
				goto IL_0160;
			case 5:
				{
					<>1__state = -1;
					Object.Destroy((Object)(object)((Component)cg).gameObject);
					return false;
				}
				IL_0160:
				if (<timer>5__1 < 1f)
				{
					<timer>5__1 += Time.deltaTime * fadeOutTime;
					cg.alpha = 1f - <timer>5__1;
					<>2__current = null;
					<>1__state = 4;
					return true;
				}
				cg.alpha = 0f;
				<>2__current = null;
				<>1__state = 5;
				return true;
				IL_00c6:
				if (<timer>5__1 < 1f)
				{
					<timer>5__1 += Time.deltaTime / fadeInTime;
					cg.alpha = <timer>5__1;
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				cg.alpha = 1f;
				<>2__current = (object)new WaitForSeconds(stayTime);
				<>1__state = 3;
				return true;
			}
		}

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

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

	public static UIHandler instance;

	public static ManualLogSource logger;

	public static Font poyFont;

	private Transform chatBoxTransform;

	private Transform unlockNotifsTransform;

	public GameObject canvas;

	private Queue<string> messages = new Queue<string>();

	private void Awake()
	{
		poyFont = Object.FindObjectOfType<Text>().font;
		logger.LogInfo((object)poyFont);
		Canvas obj = Object.FindObjectOfType<Canvas>();
		canvas = ((obj != null) ? ((Component)obj).gameObject : null);
		if ((Object)(object)canvas == (Object)null)
		{
			logger.LogError((object)"Couldn't find Canvas");
			((Behaviour)this).enabled = false;
		}
		instance = this;
	}

	private void Start()
	{
		CreateUI();
	}

	private void Update()
	{
		if (messages.Count != 0)
		{
			CreateChatMessage(messages.Dequeue());
		}
	}

	private void OnDestroy()
	{
		Transform obj = chatBoxTransform;
		Object.Destroy((Object)(object)((obj != null) ? ((Component)obj).gameObject : null));
		Transform obj2 = unlockNotifsTransform;
		Object.Destroy((Object)(object)((obj2 != null) ? ((Component)obj2).gameObject : null));
	}

	private void CreateUI()
	{
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
		chatBoxTransform = CreatePanel("chatbox", new Color(0f, 0f, 0f, 0f), canvas.transform, new Vector2(-12.5f, 0f), 1f, 0.75f, 1f, 0f, (TextAnchor)8).transform;
		((Component)chatBoxTransform).GetComponent<HorizontalOrVerticalLayoutGroup>().childForceExpandWidth = false;
		((Component)chatBoxTransform).GetComponent<HorizontalOrVerticalLayoutGroup>().childForceExpandHeight = false;
		unlockNotifsTransform = CreatePanel("unlock notifications", new Color(0f, 0f, 0f, 0f), canvas.transform, Vector2.zero, 0.5f, 0.75f, 0.5f, 0.5f, (TextAnchor)4).transform;
		((Component)unlockNotifsTransform).GetComponent<HorizontalOrVerticalLayoutGroup>().childForceExpandWidth = false;
		((Component)unlockNotifsTransform).GetComponent<HorizontalOrVerticalLayoutGroup>().childForceExpandHeight = false;
		logger.LogInfo((object)"created UI");
	}

	public void AddChatMessage(string text)
	{
		messages.Enqueue(text);
	}

	private void CreateChatMessage(string text)
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = CreatePanel("chatmessagepanel", new Color(0f, 0f, 0f, 0.8f), chatBoxTransform, new Vector2(0f, 0f), 0f, 1f, 1f, 0f, (TextAnchor)8);
		CanvasGroup cg = val.AddComponent<CanvasGroup>();
		Text val2 = CreateTextElem("chatmessageText", 20, val.transform, (TextAnchor)8);
		val2.text = text;
		((MonoBehaviour)this).StartCoroutine(FadeAndShowText(cg, 0.5f, 4f, 0.5f));
	}

	public void Notify(string text, float fadeInTime = 0.5f, float stayTime = 2f, float fadeOutTime = 0.5f)
	{
		//IL_001a: 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)
		GameObject val = CreatePanel("textmoment", new Color(0f, 0f, 0f, 0.8f), unlockNotifsTransform, Vector2.zero, 0.5f, 0.5f, -1f, -1f, (TextAnchor)4);
		CanvasGroup cg = val.AddComponent<CanvasGroup>();
		Text val2 = CreateTextElem("Textmomento", 32, val.transform, (TextAnchor)4);
		val2.text = text;
		((MonoBehaviour)this).StartCoroutine(FadeAndShowText(cg, fadeInTime, stayTime, fadeOutTime));
	}

	public void ShowTextAtPosition(string text, Vector2 offset, float fadeInTime = 0.5f, float stayTime = 2f, float fadeOutTime = 0.5f)
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = CreatePanel("textmoment", new Color(0f, 0f, 0f, 0.8f), canvas.transform, offset, 0.5f, 0.75f, -1f, -1f, (TextAnchor)4);
		CanvasGroup cg = val.AddComponent<CanvasGroup>();
		Text val2 = CreateTextElem("Textmomento", 32, val.transform, (TextAnchor)4);
		val2.text = text;
		((MonoBehaviour)this).StartCoroutine(FadeAndShowText(cg, fadeInTime, stayTime, fadeOutTime));
	}

	[IteratorStateMachine(typeof(<FadeAndShowText>d__16))]
	private IEnumerator FadeAndShowText(CanvasGroup cg, float fadeInTime, float stayTime, float fadeOutTime)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <FadeAndShowText>d__16(0)
		{
			<>4__this = this,
			cg = cg,
			fadeInTime = fadeInTime,
			stayTime = stayTime,
			fadeOutTime = fadeOutTime
		};
	}

	public static GameObject CreatePanel(string name, Color color, Transform parent, Vector2 position, float anchorx = 0.5f, float anchory = 0.5f, float pivotx = -1f, float pivoty = -1f, TextAnchor alignment = 4, bool vertical = true)
	{
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Expected O, but got Unknown
		//IL_003e: 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_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)parent == (Object)null)
		{
			Canvas obj = Object.FindObjectOfType<Canvas>();
			parent = ((obj != null) ? ((Component)obj).transform : null);
		}
		GameObject val = new GameObject(name);
		val.transform.SetParent(parent, false);
		Image val2 = val.AddComponent<Image>();
		((Graphic)val2).color = color;
		RectTransform val3 = val.GetComponent<RectTransform>() ?? val.AddComponent<RectTransform>();
		Vector2 val4 = default(Vector2);
		((Vector2)(ref val4))..ctor(anchorx, anchory);
		Vector2 pivot = (Vector2)((pivotx == -1f) ? val4 : new Vector2(pivotx, pivoty));
		val3.anchorMax = val4;
		val3.anchorMin = val4;
		val3.anchoredPosition = position;
		val3.pivot = pivot;
		HorizontalOrVerticalLayoutGroup val5 = (HorizontalOrVerticalLayoutGroup)(vertical ? ((object)val.AddComponent<VerticalLayoutGroup>()) : ((object)val.AddComponent<HorizontalLayoutGroup>()));
		((LayoutGroup)val5).childAlignment = alignment;
		val5.spacing = 25f;
		((LayoutGroup)val5).padding.bottom = 30;
		((LayoutGroup)val5).padding.right = 10;
		((LayoutGroup)val5).padding.left = 10;
		((LayoutGroup)val5).padding.top = 10;
		ContentSizeFitter val6 = val.AddComponent<ContentSizeFitter>();
		val6.horizontalFit = (FitMode)2;
		val6.verticalFit = (FitMode)2;
		return val;
	}

	public static GameObject CreateClock(string name, Color color, Transform parent, Vector2 position, float size, float anchorx = 0.5f, float anchory = 0.5f, float pivotx = -1f, float pivoty = -1f)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: 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_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = new GameObject(name);
		val.transform.SetParent(parent, false);
		Image val2 = val.AddComponent<Image>();
		((Graphic)val2).color = color;
		val2.sprite = GenerateCircleSprite(Mathf.RoundToInt(size));
		val2.type = (Type)3;
		val2.fillMethod = (FillMethod)4;
		val2.fillOrigin = 2;
		RectTransform val3 = val.GetComponent<RectTransform>() ?? val.AddComponent<RectTransform>();
		Vector2 val4 = default(Vector2);
		((Vector2)(ref val4))..ctor(anchorx, anchory);
		Vector2 pivot = (Vector2)((pivotx == -1f) ? val4 : new Vector2(pivotx, pivoty));
		val3.anchorMax = val4;
		val3.anchorMin = val4;
		val3.pivot = pivot;
		val3.anchoredPosition = position;
		val3.sizeDelta = Vector2.one * size;
		return val;
	}

	public static Text CreateTextElem(string name, int fontSize, Transform parent, TextAnchor alignment = 4)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = new GameObject(name);
		val.transform.SetParent(parent, false);
		Text val2 = val.AddComponent<Text>();
		if ((Object)(object)poyFont != (Object)null)
		{
			val2.font = poyFont;
		}
		else
		{
			logger.LogError((object)"No font found :(");
			val2.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
		}
		val2.alignment = alignment;
		val2.fontSize = fontSize;
		((Graphic)val2).color = Color.white;
		val2.lineSpacing = 3f;
		val2.supportRichText = true;
		RectTransform val3 = val.GetComponent<RectTransform>() ?? val.AddComponent<RectTransform>();
		ContentSizeFitter val4 = val.AddComponent<ContentSizeFitter>();
		val4.horizontalFit = (FitMode)2;
		val4.verticalFit = (FitMode)2;
		return val2;
	}

	private static Sprite GenerateCircleSprite(int size)
	{
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Expected O, but got Unknown
		//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d0: 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_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: 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_0076: Unknown result type (might be due to invalid IL or missing references)
		Texture2D val = new Texture2D(size, size);
		Color[] array = (Color[])(object)new Color[size * size];
		Vector2 val2 = default(Vector2);
		((Vector2)(ref val2))..ctor((float)(size / 2), (float)(size / 2));
		float num = (float)size / 2f;
		for (int i = 0; i < size; i++)
		{
			for (int j = 0; j < size; j++)
			{
				float num2 = Vector2.Distance(new Vector2((float)j, (float)i), val2);
				array[i * size + j] = (Color)((num2 <= num) ? Color.white : new Color(0f, 0f, 0f, 0f));
			}
		}
		val.SetPixels(array);
		val.Apply();
		Rect val3 = default(Rect);
		((Rect)(ref val3))..ctor(0f, 0f, (float)size, (float)size);
		return Sprite.Create(val, val3, new Vector2(0.5f, 0.5f));
	}
}
namespace Archipelago.MultiClient.Net
{
	[AttributeUsage(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_0010: 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)
			SessionVariable = sessionVariable;
			Scope = scope;
			Key = key;
		}

		public DataStoragePropertyAttribute(string sessionVariable, string key)
			: this(sessionVariable, (Scope)0, key)
		{
		}
	}
}
namespace PeaksOfArchipelago
{
	public static class ModInfo
	{
		public const string MOD_GUID = "PeaksOfArchipelago";

		public const string MOD_NAME = "Peaks Of Archipelago";

		public const string MOD_DESC = "An Archipelago Implementation for Peaks Of Yore!";

		public const string MOD_VERSION = "1.7.1";
	}
	[BepInPlugin("PeaksOfArchipelago", "Peaks Of Archipelago", "1.7.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class PeaksOfArchipelago : BaseUnityPlugin
	{
		internal static ManualLogSource Logger;

		private void Awake()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"Plugin PeaksOfArchipelago is loaded!");
			Harmony val = new Harmony("PeaksOfArchipelago_Paths");
			MethodInfo methodInfo = AccessTools.PropertyGetter(AccessTools.TypeByName("POKModManager.Paths"), "GameFolder");
			MethodInfo method = typeof(Patch_Paths).GetMethod("Prefix", BindingFlags.Static | BindingFlags.Public);
			val.Patch((MethodBase)methodInfo, new HarmonyMethod(method), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			new POKManager(true);
		}

		private void Start()
		{
			GameObject obj = GameObject.Find("Options");
			object poyFont;
			if (obj == null)
			{
				poyFont = null;
			}
			else
			{
				Text componentInChildren = obj.GetComponentInChildren<Text>();
				poyFont = ((componentInChildren != null) ? componentInChildren.font : null);
			}
			UIHandler.poyFont = (Font)poyFont;
			POKManager.RegisterMod((ModClass)(object)new PeaksOfArchipelagoMod(Logger), "Peaks Of Archipelago", "1.7.1", "An Archipelago Implementation for Peaks Of Yore!", true);
		}
	}
	public class Patch_Paths
	{
		public static bool Prefix(ref string __result)
		{
			__result = Directory.GetParent(Paths.BepInExRootPath).ToString();
			return false;
		}
	}
	public class PeaksOfArchipelagoMod : ModClass
	{
		[HarmonyPatch(typeof(StamperPeakSummit), "StampJournal")]
		public class PeakSummitedPatch
		{
			private static void Prefix(StamperPeakSummit __instance)
			{
				Peaks peakFromCollectable = Utils.GetPeakFromCollectable(__instance);
				session.NotifyCollection(Utils.PeakToId(peakFromCollectable));
				session.CompletePeakCheck(peakFromCollectable);
				if (GameObject.FindGameObjectWithTag("Player").GetComponent<RopeAnchor>().ropesPlacedDuringMap == 0 && peakFromCollectable >= Peaks.WalkersPillar)
				{
					session.NotifyCollection(Utils.FSPeakToId(peakFromCollectable));
					session.CompleteFSPeakCheck(peakFromCollectable);
				}
			}
		}

		[HarmonyPatch(typeof(ArtefactOnPeak), "PickUpItem")]
		public class ArtefactOnPeakPatch
		{
			private static void Postfix(ArtefactOnPeak __instance)
			{
				Artefacts artefactFromCollectable = Utils.GetArtefactFromCollectable(__instance);
				session.NotifyCollection(Utils.ArtefactToId(artefactFromCollectable));
				session.CompleteArtefactCheck(artefactFromCollectable);
			}
		}

		[HarmonyPatch(typeof(RopeCollectable), "PickUpRope")]
		public class RopeCollectablePatch
		{
			[CompilerGenerated]
			private sealed class <MyWrapper>d__2 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public IEnumerator original;

				public RopeCollectable __instance;

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

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

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

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

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						goto IL_0050;
					case 1:
						<>1__state = -1;
						goto IL_0050;
					case 2:
						{
							<>1__state = -1;
							return false;
						}
						IL_0050:
						if (original.MoveNext())
						{
							<>2__current = original.Current;
							<>1__state = 1;
							return true;
						}
						UnityUtils.UndoRopeProgress(__instance);
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
				}

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

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

			private static void Prefix(RopeCollectable __instance)
			{
				Ropes ropeFromCollectable = Utils.GetRopeFromCollectable(__instance);
				session.NotifyCollection(Utils.RopeToId(ropeFromCollectable));
				session.CompleteRopeCheck(ropeFromCollectable);
			}

			private static void Postfix(ref IEnumerator __result, RopeCollectable __instance)
			{
				__result = MyWrapper(__result, __instance);
			}

			[IteratorStateMachine(typeof(<MyWrapper>d__2))]
			private static IEnumerator MyWrapper(IEnumerator original, RopeCollectable __instance)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <MyWrapper>d__2(0)
				{
					original = original,
					__instance = __instance
				};
			}
		}

		[HarmonyPatch(typeof(BirdSeedCollectable), "PickUpBirdSeed")]
		public class BirdSeedCollectablePatch
		{
			[CompilerGenerated]
			private sealed class <MyWrapper>d__2 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public IEnumerator original;

				public RopeCollectable __instance;

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

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

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

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

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						goto IL_0050;
					case 1:
						<>1__state = -1;
						goto IL_0050;
					case 2:
						{
							<>1__state = -1;
							return false;
						}
						IL_0050:
						if (original.MoveNext())
						{
							<>2__current = original.Current;
							<>1__state = 1;
							return true;
						}
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
				}

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

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

			private static void Prefix(BirdSeedCollectable __instance)
			{
				BirdSeeds seedFromCollectable = Utils.GetSeedFromCollectable(__instance);
				session.NotifyCollection(Utils.BirdSeedToId(seedFromCollectable));
				session.CompleteSeedCheck(seedFromCollectable);
				GameManager control = GameManager.control;
				control.extraBirdSeedUses--;
			}

			private static void Postfix(ref IEnumerator __result, RopeCollectable __instance)
			{
				__result = MyWrapper(__result, __instance);
			}

			[IteratorStateMachine(typeof(<MyWrapper>d__2))]
			private static IEnumerator MyWrapper(IEnumerator original, RopeCollectable __instance)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <MyWrapper>d__2(0)
				{
					original = original,
					__instance = __instance
				};
			}
		}

		[HarmonyPatch(typeof(TimeAttack), "SetBestTime")]
		public class SetBestTimePatch
		{
			public static void Prefix(TimeAttack __instance)
			{
				if (!__instance.summitStamper.isCategory4)
				{
					Peaks peakFromCollectable = Utils.GetPeakFromCollectable(__instance.summitStamper);
					if (__instance.timer < timeAttackDefaultData.times[(int)peakFromCollectable])
					{
						session.NotifyCollection((long)peakFromCollectable + 8000L);
						session.CompleteTimePBCheck(peakFromCollectable);
					}
					if (__instance.holdsMade < timeAttackDefaultData.holds[(int)peakFromCollectable])
					{
						session.NotifyCollection((long)peakFromCollectable + 10000L);
						session.CompleteHoldsPBCheck(peakFromCollectable);
					}
					if (__instance.ropesUsed <= timeAttackDefaultData.ropes[(int)peakFromCollectable])
					{
						session.NotifyCollection((long)peakFromCollectable + 9000L);
						session.CompleteRopesPBCheck(peakFromCollectable);
					}
				}
			}
		}

		[HarmonyPatch(typeof(TimeAttackSetter), "SetDefaults")]
		public class SetDefaultTimes
		{
			public static void Postfix(TimeAttackSetter __instance)
			{
				if (timeAttackDefaultData.holds == null)
				{
					float[] category1_defaultTimes = __instance.category1_defaultTimes;
					float[] category2_defaultTimes = __instance.category2_defaultTimes;
					float[] category3_defaultTimes = __instance.category3_defaultTimes;
					int num = 0;
					float[] array = new float[category1_defaultTimes.Length + category2_defaultTimes.Length + category3_defaultTimes.Length];
					float[] array2 = category1_defaultTimes;
					foreach (float num2 in array2)
					{
						array[num] = num2;
						num++;
					}
					float[] array3 = category2_defaultTimes;
					foreach (float num2 in array3)
					{
						array[num] = num2;
						num++;
					}
					float[] array4 = category3_defaultTimes;
					foreach (float num2 in array4)
					{
						array[num] = num2;
						num++;
					}
					timeAttackDefaultData.times = array;
					int[] category1_defaultHolds = __instance.category1_defaultHolds;
					int[] category2_defaultHolds = __instance.category2_defaultHolds;
					int[] category3_defaultHolds = __instance.category3_defaultHolds;
					int num3 = 0;
					int[] array5 = new int[category1_defaultHolds.Length + category2_defaultHolds.Length + category3_defaultHolds.Length];
					int[] array6 = category1_defaultHolds;
					foreach (int num4 in array6)
					{
						array5[num3] = num4;
						num3++;
					}
					int[] array7 = category2_defaultHolds;
					foreach (int num4 in array7)
					{
						array5[num3] = num4;
						num3++;
					}
					int[] array8 = category3_defaultHolds;
					foreach (int num4 in array8)
					{
						array5[num3] = num4;
						num3++;
					}
					timeAttackDefaultData.holds = array5;
					int[] category1_defaultRopes = __instance.category1_defaultRopes;
					int[] category2_defaultRopes = __instance.category2_defaultRopes;
					int[] category3_defaultRopes = __instance.category3_defaultRopes;
					int num5 = 0;
					int[] array9 = new int[category1_defaultRopes.Length + category2_defaultRopes.Length + category3_defaultRopes.Length];
					int[] array10 = category1_defaultRopes;
					foreach (int num4 in array10)
					{
						array9[num5] = num4;
						num5++;
					}
					int[] array11 = category2_defaultRopes;
					foreach (int num4 in array11)
					{
						array9[num5] = num4;
						num5++;
					}
					int[] array12 = category3_defaultRopes;
					foreach (int num4 in array12)
					{
						array9[num5] = num4;
						num5++;
					}
					timeAttackDefaultData.ropes = array9;
				}
			}
		}

		[HarmonyPatch(typeof(FallingEvent), "FellToDeath")]
		public class FellToDeathPatch
		{
			private static void Postfix()
			{
				session.HandleDeath();
			}
		}

		[HarmonyPatch(typeof(ResetPosition), "FadeToBlack")]
		public class ResetPositionPatch
		{
			private static void Prefix(ResetPosition __instance)
			{
				if (!__instance.isSea)
				{
					session.HandleDeath();
				}
			}
		}

		[HarmonyPatch(typeof(ArtefactLoaderCabin), "LoadArtefacts")]
		public class ArtefactLoaderPatch
		{
			private static CheckList<Artefacts> savestate = new CheckList<Artefacts>();

			public static void Prefix(ArtefactLoaderCabin __instance)
			{
				foreach (Artefacts value in Enum.GetValues(typeof(Artefacts)))
				{
					savestate.SetCheck(value, UnityUtils.GetGameManagerArtefactCollected(value));
					UnityUtils.SetGameManagerArtefactCollected(value, session.playerData.items.artefacts.IsChecked(value));
					if (session.playerData.items.artefacts.IsChecked(value))
					{
						UnityUtils.SetGameManagerArtefactDirty(value, value: false);
					}
				}
			}

			public static void Postfix()
			{
				foreach (Artefacts value in Enum.GetValues(typeof(Artefacts)))
				{
					UnityUtils.SetGameManagerArtefactCollected(value, savestate.IsChecked(value));
					if (UnityUtils.GetGameManagerArtefactCollected(value) != savestate.IsChecked(value))
					{
						logger.LogWarning((object)$"Error: {value} should be {savestate.IsChecked(value)} but is {!savestate.IsChecked(value)}!");
					}
				}
				GameManager.control.Save();
			}
		}

		[HarmonyPatch(typeof(NPCEvents), "CheckProgress")]
		public class CheckProgressPatch
		{
			private static bool usingPipe;

			public static void Prefix(NPCEvents __instance)
			{
				usingPipe = GameManager.control.isUsingPipe;
				ItemEventsPatch.isCustomEvent = false;
				session.CheckWin();
				session.UpdateReceivedItems();
				if (session.uncollectedItems.Count != 0 && !__instance.runningEvent && session.currentScene != "TitleScreen")
				{
					logger.LogInfo((object)"starting custom event");
					ItemEventsPatch.isCustomEvent = true;
					__instance.eventName = "AllArtefacts";
					__instance.runningEvent = true;
					((MonoBehaviour)__instance.npcParcelDeliverySystem).StartCoroutine("FadeScreenAndStartUnpackEvent");
				}
				else if (session.finished && !session.seenFinishedCutScene)
				{
					ItemEventsPatch.isFinishEvent = true;
					session.seenFinishedCutScene = true;
					__instance.eventName = "CompleteGame_Base";
					((MonoBehaviour)__instance).StartCoroutine("GlowDoorEvent");
				}
			}

			public static void Postfix(NPCEvents __instance)
			{
				session.SetFundamentalsBookActive(session.playerData.items.books.IsChecked(Books.Fundamentals));
				GameManager.control.monocular = session.playerData.items.monocular;
				if (!GameManager.control.monocular)
				{
					((MonoBehaviour)__instance).StopCoroutine("MissedMonocularTooltip");
				}
				if (__instance.runningEvent)
				{
					switch (__instance.eventName)
					{
					case "Rope":
					case "RopesUpgrade":
					case "ArtefactMap":
					case "Pocketwatch":
					case "Crampons":
					case "CramponsUpgrade":
					case "Chalkbag":
					case "TimeAttack_Event1":
					case "Category_2":
					case "Category_3":
					case "Category_4":
					case "Phonograph":
						__instance.runningEvent = false;
						logger.LogInfo((object)("Blocking event: " + __instance.eventName));
						((MonoBehaviour)__instance).StopCoroutine("GlowDoorEvent");
						break;
					case "AllArtefacts":
						if (!ItemEventsPatch.isCustomEvent)
						{
							__instance.runningEvent = false;
							logger.LogInfo((object)("Blocking event: " + __instance.eventName));
							((MonoBehaviour)__instance).StopCoroutine("GlowDoorEvent");
						}
						break;
					}
				}
				if (session.playerData.items.pipe)
				{
					GameManager.control.smokingpipe = true;
					GameManager.control.isUsingPipe = usingPipe;
					__instance.cabinPipe.SetActive(true);
				}
			}
		}

		[HarmonyPatch(typeof(NPCSystem), "GivePlayerMonocular")]
		public class GivePlayerMonocularPatch
		{
			public static void Postfix()
			{
				GameManager.control.monocular = session.playerData.items.monocular;
				GameManager.control.Save();
			}
		}

		[HarmonyPatch(typeof(NPCSystem), "GivePlayerCoffee")]
		public class GivePlayerCoffeePatch
		{
			public static void Postfix()
			{
				GameManager.control.coffee = session.playerData.items.coffee;
				GameManager.control.Save();
			}
		}

		[HarmonyPatch(typeof(NPCSystem), "GivePlayerRope")]
		public class GivePlayerRopePatch
		{
			public static void Postfix(NPCSystem __instance)
			{
				Ropes rope = (Ropes)(-1);
				if (__instance.isStHaelga)
				{
					rope = Ropes.StHaelga;
				}
				if (__instance.isGreatGaol)
				{
					rope = Ropes.GreatGaol;
				}
				GameManager control = GameManager.control;
				control.ropesCollected--;
				RopeAnchor component = GameObject.FindGameObjectWithTag("Player").GetComponent<RopeAnchor>();
				component.anchorsInBackpack--;
				session.NotifyCollection(Utils.RopeToId(rope));
				session.CompleteRopeCheck(rope);
			}
		}

		[HarmonyPatch(typeof(NPC_Climber), "GivePlayerRope")]
		public class ClimberGivePlayerRopePatch
		{
			public static void Postfix(NPC_Climber __instance)
			{
				Ropes rope = (Ropes)(-1);
				if (__instance.isWaltersCrag)
				{
					rope = Ropes.WaltersCrag;
				}
				if (__instance.isWalkersPillar)
				{
					rope = Ropes.WalkersPillar;
				}
				GameManager control = GameManager.control;
				control.ropesCollected--;
				RopeAnchor component = GameObject.FindGameObjectWithTag("Player").GetComponent<RopeAnchor>();
				component.anchorsInBackpack--;
				session.NotifyCollection(Utils.RopeToId(rope));
				session.CompleteRopeCheck(rope);
			}
		}

		[HarmonyPatch(typeof(NPCEvents), "ItemEvents")]
		public class ItemEventsPatch
		{
			[CompilerGenerated]
			private sealed class <MyWrapper>d__8 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public IEnumerator original;

				public NPCEvents __instance;

				private List<SimpleItemInfo> <items>5__1;

				private List<SimpleItemInfo>.Enumerator <>s__2;

				private SimpleItemInfo <item>5__3;

				private RopeCabinDescription[] <>s__4;

				private int <>s__5;

				private RopeCabinDescription <ropeCabinDescription>5__6;

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

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

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

				[DebuggerHidden]
				void IDisposable.Dispose()
				{
					<items>5__1 = null;
					<item>5__3 = default(SimpleItemInfo);
					<>s__4 = null;
					<ropeCabinDescription>5__6 = null;
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						goto IL_0053;
					case 1:
						<>1__state = -1;
						goto IL_0053;
					case 2:
						{
							<>1__state = -1;
							return false;
						}
						IL_0053:
						if (original.MoveNext())
						{
							<>2__current = original.Current;
							<>1__state = 1;
							return true;
						}
						if (isCustomEvent)
						{
							isCustomEvent = false;
							GameManager.control.allArtefactsUnlocked = hasAllArtefacts;
							GameManager control = GameManager.control;
							control.ropesCollected -= 5;
							GameManager control2 = GameManager.control;
							control2.extraCoffeeUses -= 999999999;
							GameManager control3 = GameManager.control;
							control3.extraChalkUses -= 999999999;
							textElement.text = tempText;
							session.UpdateReceivedItems();
							<items>5__1 = session.uncollectedItems;
							session.uncollectedItems = new List<SimpleItemInfo>();
							<>s__2 = <items>5__1.GetEnumerator();
							try
							{
								while (<>s__2.MoveNext())
								{
									<item>5__3 = <>s__2.Current;
									session.UnlockById(<item>5__3.id);
									<item>5__3 = default(SimpleItemInfo);
								}
							}
							finally
							{
								((IDisposable)<>s__2).Dispose();
							}
							<>s__4 = Object.FindObjectsOfType<RopeCabinDescription>();
							for (<>s__5 = 0; <>s__5 < <>s__4.Length; <>s__5++)
							{
								<ropeCabinDescription>5__6 = <>s__4[<>s__5];
								<ropeCabinDescription>5__6.UpdateCoffeeChalk();
								<ropeCabinDescription>5__6 = null;
							}
							<>s__4 = null;
							ArtefactLoaderCabin obj = Object.FindObjectOfType<ArtefactLoaderCabin>();
							if (obj != null)
							{
								obj.LoadArtefacts();
							}
							RopeCabinDescription obj2 = Object.FindObjectOfType<RopeCabinDescription>();
							if (obj2 != null)
							{
								obj2.CheckCabinItems();
							}
							<items>5__1 = null;
						}
						if (session.playerData.items.pipe)
						{
							GameManager.control.smokingpipe = true;
							GameManager.control.isUsingPipe = usingPipe;
							__instance.cabinPipe.SetActive(true);
						}
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
				}

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

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

			public static bool isCustomEvent = false;

			public static bool isFinishEvent = false;

			private static bool hasAllArtefacts = false;

			private static string tempText = "";

			private static bool usingPipe;

			private static Text textElement;

			private static void Prefix(NPCEvents __instance)
			{
				if (!isCustomEvent)
				{
					return;
				}
				usingPipe = GameManager.control.isUsingPipe;
				hasAllArtefacts = GameManager.control.allArtefactsUnlocked;
				Text componentInChildren = __instance.allArtefactsInfo.GetComponentInChildren<Text>();
				tempText = componentInChildren.text;
				textElement = componentInChildren;
				string text = "You got: ";
				session.UpdateReceivedItems();
				for (int i = 0; i < session.uncollectedItems.Count; i++)
				{
					SimpleItemInfo simpleItemInfo = session.uncollectedItems[i];
					if (!(simpleItemInfo.itemName == "Trap"))
					{
						text += simpleItemInfo.itemName;
						if (i != session.uncollectedItems.Count - 1)
						{
							text += ", ";
						}
					}
				}
				componentInChildren.text = text;
			}

			private static void Postfix(ref IEnumerator __result, NPCEvents __instance)
			{
				__result = MyWrapper(__result, __instance);
			}

			[IteratorStateMachine(typeof(<MyWrapper>d__8))]
			private static IEnumerator MyWrapper(IEnumerator original, NPCEvents __instance)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <MyWrapper>d__8(0)
				{
					original = original,
					__instance = __instance
				};
			}
		}

		[HarmonyPatch(typeof(Pipe), "CheckLoad")]
		public class PipeCheckPatch
		{
			private static bool isUsingPipe;

			private static void Prefix()
			{
				isUsingPipe = GameManager.control.isUsingPipe;
			}

			private static void Postfix(Pipe __instance)
			{
				if (session.playerData.items.pipe)
				{
					GameManager.control.isUsingPipe = isUsingPipe;
					GameManager.control.smokingpipe = true;
					((Component)__instance).gameObject.SetActive(isUsingPipe);
				}
			}
		}

		[HarmonyPatch(typeof(PipeCabin), "CheckLoad")]
		public class PipeCheck2Patch
		{
			private static bool isUsingPipe;

			private static void Prefix()
			{
				isUsingPipe = GameManager.control.isUsingPipe;
			}

			private static void Postfix(PipeCabin __instance)
			{
				if (session.playerData.items.pipe)
				{
					GameManager.control.isUsingPipe = isUsingPipe;
					GameManager.control.smokingpipe = true;
					((Component)__instance).gameObject.SetActive(true);
					__instance.playerPipe.SetActive(isUsingPipe);
				}
			}
		}

		[HarmonyPatch(typeof(EnterPeakScene), "Awake")]
		public class EnterPeakScenePatch
		{
			private static void Prefix(EnterPeakScene __instance)
			{
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				if (!(session.currentScene == "IceWaterfallDemo"))
				{
					string text = ((object)(PeakNames)(ref GameObject.FindGameObjectWithTag("SummitBox").GetComponent<StamperPeakSummit>().peakNames)).ToString();
					logger.LogInfo((object)("Entering peak: " + text));
					GameObject val = (GameObject)(((object)GameObject.Find("PeaksOfArchipelagoScriptHolder")) ?? ((object)new GameObject("PeaksOfArchipelagoScriptHolder")));
					Traps instance = val.AddComponent<Traps>();
					logger.LogInfo((object)"Adding traps instance");
					Traps.instance = instance;
					Traps.playerData = session.playerData;
				}
			}
		}

		[HarmonyPatch(typeof(OilLamp), "OilLampLightUp")]
		public class OilLampLightUpPatch
		{
			[CompilerGenerated]
			private sealed class <Wrapper>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public OilLamp __instance;

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

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

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

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

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						__instance.oilLampLight.intensity = 0f;
						<>2__current = null;
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						return false;
					}
				}

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

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

			private static void Postfix(OilLamp __instance, ref IEnumerator __result)
			{
				if (!session.playerData.items.lamp)
				{
					__result = Wrapper(__instance);
				}
			}

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

		[HarmonyPatch(typeof(Player), "GetButton", new Type[] { typeof(string) })]
		public class HandPatch
		{
			private static bool Prefix(ref bool __result, string actionName)
			{
				if (actionName == "Arm Right" && !session.playerData.items.rightHand)
				{
					return false;
				}
				if (actionName == "Arm Left" && !session.playerData.items.leftHand)
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(StatsAndAchievements), "SetAchievement")]
		[HarmonyPatch(typeof(StatsAndAchievements), "SetStatFloat")]
		[HarmonyPatch(typeof(StatsAndAchievements), "SetStatInt")]
		[HarmonyPatch(typeof(StatsAndAchievements), "ResetStatsAndAchievements")]
		public class SetAchievementPatch
		{
			private static bool Prefix()
			{
				logger.LogInfo((object)"Game wants to do something with achievements, but I say no");
				return false;
			}
		}

		[HarmonyPatch(typeof(SteamUserStats), "SetAchievement")]
		[HarmonyPatch(typeof(SteamUserStats), "StoreStats")]
		public class SetSteamAchievementPatch
		{
			private static bool Prefix(ref bool __result)
			{
				logger.LogInfo((object)"Game wants to do something with achievements, but I say no");
				__result = true;
				return false;
			}
		}

		[HarmonyPatch]
		public class CollectionTextPatch
		{
			[CompilerGenerated]
			private sealed class <TargetMethods>d__0 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private MethodBase <>2__current;

				private int <>l__initialThreadId;

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

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

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

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

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(BirdSeedCollectedText), "InitiateCollectedTextSingle", (Type[])null, (Type[])null);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(RopeCollectedText), "InitiateCollectedTextSingle", (Type[])null, (Type[])null);
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(BirdSeedCollectedText), "InitiateCollectedText", (Type[])null, (Type[])null);
						<>1__state = 3;
						return true;
					case 3:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(RopeCollectedText), "InitiateCollectedText", (Type[])null, (Type[])null);
						<>1__state = 4;
						return true;
					case 4:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(ArtefactCollectedText), "InitiateCollectedText", (Type[])null, (Type[])null);
						<>1__state = 5;
						return true;
					case 5:
						<>1__state = -1;
						return false;
					}
				}

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

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

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

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

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

			private static bool Prefix()
			{
				logger.LogInfo((object)"Blocking collection Text");
				return false;
			}
		}

		[HarmonyPatch(typeof(PeakSelection), "OnMouseSpriteDown")]
		public class FundamentalPeakSelectionPatch
		{
			private static bool Prefix(PeakSelection __instance)
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Expected O, but got Unknown
				PeakJournal val = (PeakJournal)typeof(PeakSelection).GetField("peakJournal", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(__instance);
				if ((__instance.leftPage && !Utils.IsJournalPageUnlocked(val.currentPage, Books.Fundamentals, session.playerData)) || (!__instance.leftPage && !Utils.IsJournalPageUnlocked(val.currentPage + 1, Books.Fundamentals, session.playerData)))
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(PeakSelection), "OnMouseSpriteOver")]
		public class FundamentalPeakSelectionColorPatch
		{
			private static void Prefix(PeakSelection __instance)
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Expected O, but got Unknown
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_0119: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
				PeakJournal val = (PeakJournal)typeof(PeakSelection).GetField("peakJournal", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(__instance);
				MeshRenderer component = __instance.rightSelectOutlineOBJ.GetComponent<MeshRenderer>();
				MeshRenderer component2 = __instance.leftSelectOutlineOBJ.GetComponent<MeshRenderer>();
				if (__instance.leftPage && !Utils.IsJournalPageUnlocked(val.currentPage, Books.Fundamentals, session.playerData))
				{
					((Renderer)component2).material.color = new Color(2f, 0f, 0f);
				}
				else
				{
					((Renderer)component2).material.color = new Color(1f, 1f, 1f, 0.349f);
				}
				if (!__instance.leftPage && !Utils.IsJournalPageUnlocked(val.currentPage + 1, Books.Fundamentals, session.playerData))
				{
					((Renderer)component).material.color = new Color(2f, 0f, 0f);
				}
				else
				{
					((Renderer)component).material.color = new Color(1f, 1f, 1f, 0.349f);
				}
			}
		}

		[HarmonyPatch(typeof(PeakJournal), "PageTurnSound")]
		public class FundamentalJournalColorPatch
		{
			private static void Postfix(PeakJournal __instance)
			{
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0115: Unknown result type (might be due to invalid IL or missing references)
				//IL_0137: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance.journalPageAnim.clip == (Object)(object)__instance.journalPage_TurnLeft)
				{
					__instance.backPage.color = Utils.GetJournalPageColor(__instance.currentPage, Books.Fundamentals, session.playerData);
					__instance.frontPage.color = Utils.GetJournalPageColor(__instance.currentPage - 1, Books.Fundamentals, session.playerData);
					__instance.rightPage.color = Utils.GetJournalPageColor(__instance.currentPage + 1, Books.Fundamentals, session.playerData);
					__instance.leftPage.color = Utils.GetJournalPageColor(__instance.currentPage - 2, Books.Fundamentals, session.playerData);
				}
				else
				{
					__instance.backPage.color = Utils.GetJournalPageColor(__instance.currentPage + 2, Books.Fundamentals, session.playerData);
					__instance.frontPage.color = Utils.GetJournalPageColor(__instance.currentPage + 1, Books.Fundamentals, session.playerData);
					__instance.rightPage.color = Utils.GetJournalPageColor(__instance.currentPage + 3, Books.Fundamentals, session.playerData);
					__instance.leftPage.color = Utils.GetJournalPageColor(__instance.currentPage, Books.Fundamentals, session.playerData);
				}
			}
		}

		[HarmonyPatch(typeof(PeakJournal), "UpdatePage")]
		public class FundamentalUpdatePagePatch
		{
			private static void Postfix(PeakJournal __instance)
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: 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)
				__instance.backPage.color = Utils.GetJournalPageColor(__instance.currentPage + 2, Books.Fundamentals, session.playerData);
				__instance.frontPage.color = Utils.GetJournalPageColor(__instance.currentPage + 1, Books.Fundamentals, session.playerData);
				__instance.rightPage.color = Utils.GetJournalPageColor(__instance.currentPage + 3, Books.Fundamentals, session.playerData);
				__instance.leftPage.color = Utils.GetJournalPageColor(__instance.currentPage, Books.Fundamentals, session.playerData);
			}
		}

		[HarmonyPatch(typeof(IntermediatePeakSelection), "OnMouseSpriteDown")]
		public class IntermediatePeakSelectionPatch
		{
			private static bool Prefix(IntermediatePeakSelection __instance)
			{
				IntermediateJournal peakJournal = __instance.peakJournal;
				if ((__instance.leftPage && !Utils.IsJournalPageUnlocked(peakJournal.currentPage, Books.Intermediate, session.playerData)) || (!__instance.leftPage && !Utils.IsJournalPageUnlocked(peakJournal.currentPage + 1, Books.Intermediate, session.playerData)))
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(IntermediatePeakSelection), "OnMouseSpriteOver")]
		public class IntermediatePeakSelectionColorPatch
		{
			private static void Prefix(IntermediatePeakSelection __instance)
			{
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
				IntermediateJournal peakJournal = __instance.peakJournal;
				MeshRenderer component = __instance.rightSelectOutlineOBJ.GetComponent<MeshRenderer>();
				MeshRenderer component2 = __instance.leftSelectOutlineOBJ.GetComponent<MeshRenderer>();
				if (__instance.leftPage && !Utils.IsJournalPageUnlocked(peakJournal.currentPage, Books.Intermediate, session.playerData))
				{
					((Renderer)component2).material.color = new Color(2f, 0f, 0f);
				}
				else
				{
					((Renderer)component2).material.color = new Color(1f, 1f, 1f, 0.349f);
				}
				if (!__instance.leftPage && !Utils.IsJournalPageUnlocked(peakJournal.currentPage + 1, Books.Intermediate, session.playerData))
				{
					((Renderer)component).material.color = new Color(2f, 0f, 0f);
				}
				else
				{
					((Renderer)component).material.color = new Color(1f, 1f, 1f, 0.349f);
				}
			}
		}

		[HarmonyPatch(typeof(IntermediateJournal), "PageTurnSound")]
		public class IntermediateJournalColorPatch
		{
			private static void Postfix(IntermediateJournal __instance)
			{
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0115: Unknown result type (might be due to invalid IL or missing references)
				//IL_0137: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance.journalPageAnim.clip == (Object)(object)__instance.journalPage_TurnLeft)
				{
					__instance.backPage.color = Utils.GetJournalPageColor(__instance.currentPage, Books.Intermediate, session.playerData);
					__instance.frontPage.color = Utils.GetJournalPageColor(__instance.currentPage - 1, Books.Intermediate, session.playerData);
					__instance.rightPage.color = Utils.GetJournalPageColor(__instance.currentPage + 1, Books.Intermediate, session.playerData);
					__instance.leftPage.color = Utils.GetJournalPageColor(__instance.currentPage - 2, Books.Intermediate, session.playerData);
				}
				else
				{
					__instance.backPage.color = Utils.GetJournalPageColor(__instance.currentPage + 2, Books.Intermediate, session.playerData);
					__instance.frontPage.color = Utils.GetJournalPageColor(__instance.currentPage + 1, Books.Intermediate, session.playerData);
					__instance.rightPage.color = Utils.GetJournalPageColor(__instance.currentPage + 3, Books.Intermediate, session.playerData);
					__instance.leftPage.color = Utils.GetJournalPageColor(__instance.currentPage, Books.Intermediate, session.playerData);
				}
			}
		}

		[HarmonyPatch(typeof(IntermediateJournal), "UpdatePage")]
		public class IntermediateUpdatePagePatch
		{
			private static void Postfix(IntermediateJournal __instance)
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: 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)
				__instance.backPage.color = Utils.GetJournalPageColor(__instance.currentPage + 2, Books.Intermediate, session.playerData);
				__instance.frontPage.color = Utils.GetJournalPageColor(__instance.currentPage + 1, Books.Intermediate, session.playerData);
				__instance.rightPage.color = Utils.GetJournalPageColor(__instance.currentPage + 3, Books.Intermediate, session.playerData);
				__instance.leftPage.color = Utils.GetJournalPageColor(__instance.currentPage, Books.Intermediate, session.playerData);
			}
		}

		[HarmonyPatch(typeof(AdvancedPeakSelection), "OnMouseSpriteDown")]
		public class AdvancedPeakSelectionPatch
		{
			private static bool Prefix(AdvancedPeakSelection __instance)
			{
				AdvancedJournal peakJournal = __instance.peakJournal;
				if ((__instance.leftPage && !Utils.IsJournalPageUnlocked(peakJournal.currentPage, Books.Advanced, session.playerData)) || (!__instance.leftPage && !Utils.IsJournalPageUnlocked(peakJournal.currentPage + 1, Books.Advanced, session.playerData)))
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(AdvancedPeakSelection), "OnMouseSpriteOver")]
		public class AdvancedPeakSelectionColorPatch
		{
			private static void Prefix(AdvancedPeakSelection __instance)
			{
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
				AdvancedJournal peakJournal = __instance.peakJournal;
				MeshRenderer component = __instance.rightSelectOutlineOBJ.GetComponent<MeshRenderer>();
				MeshRenderer component2 = __instance.leftSelectOutlineOBJ.GetComponent<MeshRenderer>();
				if (__instance.leftPage && !Utils.IsJournalPageUnlocked(peakJournal.currentPage, Books.Advanced, session.playerData))
				{
					((Renderer)component2).material.color = new Color(2f, 0f, 0f);
				}
				else
				{
					((Renderer)component2).material.color = new Color(1f, 1f, 1f, 0.349f);
				}
				if (!__instance.leftPage && !Utils.IsJournalPageUnlocked(peakJournal.currentPage + 1, Books.Advanced, session.playerData))
				{
					((Renderer)component).material.color = new Color(2f, 0f, 0f);
				}
				else
				{
					((Renderer)component).material.color = new Color(1f, 1f, 1f, 0.349f);
				}
			}
		}

		[HarmonyPatch(typeof(AdvancedJournal), "PageTurnSound")]
		public class AdvancedJournalColorPatch
		{
			private static void Postfix(AdvancedJournal __instance)
			{
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0115: Unknown result type (might be due to invalid IL or missing references)
				//IL_0137: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance.journalPageAnim.clip == (Object)(object)__instance.journalPage_TurnLeft)
				{
					__instance.backPage.color = Utils.GetJournalPageColor(__instance.currentPage, Books.Advanced, session.playerData);
					__instance.frontPage.color = Utils.GetJournalPageColor(__instance.currentPage - 1, Books.Advanced, session.playerData);
					__instance.rightPage.color = Utils.GetJournalPageColor(__instance.currentPage + 1, Books.Advanced, session.playerData);
					__instance.leftPage.color = Utils.GetJournalPageColor(__instance.currentPage - 2, Books.Advanced, session.playerData);
				}
				else
				{
					__instance.backPage.color = Utils.GetJournalPageColor(__instance.currentPage + 2, Books.Advanced, session.playerData);
					__instance.frontPage.color = Utils.GetJournalPageColor(__instance.currentPage + 1, Books.Advanced, session.playerData);
					__instance.rightPage.color = Utils.GetJournalPageColor(__instance.currentPage + 3, Books.Advanced, session.playerData);
					__instance.leftPage.color = Utils.GetJournalPageColor(__instance.currentPage, Books.Advanced, session.playerData);
				}
			}
		}

		[HarmonyPatch(typeof(AdvancedJournal), "UpdatePage")]
		public class AdvancedUpdatePagePatch
		{
			private static void Postfix(AdvancedJournal __instance)
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: 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)
				__instance.backPage.color = Utils.GetJournalPageColor(__instance.currentPage + 2, Books.Advanced, session.playerData);
				__instance.frontPage.color = Utils.GetJournalPageColor(__instance.currentPage + 1, Books.Advanced, session.playerData);
				__instance.rightPage.color = Utils.GetJournalPageColor(__instance.currentPage + 3, Books.Advanced, session.playerData);
				__instance.leftPage.color = Utils.GetJournalPageColor(__instance.currentPage, Books.Advanced, session.playerData);
			}
		}

		[HarmonyPatch(typeof(DisableCabin4Flag), "CheckFlag")]
		public class DisableCabin4Things
		{
			private static void Postfix(DisableCabin4Flag __instance)
			{
				__instance.solemnTempestGateway.SetActive(session.playerData.items.peaks.IsChecked(Peaks.SolemnTempest));
			}
		}

		[HarmonyPatch(typeof(Category4CabinLeave), "Update")]
		public class BulwarkStopperPatch
		{
			private static bool Prefix(Category4CabinLeave __instance)
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				((MonoBehaviour)__instance).StopCoroutine("GlowDoor");
				__instance.itemMat.SetColor("_EmissionColor", Color.black);
				return session.playerData.items.peaks.IsChecked(Peaks.GreatBulwark);
			}
		}

		[HarmonyPatch(typeof(Cabin4Map), "Update")]
		public class SolemnTempestLoaderTranspiler
		{
			private static bool didBulwark;

			private static void Prefix()
			{
				didBulwark = GameManager.control.greatbulwark;
				GameManager.control.greatbulwark = session.playerData.items.peaks.IsChecked(Peaks.SolemnTempest);
			}

			private static void Postfix()
			{
				GameManager.control.greatbulwark = didBulwark;
			}
		}

		[HarmonyPatch(typeof(StamperPeakSummit), "JournalPageUpdate")]
		public class StamperJournalColorPatch
		{
			private static void Postfix(StamperPeakSummit __instance)
			{
				//IL_0007: 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)
				__instance.leftPage.color = Color.white;
				__instance.rightPage.color = Color.white;
			}
		}

		[HarmonyPatch(typeof(RopeAnchor), "Start")]
		public class StartTranspiler
		{
			[CompilerGenerated]
			private sealed class <Transpiler>d__0 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private CodeInstruction <>2__current;

				private int <>l__initialThreadId;

				private IEnumerable<CodeInstruction> instructions;

				public IEnumerable<CodeInstruction> <>3__instructions;

				private List<CodeInstruction> <codes>5__1;

				private int <i>5__2;

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

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

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

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

				private bool MoveNext()
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -1;
						goto IL_008b;
					}
					<>1__state = -1;
					<codes>5__1 = new List<CodeInstruction>(instructions);
					<i>5__2 = 0;
					goto IL_009b;
					IL_008b:
					<i>5__2++;
					goto IL_009b;
					IL_009b:
					if (<i>5__2 < <codes>5__1.Count)
					{
						if (<i>5__2 == 76 || <i>5__2 == 77 || <i>5__2 == 78)
						{
							goto IL_008b;
						}
						<>2__current = <codes>5__1[<i>5__2];
						<>1__state = 1;
						return true;
					}
					return false;
				}

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

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

				[DebuggerHidden]
				IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
				{
					<Transpiler>d__0 <Transpiler>d__;
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						<Transpiler>d__ = this;
					}
					else
					{
						<Transpiler>d__ = new <Transpiler>d__0(0);
					}
					<Transpiler>d__.instructions = <>3__instructions;
					return <Transpiler>d__;
				}

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

			[IteratorStateMachine(typeof(<Transpiler>d__0))]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <Transpiler>d__0(-2)
				{
					<>3__instructions = instructions
				};
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		public class DetachThenAttachToNewTranspiler
		{
			[CompilerGenerated]
			private sealed class <Transpiler>d__0 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private CodeInstruction <>2__current;

				private int <>l__initialThreadId;

				private IEnumerable<CodeInstruction> instructions;

				public IEnumerable<CodeInstruction> <>3__instructions;

				private List<CodeInstruction> <codes>5__1;

				private int <i>5__2;

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

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

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

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

				private bool MoveNext()
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -1;
						goto IL_0095;
					}
					<>1__state = -1;
					<codes>5__1 = new List<CodeInstruction>(instructions);
					<i>5__2 = 0;
					goto IL_00a5;
					IL_0095:
					<i>5__2++;
					goto IL_00a5;
					IL_00a5:
					if (<i>5__2 < <codes>5__1.Count)
					{
						if (<i>5__2 == 120 || <i>5__2 == 121 || <i>5__2 == 122 || <i>5__2 == 123)
						{
							goto IL_0095;
						}
						<>2__current = <codes>5__1[<i>5__2];
						<>1__state = 1;
						return true;
					}
					return false;
				}

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

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

				[DebuggerHidden]
				IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
				{
					<Transpiler>d__0 <Transpiler>d__;
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						<Transpiler>d__ = this;
					}
					else
					{
						<Transpiler>d__ = new <Transpiler>d__0(0);
					}
					<Transpiler>d__.instructions = <>3__instructions;
					return <Transpiler>d__;
				}

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

			[IteratorStateMachine(typeof(<Transpiler>d__0))]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <Transpiler>d__0(-2)
				{
					<>3__instructions = instructions
				};
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		public class PullOutAnchorTranspiler
		{
			[CompilerGenerated]
			private sealed class <Transpiler>d__0 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private CodeInstruction <>2__current;

				private int <>l__initialThreadId;

				private IEnumerable<CodeInstruction> instructions;

				public IEnumerable<CodeInstruction> <>3__instructions;

				private List<CodeInstruction> <codes>5__1;

				private int <i>5__2;

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

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

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

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

				private bool MoveNext()
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -1;
						goto IL_0095;
					}
					<>1__state = -1;
					<codes>5__1 = new List<CodeInstruction>(instructions);
					<i>5__2 = 0;
					goto IL_00a5;
					IL_0095:
					<i>5__2++;
					goto IL_00a5;
					IL_00a5:
					if (<i>5__2 < <codes>5__1.Count)
					{
						if (<i>5__2 == 79 || <i>5__2 == 80 || <i>5__2 == 81 || <i>5__2 == 82)
						{
							goto IL_0095;
						}
						<>2__current = <codes>5__1[<i>5__2];
						<>1__state = 1;
						return true;
					}
					return false;
				}

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

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

				[DebuggerHidden]
				IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
				{
					<Transpiler>d__0 <Transpiler>d__;
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						<Transpiler>d__ = this;
					}
					else
					{
						<Transpiler>d__ = new <Transpiler>d__0(0);
					}
					<Transpiler>d__.instructions = <>3__instructions;
					return <Transpiler>d__;
				}

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

			[IteratorStateMachine(typeof(<Transpiler>d__0))]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <Transpiler>d__0(-2)
				{
					<>3__instructions = instructions
				};
			}
		}

		[HarmonyPatch(typeof(RopeCollectable), "CheckRope")]
		public class CheckRopeTranspiler
		{
			[CompilerGenerated]
			private sealed class <Transpiler>d__0 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private CodeInstruction <>2__current;

				private int <>l__initialThreadId;

				private IEnumerable<CodeInstruction> instructions;

				public IEnumerable<CodeInstruction> <>3__instructions;

				private List<CodeInstruction> <codes>5__1;

				private int <i>5__2;

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

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

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

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

				private bool MoveNext()
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -1;
						goto IL_00a4;
					}
					<>1__state = -1;
					<codes>5__1 = new List<CodeInstruction>(instructions);
					<i>5__2 = 0;
					goto IL_00b4;
					IL_00a4:
					<i>5__2++;
					goto IL_00b4;
					IL_00b4:
					if (<i>5__2 < <codes>5__1.Count)
					{
						if (<i>5__2 == 267 || <i>5__2 == 268 || <i>5__2 == 269 || <i>5__2 == 270)
						{
							goto IL_00a4;
						}
						<>2__current = <codes>5__1[<i>5__2];
						<>1__state = 1;
						return true;
					}
					return false;
				}

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

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

				[DebuggerHidden]
				IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
				{
					<Transpiler>d__0 <Transpiler>d__;
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						<Transpiler>d__ = this;
					}
					else
					{
						<Transpiler>d__ = new <Transpiler>d__0(0);
					}
					<Transpiler>d__.instructions = <>3__instructions;
					return <Transpiler>d__;
				}

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

			[IteratorStateMachine(typeof(<Transpiler>d__0))]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <Transpiler>d__0(-2)
				{
					<>3__instructions = instructions
				};
			}
		}

		[HarmonyPatch(typeof(BirdSeedCollectable), "CheckBirdSeed")]
		public class CheckBirdSeedTranspler
		{
			[CompilerGenerated]
			private sealed class <Transpiler>d__0 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private CodeInstruction <>2__current;

				private int <>l__initialThreadId;

				private IEnumerable<CodeInstruction> instructions;

				public IEnumerable<CodeInstruction> <>3__instructions;

				private List<CodeInstruction> <codes>5__1;

				private int <i>5__2;

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

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

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

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

				private bool MoveNext()
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -1;
						goto IL_0095;
					}
					<>1__state = -1;
					<codes>5__