using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using Architect.Api;
using Architect.Editor;
using Architect.Events.Blocks;
using Architect.Placements;
using Architect.Storage;
using BepInEx;
using GlobalEnums;
using HutongGames.PlayMaker;
using HutongGames.PlayMaker.Actions;
using Md.GameManager;
using Md.HeroController;
using Md.HutongGames.PlayMaker.Fsm;
using Md.Lever;
using Md.Lever_tk2d;
using Md.PlayMakerFSM;
using Md.PlayerData;
using Md.ShopItem;
using Md.SilkSpool;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoDetour;
using MonoDetour.Cil;
using MonoDetour.DetourTypes;
using MonoDetour.HookGen;
using MonoDetour.Reflection.Unspeakable;
using MonoMod.Cil;
using MonoMod.Utils;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using PrepatcherPlugin;
using SSMP.Api.Client;
using SSMP.Api.Client.Networking;
using SSMP.Api.Command;
using SSMP.Api.Command.Server;
using SSMP.Api.Server;
using SSMP.Api.Server.Networking;
using SSMP.Networking.Packet;
using SSMP.Networking.Packet.Data;
using Silksong.DataManager;
using Silksong.FsmUtil;
using Silksong.FsmUtil.Actions;
using Silksong.ModMenu.Elements;
using Silksong.ModMenu.Models;
using Silksong.ModMenu.Plugin;
using Silksong.ModMenu.Screens;
using Silksong.PurenailUtil.Collections;
using Silksong.TheHuntIsOn.Menu;
using Silksong.TheHuntIsOn.Modules;
using Silksong.TheHuntIsOn.Modules.ArchitectModule;
using Silksong.TheHuntIsOn.Modules.EventsModule;
using Silksong.TheHuntIsOn.Modules.Lib;
using Silksong.TheHuntIsOn.Modules.PauseTimerModule;
using Silksong.TheHuntIsOn.SsmpAddon;
using Silksong.TheHuntIsOn.SsmpAddon.PacketUtil;
using Silksong.TheHuntIsOn.Util;
using Silksong.UnityHelper.Extensions;
using TMProOld;
using TeamCherry.SharedUtils;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Silksong.TheHuntIsOn")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("SSMP add-on mod for speedrunners vs. hunters.")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: AssemblyInformationalVersion("1.0.1+bd79a138b865d4d80037a8813ea513830aeb0bc1")]
[assembly: AssemblyProduct("Silksong.TheHuntIsOn")]
[assembly: AssemblyTitle("TheHuntIsOn")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/dplochcoder/Silksong.TheHuntIsOn")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[CompilerGenerated]
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Length;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

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

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

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

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

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

	bool ICollection<T>.IsReadOnly => true;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlyList<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Count;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

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

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

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

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

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

	bool ICollection<T>.IsReadOnly => true;

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

	public <>z__ReadOnlyList(List<T> items)
	{
		_items = items;
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		T IEnumerator<T>.Current => _item;

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

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

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

		void IDisposable.Dispose()
		{
		}
	}

	int ICollection.Count => 1;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

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

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => 1;

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

	int ICollection<T>.Count => 1;

	bool ICollection<T>.IsReadOnly => true;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
namespace 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 System.Runtime.Versioning
{
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiresPreviewFeaturesAttribute : Attribute
	{
		public string? Message { get; }

		public string? Url { get; set; }

		public RequiresPreviewFeaturesAttribute()
		{
		}

		public RequiresPreviewFeaturesAttribute(string? message)
		{
			Message = message;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CallerArgumentExpressionAttribute : Attribute
	{
		public string ParameterName { get; }

		public CallerArgumentExpressionAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CollectionBuilderAttribute : Attribute
	{
		public Type BuilderType { get; }

		public string MethodName { get; }

		public CollectionBuilderAttribute(Type builderType, string methodName)
		{
			BuilderType = builderType;
			MethodName = methodName;
		}
	}
	[AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CompilerFeatureRequiredAttribute : Attribute
	{
		public const string RefStructs = "RefStructs";

		public const string RequiredMembers = "RequiredMembers";

		public string FeatureName { get; }

		public bool IsOptional { get; set; }

		public CompilerFeatureRequiredAttribute(string featureName)
		{
			FeatureName = featureName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class InterpolatedStringHandlerArgumentAttribute : Attribute
	{
		public string[] Arguments { get; }

		public InterpolatedStringHandlerArgumentAttribute(string argument)
		{
			Arguments = new string[1] { argument };
		}

		public InterpolatedStringHandlerArgumentAttribute(params string[] arguments)
		{
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class InterpolatedStringHandlerAttribute : Attribute
	{
	}
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal static class IsExternalInit
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ModuleInitializerAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class OverloadResolutionPriorityAttribute : Attribute
	{
		public int Priority { get; }

		public OverloadResolutionPriorityAttribute(int priority)
		{
			Priority = priority;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = true, AllowMultiple = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ParamCollectionAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiredMemberAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiresLocationAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SkipLocalsInitAttribute : Attribute
	{
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ConstantExpectedAttribute : Attribute
	{
		public object? Min { get; set; }

		public object? Max { get; set; }
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ExperimentalAttribute : Attribute
	{
		public string DiagnosticId { get; }

		public string? UrlFormat { get; set; }

		public ExperimentalAttribute(string diagnosticId)
		{
			DiagnosticId = diagnosticId;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SetsRequiredMembersAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class StringSyntaxAttribute : Attribute
	{
		public const string CompositeFormat = "CompositeFormat";

		public const string DateOnlyFormat = "DateOnlyFormat";

		public const string DateTimeFormat = "DateTimeFormat";

		public const string EnumFormat = "EnumFormat";

		public const string GuidFormat = "GuidFormat";

		public const string Json = "Json";

		public const string NumericFormat = "NumericFormat";

		public const string Regex = "Regex";

		public const string TimeOnlyFormat = "TimeOnlyFormat";

		public const string TimeSpanFormat = "TimeSpanFormat";

		public const string Uri = "Uri";

		public const string Xml = "Xml";

		public string Syntax { get; }

		public object?[] Arguments { get; }

		public StringSyntaxAttribute(string syntax)
		{
			Syntax = syntax;
			Arguments = new object[0];
		}

		public StringSyntaxAttribute(string syntax, params object?[] arguments)
		{
			Syntax = syntax;
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class UnscopedRefAttribute : Attribute
	{
	}
}
namespace Md.ShopItem
{
	internal static class Awake
	{
		public delegate void PrefixSignature(ShopItem self);

		public delegate void PostfixSignature(ShopItem 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(ShopItem).GetMethod("Awake", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("ShopItem", "Awake");
		}
	}
	internal static class SetPurchased
	{
		public delegate void PrefixSignature(ShopItem self, ref Action onComplete, ref int subItemIndex);

		public delegate void PostfixSignature(ShopItem self, ref Action onComplete, ref int subItemIndex);

		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(ShopItem).GetMethod("SetPurchased", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(Action),
				typeof(int)
			}, null) ?? throw new MissingMethodException("ShopItem", "SetPurchased");
		}
	}
	internal static class get_OverrideCostDelegate
	{
	}
	internal static class set_OverrideCostDelegate
	{
	}
	internal static class get_DisplayName
	{
	}
	internal static class get_Description
	{
	}
	internal static class get_ItemSprite
	{
	}
	internal static class get_ItemSpriteScale
	{
	}
	internal static class get_CurrencyType
	{
	}
	internal static class get_Cost
	{
	}
	internal static class get_RequiredItem
	{
	}
	internal static class get_RequiredItemAmount
	{
	}
	internal static class get_RequiredTools
	{
	}
	internal static class get_RequiredToolsAmount
	{
	}
	internal static class get_UpgradeFromItem
	{
	}
	internal static class get_IsAvailable
	{
	}
	internal static class get_IsPurchased
	{
	}
	internal static class get_IsAvailableNotInfinite
	{
	}
	internal static class get_Item
	{
	}
	internal static class get_EventAfterPurchase
	{
	}
	internal static class get_SubItemsCount
	{
	}
	internal static class get_HasSubItems
	{
	}
	internal static class get_SubItemSelectPrompt
	{
	}
	internal static class IsUsingCostReference
	{
	}
	internal static class IsUsingRequiredTools
	{
	}
	internal static class ItemSpriteValidation
	{
	}
	internal static class OnValidate
	{
	}
	internal static class IsToolItem
	{
	}
	internal static class IsAtMax
	{
	}
	internal static class GetToolType
	{
	}
	internal static class GetPurchaseType
	{
	}
	internal static class GetTypeFlags
	{
	}
	internal static class EnsurePool
	{
	}
	internal static class GetSubItem
	{
	}
	internal static class CreateTemp
	{
	}
	internal static class _ctor
	{
	}
	internal static class ConditionalSpawn
	{
		internal static class EnsurePool
		{
		}

		internal static class TryInstantiate
		{
		}

		internal static class _ctor
		{
		}
	}
	internal static class LocalisedStringPlural
	{
		internal static class _ctor
		{
		}
	}
	internal static class TypeFlags
	{
		internal static class _ctor
		{
		}
	}
	internal static class PurchaseTypes
	{
		internal static class _ctor
		{
		}
	}
	internal static class SubItem
	{
		internal static class _ctor
		{
		}
	}
}
namespace Md.PlayerData
{
	internal static class GetBool
	{
		public delegate void PrefixSignature(PlayerData self, ref string boolName);

		public delegate ReturnFlow ControlFlowPrefixSignature(PlayerData self, ref string boolName, ref bool returnValue);

		public delegate void PostfixSignature(PlayerData self, ref string boolName, 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(PlayerData).GetMethod("GetBool", (BindingFlags)(-1), null, new Type[1] { typeof(string) }, null) ?? throw new MissingMethodException("PlayerData", "GetBool");
		}
	}
	internal static class GetInt
	{
		public delegate void PrefixSignature(PlayerData self, ref string intName);

		public delegate ReturnFlow ControlFlowPrefixSignature(PlayerData self, ref string intName, ref int returnValue);

		public delegate void PostfixSignature(PlayerData self, ref string intName, ref int 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(PlayerData).GetMethod("GetInt", (BindingFlags)(-1), null, new Type[1] { typeof(string) }, null) ?? throw new MissingMethodException("PlayerData", "GetInt");
		}
	}
	internal static class MaxHealth
	{
		public delegate void PrefixSignature(PlayerData self);

		public delegate ReturnFlow ControlFlowPrefixSignature(PlayerData self);

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

		public delegate ReturnFlow ControlFlowPrefixSignature(PlayerData self, ref int amount);

		public delegate void PostfixSignature(PlayerData self, ref int amount);

		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(PlayerData).GetMethod("AddToMaxHealth", (BindingFlags)(-1), null, new Type[1] { typeof(int) }, null) ?? throw new MissingMethodException("PlayerData", "AddToMaxHealth");
		}
	}
	internal static class AddSilk
	{
		public delegate void PrefixSignature(PlayerData self, ref int amount);

		public delegate ReturnFlow ControlFlowPrefixSignature(PlayerData self, ref int amount, ref bool returnValue);

		public delegate void PostfixSignature(PlayerData self, ref int amount, 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(PlayerData).GetMethod("AddSilk", (BindingFlags)(-1), null, new Type[1] { typeof(int) }, null) ?? throw new MissingMethodException("PlayerData", "AddSilk");
		}
	}
	internal static class get_IsDemoMode
	{
	}
	internal static class get_IsExhibitionMode
	{
	}
	internal static class get_IsHornetStrengthRegained
	{
	}
	internal static class get_nailDamage
	{
	}
	internal static class get_MapBools
	{
	}
	internal static class get_HasAnyMap
	{
	}
	internal static class get_HasAllMaps
	{
	}
	internal static class get_MapCount
	{
	}
	internal static class get_CanUpdateMap
	{
	}
	internal static class get_IsWildsWideMapFull
	{
	}
	internal static class get_HasAnyFleaPin
	{
	}
	internal static class get_IsFleaPinMapKeyVisible
	{
	}
	internal static class get_SavedFleasCount
	{
	}
	internal static class CacheSavedFleas
	{
	}
	internal static class get_HasAnyPin
	{
	}
	internal static class get_VampireGnatBossInAltLoc
	{
	}
	internal static class get_CaravanInGreymoor
	{
	}
	internal static class get_HasLifebloodSyringeGland
	{
	}
	internal static class get_GourmandQuestAccepted
	{
	}
	internal static class get_SlaveDeliveryQuestCompleted
	{
	}
	internal static class get_BelltownHouseVisited
	{
	}
	internal static class get_CrawbellHasSomething
	{
	}
	internal static class get_HasAnyMemento
	{
	}
	internal static class get_CloakFlySmell
	{
	}
	internal static class get_IsAnyRelicsDeposited
	{
	}
	internal static class get_WillLoadWardBoss
	{
	}
	internal static class get_CollectedCloverMemoryOrbs
	{
	}
	internal static class get_CloverMemoryOrbsCollectedAll
	{
	}
	internal static class get_CloverMemoryOrbsCollectedTarget
	{
	}
	internal static class get_IsAct3IntroQueued
	{
	}
	internal static class get_HasWhiteFlower
	{
	}
	internal static class get_FleaGamesIsJugglingChampion
	{
	}
	internal static class get_FleaGamesIsJugglingSethChampion
	{
	}
	internal static class get_FleaGamesIsBouncingChampion
	{
	}
	internal static class get_FleaGamesIsBouncingSethChampion
	{
	}
	internal static class get_FleaGamesIsDodgingChampion
	{
	}
	internal static class get_FleaGamesIsDodgingSethChampion
	{
	}
	internal static class get_FleaGamesOutroReady
	{
	}
	internal static class get_FleaGamesBestedSeth
	{
	}
	internal static class get_BellCentipedeWaiting
	{
	}
	internal static class get_BellCentipedeLocked
	{
	}
	internal static class get_UnlockedAnyTube
	{
	}
	internal static class get_CurrentMaxHealth
	{
	}
	internal static class get_CurrentSilkMax
	{
	}
	internal static class get_CurrentSilkMaxBasic
	{
	}
	internal static class get_SilkSkillCost
	{
	}
	internal static class get_IsAnyCursed
	{
	}
	internal static class get_CurrentSilkRegenMax
	{
	}
	internal static class get_JournalIsCompleted
	{
	}
	internal static class get_JournalCompletedCount
	{
	}
	internal static class get_MushroomQuestCompleted
	{
	}
	internal static class get_instance
	{
	}
	internal static class set_instance
	{
	}
	internal static class get_HasInstance
	{
	}
	internal static class _ctor
	{
	}
	internal static class CreateNewSingleton
	{
	}
	internal static class OnDeserialized
	{
	}
	internal static class ClearOptimisers
	{
	}
	internal static class SetBool
	{
	}
	internal static class SetInt
	{
	}
	internal static class IncrementInt
	{
	}
	internal static class IntAdd
	{
	}
	internal static class SetFloat
	{
	}
	internal static class DecrementInt
	{
	}
	internal static class GetFloat
	{
	}
	internal static class GetString
	{
	}
	internal static class SetString
	{
	}
	internal static class SetVector3
	{
	}
	internal static class GetVector3
	{
	}
	internal static class GetNextMossberryValue
	{
	}
	internal static class GetNextSilkGrubValue
	{
	}
	internal static class CaptureToolAmountsOverride
	{
	}
	internal static class ClearToolAmountsOverride
	{
	}
	internal static class GetToolData
	{
	}
	internal static class SetToolData
	{
	}
	internal static class AddHealth
	{
	}
	internal static class TakeHealth
	{
	}
	internal static class ActivateTestingCheats
	{
	}
	internal static class GetAllPowerups
	{
	}
	internal static class AddGeo
	{
	}
	internal static class TakeGeo
	{
	}
	internal static class AddShards
	{
	}
	internal static class TakeShards
	{
	}
	internal static class WouldDie
	{
	}
	internal static class TakeSilk
	{
	}
	internal static class ReduceOdours
	{
	}
	internal static class EquipCharm
	{
	}
	internal static class UnequipCharm
	{
	}
	internal static class CalculateNotchesUsed
	{
	}
	internal static class SetBenchRespawn_RespawnMarker_System_String_System_Int32
	{
	}
	internal static class SetBenchRespawn_System_String_System_String_System_Boolean
	{
	}
	internal static class SetBenchRespawn_System_String_System_String_System_Int32_System_Boolean
	{
	}
	internal static class SetHazardRespawn_HazardRespawnMarker
	{
	}
	internal static class SetHazardRespawn_UnityEngine_Vector3_System_Boolean
	{
	}
	internal static class MapperLeaveAll
	{
	}
	internal static class CountGameCompletion
	{
	}
	internal static class SetupNewPlayerData
	{
	}
	internal static class SetupExistingPlayerData
	{
	}
	internal static class ResetNonSerializableFields
	{
	}
	internal static class ResetTempRespawn
	{
	}
	internal static class ResetCutsceneBools
	{
	}
	internal static class AddGGPlayerDataOverrides
	{
	}
	internal static class OnUpdatedVariable
	{
	}
	internal static class GetDateString
	{
	}
	internal static class OnBeforeSave
	{
	}
	internal static class UpdateDate
	{
	}
	internal static class AddEditorOverrides
	{
	}
	internal static class _cctor
	{
	}
	internal static class MapBoolList
	{
		internal static class get_HasAnyMap
		{
		}

		internal static class get_HasAllMaps
		{
		}

		internal static class get_HasCount
		{
		}

		internal static class _ctor
		{
		}

		internal static class BuildTargetList
		{
		}

		internal static class __c
		{
			internal static class _ctor
			{
			}
		}

		internal static class __c__DisplayClass8_0
		{
			internal static class _ctor
			{
			}
		}

		internal static class __c__DisplayClass8_1
		{
			internal static class _ctor
			{
			}
		}

		internal static class __c__DisplayClass8_2
		{
			internal static class _ctor
			{
			}
		}
	}
	internal static class __c
	{
		internal static class _ctor
		{
		}
	}
}
namespace Md.Lever_tk2d
{
	internal static class _Execute_d__32
	{
		internal static class MoveNext
		{
			public delegate void PrefixSignature(object self);

			public delegate void PostfixSignature(object 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 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 (Type.GetType("Lever_tk2d+<Execute>d__32, Assembly-CSharp") ?? throw new Exception("Missing Type: 'Lever_tk2d+<Execute>d__32'")).GetMethod("MoveNext", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("Lever_tk2d+<Execute>d__32", "MoveNext");
			}
		}

		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		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 Awake
	{
		public delegate void PrefixSignature(Lever_tk2d self);

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

		public delegate void PostfixSignature(Lever_tk2d self, ref IEnumerator returnValue);

		public delegate void PrefixMoveNextSignature(SpeakableEnumerator<object, Lever_tk2d> self);

		public delegate void PostfixMoveNextSignature(SpeakableEnumerator<object, Lever_tk2d> self, ref bool continueEnumeration);

		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 MonoDetourHook PrefixMoveNext(PrefixMoveNextSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>((MethodBase)StateMachineTarget(), (Delegate)hook, config, applyByDefault);
		}

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

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

		public static MethodBase Target()
		{
			return typeof(Lever_tk2d).GetMethod("Execute", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("Lever_tk2d", "Execute");
		}

		public static MethodInfo StateMachineTarget()
		{
			return Extensions.GetStateMachineTarget((MethodInfo)Target());
		}
	}
	internal static class Start
	{
	}
	internal static class IsFsmEventValidRequiredFSM
	{
	}
	internal static class IsFsmEventValidRequired
	{
	}
	internal static class Hit
	{
	}
	internal static class PlaySound
	{
	}
	internal static class PlaySoundOneShot
	{
	}
	internal static class _ctor
	{
	}
}
namespace Md.Lever
{
	internal static class _Execute_d__35
	{
		internal static class MoveNext
		{
			public delegate void PrefixSignature(object self);

			public delegate void PostfixSignature(object 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 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 (Type.GetType("Lever+<Execute>d__35, Assembly-CSharp") ?? throw new Exception("Missing Type: 'Lever+<Execute>d__35'")).GetMethod("MoveNext", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("Lever+<Execute>d__35", "MoveNext");
			}
		}

		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		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 Awake
	{
		public delegate void PrefixSignature(Lever self);

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

		public delegate void PostfixSignature(Lever self, ref IEnumerator returnValue);

		public delegate void PrefixMoveNextSignature(SpeakableEnumerator<object, Lever> self);

		public delegate void PostfixMoveNextSignature(SpeakableEnumerator<object, Lever> self, ref bool continueEnumeration);

		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 MonoDetourHook PrefixMoveNext(PrefixMoveNextSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>((MethodBase)StateMachineTarget(), (Delegate)hook, config, applyByDefault);
		}

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

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

		public static MethodBase Target()
		{
			return typeof(Lever).GetMethod("Execute", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("Lever", "Execute");
		}

		public static MethodInfo StateMachineTarget()
		{
			return Extensions.GetStateMachineTarget((MethodInfo)Target());
		}
	}
	internal static class get_HitBlocked
	{
	}
	internal static class set_HitBlocked
	{
	}
	internal static class Start
	{
	}
	internal static class Hit
	{
	}
	internal static class SetActivated
	{
	}
	internal static class SetActivated_System_Boolean
	{
	}
	internal static class SetActivatedInert
	{
	}
	internal static class SetActivatedInertWithAnim
	{
	}
	internal static class SetActivatedAnim
	{
	}
	internal static class _ctor
	{
	}
}
namespace Md.SilkSpool
{
	internal static class get_BindCost
	{
		public delegate void PrefixSignature();

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

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

		public delegate void PostfixSignature(SilkSpool 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(SilkSpool).GetMethod("Awake", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SilkSpool", "Awake");
		}
	}
	internal static class get_Instance
	{
	}
	internal static class set_Instance
	{
	}
	internal static class OnDestroy
	{
	}
	internal static class Start
	{
	}
	internal static class DrawSpool
	{
	}
	internal static class DrawSpool_System_Int32
	{
	}
	internal static class ChangeSilk
	{
	}
	internal static class IsGlowing
	{
	}
	internal static class RefreshSilk_SilkSpool_SilkAddSource_SilkSpool_SilkTakeSource
	{
	}
	internal static class RefreshBindNotch
	{
	}
	internal static class SpawnNewChunk
	{
	}
	internal static class AddUsing
	{
	}
	internal static class RemoveUsing
	{
	}
	internal static class SetRegen
	{
	}
	internal static class ResumeSilkAudio
	{
	}
	internal static class EndSilkAudio
	{
	}
	internal static class EvaluatePositions
	{
	}
	internal static class SetMossState
	{
	}
	internal static class CancelMossChunk
	{
	}
	internal static class _ctor
	{
	}
	internal static class SilkAddSource
	{
		internal static class _ctor
		{
		}
	}
	internal static class SilkTakeSource
	{
		internal static class _ctor
		{
		}
	}
	internal static class SilkUsingFlags
	{
		internal static class _ctor
		{
		}
	}
}
namespace Md.HutongGames.PlayMaker.Actions.CallMethodProper
{
	internal static class Awake
	{
		public delegate void PrefixSignature(CallMethodProper self);

		public delegate void PostfixSignature(CallMethodProper 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(CallMethodProper).GetMethod("Awake", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("HutongGames.PlayMaker.Actions.CallMethodProper", "Awake");
		}
	}
	internal static class OnEnter
	{
	}
	internal static class OnUpdate
	{
	}
	internal static class DoMethodCall
	{
	}
	internal static class DoCache
	{
	}
	internal static class PreCache
	{
	}
	internal static class _ctor
	{
	}
	internal static class __c
	{
		internal static class _ctor
		{
		}
	}
}
namespace Md.HutongGames.PlayMaker.Fsm
{
	internal static class Clear
	{
		public delegate void PrefixSignature(Fsm self, ref MonoBehaviour component);

		public delegate void PostfixSignature(Fsm self, ref MonoBehaviour component);

		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(Fsm).GetMethod("Clear", (BindingFlags)(-1), null, new Type[1] { typeof(MonoBehaviour) }, null) ?? throw new MissingMethodException("HutongGames.PlayMaker.Fsm", "Clear");
		}
	}
	internal static class CompareTo
	{
		public delegate void PrefixSignature(Fsm self, ref object obj);

		public delegate void PostfixSignature(Fsm self, ref object obj, ref int 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 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(Fsm).GetMethod("CompareTo", (BindingFlags)(-1), null, new Type[1] { typeof(object) }, null) ?? throw new MissingMethodException("HutongGames.PlayMaker.Fsm", "CompareTo");
		}
	}
	internal static class GetState
	{
		public delegate void PrefixSignature(Fsm self, ref string stateName);

		public delegate void PostfixSignature(Fsm self, ref string stateName, ref FsmState 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 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(Fsm).GetMethod("GetState", (BindingFlags)(-1), null, new Type[1] { typeof(string) }, null) ?? throw new MissingMethodException("HutongGames.PlayMaker.Fsm", "GetState");
		}
	}
	internal static class GetFsmInt
	{
		public delegate void PrefixSignature(Fsm self, ref string varName);

		public delegate void PostfixSignature(Fsm self, ref string varName, ref FsmInt 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 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(Fsm).GetMethod("GetFsmInt", (BindingFlags)(-1), null, new Type[1] { typeof(string) }, null) ?? throw new MissingMethodException("HutongGames.PlayMaker.Fsm", "GetFsmInt");
		}
	}
	internal static class GetFsmFloat
	{
		public delegate void PrefixSignature(Fsm self, ref string varName);

		public delegate void PostfixSignature(Fsm self, ref string varName, ref FsmFloat 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 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(Fsm).GetMethod("GetFsmFloat", (BindingFlags)(-1), null, new Type[1] { typeof(string) }, null) ?? throw new MissingMethodException("HutongGames.PlayMaker.Fsm", "GetFsmFloat");
		}
	}
	internal static class Update
	{
		public delegate void PrefixSignature(Fsm self);

		public delegate void PostfixSignature(Fsm 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(Fsm).GetMethod("Update", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("HutongGames.PlayMaker.Fsm", "Update");
		}
	}
	internal static class Reset
	{
		public delegate void PrefixSignature(Fsm self, ref MonoBehaviour component);

		public delegate void PostfixSignature(Fsm self, ref MonoBehaviour component);

		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(Fsm).GetMethod("Reset", (BindingFlags)(-1), null, new Type[1] { typeof(MonoBehaviour) }, null) ?? throw new MissingMethodException("HutongGames.PlayMaker.Fsm", "Reset");
		}
	}
	internal static class GetFsmEnum
	{
		public delegate void PrefixSignature(Fsm self, ref string varName);

		public delegate void PostfixSignature(Fsm self, ref string varName, ref FsmEnum 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 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(Fsm).GetMethod("GetFsmEnum", (BindingFlags)(-1), null, new Type[1] { typeof(string) }, null) ?? throw new MissingMethodException("HutongGames.PlayMaker.Fsm", "GetFsmEnum");
		}
	}
	internal static class Awake
	{
		public delegate void PrefixSignature(Fsm self);

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

		public delegate void PostfixSignature(Fsm 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(Fsm).GetMethod("OnEnable", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("HutongGames.PlayMaker.Fsm", "OnEnable");
		}
	}
	internal static class get_FsmList
	{
	}
	internal static class get_SortedFsmList
	{
	}
	internal static class get_UpdateHelperSetDirty
	{
	}
	internal static class ClearOutputFlags
	{
	}
	internal static class GetOutputVariables
	{
	}
	internal static class GetOutputVariableNames
	{
	}
	internal static class SetOutputVariables
	{
	}
	internal static class SanityCheckOutputIndices
	{
	}
	internal static class OutVariableIndicesNeedFixing
	{
	}
	internal static class get_ManualUpdate
	{
	}
	internal static class set_ManualUpdate
	{
	}
	internal static class get_KeepDelayedEventsOnStateExit
	{
	}
	internal static class set_KeepDelayedEventsOnStateExit
	{
	}
	internal static class get_Preprocessed
	{
	}
	internal static class set_Preprocessed
	{
	}
	internal static class get_Host
	{
	}
	internal static class set_Host
	{
	}
	internal static class get_Password
	{
	}
	internal static class get_Locked
	{
	}
	internal static class Lock
	{
	}
	internal static class Unlock
	{
	}
	internal static class get_Template
	{
	}
	internal static class get_IsSubFsm
	{
	}
	internal static class get_RootFsm
	{
	}
	internal static class get_SubFsmList
	{
	}
	internal static class get_DefaultVariableValues
	{
	}
	internal static class set_DefaultVariableValues
	{
	}
	internal static class get_HasErrors
	{
	}
	internal static class set_HasErrors
	{
	}
	internal static class get_Started
	{
	}
	internal static class set_Started
	{
	}
	internal static class get_DelayedEvents
	{
	}
	internal static class KillDelayedEvents
	{
	}
	internal static class get_DataVersion
	{
	}
	internal static class set_DataVersion
	{
	}
	internal static class get_Owner
	{
	}
	internal static class set_Owner
	{
	}
	internal static class get_NameIsExpanded
	{
	}
	internal static class set_NameIsExpanded
	{
	}
	internal static class get_ControlsIsExpanded
	{
	}
	internal static class set_ControlsIsExpanded
	{
	}
	internal static class get_DebugIsExpanded
	{
	}
	internal static class set_DebugIsExpanded
	{
	}
	internal static class get_ExperimentalIsExpanded
	{
	}
	internal static class set_ExperimentalIsExpanded
	{
	}
	internal static class get_InfoIsExpanded
	{
	}
	internal static class set_InfoIsExpanded
	{
	}
	internal static class get_InputsIsExpanded
	{
	}
	internal static class set_InputsIsExpanded
	{
	}
	internal static class get_OutputsIsExpanded
	{
	}
	internal static class set_OutputsIsExpanded
	{
	}
	internal static class get_EventsIsExpanded
	{
	}
	internal static class set_EventsIsExpanded
	{
	}
	internal static class get_SettingsIsExpanded
	{
	}
	internal static class set_SettingsIsExpanded
	{
	}
	internal static class get_Name
	{
	}
	internal static class set_Name
	{
	}
	internal static class get_UsedInTemplate
	{
	}
	internal static class set_UsedInTemplate
	{
	}
	internal static class get_StartState
	{
	}
	internal static class set_StartState
	{
	}
	internal static class get_States
	{
	}
	internal static class set_States
	{
	}
	internal static class get_Events
	{
	}
	internal static class set_Events
	{
	}
	internal static class get_GlobalTransitions
	{
	}
	internal static class set_GlobalTransitions
	{
	}
	internal static class get_Variables
	{
	}
	internal static class set_Variables
	{
	}
	internal static class get_EventTarget
	{
	}
	internal static class set_EventTarget
	{
	}
	internal static class get_Initialized
	{
	}
	internal static class get_Active
	{
	}
	internal static class get_Finished
	{
	}
	internal static class set_Finished
	{
	}
	internal static class get_IsSwitchingState
	{
	}
	internal static class get_ActiveState
	{
	}
	internal static class set_ActiveState
	{
	}
	internal static class get_ActiveStateName
	{
	}
	internal static class get_PreviousActiveState
	{
	}
	internal static class set_PreviousActiveState
	{
	}
	internal static class get_LastTransition
	{
	}
	internal static class set_LastTransition
	{
	}
	internal static class get_MaxLoopCount
	{
	}
	internal static class get_MaxLoopCountOverride
	{
	}
	internal static class set_MaxLoopCountOverride
	{
	}
	internal static class get_OwnerName
	{
	}
	internal static class get_OwnerDebugName
	{
	}
	internal static class get_GameObject
	{
	}
	internal static class get_GameObjectName
	{
	}
	internal static class get_OwnerObject
	{
	}
	internal static class get_FsmComponent
	{
	}
	internal static class get_MyLog
	{
	}
	internal static class get_IsModifiedPrefabInstance
	{
	}
	internal static class set_IsModifiedPrefabInstance
	{
	}
	internal static class get_Description
	{
	}
	internal static class set_Description
	{
	}
	internal static class get_Watermark
	{
	}
	internal static class set_Watermark
	{
	}
	internal static class get_ShowStateLabel
	{
	}
	internal static class set_ShowStateLabel
	{
	}
	internal static class get_GuiLabel
	{
	}
	internal static class get_DocUrl
	{
	}
	internal static class set_DocUrl
	{
	}
	internal static class get_EditState
	{
	}
	internal static class set_EditState
	{
	}
	internal static class get_LastClickedObject
	{
	}
	internal static class set_LastClickedObject
	{
	}
	internal static class get_BreakpointsEnabled
	{
	}
	internal static class set_BreakpointsEnabled
	{
	}
	internal static class get_HitBreakpoint
	{
	}
	internal static class set_HitBreakpoint
	{
	}
	internal static class get_BreakAtFsm
	{
	}
	internal static class set_BreakAtFsm
	{
	}
	internal static class get_BreakAtState
	{
	}
	internal static class set_BreakAtState
	{
	}
	internal static class get_IsBreak
	{
	}
	internal static class set_IsBreak
	{
	}
	internal static class get_IsErrorBreak
	{
	}
	internal static class set_IsErrorBreak
	{
	}
	internal static class get_LastError
	{
	}
	internal static class set_LastError
	{
	}
	internal static class get_StepToStateChange
	{
	}
	internal static class set_StepToStateChange
	{
	}
	internal static class get_StepFsm
	{
	}
	internal static class set_StepFsm
	{
	}
	internal static class get_SwitchedState
	{
	}
	internal static class set_SwitchedState
	{
	}
	internal static class get_MouseEvents
	{
	}
	internal static class set_MouseEvents
	{
	}
	internal static class get_HandleLevelLoaded
	{
	}
	internal static class set_HandleLevelLoaded
	{
	}
	internal static class get_HandleTriggerEnter2D
	{
	}
	internal static class set_HandleTriggerEnter2D
	{
	}
	internal static class get_HandleTriggerExit2D
	{
	}
	internal static class set_HandleTriggerExit2D
	{
	}
	internal static class get_HandleTriggerStay2D
	{
	}
	internal static class set_HandleTriggerStay2D
	{
	}
	internal static class get_HandleCollisionEnter2D
	{
	}
	internal static class set_HandleCollisionEnter2D
	{
	}
	internal static class get_HandleCollisionExit2D
	{
	}
	internal static class set_HandleCollisionExit2D
	{
	}
	internal static class get_HandleCollisionStay2D
	{
	}
	internal static class set_HandleCollisionStay2D
	{
	}
	internal static class get_HandleTriggerEnter
	{
	}
	internal static class set_HandleTriggerEnter
	{
	}
	internal static class get_HandleTriggerExit
	{
	}
	internal static class set_HandleTriggerExit
	{
	}
	internal static class get_HandleTriggerStay
	{
	}
	internal static class set_HandleTriggerStay
	{
	}
	internal static class get_HandleCollisionEnter
	{
	}
	internal static class set_HandleCollisionEnter
	{
	}
	internal static class get_HandleCollisionExit
	{
	}
	internal static class set_HandleCollisionExit
	{
	}
	internal static class get_HandleCollisionStay
	{
	}
	internal static class set_HandleCollisionStay
	{
	}
	internal static class get_HandleParticleCollision
	{
	}
	internal static class set_HandleParticleCollision
	{
	}
	internal static class get_HandleControllerColliderHit
	{
	}
	internal static class set_HandleControllerColliderHit
	{
	}
	internal static class get_HandleJointBreak
	{
	}
	internal static class set_HandleJointBreak
	{
	}
	internal static class get_HandleJointBreak2D
	{
	}
	internal static class set_HandleJointBreak2D
	{
	}
	internal static class get_HandleOnGUI
	{
	}
	internal static class set_HandleOnGUI
	{
	}
	internal static class get_HandleFixedUpdate
	{
	}
	internal static class set_HandleFixedUpdate
	{
	}
	internal static class get_HandleLateUpdate
	{
	}
	internal static class set_HandleLateUpdate
	{
	}
	internal static class get_HandleApplicationEvents
	{
	}
	internal static class set_HandleApplicationEvents
	{
	}
	internal static class get_HandleUiEvents
	{
	}
	internal static class set_HandleUiEvents
	{
	}
	internal static class get_HandleLegacyNetworking
	{
	}
	internal static class set_HandleLegacyNetworking
	{
	}
	internal static class ForcePreprocess
	{
	}
	internal static class ResetEventHandlerFlags
	{
	}
	internal static class get_CollisionInfo
	{
	}
	internal static class set_CollisionInfo
	{
	}
	internal static class get_TriggerCollider
	{
	}
	internal static class set_TriggerCollider
	{
	}
	internal static class get_Collision2DInfo
	{
	}
	internal static class set_Collision2DInfo
	{
	}
	internal static class get_TriggerCollider2D
	{
	}
	internal static class set_TriggerCollider2D
	{
	}
	internal static class get_JointBreakForce
	{
	}
	internal static class set_JointBreakForce
	{
	}
	internal static class get_BrokenJoint2D
	{
	}
	internal static class set_BrokenJoint2D
	{
	}
	internal static class get_ParticleCollisionGO
	{
	}
	internal static class set_ParticleCollisionGO
	{
	}
	internal static class get_CollisionGO
	{
	}
	internal static class get_Collision2dGO
	{
	}
	internal static class get_TriggerGO
	{
	}
	internal static class get_Trigger2dGO
	{
	}
	internal static class get_TriggerName
	{
	}
	internal static class set_TriggerName
	{
	}
	internal static class get_CollisionName
	{
	}
	internal static class set_CollisionName
	{
	}
	internal static class get_Trigger2dName
	{
	}
	internal static class set_Trigger2dName
	{
	}
	internal static class get_Collision2dName
	{
	}
	internal static class set_Collision2dName
	{
	}
	internal static class get_ControllerCollider
	{
	}
	internal static class set_ControllerCollider
	{
	}
	internal static class get_RaycastHitInfo
	{
	}
	internal static class set_RaycastHitInfo
	{
	}
	internal static class RecordLastRaycastHit2DInfo
	{
	}
	internal static class GetLastRaycastHit2DInfo
	{
	}
	internal static class get_HandleAnimatorMove
	{
	}
	internal static class set_HandleAnimatorMove
	{
	}
	internal static class get_HandleAnimatorIK
	{
	}
	internal static class set_HandleAnimatorIK
	{
	}
	internal static class NewTempFsm
	{
	}
	internal static class _ctor
	{
	}
	internal static class _ctor_HutongGames_PlayMaker_Fsm_HutongGames_PlayMaker_FsmVariables
	{
	}
	internal static class CreateSubFsm
	{
	}
	internal static class GetRootFsm
	{
	}
	internal static class CheckIfDirty
	{
	}
	internal static class UpdateDataVersion
	{
	}
	internal static class SaveActions
	{
	}
	internal static class FixDataVersion
	{
	}
	internal static class DeduceDataVersion
	{
	}
	internal static class Preprocess_UnityEngine_MonoBehaviour
	{
	}
	internal static class Preprocess
	{
	}
	internal static class Init
	{
	}
	internal static class Reinitialize
	{
	}
	internal static class InitStates
	{
	}
	internal static class InitData
	{
	}
	internal static class InitEvents
	{
	}
	internal static class CheckFsmEventsForEventHandlers
	{
	}
	internal static class InitInEditor
	{
	}
	internal static class SaveDefaultVariableValues
	{
	}
	internal static class ResetVariableValues
	{
	}
	internal static class OnSceneLoaded
	{
	}
	internal static class Start
	{
	}
	internal static class UpdateDelayedEvents
	{
	}
	internal static class ClearDelayedEvents
	{
	}
	internal static class FixedUpdate
	{
	}
	internal static class LateUpdate
	{
	}
	internal static class OnDisable
	{
	}
	internal static class SendDisableEvent
	{
	}
	internal static class Stop
	{
	}
	internal static class StopAndReset
	{
	}
	internal static class HasEvent
	{
	}
	internal static class ProcessEvent
	{
	}
	internal static class SetEventDataSentByInfo
	{
	}
	internal static class SetEventDataSentByInfo_HutongGames_PlayMaker_FsmEventData
	{
	}
	internal static class GetEventDataSentByInfo
	{
	}
	internal static class Event_HutongGames_PlayMaker_FsmEventTarget_System_String
	{
	}
	internal static class Event_UnityEngine_GameObject_HutongGames_PlayMaker_FsmEventTarget_HutongGames_PlayMaker_FsmEvent
	{
	}
	internal static class Event_UnityEngine_GameObject_HutongGames_PlayMaker_FsmEvent
	{
	}
	internal static class Event_HutongGames_PlayMaker_FsmEventTarget_HutongGames_PlayMaker_FsmEvent
	{
	}
	internal static class Event_System_String
	{
	}
	internal static class Event_HutongGames_PlayMaker_FsmEvent
	{
	}
	internal static class DelayedEvent_HutongGames_PlayMaker_FsmEvent_System_Single
	{
	}
	internal static class DelayedEvent_HutongGames_PlayMaker_FsmEventTarget_HutongGames_PlayMaker_FsmEvent_System_Single
	{
	}
	internal static class BroadcastEvent_System_String_System_Boolean
	{
	}
	internal static class BroadcastEvent_HutongGames_PlayMaker_FsmEvent_System_Boolean
	{
	}
	internal static class BroadcastEventToGameObject_UnityEngine_GameObject_System_String_System_Boolean_System_Boolean
	{
	}
	internal static class BroadcastEventToGameObject_UnityEngine_GameObject_HutongGames_PlayMaker_FsmEvent_HutongGames_PlayMaker_FsmEventData_System_Boolean_System_Boolean
	{
	}
	internal static class IsFsmChildOfGameObject
	{
	}
	internal static class SendEventToFsmOnGameObject_UnityEngine_GameObject_System_String_System_String
	{
	}
	internal static class SendEventToFsmOnGameObject_UnityEngine_GameObject_System_String_HutongGames_PlayMaker_FsmEvent
	{
	}
	internal static class HasState
	{
	}
	internal static class SetState
	{
	}
	internal static class UpdateStateChanges
	{
	}
	internal static class DoTransition
	{
	}
	internal static class SwitchState
	{
	}
	internal static class GotoPreviousState
	{
	}
	internal static class ReEnterState
	{
	}
	internal static class EnterState
	{
	}
	internal static class FixedUpdateState
	{
	}
	internal static class UpdateState
	{
	}
	internal static class LateUpdateState
	{
	}
	internal static class ExitState
	{
	}
	internal static class GetSubFsm
	{
	}
	internal static class GetFullFsmLabel
	{
	}
	internal static class GetOwnerDefaultTarget
	{
	}
	internal static class GetStateIndex
	{
	}
	internal static class GetEvent
	{
	}
	internal static class FindEvent
	{
	}
	internal static class GetGlobalTransitionsToState
	{
	}
	internal static class GetFsmObject
	{
	}
	internal static class GetFsmMaterial
	{
	}
	internal static class GetFsmTexture
	{
	}
	internal static class GetFsmBool
	{
	}
	internal static class GetFsmString
	{
	}
	internal static class GetFsmVector2
	{
	}
	internal static class GetFsmVector3
	{
	}
	internal static class GetFsmRect
	{
	}
	internal static class GetFsmQuaternion
	{
	}
	internal static class GetFsmColor
	{
	}
	internal static class GetFsmGameObject
	{
	}
	internal static class GetFsmArray
	{
	}
	internal static class OnDrawGizmos
	{
	}
	internal static class OnDrawGizmosSelected
	{
	}
	internal static class OnCollisionEnter
	{
	}
	internal static class OnCollisionStay
	{
	}
	internal static class OnCollisionExit
	{
	}
	internal static class OnTriggerEnter
	{
	}
	internal static class OnTriggerStay
	{
	}
	internal static class OnTriggerExit
	{
	}
	internal static class OnParticleCollision
	{
	}
	internal static class OnCollisionEnter2D
	{
	}
	internal static class OnCollisionStay2D
	{
	}
	internal static class OnCollisionExit2D
	{
	}
	internal static class OnTriggerEnter2D
	{
	}
	internal static class OnTriggerStay2D
	{
	}
	internal static class OnTriggerExit2D
	{
	}
	internal static class OnControllerColliderHit
	{
	}
	internal static class OnJointBreak
	{
	}
	internal static class OnJointBreak2D
	{
	}
	internal static class OnAnimatorMove
	{
	}
	internal static class OnAnimatorIK
	{
	}
	internal static class OnGUI
	{
	}
	internal static class DoBreakpoint
	{
	}
	internal static class DoBreakError
	{
	}
	internal static class DoBreak
	{
	}
	internal static class Continue
	{
	}
	internal static class OnDestroy
	{
	}
	internal static class DebugLog
	{
	}
	internal static class DebugEvent
	{
	}
	internal static class DebugLifetime
	{
	}
	internal static class DebugDebugger
	{
	}
	internal static class get_DebugLookAtColor
	{
	}
	internal static class set_DebugLookAtColor
	{
	}
	internal static class get_DebugRaycastColor
	{
	}
	internal static class set_DebugRaycastColor
	{
	}
	internal static class _cctor
	{
	}
	internal static class EditorFlags
	{
		internal static class _ctor
		{
		}
	}
}
namespace Md.PlayMakerFSM
{
	internal static class AddEventHandlerDelegate
	{
		internal static class Invoke
		{
			public delegate void PrefixSignature(AddEventHandlerDelegate self, ref PlayMakerFSM fsm);

			public delegate void PostfixSignature(AddEventHandlerDelegate self, ref PlayMakerFSM fsm);

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

		internal static class _ctor
		{
		}

		internal static class BeginInvoke
		{
		}

		internal static class EndInvoke
		{
		}
	}
	internal static class SendEvent
	{
		public delegate void PrefixSignature(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 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 _DoCoroutine_d__46
	{
		internal static class MoveNext
		{
			public delegate void PrefixSignature(object self);

			public delegate void PostfixSignature(object 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 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 (Type.GetType("PlayMakerFSM+<DoCoroutine>d__46, PlayMaker") ?? throw new Exception("Missing Type: 'PlayMakerFSM+<DoCoroutine>d__46'")).GetMethod("MoveNext", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("PlayMakerFSM+<DoCoroutine>d__46", "MoveNext");
			}
		}

		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		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 Update
	{
		public delegate void PrefixSignature(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 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 Reset
	{
		public delegate void PrefixSignature(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 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("Reset", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("PlayMakerFSM", "Reset");
		}
	}
	internal static class Awake
	{
		public delegate void PrefixSignature(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 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("Awake", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("PlayMakerFSM", "Awake");
		}
	}
	internal static class OnEnable
	{
		public delegate void PrefixSignature(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 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("OnEnable", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("PlayMakerFSM", "OnEnable");
		}
	}
	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 OnValidate
	{
	}
	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 Start
	{
	}
	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
	{
	}
}
namespace Md.HealthManager
{
	internal static class DeathEvent
	{
		internal static class Invoke
		{
			public delegate void PrefixSignature(DeathEvent self);

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

		internal static class _ctor
		{
		}

		internal static class BeginInvoke
		{
		}

		internal static class EndInvoke
		{
		}
	}
	internal static class _CheckPersistence_d__180
	{
		internal static class MoveNext
		{
			public delegate void PrefixSignature(object self);

			public delegate void PostfixSignature(object 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 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 (Type.GetType("HealthManager+<CheckPersistence>d__180, Assembly-CSharp") ?? throw new Exception("Missing Type: 'HealthManager+<CheckPersistence>d__180'")).GetMethod("MoveNext", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("HealthManager+<CheckPersistence>d__180", "MoveNext");
			}
		}

		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class Syst