using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GlobalEnums;
using HutongGames.PlayMaker;
using InControl;
using Md.HeroController;
using Md.PlayMakerFSM;
using Microsoft.CodeAnalysis;
using MonoDetour;
using MonoDetour.Cil;
using MonoDetour.DetourTypes;
using MonoDetour.HookGen;
using Silksong.FsmUtil;
using UnityEngine;
using UnityEngine.UI;
using WavLib;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MonoDetourTargets(typeof(HeroController), GenerateControlFlowVariants = true)]
[assembly: MonoDetourTargets(typeof(PlayMakerFSM), GenerateControlFlowVariants = true)]
[assembly: IgnoresAccessChecksTo("Accessibility")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp-firstpass")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("Coffee.SoftMaskForUGUI")]
[assembly: IgnoresAccessChecksTo("com.rlabrecque.steamworks.net")]
[assembly: IgnoresAccessChecksTo("ConditionalExpression")]
[assembly: IgnoresAccessChecksTo("GalaxyCSharp")]
[assembly: IgnoresAccessChecksTo("Newtonsoft.Json")]
[assembly: IgnoresAccessChecksTo("Newtonsoft.Json.UnityConverters.Addressables")]
[assembly: IgnoresAccessChecksTo("Newtonsoft.Json.UnityConverters")]
[assembly: IgnoresAccessChecksTo("Newtonsoft.Json.UnityConverters.Mathematics")]
[assembly: IgnoresAccessChecksTo("PlayMaker")]
[assembly: IgnoresAccessChecksTo("SharpDX.DirectInput")]
[assembly: IgnoresAccessChecksTo("SharpDX")]
[assembly: IgnoresAccessChecksTo("TeamCherry.BuildBot")]
[assembly: IgnoresAccessChecksTo("TeamCherry.Cinematics")]
[assembly: IgnoresAccessChecksTo("TeamCherry.Localization")]
[assembly: IgnoresAccessChecksTo("TeamCherry.NestedFadeGroup")]
[assembly: IgnoresAccessChecksTo("TeamCherry.SharedUtils")]
[assembly: IgnoresAccessChecksTo("TeamCherry.Splines")]
[assembly: IgnoresAccessChecksTo("TeamCherry.TK2D")]
[assembly: IgnoresAccessChecksTo("Unity.Addressables")]
[assembly: IgnoresAccessChecksTo("Unity.Burst")]
[assembly: IgnoresAccessChecksTo("Unity.Burst.Unsafe")]
[assembly: IgnoresAccessChecksTo("Unity.Collections")]
[assembly: IgnoresAccessChecksTo("Unity.Collections.LowLevel.ILSupport")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem.ForUI")]
[assembly: IgnoresAccessChecksTo("Unity.Mathematics")]
[assembly: IgnoresAccessChecksTo("Unity.MemoryProfiler")]
[assembly: IgnoresAccessChecksTo("Unity.Profiling.Core")]
[assembly: IgnoresAccessChecksTo("Unity.Recorder.Base")]
[assembly: IgnoresAccessChecksTo("Unity.Recorder")]
[assembly: IgnoresAccessChecksTo("Unity.ResourceManager")]
[assembly: IgnoresAccessChecksTo("Unity.ScriptableBuildPipeline")]
[assembly: IgnoresAccessChecksTo("Unity.TextMeshPro")]
[assembly: IgnoresAccessChecksTo("Unity.Timeline")]
[assembly: IgnoresAccessChecksTo("UnityEngine.AMDModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.ARModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.NVIDIAModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.UI")]
[assembly: IgnoresAccessChecksTo("XblPCSandbox")]
[assembly: IgnoresAccessChecksTo("XGamingRuntime")]
[assembly: IgnoresAccessChecksTo("zlib.net")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("StubbornHornet")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+5a68a633a626935d96c30b5c1ef2bf59eb2b34ca")]
[assembly: AssemblyProduct("StubbornHornet")]
[assembly: AssemblyTitle("StubbornHornet")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/MCXGK3/StubbornHornet")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.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;
		}
	}
}
namespace Md.PlayMakerFSM
{
	internal static class Update
	{
		public delegate void PrefixSignature(PlayMakerFSM self);

		public delegate ReturnFlow ControlFlowPrefixSignature(PlayMakerFSM self);

		public delegate void PostfixSignature(PlayMakerFSM self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ControlFlowPrefix(ControlFlowPrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			return typeof(PlayMakerFSM).GetMethod("Update", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("PlayMakerFSM", "Update");
		}
	}
	internal static class Start
	{
		public delegate void PrefixSignature(PlayMakerFSM self);

		public delegate ReturnFlow ControlFlowPrefixSignature(PlayMakerFSM self);

		public delegate void PostfixSignature(PlayMakerFSM self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ControlFlowPrefix(ControlFlowPrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			return typeof(PlayMakerFSM).GetMethod("Start", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("PlayMakerFSM", "Start");
		}
	}
	internal static class SendEvent
	{
		public delegate void PrefixSignature(PlayMakerFSM self, ref string eventName);

		public delegate ReturnFlow ControlFlowPrefixSignature(PlayMakerFSM self, ref string eventName);

		public delegate void PostfixSignature(PlayMakerFSM self, ref string eventName);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ControlFlowPrefix(ControlFlowPrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			return typeof(PlayMakerFSM).GetMethod("SendEvent", (BindingFlags)(-1), null, new Type[1] { typeof(string) }, null) ?? throw new MissingMethodException("PlayMakerFSM", "SendEvent");
		}
	}
	internal static class ShowFullFsmInspector
	{
	}
	internal static class get_VersionNotes
	{
	}
	internal static class get_VersionLabel
	{
	}
	internal static class get_FsmList
	{
	}
	internal static class FindFsmOnGameObject
	{
	}
	internal static class get_IsMainThread
	{
	}
	internal static class get_NotMainThread
	{
	}
	internal static class InitInEditor
	{
	}
	internal static class get_FsmTemplate
	{
	}
	internal static class get_DrawGizmos
	{
	}
	internal static class set_DrawGizmos
	{
	}
	internal static class Reset
	{
	}
	internal static class OnValidate
	{
	}
	internal static class Awake
	{
	}
	internal static class Preprocess
	{
	}
	internal static class Init
	{
	}
	internal static class InitTemplate
	{
	}
	internal static class InitFsm
	{
	}
	internal static class AddEventHandlerComponents
	{
	}
	internal static class get_AddEventHandlers
	{
	}
	internal static class SetFsmTemplate
	{
	}
	internal static class OnEnable
	{
	}
	internal static class DoCoroutine
	{
	}
	internal static class OnDisable
	{
	}
	internal static class OnDestroy
	{
	}
	internal static class OnApplicationQuit
	{
	}
	internal static class OnDrawGizmos
	{
	}
	internal static class SetState
	{
	}
	internal static class ChangeState_HutongGames_PlayMaker_FsmEvent
	{
	}
	internal static class ChangeState_System_String
	{
	}
	internal static class SendRemoteFsmEvent
	{
	}
	internal static class SendRemoteFsmEventWithData
	{
	}
	internal static class BroadcastEvent_System_String
	{
	}
	internal static class BroadcastEvent_HutongGames_PlayMaker_FsmEvent
	{
	}
	internal static class OnBecameVisible
	{
	}
	internal static class OnBecameInvisible
	{
	}
	internal static class get_Fsm
	{
	}
	internal static class set_Fsm
	{
	}
	internal static class get_FsmName
	{
	}
	internal static class set_FsmName
	{
	}
	internal static class get_FsmDescription
	{
	}
	internal static class set_FsmDescription
	{
	}
	internal static class get_Active
	{
	}
	internal static class get_ActiveStateName
	{
	}
	internal static class get_FsmStates
	{
	}
	internal static class get_FsmEvents
	{
	}
	internal static class get_FsmGlobalTransitions
	{
	}
	internal static class get_FsmVariables
	{
	}
	internal static class get_UsesTemplate
	{
	}
	internal static class OnBeforeSerialize
	{
	}
	internal static class OnAfterDeserialize
	{
	}
	internal static class DebugLog
	{
	}
	internal static class _ctor
	{
	}
	internal static class _cctor
	{
	}
	internal static class AddEventHandlerDelegate
	{
		internal static class _ctor
		{
		}

		internal static class Invoke
		{
		}

		internal static class BeginInvoke
		{
		}

		internal static class EndInvoke
		{
		}
	}
	internal static class _DoCoroutine_d__46
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
}
namespace Md.HeroController
{
	internal static class Update
	{
		public delegate void PrefixSignature(HeroController self);

		public delegate ReturnFlow ControlFlowPrefixSignature(HeroController self);

		public delegate void PostfixSignature(HeroController self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ControlFlowPrefix(ControlFlowPrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			return typeof(HeroController).GetMethod("Update", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("HeroController", "Update");
		}
	}
	internal static class Start
	{
		public delegate void PrefixSignature(HeroController self);

		public delegate ReturnFlow ControlFlowPrefixSignature(HeroController self);

		public delegate void PostfixSignature(HeroController self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ControlFlowPrefix(ControlFlowPrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			return typeof(HeroController).GetMethod("Start", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("HeroController", "Start");
		}
	}
	internal static class Attack
	{
		public delegate void PrefixSignature(HeroController self, ref AttackDirection attackDir);

		public delegate ReturnFlow ControlFlowPrefixSignature(HeroController self, ref AttackDirection attackDir);

		public delegate void PostfixSignature(HeroController self, ref AttackDirection attackDir);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ControlFlowPrefix(ControlFlowPrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			return typeof(HeroController).GetMethod("Attack", (BindingFlags)(-1), null, new Type[1] { typeof(AttackDirection) }, null) ?? throw new MissingMethodException("HeroController", "Attack");
		}
	}
	internal static class CanNailArt
	{
		public delegate void PrefixSignature(HeroController self);

		public delegate ReturnFlow ControlFlowPrefixSignature(HeroController self, ref bool returnValue);

		public delegate void PostfixSignature(HeroController self, ref bool returnValue);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ControlFlowPrefix(ControlFlowPrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			return typeof(HeroController).GetMethod("CanNailArt", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("HeroController", "CanNailArt");
		}
	}
	internal static class GetWillThrowTool
	{
		public delegate void PrefixSignature(HeroController self, ref bool reportFailure);

		public delegate ReturnFlow ControlFlowPrefixSignature(HeroController self, ref bool reportFailure, ref bool returnValue);

		public delegate void PostfixSignature(HeroController self, ref bool reportFailure, ref bool returnValue);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ControlFlowPrefix(ControlFlowPrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			return typeof(HeroController).GetMethod("GetWillThrowTool", (BindingFlags)(-1), null, new Type[1] { typeof(bool) }, null) ?? throw new MissingMethodException("HeroController", "GetWillThrowTool");
		}
	}
	internal static class UpdateConfig
	{
		public delegate void PrefixSignature(HeroController self);

		public delegate ReturnFlow ControlFlowPrefixSignature(HeroController self);

		public delegate void PostfixSignature(HeroController self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ControlFlowPrefix(ControlFlowPrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			return typeof(HeroController).GetMethod("UpdateConfig", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("HeroController", "UpdateConfig");
		}
	}
	internal static class StartAnimationControlToIdle
	{
		public delegate void PrefixSignature(HeroController self);

		public delegate ReturnFlow ControlFlowPrefixSignature(HeroController self);

		public delegate void PostfixSignature(HeroController self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ControlFlowPrefix(ControlFlowPrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			return typeof(HeroController).GetMethod("StartAnimationControlToIdle", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("HeroController", "StartAnimationControlToIdle");
		}
	}
	internal static class get_CurrentNailChargeTime
	{
	}
	internal static class get_CurrentNailChargeBeginTime
	{
	}
	internal static class get_HeroLockState
	{
	}
	internal static class set_HeroLockState
	{
	}
	internal static class get_CanTurn
	{
	}
	internal static class get_fallTimer
	{
	}
	internal static class set_fallTimer
	{
	}
	internal static class get_AudioCtrl
	{
	}
	internal static class get_Bounds
	{
	}
	internal static class get_proxyFSM
	{
	}
	internal static class set_proxyFSM
	{
	}
	internal static class get_NailImbuement
	{
	}
	internal static class set_NailImbuement
	{
	}
	internal static class get_IsSprintMasterActive
	{
	}
	internal static class get_IsGravityApplied
	{
	}
	internal static class set_IsGravityApplied
	{
	}
	internal static class get_sceneEntryGate
	{
	}
	internal static class set_sceneEntryGate
	{
	}
	internal static class get_PositionHistory
	{
	}
	internal static class add_FrostAmountUpdated
	{
	}
	internal static class remove_FrostAmountUpdated
	{
	}
	internal static class add_OnDoubleJumped
	{
	}
	internal static class remove_OnDoubleJumped
	{
	}
	internal static class get_ForceWalkingSound
	{
	}
	internal static class set_ForceWalkingSound
	{
	}
	internal static class get_ForceRunningSound
	{
	}
	internal static class set_ForceRunningSound
	{
	}
	internal static class get_IsStunned
	{
	}
	internal static class set_IsStunned
	{
	}
	internal static class get_SlashComponent
	{
	}
	internal static class set_SlashComponent
	{
	}
	internal static class add_OnHeroInstanceSet
	{
	}
	internal static class remove_OnHeroInstanceSet
	{
	}
	internal static class add_preHeroInPosition
	{
	}
	internal static class remove_preHeroInPosition
	{
	}
	internal static class add_heroInPosition
	{
	}
	internal static class remove_heroInPosition
	{
	}
	internal static class add_heroInPositionDelayed
	{
	}
	internal static class remove_heroInPositionDelayed
	{
	}
	internal static class add_OnTakenDamage
	{
	}
	internal static class remove_OnTakenDamage
	{
	}
	internal static class add_OnTakenDamageExtra
	{
	}
	internal static class remove_OnTakenDamageExtra
	{
	}
	internal static class add_OnDeath
	{
	}
	internal static class remove_OnDeath
	{
	}
	internal static class add_OnHazardDeath
	{
	}
	internal static class remove_OnHazardDeath
	{
	}
	internal static class add_OnHazardRespawn
	{
	}
	internal static class remove_OnHazardRespawn
	{
	}
	internal static class add_BeforeApplyConveyorSpeed
	{
	}
	internal static class remove_BeforeApplyConveyorSpeed
	{
	}
	internal static class add_FlippedSprite
	{
	}
	internal static class remove_FlippedSprite
	{
	}
	internal static class add_HeroLeavingScene
	{
	}
	internal static class remove_HeroLeavingScene
	{
	}
	internal static class get_WarriorState
	{
	}
	internal static class get_ReaperState
	{
	}
	internal static class get_HunterUpgState
	{
	}
	internal static class get_WandererState
	{
	}
	internal static class set_WandererState
	{
	}
	internal static class get_IsUsingQuickening
	{
	}
	internal static class get_IsInLifebloodState
	{
	}
	internal static class set_IsInLifebloodState
	{
	}
	internal static class get_IsWandererLucky
	{
	}
	internal static class get_PoisonHealthCount
	{
	}
	internal static class set_PoisonHealthCount
	{
	}
	internal static class get_Body
	{
	}
	internal static class get_HasAnimationControl
	{
	}
	internal static class get_AnimCtrl
	{
	}
	internal static class get_instance
	{
	}
	internal static class get_SilentInstance
	{
	}
	internal static class get_UnsafeInstance
	{
	}
	internal static class get_Config
	{
	}
	internal static class get_CurrentConfigGroup
	{
	}
	internal static class set_CurrentConfigGroup
	{
	}
	internal static class get_SpriteFlash
	{
	}
	internal static class get_TagDamageEffectPos
	{
	}
	internal static class get_IsRefillSoundsSuppressed
	{
	}
	internal static class get_ForceClampTerminalVelocity
	{
	}
	internal static class set_ForceClampTerminalVelocity
	{
	}
	internal static class get_CriticalHealthValue
	{
	}
	internal static class OnValidate
	{
	}
	internal static class Awake
	{
	}
	internal static class OnDestroy
	{
	}
	internal static class SpawnChildPrefab_UnityEngine_GameObject
	{
	}
	internal static class SendPreHeroInPosition
	{
	}
	internal static class SendHeroInPosition
	{
	}
	internal static class SetConfigGroup
	{
	}
	internal static class SceneInit
	{
	}
	internal static class SetIsMaggoted
	{
	}
	internal static class AddToMaggotCharmTimer
	{
	}
	internal static class DidMaggotCharmHit
	{
	}
	internal static class TickFrostEffect
	{
	}
	internal static class SpawnDeliveryItemEffect
	{
	}
	internal static class RemoveDeliveryItemEffect
	{
	}
	internal static class SetupDeliveryItems
	{
	}
	internal static class TickDeliveryItems
	{
	}
	internal static class GetDeliveryTimers
	{
	}
	internal static class GetTotalFrostSpeed
	{
	}
	internal static class TickSilkEat
	{
	}
	internal static class ShuttleCockCancel
	{
	}
	internal static class ShuttleCockCancelInert
	{
	}
	internal static class FixedUpdate
	{
	}
	internal static class ShoveOff
	{
	}
	internal static class UpdateMoveInput
	{
	}
	internal static class DoMovement
	{
	}
	internal static class DoRecoilMovement
	{
	}
	internal static class ConveyorReset
	{
	}
	internal static class SetBlockSteepSlopes
	{
	}
	internal static class IsSteepSlopeRayHitting
	{
	}
	internal static class UpdateSteepSlopes
	{
	}
	internal static class UpdateEdgeAdjust
	{
	}
	internal static class CanThrowTool_ToolItem_AttackToolBinding_System_Boolean
	{
	}
	internal static class SetToolCooldown
	{
	}
	internal static class ThrowTool
	{
	}
	internal static class DidUseAttackTool
	{
	}
	internal static class ThrowToolEnd
	{
	}
	internal static class QueueLifeBloodStateQuick
	{
	}
	internal static class EnterLifebloodStateQuick
	{
	}
	internal static class TrySetCorrectFacing
	{
	}
	internal static class DoEdgeAdjust
	{
	}
	internal static class Update10
	{
	}
	internal static class LateUpdate
	{
	}
	internal static class OnLevelUnload
	{
	}
	internal static class OnDisable
	{
	}
	internal static class Move
	{
	}
	internal static class Jump
	{
	}
	internal static class DoubleJump
	{
	}
	internal static class SetSlashComponent
	{
	}
	internal static class DoAttack
	{
	}
	internal static class IncrementAttackCounter
	{
	}
	internal static class AttackCancelWallSlide
	{
	}
	internal static class QueueCancelDownAttack
	{
	}
	internal static class DownAttack
	{
	}
	internal static class DidAttack
	{
	}
	internal static class Dash
	{
	}
	internal static class BackDash
	{
	}
	internal static class Downspike
	{
	}
	internal static class StartAirHang
	{
	}
	internal static class FaceRight
	{
	}
	internal static class FaceLeft
	{
	}
	internal static class ChangedFacing
	{
	}
	internal static class SetBackOnGround
	{
	}
	internal static class SetStartWithWallslide
	{
	}
	internal static class TryFsmCancelToWallSlide
	{
	}
	internal static class SetStartWithShuttlecock
	{
	}
	internal static class SetStartWithJump
	{
	}
	internal static class SetStartWithWallJump
	{
	}
	internal static class SetStartWithTinyJump
	{
	}
	internal static class SetStartWithFlipJump
	{
	}
	internal static class SilkChargeEnd
	{
	}
	internal static class HarpoonDashEnd
	{
	}
	internal static class SetStartWithAnyJump
	{
	}
	internal static class SetStartWithFullJump
	{
	}
	internal static class SetStartWithBackflipJump
	{
	}
	internal static class SetStartWithBrolly
	{
	}
	internal static class SetStartWithDoubleJump
	{
	}
	internal static class SetStartWithWallsprintLaunch
	{
	}
	internal static class SetStartWithDash
	{
	}
	internal static class SetStartWithDashKeepFacing
	{
	}
	internal static class SetStartWithAttack
	{
	}
	internal static class SetStartWithToolThrow
	{
	}
	internal static class SetStartWithDashStabBounce
	{
	}
	internal static class SetStartWithDownSpikeBounce
	{
	}
	internal static class SetStartWithDownSpikeBounceSlightlyShort
	{
	}
	internal static class SetStartWithDownSpikeBounceShort
	{
	}
	internal static class ResetAnimationDownspikeBounce
	{
	}
	internal static class SetStartWithDownSpikeEnd
	{
	}
	internal static class SetStartWithBalloonBounce
	{
	}
	internal static class SetStartWithHarpoonBounce
	{
	}
	internal static class CancelQueuedBounces
	{
	}
	internal static class SetStartWithWitchSprintBounce
	{
	}
	internal static class SetStartWithUpdraftExit
	{
	}
	internal static class SetStartWithScrambleLeap
	{
	}
	internal static class SetStartWithRecoilBack
	{
	}
	internal static class SetStartWithRecoilBackLong
	{
	}
	internal static class SetStartWithWhipPullRecoil
	{
	}
	internal static class SetSuperDashExit
	{
	}
	internal static class SetQuakeExit
	{
	}
	internal static class SetTakeNoDamage
	{
	}
	internal static class EndTakeNoDamage
	{
	}
	internal static class SetStartFromMantle
	{
	}
	internal static class SetStartFromReaperUpperslash
	{
	}
	internal static class SetHeroParent
	{
	}
	internal static class SetBlockFsmMove
	{
	}
	internal static class IsSwimming
	{
	}
	internal static class AddFrost
	{
	}
	internal static class SetFrostAmount
	{
	}
	internal static class NotSwimming
	{
	}
	internal static class GetAirdashed
	{
	}
	internal static class GetCanAirDashCancel
	{
	}
	internal static class EnableRenderer
	{
	}
	internal static class ResetAirMoves
	{
	}
	internal static class SetConveyorSpeed
	{
	}
	internal static class EnterWithoutInput
	{
	}
	internal static class SetDarkness
	{
	}
	internal static class CancelHeroJump
	{
	}
	internal static class StartHarpoonDashCooldown
	{
	}
	internal static class StartHarpoonDashCooldownShort
	{
	}
	internal static class CharmUpdate
	{
	}
	internal static class UpdateBlueHealth
	{
	}
	internal static class HitMaxBlueHealth
	{
	}
	internal static class HitMaxBlueHealthBurst
	{
	}
	internal static class GetMaxFallVelocity
	{
	}
	internal static class ResetLifebloodState
	{
	}
	internal static class checkEnvironment
	{
	}
	internal static class SetBenchRespawn_System_String_System_String_System_Int32_System_Boolean
	{
	}
	internal static class SetBenchRespawn_RespawnMarker_System_String_System_Int32
	{
	}
	internal static class SetHazardRespawn
	{
	}
	internal static class AddGeo
	{
	}
	internal static class ToZero
	{
	}
	internal static class AddGeoQuietly
	{
	}
	internal static class AddGeoToCounter
	{
	}
	internal static class TakeGeo
	{
	}
	internal static class AddShards
	{
	}
	internal static class TakeShards
	{
	}
	internal static class AddCurrency
	{
	}
	internal static class TakeCurrency
	{
	}
	internal static class GetCurrencyAmount
	{
	}
	internal static class TempStoreCurrency
	{
	}
	internal static class RestoreTempStoredCurrency
	{
	}
	internal static class UpdateGeo
	{
	}
	internal static class CanInput
	{
	}
	internal static class IsPaused
	{
	}
	internal static class IsHunterCrestEquipped
	{
	}
	internal static class IsArchitectCrestEquipped
	{
	}
	internal static class IsShamanCrestEquipped
	{
	}
	internal static class FlipSprite
	{
	}
	internal static class RefreshFacing
	{
	}
	internal static class RefreshScale
	{
	}
	internal static class NeedleArtRecovery
	{
	}
	internal static class CrestAttackRecovery
	{
	}
	internal static class NailParry
	{
	}
	internal static class IsParrying
	{
	}
	internal static class IsParryingActive
	{
	}
	internal static class NailParryRecover
	{
	}
	internal static class QuakeInvuln
	{
	}
	internal static class CrossStitchInvuln
	{
	}
	internal static class StartRevengeWindow
	{
	}
	internal static class StartWandererDashComboWindow
	{
	}
	internal static class ForceSoftLanding
	{
	}
	internal static class PlaySoftLandingEffect
	{
	}
	internal static class TakeQuickDamage_System_Int32_System_Boolean
	{
	}
	internal static class TakeQuickDamage_System_Int32_System_Boolean_System_Boolean
	{
	}
	internal static class TakeQuickDamageSimple
	{
	}
	internal static class TakeFrostDamage
	{
	}
	internal static class TakeChompDamage
	{
	}
	internal static class ApplyTagDamage
	{
	}
	internal static class DoSpecialDamage
	{
	}
	internal static class CriticalDamage
	{
	}
	internal static class CheckParry
	{
	}
	internal static class TakeDamage
	{
	}
	internal static class CheckDeathCatch
	{
	}
	internal static class ActivateVoidAcid
	{
	}
	internal static class IsLavaBellActive
	{
	}
	internal static class UseLavaBell
	{
	}
	internal static class GetLuckyDiceShieldThreshold
	{
	}
	internal static class GetLuckModifier
	{
	}
	internal static class DamageSelf
	{
	}
	internal static class CanTryHarpoonDash
	{
	}
	internal static class HeroDamaged
	{
	}
	internal static class SendHeroDamagedEvent
	{
	}
	internal static class SendHeroDamagedEvent_HeroController_DamageInfo
	{
	}
	internal static class HeroRespawned
	{
	}
	internal static class DoBindReminder
	{
	}
	internal static class WillDoBellBindHit
	{
	}
	internal static class WillDoBellBindHit_System_Boolean
	{
	}
	internal static class DoMossToolHit
	{
	}
	internal static class GetEntryGateName
	{
	}
	internal static class GetShuttlecockTime
	{
	}
	internal static class SilkGain
	{
	}
	internal static class SilkGain_HitInstance
	{
	}
	internal static class NailHitEnemy
	{
	}
	internal static class GetRageModeHealCap
	{
	}
	internal static class GetWitchHealCap
	{
	}
	internal static class GetReaperPayout
	{
	}
	internal static class ResetAllCrestStateMinimal
	{
	}
	internal static class ResetAllCrestState
	{
	}
	internal static class ResetAllCrestState_System_Boolean
	{
	}
	internal static class ResetWarriorRageEffect
	{
	}
	internal static class ResetWarriorCrestState
	{
	}
	internal static class ResetReaperCrestState
	{
	}
	internal static class SetSilkPartsTimeLeft
	{
	}
	internal static class ResetHunterUpgCrestState
	{
	}
	internal static class ResetWandererCrestState
	{
	}
	internal static class AddSilk_System_Int32_System_Boolean
	{
	}
	internal static class ReduceOdours
	{
	}
	internal static class AddSilk_System_Int32_System_Boolean_SilkSpool_SilkAddSource
	{
	}
	internal static class AddSilk_System_Int32_System_Boolean_SilkSpool_SilkAddSource_System_Boolean
	{
	}
	internal static class RefillSilkToMax
	{
	}
	internal static class RefreshSilk
	{
	}
	internal static class AddFinalMaxSilk
	{
	}
	internal static class AddSilkParts_System_Int32
	{
	}
	internal static class AddSilkParts_System_Int32_System_Boolean
	{
	}
	internal static class TakeSilk_System_Int32
	{
	}
	internal static class TakeSilk_System_Int32_SilkSpool_SilkTakeSource
	{
	}
	internal static class ClearSpoolMossChunks
	{
	}
	internal static class MaxRegenSilk
	{
	}
	internal static class MaxRegenSilkInstant
	{
	}
	internal static class StartSilkRegen
	{
	}
	internal static class DoSilkRegen
	{
	}
	internal static class ResetSilkRegen
	{
	}
	internal static class SetSilkRegenBlocked
	{
	}
	internal static class SetSilkRegenBlockedSilkHeart
	{
	}
	internal static class UpdateSilkCursed
	{
	}
	internal static class AddHealth
	{
	}
	internal static class RefillHealthToMax
	{
	}
	internal static class SuppressRefillSound
	{
	}
	internal static class RefillAll
	{
	}
	internal static class RefillSilkToMaxSilent
	{
	}
	internal static class BindCompleted
	{
	}
	internal static class RestartWarriorRageEffect
	{
	}
	internal static class BindInterrupted
	{
	}
	internal static class TakeHealth
	{
	}
	internal static class MaxHealth
	{
	}
	internal static class MaxHealthKeepBlue
	{
	}
	internal static class AddToMaxHealth
	{
	}
	internal static class AddToMaxSilk
	{
	}
	internal static class AddToMaxSilkRegen
	{
	}
	internal static class IsHealthCritical
	{
	}
	internal static class DownspikeBounce
	{
	}
	internal static class DownspikeBounceSlightlyShort
	{
	}
	internal static class DownspikeBounceShort
	{
	}
	internal static class Bounce
	{
	}
	internal static class BounceShort
	{
	}
	internal static class BounceHigh
	{
	}
	internal static class ShroomBounce
	{
	}
	internal static class RecoilLeft
	{
	}
	internal static class RecoilRight
	{
	}
	internal static class RecoilRightLong
	{
	}
	internal static class RecoilLeftLong
	{
	}
	internal static class CanRecoil
	{
	}
	internal static class CanCustomRecoil
	{
	}
	internal static class PreventRecoil
	{
	}
	internal static class AllowRecoil
	{
	}
	internal static class Recoil_System_Boolean_System_Boolean
	{
	}
	internal static class DrillDash
	{
	}
	internal static class DrillPull
	{
	}
	internal static class Recoil_System_Int32_System_Single
	{
	}
	internal static class Recoil_System_Boolean_System_Int32_System_Single
	{
	}
	internal static class ChargeSlashRecoilRight
	{
	}
	internal static class ChargeSlashRecoilLeft
	{
	}
	internal static class RecoilDown
	{
	}
	internal static class ForceHardLanding
	{
	}
	internal static class EnterUpdraft
	{
	}
	internal static class ExitUpdraft
	{
	}
	internal static class ResetUpdraft
	{
	}
	internal static class AllowMantle
	{
	}
	internal static class EnterSceneDreamGate
	{
	}
	internal static class EnterScene
	{
	}
	internal static class EnterHeroSubHorizontal
	{
	}
	internal static class EnterHeroSubFadeUp
	{
	}
	internal static class GetSceneFadeUpPadding
	{
	}
	internal static class MoveIfNotInDontDestroyOnLoad
	{
	}
	internal static class ResetHeroInPositionState
	{
	}
	internal static class LeaveScene
	{
	}
	internal static class BetaLeave
	{
	}
	internal static class BetaReturn
	{
	}
	internal static class Respawn
	{
	}
	internal static class HazardRespawnReset
	{
	}
	internal static class ResetShuttlecock
	{
	}
	internal static class HazardRespawn
	{
	}
	internal static class GetState
	{
	}
	internal static class GetCState
	{
	}
	internal static class SetCState
	{
	}
	internal static class CStateExists
	{
	}
	internal static class ResetHardLandingTimer
	{
	}
	internal static class CancelSuperDash
	{
	}
	internal static class CancelDownSpike
	{
	}
	internal static class CancelDownSpikeBounces
	{
	}
	internal static class RelinquishControlNotVelocity
	{
	}
	internal static class get_ControlVersion
	{
	}
	internal static class set_ControlVersion
	{
	}
	internal static class RelinquishControl
	{
	}
	internal static class RegainControl
	{
	}
	internal static class RegainControl_System_Boolean
	{
	}
	internal static class OnShuttleCockJump
	{
	}
	internal static class PreventCastByDialogueEnd
	{
	}
	internal static class CanDoFsmMove
	{
	}
	internal static class IsHardLanding
	{
	}
	internal static class CanCast
	{
	}
	internal static class CanBind
	{
	}
	internal static class CanDoFSMCancelMove
	{
	}
	internal static class CanDoSpecial
	{
	}
	internal static class CanQuickMap
	{
	}
	internal static class CanQuickMapBench
	{
	}
	internal static class CanQuickMap_System_Boolean
	{
	}
	internal static class IsLostInSlab
	{
	}
	internal static class HasNoMap
	{
	}
	internal static class CanInspect
	{
	}
	internal static class CanBackDash
	{
	}
	internal static class CanPlayNeedolin
	{
	}
	internal static class HasNeedolin
	{
	}
	internal static class CanInteract
	{
	}
	internal static class CanTakeControl
	{
	}
	internal static class CanOpenInventory
	{
	}
	internal static class SetDamageMode_System_Int32
	{
	}
	internal static class SetDamageModeFSM
	{
	}
	internal static class ResetQuakeDamage
	{
	}
	internal static class SetDamageMode_GlobalEnums_DamageMode
	{
	}
	internal static class get_AnimationControlVersion
	{
	}
	internal static class set_AnimationControlVersion
	{
	}
	internal static class StopAnimationControl
	{
	}
	internal static class StopAnimationControlVersioned
	{
	}
	internal static class StartAnimationControl
	{
	}
	internal static class StartAnimationControl_System_Int32
	{
	}
	internal static class StartAnimationControlRunning
	{
	}
	internal static class StartAnimationControlToIdleForcePlay
	{
	}
	internal static class IgnoreInput
	{
	}
	internal static class IgnoreInputWithoutReset
	{
	}
	internal static class AcceptInput
	{
	}
	internal static class Pause
	{
	}
	internal static class UnPause
	{
	}
	internal static class NearBench
	{
	}
	internal static class SetWalkZone
	{
	}
	internal static class ResetState
	{
	}
	internal static class StopPlayingAudio
	{
	}
	internal static class PauseAudio
	{
	}
	internal static class UnPauseAudio
	{
	}
	internal static class PauseInput
	{
	}
	internal static class UnPauseInput
	{
	}
	internal static class SetCanSoftLand
	{
	}
	internal static class TrySpawnSoftLandingPrefab
	{
	}
	internal static class CanSoftLand
	{
	}
	internal static class PreventSoftLand
	{
	}
	internal static class SpawnSoftLandingPrefab
	{
	}
	internal static class AffectedByGravity
	{
	}
	internal static class TryRestoreGravity
	{
	}
	internal static class ResetGravity
	{
	}
	internal static class ResetVelocity
	{
	}
	internal static class AddInputBlocker
	{
	}
	internal static class RemoveInputBlocker
	{
	}
	internal static class IsInputBlocked
	{
	}
	internal static class IsPressingOnlyDown
	{
	}
	internal static class LookForInput
	{
	}
	internal static class ForceTouchingWall
	{
	}
	internal static class BeginWallSlide
	{
	}
	internal static class WallKickoff
	{
	}
	internal static class TryDoWallJumpFromMove
	{
	}
	internal static class LookForQueueInput
	{
	}
	internal static class ResetInputQueues
	{
	}
	internal static class HeroJump
	{
	}
	internal static class ResetStartWithJumps
	{
	}
	internal static class PreventShuttlecock
	{
	}
	internal static class HeroJump_System_Boolean
	{
	}
	internal static class OnHeroJumped
	{
	}
	internal static class BecomeAirborne
	{
	}
	internal static class HeroJumpNoEffect
	{
	}
	internal static class ClearActionsInputState
	{
	}
	internal static class ClearJumpInputState
	{
	}
	internal static class DoWallJump
	{
	}
	internal static class DoDoubleJump
	{
	}
	internal static class SetBlockFootstepAudio
	{
	}
	internal static class StartFloat
	{
	}
	internal static class DoHardLanding
	{
	}
	internal static class DoHardLandingEffect
	{
	}
	internal static class DoHardLandingEffectNoHit
	{
	}
	internal static class HeroDashPressed
	{
	}
	internal static class HeroDash
	{
	}
	internal static class SetDashCooldownTimer
	{
	}
	internal static class StartDashEffect
	{
	}
	internal static class StartFallRumble
	{
	}
	internal static class IsOnWall
	{
	}
	internal static class CanExitNoInput
	{
	}
	internal static class SetState
	{
	}
	internal static class FinishedEnteringScene
	{
	}
	internal static class ResetSceneExitedStates
	{
	}
	internal static class Die
	{
	}
	internal static class GetHeroDeathPrefab
	{
	}
	internal static class ElevatorReset
	{
	}
	internal static class DieFromHazard
	{
	}
	internal static class StartRecoil
	{
	}
	internal static class StartInvulnerable
	{
	}
	internal static class Invulnerable
	{
	}
	internal static class AddInvulnerabilitySource
	{
	}
	internal static class RemoveInvulnerabilitySource
	{
	}
	internal static class FirstFadeIn
	{
	}
	internal static class FallCheck
	{
	}
	internal static class OutOfBoundsCheck
	{
	}
	internal static class ConfirmOutOfBounds
	{
	}
	internal static class FailSafeChecks
	{
	}
	internal static class LocateSpawnPoint
	{
	}
	internal static class CancelJump
	{
	}
	internal static class CancelDoubleJump
	{
	}
	internal static class CancelDash
	{
	}
	internal static class StopDashEffect
	{
	}
	internal static class CancelWallsliding
	{
	}
	internal static class CancelBackDash
	{
	}
	internal static class CancelDownAttack
	{
	}
	internal static class CancelAttack
	{
	}
	internal static class CancelAttack_System_Boolean
	{
	}
	internal static class CancelDownspike
	{
	}
	internal static class CancelDownspikeAndDamage
	{
	}
	internal static class CancelAttackNotDownspikeBounce
	{
	}
	internal static class CancelAttackNotDownspikeBounce_System_Boolean
	{
	}
	internal static class CancelAttackNotSlash
	{
	}
	internal static class CancelBounce
	{
	}
	internal static class CancelRecoilHorizontal
	{
	}
	internal static class CancelDamageRecoil
	{
	}
	internal static class CancelDamageRecoilSimple
	{
	}
	internal static class CancelFallEffects
	{
	}
	internal static class ResetAttacksShared
	{
	}
	internal static class ResetAttacks
	{
	}
	internal static class StopNailChargeEffects
	{
	}
	internal static class CancelNailCharge
	{
	}
	internal static class ResetAttacksDash
	{
	}
	internal static class ResetMotion
	{
	}
	internal static class ResetMotionNotVelocity
	{
	}
	internal static class ResetLook
	{
	}
	internal static class ResetInput
	{
	}
	internal static class CheckAndRequestUnlock
	{
	}
	internal static class IsBlocked
	{
	}
	internal static class AddLockStates
	{
	}
	internal static class RemoveLockStates
	{
	}
	internal static class SetLockStates
	{
	}
	internal static class AddUnlockRequest
	{
	}
	internal static class RemoveUnlockRequest
	{
	}
	internal static class BackOnGround
	{
	}
	internal static class JumpReleased
	{
	}
	internal static class SetDoFullJump
	{
	}
	internal static class FinishedDashing
	{
	}
	internal static class FinishDownspike
	{
	}
	internal static class FinishDownspike_System_Boolean
	{
	}
	internal static class SetStartingMotionState
	{
	}
	internal static class SetStartingMotionState_System_Boolean
	{
	}
	internal static class TileMapTest
	{
	}
	internal static class TilemapTestPause
	{
	}
	internal static class StopTilemapTest
	{
	}
	internal static class TryDoTerrainThunk
	{
	}
	internal static class ResetFixedUpdateCaches
	{
	}
	internal static class CheckStillTouchingWall
	{
	}
	internal static class CheckForBump_GlobalEnums_CollisionSide
	{
	}
	internal static class CheckForBump_GlobalEnums_CollisionSide_out_System_Boolean_out_System_Boolean_out_System_Boolean
	{
	}
	internal static class CheckNearRoof
	{
	}
	internal static class CheckClamberLedge
	{
	}
	internal static class CheckTouchingGround
	{
	}
	internal static class CheckTouchingGround_System_Boolean
	{
	}
	internal static class CheckTouching
	{
	}
	internal static class CheckTouchingAdvanced
	{
	}
	internal static class FindCollisionDirection
	{
	}
	internal static class CanJump
	{
	}
	internal static class AllowShuttleCock
	{
	}
	internal static class CouldJumpCancel
	{
	}
	internal static class CanDoubleJump
	{
	}
	internal static class CanInfiniteAirJump
	{
	}
	internal static class CanSwim
	{
	}
	internal static class CanDash
	{
	}
	internal static class DashCooldownReady
	{
	}
	internal static class HasHarpoonDash
	{
	}
	internal static class CanHarpoonDash
	{
	}
	internal static class CanSprint
	{
	}
	internal static class CanSuperJump
	{
	}
	internal static class CanAttack
	{
	}
	internal static class ThrowToolCooldownReady
	{
	}
	internal static class CanThrowTool
	{
	}
	internal static class CanThrowTool_System_Boolean
	{
	}
	internal static class CanStartWithThrowTool
	{
	}
	internal static class CanAttackAction
	{
	}
	internal static class CanDownAttack
	{
	}
	internal static class TryQueueWallJumpInterrupt
	{
	}
	internal static class IsAttackLocked
	{
	}
	internal static class IsDashLocked
	{
	}
	internal static class CanFloat
	{
	}
	internal static class IsApproachingSolidGround
	{
	}
	internal static class CanNailCharge
	{
	}
	internal static class IsFacingNearWall_System_Single_UnityEngine_Color
	{
	}
	internal static class IsFacingNearWall_System_Boolean_System_Single_UnityEngine_Color
	{
	}
	internal static class IsFacingNearWall_System_Single_UnityEngine_Color_out_UnityEngine_Collider2D
	{
	}
	internal static class IsFacingNearWall_System_Boolean_System_Single_UnityEngine_Color_out_UnityEngine_Collider2D
	{
	}
	internal static class IsFacingNearSlideableWall
	{
	}
	internal static class CanStartWithWallSlide
	{
	}
	internal static class CanWallSlide
	{
	}
	internal static class CanContinueWallSlide
	{
	}
	internal static class CanTakeDamage
	{
	}
	internal static class CanTakeDamageIgnoreInvul
	{
	}
	internal static class CanBeGrabbed_System_Boolean
	{
	}
	internal static class CanBeGrabbed
	{
	}
	internal static class CanBeBarnacleGrabbed
	{
	}
	internal static class CanWallJump
	{
	}
	internal static class CanChainWallJumps
	{
	}
	internal static class CanWallScramble
	{
	}
	internal static class ShouldHardLand
	{
	}
	internal static class IsOnGroundLayer
	{
	}
	internal static class OnCollisionEnter2D
	{
	}
	internal static class HandleCollisionTouching
	{
	}
	internal static class OnCollisionStay2D
	{
	}
	internal static class OnCollisionExit2D
	{
	}
	internal static class LeftGround
	{
	}
	internal static class SetupGameRefs
	{
	}
	internal static class SetupPools
	{
	}
	internal static class FilterInput
	{
	}
	internal static class FindGroundPoint
	{
	}
	internal static class FindGroundPointY
	{
	}
	internal static class TryFindGroundPoint
	{
	}
	internal static class StartDownspikeInvulnerability
	{
	}
	internal static class StartDownspikeInvulnerabilityLong
	{
	}
	internal static class CancelDownspikeInvulnerability
	{
	}
	internal static class DetachHeroLight
	{
	}
	internal static class ReattachHeroLight
	{
	}
	internal static class SetAllowNailChargingWhileRelinquished
	{
	}
	internal static class SetAllowRecoilWhileRelinquished
	{
	}
	internal static class SetRecoilZeroVelocity
	{
	}
	internal static class MoveToPositionX
	{
	}
	internal static class ToggleNoClip
	{
	}
	internal static class GetIsNoClip
	{
	}
	internal static class GetRunSpeed
	{
	}
	internal static class GetWalkSpeed
	{
	}
	internal static class ActivateQuickening
	{
	}
	internal static class StartRoarLock
	{
	}
	internal static class StartRoarLockNoRecoil
	{
	}
	internal static class StopRoarLock
	{
	}
	internal static class CocoonBroken
	{
	}
	internal static class CocoonBroken_System_Boolean
	{
	}
	internal static class CocoonBroken_System_Boolean_System_Boolean
	{
	}
	internal static class CocoonFloatRoutine
	{
	}
	internal static class RecordLeaveSceneCState
	{
	}
	internal static class CleanSpawnedDeliveryEffects
	{
	}
	internal static class LeavingScene
	{
	}
	internal static class DoSprintSkid
	{
	}
	internal static class AddExtraAirMoveVelocity
	{
	}
	internal static class ClearEffectsInstant
	{
	}
	internal static class ClearEffects
	{
	}
	internal static class ClearEffectsLite
	{
	}
	internal static class ResetMaggotCharm
	{
	}
	internal static class StopQuickening
	{
	}
	internal static class SilkTaunted
	{
	}
	internal static class SilkTauntEffectConsume
	{
	}
	internal static class RingTaunted
	{
	}
	internal static class RingTauntEffectConsume
	{
	}
	internal static class ResetTauntEffects
	{
	}
	internal static class ResetLavaBell
	{
	}
	internal static class GetVibrationCtrl
	{
	}
	internal static class ReportPoisonHealthAdded
	{
	}
	internal static class ReportPoisonHealthRemoved
	{
	}
	internal static class _ctor
	{
	}
	internal static class _cctor
	{
	}
	internal static class ITagDamageTakerOwner_get_transform
	{
	}
	internal static class ConfigGroup
	{
		internal static class get_NormalSlash
		{
		}

		internal static class set_NormalSlash
		{
		}

		internal static class get_NormalSlashDamager
		{
		}

		internal static class set_NormalSlashDamager
		{
		}

		internal static class get_AlternateSlash
		{
		}

		internal static class set_AlternateSlash
		{
		}

		internal static class get_AlternateSlashDamager
		{
		}

		internal static class set_AlternateSlashDamager
		{
		}

		internal static class get_UpSlash
		{
		}

		internal static class set_UpSlash
		{
		}

		internal static class get_UpSlashDamager
		{
		}

		internal static class set_UpSlashDamager
		{
		}

		internal static class get_AltUpSlash
		{
		}

		internal static class set_AltUpSlash
		{
		}

		internal static class get_AltUpSlashDamager
		{
		}

		internal static class set_AltUpSlashDamager
		{
		}

		internal static class get_DownSlash
		{
		}

		internal static class set_DownSlash
		{
		}

		internal static class get_Downspike
		{
		}

		internal static class set_Downspike
		{
		}

		internal static class get_DownSlashDamager
		{
		}

		internal static class set_DownSlashDamager
		{
		}

		internal static class get_AltDownSlash
		{
		}

		internal static class set_AltDownSlash
		{
		}

		internal static class get_AltDownspike
		{
		}

		internal static class set_AltDownspike
		{
		}

		internal static class get_AltDownSlashDamager
		{
		}

		internal static class set_AltDownSlashDamager
		{
		}

		internal static class get_WallSlash
		{
		}

		internal static class set_WallSlash
		{
		}

		internal static class get_WallSlashDamager
		{
		}

		internal static class set_WallSlashDamager
		{
		}

		internal static class Setup
		{
		}

		internal static class _ctor
		{
		}
	}
	internal static class DecayingVelocity
	{
		internal static class _ctor
		{
		}

		internal static class SkipBehaviours
		{
			internal static class _ctor
			{
			}
		}
	}
	internal static class SilkEatTracker
	{
		internal static class _ctor
		{
		}
	}
	internal static class DeliveryTimer
	{
		internal static class _ctor
		{
		}
	}
	internal static class HeroSetDelegate
	{
		internal static class _ctor
		{
		}

		internal static class Invoke
		{
		}

		internal static class BeginInvoke
		{
		}

		internal static class EndInvoke
		{
		}
	}
	internal static class HeroInPosition
	{
		internal static class _ctor
		{
		}

		internal static class Invoke
		{
		}

		internal static class BeginInvoke
		{
		}

		internal static class EndInvoke
		{
		}
	}
	internal static class DamageTakenDelegate
	{
		internal static class _ctor
		{
		}

		internal static class Invoke
		{
		}

		internal static class BeginInvoke
		{
		}

		internal static class EndInvoke
		{
		}
	}
	internal static class DamageInfo
	{
		internal static class _ctor
		{
		}

		internal static class _ctor_GlobalEnums_HazardType
		{
		}
	}
	internal static class WarriorCrestStateInfo
	{
		internal static class _ctor
		{
		}
	}
	internal static class ReaperCrestStateInfo
	{
		internal static class _ctor
		{
		}
	}
	internal static class HunterUpgCrestStateInfo
	{
		internal static class _ctor
		{
		}

		internal static class get_IsComboMeterAboveExtra
		{
		}
	}
	internal static class WandererCrestStateInfo
	{
		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass1241_0
	{
		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass695_0
	{
		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass983_0
	{
		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass986_0
	{
		internal static class _ctor
		{
		}
	}
	internal static class _BetaLeave_d__981
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
	internal static class _BetaReturn_d__982
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
	internal static class _CocoonFloatRoutine_d__1253
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
	internal static class _Die_d__1101
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
	internal static class _DieFromHazard_d__1104
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
	internal static class _EnterHeroSubFadeUp_d__976
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
	internal static class _EnterHeroSubHorizontal_d__975
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
	internal static class _EnterScene_d__974
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
	internal static class _FirstFadeIn_d__1112
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
	internal static class _HazardRespawn_d__986
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
	internal static class _Invulnerable_d__1109
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
	internal static class _MoveToPositionX_d__1241
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
	internal static class _Respawn_d__983
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
	internal static class _StartRecoil_d__1105
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
	internal static class _TilemapTestPause_d__1162
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
}
namespace MonoDetour.HookGen
{
	internal static class DefaultMonoDetourManager
	{
		internal static MonoDetourManager Instance { get; } = New();


		internal static MonoDetourManager New()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			return new MonoDetourManager(typeof(DefaultMonoDetourManager).Assembly.GetName().Name);
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class, AllowMultiple = true, Inherited = false)]
	internal class MonoDetourTargetsAttribute : Attribute, IMonoDetourTargets
	{
		public Type? TargetType { get; }

		public bool IncludeNestedTypes { get; set; }

		public string[]? Members { get; set; }

		public string[]? MemberNamePrefixes { get; set; }

		public string[]? MemberNameSuffixes { get; set; }

		public bool GenerateControlFlowVariants { get; set; }

		public MonoDetourTargetsAttribute(Type? targetType = null)
		{
			TargetType = targetType;
			IncludeNestedTypes = true;
			base..ctor();
		}
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace StubbornHornet
{
	public enum ArrowDirection
	{
		Up,
		Down,
		Left,
		Right
	}
	public class ArrowGame : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <ActivateAndGetCursorSpriteCoroutine>d__40 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Transform cursorRightTransform;

			public Action<Sprite> callback;

			public ArrowGame <>4__this;

			private GameObject <tempInstance>5__2;

			private Image <tempImage>5__3;

			private Animator <tempAnimator>5__4;

			private Sprite <result>5__5;

			private int <i>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<tempInstance>5__2 = null;
				<tempImage>5__3 = null;
				<tempAnimator>5__4 = null;
				<result>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				ArrowGame arrowGame = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					GameObject gameObject = ((Component)cursorRightTransform).gameObject;
					Image component = gameObject.GetComponent<Image>();
					if ((Object)(object)component != (Object)null && (Object)(object)component.sprite != (Object)null && ((Object)component.sprite).name != "blank_frame")
					{
						callback(component.sprite);
						return false;
					}
					<tempInstance>5__2 = Object.Instantiate<GameObject>(gameObject);
					((Object)<tempInstance>5__2).name = "TempCursorRight";
					<tempInstance>5__2.SetActive(true);
					<tempInstance>5__2.transform.SetParent((Transform)null);
					<tempInstance>5__2.transform.position = new Vector3(10000f, 10000f, 0f);
					<tempImage>5__3 = <tempInstance>5__2.GetComponent<Image>();
					<tempAnimator>5__4 = <tempInstance>5__2.GetComponent<Animator>();
					if ((Object)(object)<tempAnimator>5__4 != (Object)null)
					{
						((Behaviour)<tempAnimator>5__4).enabled = true;
						<tempAnimator>5__4.Rebind();
						<tempAnimator>5__4.Update(0f);
						if (arrowGame.HasAnimatorParameter(<tempAnimator>5__4, "show"))
						{
							<tempAnimator>5__4.ResetTrigger("hide");
							<tempAnimator>5__4.SetTrigger("show");
						}
					}
					<result>5__5 = null;
					<i>5__6 = 0;
					break;
				}
				case 1:
					<>1__state = -1;
					<i>5__6++;
					break;
				}
				if (<i>5__6 < 30)
				{
					if (!((Object)(object)<tempImage>5__3 != (Object)null) || !((Object)(object)<tempImage>5__3.sprite != (Object)null) || !(((Object)<tempImage>5__3.sprite).name != "blank_frame"))
					{
						if ((Object)(object)<tempAnimator>5__4 != (Object)null)
						{
							<tempAnimator>5__4.Update(0.016f);
						}
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<result>5__5 = <tempImage>5__3.sprite;
				}
				Object.Destroy((Object)(object)<tempInstance>5__2);
				callback(<result>5__5);
				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 <LoadAudioClips>d__34 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ArrowGame <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				ArrowGame arrowGame = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					arrowGame._successClip = arrowGame.LoadAudioClipFromResources("StubbornHornet.assets.success.wav");
					arrowGame._failClip = arrowGame.LoadAudioClipFromResources("StubbornHornet.assets.fail.wav");
					arrowGame.Log($"Audio loaded: success={(Object)(object)arrowGame._successClip != (Object)null}, fail={(Object)(object)arrowGame._failClip != (Object)null}");
					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 <LoadCursorSpriteWithActivation>d__39 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ArrowGame <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				ArrowGame arrowGame = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					arrowGame._arrowSprites = (Sprite[])(object)new Sprite[4];
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					arrowGame.LoadFallbackSprites();
					arrowGame.UpdateArrowDisplay();
					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 <PlayErrorEffectCoroutine>d__31 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ArrowGame <>4__this;

			private SpriteRenderer <targetArrow>5__2;

			private Sprite <originalSprite>5__3;

			private float <duration>5__4;

			private float <elapsed>5__5;

			private Vector3 <originalPos>5__6;

			private float <shakeAmount>5__7;

			private int <shakeFrequency>5__8;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0098: 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_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_016f: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				ArrowGame arrowGame = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<targetArrow>5__2 = arrowGame._arrowRenderers[0];
					if ((Object)(object)<targetArrow>5__2 == (Object)null)
					{
						arrowGame._isPlayingErrorEffect = false;
						return false;
					}
					<originalSprite>5__3 = <targetArrow>5__2.sprite;
					if ((Object)(object)arrowGame._redArrowSprite != (Object)null)
					{
						<targetArrow>5__2.sprite = arrowGame._redArrowSprite;
					}
					<duration>5__4 = 0.2f;
					<elapsed>5__5 = 0f;
					<originalPos>5__6 = ((Component)<targetArrow>5__2).transform.localPosition;
					<shakeAmount>5__7 = 0.08f;
					<shakeFrequency>5__8 = 15;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<elapsed>5__5 < <duration>5__4)
				{
					<elapsed>5__5 += Time.deltaTime;
					float num2 = 1f - <elapsed>5__5 / <duration>5__4;
					float num3 = Mathf.Sin(<elapsed>5__5 * (float)<shakeFrequency>5__8 * MathF.PI * 2f) * <shakeAmount>5__7 * num2;
					((Component)<targetArrow>5__2).transform.localPosition = new Vector3(<originalPos>5__6.x + num3, <originalPos>5__6.y, 0f);
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				((Component)<targetArrow>5__2).transform.localPosition = <originalPos>5__6;
				<targetArrow>5__2.sprite = <originalSprite>5__3;
				arrowGame._isPlayingErrorEffect = 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 <PlaySuccessEffectCoroutine>d__28 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ArrowGame <>4__this;

			private SpriteRenderer <targetArrow>5__2;

			private Sprite <originalSprite>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Expected O, but got Unknown
				int num = <>1__state;
				ArrowGame arrowGame = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<targetArrow>5__2 = arrowGame._arrowRenderers[0];
					if ((Object)(object)<targetArrow>5__2 == (Object)null || (Object)(object)arrowGame._greenArrowSprite == (Object)null)
					{
						return false;
					}
					<originalSprite>5__3 = <targetArrow>5__2.sprite;
					<targetArrow>5__2.sprite = arrowGame._greenArrowSprite;
					<>2__current = (object)new WaitForSeconds(0.15f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<targetArrow>5__2.sprite = <originalSprite>5__3;
					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 <ResetFailSoundFlag>d__27 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ArrowGame <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Expected O, but got Unknown
				int num = <>1__state;
				ArrowGame arrowGame = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(arrowGame._failClip.length);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					arrowGame._isPlayingFailSound = 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 <RollArrowsWithAnimation>d__55 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ArrowGame <>4__this;

			private float <elapsed>5__2;

			private Vector3[] <startPositions>5__3;

			private Vector3[] <targetPositions>5__4;

			private int <topIndex>5__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<startPositions>5__3 = null;
				<targetPositions>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0132: Unknown result type (might be due to invalid IL or missing references)
				//IL_013f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0145: Unknown result type (might be due to invalid IL or missing references)
				//IL_0177: Unknown result type (might be due to invalid IL or missing references)
				//IL_017c: Unknown result type (might be due to invalid IL or missing references)
				//IL_019d: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0284: Unknown result type (might be due to invalid IL or missing references)
				//IL_0289: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				ArrowGame arrowGame = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					arrowGame._isAnimating = true;
					<elapsed>5__2 = 0f;
					<startPositions>5__3 = (Vector3[])(object)new Vector3[arrowGame._arrowCount];
					<targetPositions>5__4 = (Vector3[])(object)new Vector3[arrowGame._arrowCount];
					<topIndex>5__5 = arrowGame._arrowCount - 1;
					for (int i = 0; i < arrowGame._arrowCount; i++)
					{
						if (!((Object)(object)arrowGame._arrowRenderers[i] == (Object)null))
						{
							<startPositions>5__3[i] = ((Component)arrowGame._arrowRenderers[i]).transform.localPosition;
							<targetPositions>5__4[i] = <startPositions>5__3[i] + new Vector3(0f, -0.6f, 0f);
						}
					}
					break;
				}
				case 1:
					<>1__state = -1;
					break;
				}
				if (<elapsed>5__2 < 0.2f)
				{
					<elapsed>5__2 += Time.deltaTime;
					float num2 = Mathf.SmoothStep(0f, 1f, <elapsed>5__2 / 0.2f);
					for (int j = 0; j < arrowGame._arrowCount; j++)
					{
						if ((Object)(object)arrowGame._arrowRenderers[j] != (Object)null)
						{
							((Component)arrowGame._arrowRenderers[j]).transform.localPosition = Vector3.Lerp(<startPositions>5__3[j], <targetPositions>5__4[j], num2);
						}
					}
					if ((Object)(object)arrowGame._arrowRenderers[0] != (Object)null)
					{
						Color color = arrowGame._arrowRenderers[0].color;
						color.a = Mathf.Lerp(1f, 0f, num2);
						arrowGame._arrowRenderers[0].color = color;
					}
					if ((Object)(object)arrowGame._arrowRenderers[<topIndex>5__5] != (Object)null)
					{
						Color color2 = arrowGame._arrowRenderers[<topIndex>5__5].color;
						color2.a = Mathf.Lerp(0f, 1f, num2);
						arrowGame._arrowRenderers[<topIndex>5__5].color = color2;
					}
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				for (int num3 = arrowGame._arrowCount - 1; num3 > 0; num3--)
				{
					arrowGame._currentArrows[num3] = arrowGame._currentArrows[num3 - 1];
				}
				arrowGame._currentArrows[0] = (ArrowDirection)Random.Range(0, 4);
				arrowGame.ResetArrowPositions();
				arrowGame.UpdateArrowDisplay();
				for (int k = 0; k < arrowGame._arrowCount - 1; k++)
				{
					if ((Object)(object)arrowGame._arrowRenderers[k] != (Object)null)
					{
						Color color3 = arrowGame._arrowRenderers[k].color;
						color3.a = arrowGame._arrowOpacity;
						arrowGame._arrowRenderers[k].color = color3;
					}
				}
				arrowGame.SetTopArrowTransparent();
				arrowGame._isAnimating = 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 int _arrowCount = 3;

		private float _arrowOpacity = 1f;

		private const float ArrowSpacing = 0.6f;

		private const float HeightOffset = 2.3f;

		private SpriteRenderer[] _arrowRenderers;

		private ArrowDirection[] _currentArrows;

		private Sprite[] _arrowSprites;

		private Sprite _redArrowSprite;

		private Sprite _greenArrowSprite;

		private GameObject _container;

		private bool _isAnimating;

		private bool _isEnabled = true;

		private const float AnimationDuration = 0.2f;

		private AudioSource _audioSource;

		private AudioClip _successClip;

		private AudioClip _failClip;

		private float _soundVolume = 0.5f;

		private bool _isPlayingFailSound;

		private bool _isPlayingErrorEffect;

		public ArrowDirection CurrentTargetArrow => _currentArrows[_arrowCount - 1];

		public bool IsAnimating => _isAnimating;

		public bool IsAttackAllowed(AttackDirection dir)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected I4, but got Unknown
			ArrowDirection arrowDirection = _currentArrows[_arrowCount - 1];
			switch ((int)dir)
			{
			case 1:
				return arrowDirection == ArrowDirection.Up;
			case 2:
				return arrowDirection == ArrowDirection.Down;
			case 0:
				if ((Object)(object)HeroController.instance == (Object)null)
				{
					return false;
				}
				if (!HeroController.instance.cState.facingRight)
				{
					return arrowDirection == ArrowDirection.Left;
				}
				return arrowDirection == ArrowDirection.Right;
			default:
				return false;
			}
		}

		public bool IsSpellAllowed(ArrowDirection dir)
		{
			return _currentArrows[_arrowCount - 1] == dir;
		}

		public void OnSuccessfulAction()
		{
			if (!_isAnimating)
			{
				RollArrows();
				((MonoBehaviour)this).StartCoroutine(PlaySuccessEffectCoroutine());
				PlaySuccessSound();
			}
		}

		private void PlaySuccessSound()
		{
			if ((Object)(object)_audioSource == (Object)null)
			{
				Log("PlaySuccessSound: AudioSource is null");
				return;
			}
			if ((Object)(object)_successClip == (Object)null)
			{
				Log("PlaySuccessSound: successClip is null");
				return;
			}
			Log($"Playing success sound with volume {_soundVolume}");
			_audioSource.PlayOneShot(_successClip, _soundVolume);
		}

		private void PlayFailSound()
		{
			if (!_isPlayingFailSound)
			{
				if ((Object)(object)_audioSource == (Object)null)
				{
					Log("PlayFailSound: AudioSource is null");
					return;
				}
				if ((Object)(object)_failClip == (Object)null)
				{
					Log("PlayFailSound: failClip is null");
					return;
				}
				Log($"Playing fail sound with volume {_soundVolume}");
				_isPlayingFailSound = true;
				_audioSource.PlayOneShot(_failClip, _soundVolume);
				((MonoBehaviour)this).StartCoroutine(ResetFailSoundFlag());
			}
		}

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

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

		public void TriggerErrorEffect()
		{
			if (!((Object)(object)_arrowRenderers[0] == (Object)null) && !_isPlayingErrorEffect)
			{
				_isPlayingErrorEffect = true;
				((MonoBehaviour)this).StartCoroutine(PlayErrorEffectCoroutine());
				PlayFailSound();
			}
		}

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

		private void Start()
		{
			InitAudioSource();
			CleanupOldArrows();
			((MonoBehaviour)this).StartCoroutine(LoadCursorSpriteWithActivation());
			((MonoBehaviour)this).StartCoroutine(LoadAudioClips());
			CreateArrowDisplay();
			GenerateNewArrows();
			SetModEnabled(_isEnabled);
		}

		private void InitAudioSource()
		{
			if (!((Object)(object)HeroController.instance == (Object)null))
			{
				GameObject gameObject = ((Component)HeroController.instance).gameObject;
				_audioSource = gameObject.GetComponent<AudioSource>();
				if ((Object)(object)_audioSource == (Object)null)
				{
					_audioSource = gameObject.AddComponent<AudioSource>();
					_audioSource.spatialBlend = 0f;
					_audioSource.playOnAwake = false;
				}
			}
		}

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

		private AudioClip LoadAudioClipFromResources(string name)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			WavData val = new WavData();
			val.Parse(Assembly.GetExecutingAssembly().GetManifestResourceStream(name), (Action<string>)null);
			float[] samples = val.GetSamples();
			AudioClip obj = AudioClip.Create(name, samples.Length / val.FormatChunk.NumChannels, (int)val.FormatChunk.NumChannels, (int)val.FormatChunk.SampleRate, false);
			obj.SetData(samples, 0);
			return obj;
		}

		private void CleanupOldArrows()
		{
			GameObject[] array = Object.FindObjectsOfType<GameObject>();
			foreach (GameObject val in array)
			{
				if (((Object)val).name == "ArrowContainer" && (Object)(object)val.transform.parent == (Object)(object)HeroController.instance?.transform)
				{
					Object.Destroy((Object)(object)val);
				}
			}
		}

		private void Update()
		{
		}

		private void LateUpdate()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_container != (Object)null && (Object)(object)HeroController.instance != (Object)null)
			{
				float x = HeroController.instance.transform.lossyScale.x;
				_container.transform.localScale = new Vector3(1f / x, 1f, 1f);
			}
		}

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

		[IteratorStateMachine(typeof(<ActivateAndGetCursorSpriteCoroutine>d__40))]
		private IEnumerator ActivateAndGetCursorSpriteCoroutine(Transform cursorRightTransform, Action<Sprite> callback)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ActivateAndGetCursorSpriteCoroutine>d__40(0)
			{
				<>4__this = this,
				cursorRightTransform = cursorRightTransform,
				callback = callback
			};
		}

		private bool HasAnimatorParameter(Animator animator, string paramName)
		{
			if ((Object)(object)animator == (Object)null || (Object)(object)animator.runtimeAnimatorController == (Object)null)
			{
				return false;
			}
			AnimatorControllerParameter[] parameters = animator.parameters;
			for (int i = 0; i < parameters.Length; i++)
			{
				if (parameters[i].name == paramName)
				{
					return true;
				}
			}
			return false;
		}

		private void LoadFallbackSprites()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Assembly executingAssembly = Assembly.GetExecutingAssembly();
				string name = "StubbornHornet.assets.left-arrow.png";
				using (Stream stream = executingAssembly.GetManifestResourceStream(name))
				{
					if (stream == null)
					{
						return;
					}
					byte[] array = new byte[stream.Length];
					stream.Read(array, 0, array.Length);
					Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
					ImageConversion.LoadImage(val, array);
					val.Apply();
					Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 1024f);
					for (int i = 0; i < 4; i++)
					{
						_arrowSprites[i] = val2;
					}
				}
				_redArrowSprite = LoadSpriteFromResources("StubbornHornet.assets.red-arrow.png");
				_greenArrowSprite = LoadSpriteFromResources("StubbornHornet.assets.green-arrow.png");
			}
			catch
			{
			}
		}

		private Sprite LoadSpriteFromResources(string resourceName)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName);
				if (stream == null)
				{
					return null;
				}
				byte[] array = new byte[stream.Length];
				stream.Read(array, 0, array.Length);
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
				ImageConversion.LoadImage(val, array);
				val.Apply();
				return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 1024f);
			}
			catch
			{
				return null;
			}
		}

		private void SetArrowRotation(SpriteRenderer sr, ArrowDirection dir)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			switch (dir)
			{
			case ArrowDirection.Right:
				((Component)sr).transform.localRotation = Quaternion.Euler(0f, 180f, 0f);
				break;
			case ArrowDirection.Left:
				((Component)sr).transform.localRotation = Quaternion.identity;
				break;
			case ArrowDirection.Up:
				((Component)sr).transform.localRotation = Quaternion.Euler(0f, 0f, -90f);
				break;
			case ArrowDirection.Down:
				((Component)sr).transform.localRotation = Quaternion.Euler(0f, 0f, 90f);
				break;
			}
		}

		private void Log(string message)
		{
			StubbornHornetPlugin.logger.LogDebug((object)("[ArrowGame] " + message));
		}

		public void SetModEnabled(bool enabled)
		{
			_isEnabled = enabled;
			if ((Object)(object)_container != (Object)null)
			{
				_container.SetActive(enabled);
			}
		}

		public void SetConfig(int arrowCount, float arrowOpacity, float soundVolume)
		{
			_arrowCount = arrowCount;
			_arrowOpacity = arrowOpacity;
			_soundVolume = soundVolume / 10f;
			ApplyOpacity(arrowOpacity);
		}

		private void ApplyOpacity(float opacity)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (_arrowRenderers == null)
			{
				return;
			}
			for (int i = 0; i < _arrowRenderers.Length; i++)
			{
				if ((Object)(object)_arrowRenderers[i] != (Object)null)
				{
					Color color = _arrowRenderers[i].color;
					color.a = opacity;
					_arrowRenderers[i].color = color;
				}
			}
		}

		public void UpdateConfig(int arrowCount, float arrowOpacity, float soundVolume)
		{
			bool num = arrowCount != _arrowCount;
			_arrowCount = arrowCount;
			_arrowOpacity = arrowOpacity;
			_soundVolume = soundVolume / 10f;
			if (num && (Object)(object)_container != (Object)null)
			{
				Object.Destroy((Object)(object)_container);
				CreateArrowDisplay();
				GenerateNewArrows();
			}
			else
			{
				ApplyOpacity(arrowOpacity);
				SetTopArrowTransparent();
			}
		}

		private void CreateArrowDisplay()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0035: 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_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_010c: Unknown result type (might be due to invalid IL or missing references)
			_container = new GameObject("ArrowContainer");
			_container.transform.SetParent(HeroController.instance.transform);
			_container.transform.localPosition = Vector3.zero;
			_arrowRenderers = (SpriteRenderer[])(object)new SpriteRenderer[_arrowCount];
			_currentArrows = new ArrowDirection[_arrowCount];
			Color color = default(Color);
			((Color)(ref color))..ctor(1f, 1f, 1f, _arrowOpacity);
			for (int i = 0; i < _arrowCount; i++)
			{
				GameObject val = new GameObject($"Arrow_{i}");
				val.transform.SetParent(_container.transform);
				val.transform.localPosition = new Vector3(0f, 2.3f + (float)i * 0.6f, 0f);
				SpriteRenderer val2 = val.AddComponent<SpriteRenderer>();
				((Renderer)val2).sortingLayerName = "Effects";
				((Renderer)val2).sortingOrder = 100;
				val2.color = color;
				((Component)val2).transform.localScale = new Vector3(7.5f, 7.5f, 1f);
				_arrowRenderers[i] = val2;
			}
		}

		private void GenerateNewArrows()
		{
			for (int i = 0; i < _arrowCount; i++)
			{
				_currentArrows[i] = (ArrowDirection)Random.Range(0, 4);
			}
			UpdateArrowDisplay();
			SetTopArrowTransparent();
		}

		private void UpdateArrowDisplay()
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < _arrowCount; i++)
			{
				if (!((Object)(object)_arrowRenderers[i] == (Object)null))
				{
					int num = _arrowCount - 1 - i;
					_arrowRenderers[i].sprite = _arrowSprites[(int)_currentArrows[num]];
					SetArrowRotation(_arrowRenderers[i], _currentArrows[num]);
					float num2 = 0f;
					if (_currentArrows[num] == ArrowDirection.Right)
					{
						num2 = 0f;
					}
					else if (_currentArrows[num] == ArrowDirection.Left)
					{
						num2 = -0f;
					}
					((Component)_arrowRenderers[i]).transform.localPosition = new Vector3(num2, 2.3f + (float)i * 0.6f, 0f);
				}
			}
		}

		private void SetTopArrowTransparent()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			int num = _arrowCount - 1;
			if ((Object)(object)_arrowRenderers[num] != (Object)null)
			{
				Color color = _arrowRenderers[num].color;
				color.a = 0f;
				_arrowRenderers[num].color = color;
			}
		}

		private void RollArrows()
		{
			((MonoBehaviour)this).StartCoroutine(RollArrowsWithAnimation());
		}

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

		private void ResetArrowPositions()
		{
			//IL_004f: Unknown result type (might be due to invalid IL or mis