using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
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 CanvasUtil;
using GlobalEnums;
using InControl;
using JetBrains.Annotations;
using KeybindChaos.Components;
using Md.HeroController;
using Md.InputHandler;
using Microsoft.CodeAnalysis;
using MonoDetour;
using MonoDetour.Cil;
using MonoDetour.DetourTypes;
using MonoDetour.HookGen;
using Silksong.UnityHelper.Extensions;
using Silksong.UnityHelper.Util;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MonoDetourTargets(typeof(InputHandler), GenerateControlFlowVariants = true)]
[assembly: MonoDetourTargets(typeof(HeroController))]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("KeybindChaos")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0+b71f9b053b905a76f180aa5793233fc7f54d084b")]
[assembly: AssemblyProduct("KeybindChaos")]
[assembly: AssemblyTitle("KeybindChaos")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/flibber-hk/KeybindChaos")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.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.HeroController
{
	internal static class HeroSetDelegate
	{
		internal static class Invoke
		{
			public delegate void PrefixSignature(HeroSetDelegate self, ref HeroController heroController);

			public delegate void PostfixSignature(HeroSetDelegate self, ref HeroController heroController);

			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 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(HeroSetDelegate).GetMethod("Invoke", (BindingFlags)(-1), null, new Type[1] { typeof(HeroController) }, null) ?? throw new MissingMethodException("HeroController+HeroSetDelegate", "Invoke");
			}
		}

		internal static class _ctor
		{
		}

		internal static class BeginInvoke
		{
		}

		internal static class EndInvoke
		{
		}
	}
	internal static class HeroInPosition
	{
		internal static class Invoke
		{
			public delegate void PrefixSignature(HeroInPosition self, ref bool forceDirect);

			public delegate void PostfixSignature(HeroInPosition self, ref bool forceDirect);

			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 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(HeroInPosition).GetMethod("Invoke", (BindingFlags)(-1), null, new Type[1] { typeof(bool) }, null) ?? throw new MissingMethodException("HeroController+HeroInPosition", "Invoke");
			}
		}

		internal static class _ctor
		{
		}

		internal static class BeginInvoke
		{
		}

		internal static class EndInvoke
		{
		}
	}
	internal static class DamageTakenDelegate
	{
		internal static class Invoke
		{
			public delegate void PrefixSignature(DamageTakenDelegate self, ref DamageInfo damageInfo);

			public delegate void PostfixSignature(DamageTakenDelegate self, ref DamageInfo damageInfo);

			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 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(DamageTakenDelegate).GetMethod("Invoke", (BindingFlags)(-1), null, new Type[1] { typeof(DamageInfo) }, null) ?? throw new MissingMethodException("HeroController+DamageTakenDelegate", "Invoke");
			}
		}

		internal static class _ctor
		{
		}

		internal static class BeginInvoke
		{
		}

		internal static class EndInvoke
		{
		}
	}
	internal static class Start
	{
		public delegate void PrefixSignature(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 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 Jump
	{
		public delegate void PrefixSignature(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 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("Jump", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("HeroController", "Jump");
		}
	}
	internal static class Dash
	{
		public delegate void PrefixSignature(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 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("Dash", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("HeroController", "Dash");
		}
	}
	internal static class Attack
	{
		public delegate void PrefixSignature(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 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 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 UpdateConfig
	{
	}
	internal static class SetConfigGroup
	{
	}
	internal static class SceneInit
	{
	}
	internal static class Update
	{
	}
	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 GetWillThrowTool
	{
	}
	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 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 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 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
	{
	}
	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 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 CanNailArt
	{
	}
	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 StartAnimationControlToIdle
	{
	}
	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 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 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__DisplayClass1236_0
	{
		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass694_0
	{
		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass979_0
	{
		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass982_0
	{
		internal static class _ctor
		{
		}
	}
	internal static class _BetaLeave_d__977
	{
		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__978
	{
		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__1248
	{
		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__1097
	{
		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__1100
	{
		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__972
	{
		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__971
	{
		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__970
	{
		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__1108
	{
		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__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 _Invulnerable_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 _MoveToPositionX_d__1236
	{
		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__979
	{
		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__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 _TilemapTestPause_d__1158
	{
		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.InputHandler
{
	internal static class CursorVisibilityChange
	{
		internal static class Invoke
		{
			public delegate void PrefixSignature(CursorVisibilityChange self, ref bool isVisible);

			public delegate ReturnFlow ControlFlowPrefixSignature(CursorVisibilityChange self, ref bool isVisible);

			public delegate void PostfixSignature(CursorVisibilityChange self, ref bool isVisible);

			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(CursorVisibilityChange).GetMethod("Invoke", (BindingFlags)(-1), null, new Type[1] { typeof(bool) }, null) ?? throw new MissingMethodException("InputHandler+CursorVisibilityChange", "Invoke");
			}
		}

		internal static class _ctor
		{
		}

		internal static class BeginInvoke
		{
		}

		internal static class EndInvoke
		{
		}
	}
	internal static class ActiveControllerSwitch
	{
		internal static class Invoke
		{
			public delegate void PrefixSignature(ActiveControllerSwitch self);

			public delegate ReturnFlow ControlFlowPrefixSignature(ActiveControllerSwitch self);

			public delegate void PostfixSignature(ActiveControllerSwitch 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(ActiveControllerSwitch).GetMethod("Invoke", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("InputHandler+ActiveControllerSwitch", "Invoke");
			}
		}

		internal static class _ctor
		{
		}

		internal static class BeginInvoke
		{
		}

		internal static class EndInvoke
		{
		}
	}
	internal static class Start
	{
		public delegate void PrefixSignature(InputHandler self);

		public delegate ReturnFlow ControlFlowPrefixSignature(InputHandler self);

		public delegate void PostfixSignature(InputHandler 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(InputHandler).GetMethod("Start", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("InputHandler", "Start");
		}
	}
	internal static class GetKeyBindingForAction
	{
		public delegate void PrefixSignature(InputHandler self, ref PlayerAction action);

		public delegate ReturnFlow ControlFlowPrefixSignature(InputHandler self, ref PlayerAction action, ref KeyOrMouseBinding returnValue);

		public delegate void PostfixSignature(InputHandler self, ref PlayerAction action, ref KeyOrMouseBinding 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(InputHandler).GetMethod("GetKeyBindingForAction", (BindingFlags)(-1), null, new Type[1] { typeof(PlayerAction) }, null) ?? throw new MissingMethodException("InputHandler", "GetKeyBindingForAction");
		}
	}
	internal static class KeyOrMouseBinding
	{
		internal new static class ToString
		{
			public delegate void PrefixSignature(KeyOrMouseBinding self);

			public delegate ReturnFlow ControlFlowPrefixSignature(KeyOrMouseBinding self, ref string returnValue);

			public delegate void PostfixSignature(KeyOrMouseBinding self, ref string 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(KeyOrMouseBinding).GetMethod("ToString", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("InputHandler+KeyOrMouseBinding", "ToString");
			}
		}

		internal static class _ctor
		{
		}

		internal static class _ctor_InControl_Key
		{
		}

		internal static class _ctor_InControl_Mouse
		{
		}

		internal static class IsNone
		{
		}
	}
	internal static class GetButtonBindingForAction
	{
		public delegate void PrefixSignature(InputHandler self, ref PlayerAction action);

		public delegate ReturnFlow ControlFlowPrefixSignature(InputHandler self, ref PlayerAction action, ref InputControlType returnValue);

		public delegate void PostfixSignature(InputHandler self, ref PlayerAction action, ref InputControlType 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(InputHandler).GetMethod("GetButtonBindingForAction", (BindingFlags)(-1), null, new Type[1] { typeof(PlayerAction) }, null) ?? throw new MissingMethodException("InputHandler", "GetButtonBindingForAction");
		}
	}
	internal static class SendKeyBindingsToGameSettings
	{
		public delegate void PrefixSignature(InputHandler self);

		public delegate ReturnFlow ControlFlowPrefixSignature(InputHandler self);

		public delegate void PostfixSignature(InputHandler 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(InputHandler).GetMethod("SendKeyBindingsToGameSettings", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("InputHandler", "SendKeyBindingsToGameSettings");
		}
	}
	internal static class SendButtonBindingsToGameSettings
	{
		public delegate void PrefixSignature(InputHandler self);

		public delegate ReturnFlow ControlFlowPrefixSignature(InputHandler self);

		public delegate void PostfixSignature(InputHandler 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(InputHandler).GetMethod("SendButtonBindingsToGameSettings", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("InputHandler", "SendButtonBindingsToGameSettings");
		}
	}
	internal static class add_OnUpdateHeroActions
	{
	}
	internal static class remove_OnUpdateHeroActions
	{
	}
	internal static class add_OnCursorVisibilityChange
	{
	}
	internal static class remove_OnCursorVisibilityChange
	{
	}
	internal static class get_ActiveGamepadAlias
	{
	}
	internal static class set_ActiveGamepadAlias
	{
	}
	internal static class get_MappableControllerActions
	{
	}
	internal static class set_MappableControllerActions
	{
	}
	internal static class get_MappableKeyboardActions
	{
	}
	internal static class set_MappableKeyboardActions
	{
	}
	internal static class get_PauseAllowed
	{
	}
	internal static class set_PauseAllowed
	{
	}
	internal static class get_SkipMode
	{
	}
	internal static class set_SkipMode
	{
	}
	internal static class add_RefreshActiveControllerEvent
	{
	}
	internal static class remove_RefreshActiveControllerEvent
	{
	}
	internal static class get_WasSkipButtonPressed
	{
	}
	internal static class get_ForceDreamNailRePress
	{
	}
	internal static class set_ForceDreamNailRePress
	{
	}
	internal static class OnAwake
	{
	}
	internal static class OnStart
	{
	}
	internal static class Awake
	{
	}
	internal static class OnDestroy
	{
	}
	internal static class SceneInit
	{
	}
	internal static class OnSaveStoreStateChanged
	{
	}
	internal static class LoadSavedInputBindings
	{
	}
	internal static class SetCursorVisible
	{
	}
	internal static class SetCursorEnabled
	{
	}
	internal static class Update
	{
	}
	internal static class UpdateButtonQueueing
	{
	}
	internal static class GetWasButtonPressedQueued
	{
	}
	internal static class ControllerAttached
	{
	}
	internal static class ControllerActivated
	{
	}
	internal static class ControllerDetached
	{
	}
	internal static class PlayingInput
	{
	}
	internal static class CutsceneInput
	{
	}
	internal static class StagCutsceneInput
	{
	}
	internal static class AttachHeroController
	{
	}
	internal static class StopAcceptingInput
	{
	}
	internal static class StartAcceptingInput
	{
	}
	internal static class PreventPause
	{
	}
	internal static class AllowPause
	{
	}
	internal static class UpdateActiveController
	{
	}
	internal static class SendRefreshEvent
	{
	}
	internal static class StopUIInput
	{
	}
	internal static class StartUIInput
	{
	}
	internal static class StopMouseInput
	{
	}
	internal static class EnableMouseInput
	{
	}
	internal static class SetSkipMode
	{
	}
	internal static class RefreshPlayerData
	{
	}
	internal static class ResetDefaultKeyBindings
	{
	}
	internal static class ResetDefaultControllerButtonBindings
	{
	}
	internal static class ResetAllControllerButtonBindings
	{
	}
	internal static class MapControllerButtons
	{
	}
	internal static class RemapUiButtons
	{
	}
	internal static class ActionButtonToPlayerAction
	{
	}
	internal static class GetKeyBindingForActionBinding
	{
	}
	internal static class GetActionForMappableControllerButton
	{
	}
	internal static class GetActionForDefaultControllerButton
	{
	}
	internal static class PrintMappings
	{
	}
	internal static class ActionButtonLocalizedKey_InControl_PlayerAction
	{
	}
	internal static class ActionButtonLocalizedKey_System_String
	{
	}
	internal static class StopCutsceneInput
	{
	}
	internal static class UnlockStagInput
	{
	}
	internal static class SetupGamepadUIInputActions
	{
	}
	internal static class RemoveGamepadUiInputActions
	{
	}
	internal static class DestroyCurrentActionSet
	{
	}
	internal static class SetActiveGamepadType
	{
	}
	internal static class MapDefaultKeyboardLayout
	{
	}
	internal static class MapKeyboardLayoutFromGameSettings
	{
	}
	internal static class AddKeyBinding_InControl_PlayerAction_System_String
	{
	}
	internal static class AddKeyBinding_InControl_PlayerAction_System_String_InControl_PlayerActionSet
	{
	}
	internal static class SetupNonMappableBindings
	{
	}
	internal static class SetupMappableControllerBindingsList
	{
	}
	internal static class SetupMappableKeyboardBindingsList
	{
	}
	internal static class GetSticksInput
	{
	}
	internal static class _ctor
	{
	}
}
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 bool DistinguishOverloadsByName { 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 KeybindChaos
{
	public static class Binds
	{
		public static readonly Dictionary<string, FieldInfo> BindFieldInfos = new Dictionary<string, FieldInfo>
		{
			["Jump"] = typeof(HeroActions).GetField("Jump"),
			["Dash"] = typeof(HeroActions).GetField("Dash"),
			["Attack"] = typeof(HeroActions).GetField("Attack"),
			["QuickCast"] = typeof(HeroActions).GetField("QuickCast"),
			["QuickMap"] = typeof(HeroActions).GetField("QuickMap"),
			["Needolin"] = typeof(HeroActions).GetField("DreamNail"),
			["Harpoon"] = typeof(HeroActions).GetField("SuperDash"),
			["Focus"] = typeof(HeroActions).GetField("Cast"),
			["Taunt"] = typeof(HeroActions).GetField("Taunt")
		};

		private static Dictionary<string, Sprite>? _sprites;

		public static Dictionary<string, Sprite> Sprites
		{
			get
			{
				if (_sprites == null)
				{
					_sprites = new Dictionary<string, Sprite>();
					foreach (string availableBindName in GetAvailableBindNames())
					{
						Sprite value = SpriteUtil.LoadEmbeddedSprite(typeof(Binds).Assembly, "KeybindChaos.Resources." + availableBindName + ".png", 64f);
						_sprites[availableBindName] = value;
					}
				}
				return _sprites;
			}
		}

		public static IEnumerable<string> GetAvailableBindNames()
		{
			return BindFieldInfos.Keys;
		}
	}
	public enum ShuffleMode
	{
		None,
		Timer
	}
	internal static class Extensions
	{
		private static readonly ManualLogSource Log = Logger.CreateLogSource("KeybindChaos.Extensions");

		public static void Swap<T>(this List<T> items, int i, int j)
		{
			T value = items[i];
			items[i] = items[j];
			items[j] = value;
		}

		public static void PermuteInPlace<T>(this Random rng, List<T> items)
		{
			for (int i = 1; i < items.Count; i++)
			{
				int j = rng.Next(i + 1);
				items.Swap(i, j);
			}
		}

		public static void SafeInvoke(this Action action)
		{
			Delegate[] invocationList = action.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				Action action2 = (Action)invocationList[i];
				try
				{
					action2?.Invoke();
				}
				catch (Exception ex)
				{
					Log.LogError((object)ex);
				}
			}
		}
	}
	[BepInPlugin("io.github.flibber-hk.keybindchaos", "KeybindChaos", "0.1.0")]
	public class KeybindChaosPlugin : BaseUnityPlugin
	{
		public ConfigEntry<ShuffleMode> KeybindMode;

		public ConfigEntry<bool> ShowKeybindDisplay;

		public ConfigEntry<int> ResetTime;

		public ConfigEntry<bool> PlayTimerAudio;

		public const string Id = "io.github.flibber-hk.keybindchaos";

		public static KeybindChaosPlugin Instance { get; private set; }

		public Dictionary<string, ConfigEntry<bool>> BindConfig { get; private set; }

		public static string Name => "KeybindChaos";

		public static string Version => "0.1.0";

		private void Awake()
		{
			Instance = this;
			KeybindPermuter.EnsureHooked();
			KeybindMode = ((BaseUnityPlugin)this).Config.Bind<ShuffleMode>("General", "KeybindMode", ShuffleMode.Timer, "Choose what causes the keybinds to get shuffled.");
			ShowKeybindDisplay = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ShowKeybindDisplay", true, "Show a display with the current binds.");
			ResetTime = ((BaseUnityPlugin)this).Config.Bind<int>("Mode.Timer", "ResetTime", 30, "The number of seconds before keybinds are shuffled.");
			PlayTimerAudio = ((BaseUnityPlugin)this).Config.Bind<bool>("Mode.Timer", "PlayTimerAudio", true, "Play a countdown audio near the end of the timer.");
			BindConfig = Binds.GetAvailableBindNames().ToDictionary((string name) => name, (string name) => ((BaseUnityPlugin)this).Config.Bind<bool>("General.Binds", name, true, "Include " + name));
			Md.HeroController.Start.Postfix(AddTimerComponent);
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Plugin " + Name + " (io.github.flibber-hk.keybindchaos) has loaded!"));
		}

		private void LogBinds()
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)"=== NEW BINDS ===");
			foreach (var (text, action2) in KeybindPermuter.RetrieveBindPairs())
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)(text + ": " + bindRetrieve(action2)));
			}
			static string bindRetrieve(PlayerAction action)
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Expected I4, but got Unknown
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				BindingSourceType lastActiveController = ManagerSingleton<InputHandler>.Instance.lastActiveController;
				switch ((int)lastActiveController)
				{
				case 0:
				case 2:
				case 3:
				{
					KeyOrMouseBinding keyBindingForAction = ManagerSingleton<InputHandler>.Instance.GetKeyBindingForAction(action);
					return ((object)(KeyOrMouseBinding)(ref keyBindingForAction)).ToString();
				}
				case 1:
				{
					InputControlType buttonBindingForAction = ManagerSingleton<InputHandler>.Instance.GetButtonBindingForAction(action);
					return ((object)(InputControlType)(ref buttonBindingForAction)).ToString();
				}
				default:
					return "???";
				}
			}
		}

		private void AddTimerComponent(HeroController self)
		{
			((Component)self).gameObject.AddComponent<Display>();
			((Component)self).gameObject.AddComponent<TimeTrigger>();
		}
	}
	[PublicAPI]
	public static class KeybindPermuter
	{
		private static readonly ManualLogSource Log = Logger.CreateLogSource("KeybindChaos:KeybindPermuter");

		private static List<PlayerAction>? _storedBindings = null;

		private static readonly Random _rng = new Random();

		private static bool _preventSavingBinds = false;

		private static bool IsRandomized => _storedBindings != null;

		[PublicAPI]
		public static event Action? OnRandomize;

		[PublicAPI]
		public static event Action? OnRestore;

		internal static void EnsureHooked()
		{
			SendKeyBindingsToGameSettings.ControlFlowPrefix(PreventSavingBindsHook);
			SendButtonBindingsToGameSettings.ControlFlowPrefix(PreventSavingBindsHook);
		}

		private static ReturnFlow PreventSavingBindsHook(InputHandler self)
		{
			if (_preventSavingBinds)
			{
				Log.LogInfo((object)"Not saving binds to settings");
				return (ReturnFlow)1;
			}
			return (ReturnFlow)0;
		}

		private static void PreventSavingBinds()
		{
			_preventSavingBinds = true;
		}

		private static void AllowSavingBinds()
		{
			_preventSavingBinds = false;
		}

		[PublicAPI]
		public static void RandomizeBinds()
		{
			RandomizeBinds(_rng);
		}

		[PublicAPI]
		public static void RandomizeBinds(Random rng)
		{
			PreventSavingBinds();
			List<PlayerAction> list = RetrieveBinds();
			rng.PermuteInPlace(list);
			AssignBinds(list);
			KeybindPermuter.OnRandomize?.SafeInvoke();
		}

		[PublicAPI]
		public static void RestoreBinds()
		{
			if (IsRandomized)
			{
				AssignBinds(_storedBindings);
				_storedBindings = null;
				AllowSavingBinds();
				KeybindPermuter.OnRestore?.SafeInvoke();
			}
		}

		public static List<(string key, PlayerAction action)> RetrieveBindPairs()
		{
			List<(string, PlayerAction)> list = new List<(string, PlayerAction)>();
			HeroActions inputActions = ManagerSingleton<InputHandler>.Instance.inputActions;
			Dictionary<string, ConfigEntry<bool>> bindConfig = KeybindChaosPlugin.Instance.BindConfig;
			if (bindConfig["Jump"].Value)
			{
				list.Add(("Jump", inputActions.Jump));
			}
			if (bindConfig["Dash"].Value)
			{
				list.Add(("Dash", inputActions.Dash));
			}
			if (bindConfig["Attack"].Value)
			{
				list.Add(("Attack", inputActions.Attack));
			}
			if (bindConfig["QuickCast"].Value)
			{
				list.Add(("QuickCast", inputActions.QuickCast));
			}
			if (bindConfig["QuickMap"].Value)
			{
				list.Add(("QuickMap", inputActions.QuickMap));
			}
			if (bindConfig["Needolin"].Value)
			{
				list.Add(("Needolin", inputActions.DreamNail));
			}
			if (bindConfig["Harpoon"].Value)
			{
				list.Add(("Harpoon", inputActions.SuperDash));
			}
			if (bindConfig["Focus"].Value)
			{
				list.Add(("Focus", inputActions.Cast));
			}
			if (bindConfig["Taunt"].Value)
			{
				list.Add(("Taunt", inputActions.Taunt));
			}
			return list;
		}

		public static List<PlayerAction> RetrieveBinds()
		{
			return (from pair in RetrieveBindPairs()
				select pair.action).ToList();
		}

		private static void AssignBinds(List<PlayerAction> actions)
		{
			int num = 0;
			HeroActions inputActions = ManagerSingleton<InputHandler>.Instance.inputActions;
			foreach (var (key, fieldInfo2) in Binds.BindFieldInfos)
			{
				if (KeybindChaosPlugin.Instance.BindConfig[key].Value)
				{
					fieldInfo2.SetValue(inputActions, actions[num]);
					num++;
				}
			}
		}
	}
}
namespace KeybindChaos.Components
{
	public class Display : MonoBehaviour
	{
		private GameObject _canvas;

		private Text _text;

		private GameObject? _keybindPanel;

		public void UpdateText(string value)
		{
			_text.text = value;
		}

		private void Awake()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			_canvas = CanvasUtil.CreateCanvas((RenderMode)0, new Vector2(1920f, 1080f));
			_canvas.GetComponent<CanvasGroup>().blocksRaycasts = false;
			_canvas.GetComponent<CanvasGroup>().interactable = false;
			Object.DontDestroyOnLoad((Object)(object)_canvas);
			GameObject val = CanvasUtil.CreateTextPanel(_canvas, "abcde", 40, (TextAnchor)2, new RectData(new Vector2(200f, 100f), new Vector2(0f, 0f), new Vector2(1f, 1f), new Vector2(1f, 1f), new Vector2(1f, 1f)), Fonts.TrajanBold);
			_text = val.GetComponent<Text>();
			_text.horizontalOverflow = (HorizontalWrapMode)1;
			SetupKeybindPanel();
			KeybindPermuter.OnRandomize += SetupKeybindPanel;
			KeybindPermuter.OnRestore += DestroyKeybindPanel;
		}

		private void SetupKeybindPanel()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: 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)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Expected O, but got Unknown
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Expected O, but got Unknown
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Expected O, but got Unknown
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Expected O, but got Unknown
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Invalid comparison between Unknown and I4
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Invalid comparison between Unknown and I4
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Expected O, but got Unknown
			DestroyKeybindPanel();
			if (!KeybindChaosPlugin.Instance.ShowKeybindDisplay.Value)
			{
				return;
			}
			List<(string key, PlayerAction action)> list = KeybindPermuter.RetrieveBindPairs();
			int num = 80;
			int num2 = 80;
			int num3 = 80;
			int count = list.Count;
			int num4 = num * count;
			int num5 = num3 + num2;
			_keybindPanel = CanvasUtil.CreateBasePanel(_canvas, new RectData(new Vector2((float)num5, (float)num4), new Vector2(0f, 0f), new Vector2(1f, 0f), new Vector2(1f, 0f), new Vector2(1f, 0f)));
			int num6 = 0;
			foreach (var (key, val) in list)
			{
				if (KeybindChaosPlugin.Instance.BindConfig[key].Value)
				{
					CanvasUtil.CreateImagePanel(CanvasUtil.CreateBasePanel(_keybindPanel, new RectData(new Vector2((float)num2, (float)num), new Vector2(0f, (float)(-num6 * num)), new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(0f, 1f))), Binds.Sprites[key], new RectData(new Vector2((float)num2, (float)num), new Vector2(0f, 0f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f)));
					ButtonSkin buttonSkinFor = UIManager.instance.uiButtonSkins.GetButtonSkinFor(val);
					GameObject val2 = CanvasUtil.CreateBasePanel(_keybindPanel, new RectData(new Vector2((float)num3, (float)num), new Vector2((float)num2, (float)(-num6 * num)), new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(0f, 1f)));
					CanvasUtil.CreateImagePanel(val2, buttonSkinFor.sprite, new RectData(new Vector2((float)num3, (float)num), new Vector2(0f, 0f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f)));
					if (!string.IsNullOrEmpty(buttonSkinFor.symbol))
					{
						ButtonSkinType skinType = buttonSkinFor.skinType;
						int num7 = (((int)skinType == 1) ? ((buttonSkinFor.symbol.Length <= 2) ? 48 : 36) : (((int)skinType != 2) ? 48 : 24));
						int num8 = num7;
						CanvasUtil.CreateTextPanel(val2, buttonSkinFor.symbol, num8, (TextAnchor)4, new RectData(new Vector2((float)num3, (float)num), new Vector2(0f, 0f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f)), Fonts.GetFont("Arial"));
					}
					num6++;
				}
			}
		}

		private void DestroyKeybindPanel()
		{
			if ((Object)(object)_keybindPanel != (Object)null)
			{
				Object.Destroy((Object)(object)_keybindPanel);
			}
		}

		private void OnDestroy()
		{
			Object.Destroy((Object)(object)_canvas);
			KeybindPermuter.OnRandomize -= SetupKeybindPanel;
			KeybindPermuter.OnRestore -= DestroyKeybindPanel;
		}
	}
	public class TimeTrigger : MonoBehaviour
	{
		private float _time;

		private AudioSource _as;

		private AudioClip _clip;

		private const float audioStartTime = 4f;

		private bool _startedAudio;

		private Display _display;

		public string GetDisplayText()
		{
			if (KeybindChaosPlugin.Instance.KeybindMode.Value != ShuffleMode.Timer)
			{
				return string.Empty;
			}
			if (_time < 10f)
			{
				return $"Keybind Reset: {_time:0.00}\n";
			}
			return $"Keybind Reset: {Mathf.Floor(_time):0}s\n";
		}

		private void Awake()
		{
			_as = ((Component)this).gameObject.GetComponent<AudioSource>();
			_clip = LoadTimerAudio();
		}

		private AudioClip LoadTimerAudio()
		{
			return WavUtil.AudioClipFromEmbeddedResource("KeybindChaos.Resources.countdown.wav", typeof(TimeTrigger).Assembly, (string)null);
		}

		private void Start()
		{
			_display = UnityExtensions.GetOrAddComponent<Display>(((Component)this).gameObject);
			_time = KeybindChaosPlugin.Instance.ResetTime.Value;
			((BaseUnityPlugin)KeybindChaosPlugin.Instance).Config.SettingChanged += OnSettingsChanged;
		}

		private void OnDestroy()
		{
			((BaseUnityPlugin)KeybindChaosPlugin.Instance).Config.SettingChanged -= OnSettingsChanged;
		}

		private void OnSettingsChanged(object sender, SettingChangedEventArgs e)
		{
			_time = KeybindChaosPlugin.Instance.ResetTime.Value;
		}

		private void Update()
		{
			if (KeybindChaosPlugin.Instance.KeybindMode.Value != ShuffleMode.Timer)
			{
				return;
			}
			_time -= Time.deltaTime;
			if (_time < 0f)
			{
				_time += KeybindChaosPlugin.Instance.ResetTime.Value;
				_startedAudio = false;
				KeybindPermuter.RandomizeBinds();
			}
			if (_time < 4f && !_startedAudio)
			{
				_startedAudio = true;
				if (KeybindChaosPlugin.Instance.PlayTimerAudio.Value && (Object)(object)_clip != (Object)null)
				{
					_as.PlayOneShot(_clip);
				}
			}
			_display.UpdateText(GetDisplayText());
		}
	}
}