using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BingoUI.Components;
using BingoUI.Counters;
using BingoUI.Data;
using CanvasUtil;
using GlobalEnums;
using Md.CollectableItemManager;
using Md.CollectableItemPickup;
using Md.CollectableRelicManager;
using Md.CurrencyCounter;
using Md.FullQuestBase;
using Md.HeroController;
using Md.PlayMakerNPC;
using Md.ToolItem;
using Md.UIManager;
using Microsoft.CodeAnalysis;
using MonoDetour;
using MonoDetour.Cil;
using MonoDetour.DetourTypes;
using MonoDetour.HookGen;
using MonoDetour.Reflection.Unspeakable;
using MonoMod.Utils;
using PrepatcherPlugin;
using Silksong.DataManager;
using Silksong.ModMenu.Elements;
using Silksong.ModMenu.Plugin;
using Silksong.ModMenu.Screens;
using Silksong.UnityHelper.Extensions;
using Silksong.UnityHelper.Util;
using TMProOld;
using TeamCherry.Localization;
using UnityEngine;
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("BingoUI")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.2.5.0")]
[assembly: AssemblyInformationalVersion("1.2.5+ea2c151166221cc19077756e37f40f0c3b0ce4d4")]
[assembly: AssemblyProduct("BingoUI")]
[assembly: AssemblyTitle("BingoUI")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/flibber-hk/Silksong.BingoUI")]
[assembly: NeutralResourcesLanguage("EN")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.5.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
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.PlayMakerNPC
{
	internal static class OnStartDialogue
	{
		public delegate void PrefixSignature(PlayMakerNPC self);

		public delegate void PostfixSignature(PlayMakerNPC 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(PlayMakerNPC).GetMethod("OnStartDialogue", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("PlayMakerNPC", "OnStartDialogue");
		}
	}
}
namespace Md.CollectableRelicManager
{
	internal static class GetAllRelics
	{
		public delegate void PrefixSignature();

		public delegate void PostfixSignature(ref IReadOnlyList<CollectableRelic> 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(CollectableRelicManager).GetMethod("GetAllRelics", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("CollectableRelicManager", "GetAllRelics");
		}
	}
	internal static class GetRelicData
	{
		public delegate void PrefixSignature(ref CollectableRelic relic);

		public delegate void PostfixSignature(ref CollectableRelic relic, ref Data 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(CollectableRelicManager).GetMethod("GetRelicData", (BindingFlags)(-1), null, new Type[1] { typeof(CollectableRelic) }, null) ?? throw new MissingMethodException("CollectableRelicManager", "GetRelicData");
		}
	}
	internal static class SetRelicData
	{
		public delegate void PrefixSignature(ref CollectableRelic relic, ref Data data);

		public delegate void PostfixSignature(ref CollectableRelic relic, ref Data data);

		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(CollectableRelicManager).GetMethod("SetRelicData", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(CollectableRelic),
				typeof(Data)
			}, null) ?? throw new MissingMethodException("CollectableRelicManager", "SetRelicData");
		}
	}
}
namespace Md.ToolItem
{
	internal static class Get
	{
		public delegate void PrefixSignature(ToolItem self, ref bool showPopup);

		public delegate void PostfixSignature(ToolItem self, ref bool showPopup);

		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(ToolItem).GetMethod("Get", (BindingFlags)(-1), null, new Type[1] { typeof(bool) }, null) ?? throw new MissingMethodException("ToolItem", "Get");
		}
	}
	internal static class Unlock
	{
		public delegate void PrefixSignature(ToolItem self, ref Action afterTutorialMsg, ref PopupFlags popupFlags);

		public delegate void PostfixSignature(ToolItem self, ref Action afterTutorialMsg, ref PopupFlags popupFlags);

		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(ToolItem).GetMethod("Unlock", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(Action),
				typeof(PopupFlags)
			}, null) ?? throw new MissingMethodException("ToolItem", "Unlock");
		}
	}
}
namespace Md.FullQuestBase
{
	internal static class Get
	{
		public delegate void PrefixSignature(FullQuestBase self, ref bool showPopup);

		public delegate void PostfixSignature(FullQuestBase self, ref bool showPopup);

		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(FullQuestBase).GetMethod("Get", (BindingFlags)(-1), null, new Type[1] { typeof(bool) }, null) ?? throw new MissingMethodException("FullQuestBase", "Get");
		}
	}
	internal static class TryEndQuest
	{
		public delegate void PrefixSignature(FullQuestBase self, ref Action afterPrompt, ref bool consumeCurrency, ref bool forceEnd, ref bool showPrompt);

		public delegate void PostfixSignature(FullQuestBase self, ref Action afterPrompt, ref bool consumeCurrency, ref bool forceEnd, ref bool showPrompt, 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 typeof(FullQuestBase).GetMethod("TryEndQuest", (BindingFlags)(-1), null, new Type[4]
			{
				typeof(Action),
				typeof(bool),
				typeof(bool),
				typeof(bool)
			}, null) ?? throw new MissingMethodException("FullQuestBase", "TryEndQuest");
		}
	}
	internal static class SilentlyComplete
	{
		public delegate void PrefixSignature(FullQuestBase self);

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

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

		public delegate void PostfixSignature(ref int amount, ref CurrencyType type);

		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(CurrencyCounter).GetMethod("Add", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(int),
				typeof(CurrencyType)
			}, null) ?? throw new MissingMethodException("CurrencyCounter", "Add");
		}
	}
	internal static class Take
	{
		public delegate void PrefixSignature(ref int amount, ref CurrencyType type);

		public delegate void PostfixSignature(ref int amount, ref CurrencyType type);

		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(CurrencyCounter).GetMethod("Take", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(int),
				typeof(CurrencyType)
			}, null) ?? throw new MissingMethodException("CurrencyCounter", "Take");
		}
	}
	internal static class Awake
	{
		public delegate void PrefixSignature(CurrencyCounter self);

		public delegate void PostfixSignature(CurrencyCounter 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(CurrencyCounter).GetMethod("Awake", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("CurrencyCounter", "Awake");
		}
	}
	internal static class Show
	{
		public delegate void PrefixSignature(ref CurrencyType type, ref bool setStackVisible);

		public delegate void PostfixSignature(ref CurrencyType type, ref bool setStackVisible);

		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(CurrencyCounter).GetMethod("Show", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(CurrencyType),
				typeof(bool)
			}, null) ?? throw new MissingMethodException("CurrencyCounter", "Show");
		}
	}
}
namespace Md.CurrencyCounterBase
{
	internal static class Start
	{
		public delegate void PrefixSignature(CurrencyCounterBase self);

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

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

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

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

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

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

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

		public delegate void PostfixMoveNextSignature(SpeakableEnumerator<object, UIManager> 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(UIManager).GetMethod("GoToPauseMenu", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("UIManager", "GoToPauseMenu");
		}

		public static MethodInfo StateMachineTarget()
		{
			return Extensions.GetStateMachineTarget((MethodInfo)Target());
		}
	}
	internal static class UIClosePauseMenu
	{
		public delegate void PrefixSignature(UIManager self);

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

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

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

		public delegate void PostfixMoveNextSignature(SpeakableEnumerator<object, UIManager> 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(UIManager).GetMethod("ReturnToMainMenu", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("UIManager", "ReturnToMainMenu");
		}

		public static MethodInfo StateMachineTarget()
		{
			return Extensions.GetStateMachineTarget((MethodInfo)Target());
		}
	}
	internal static class FadeInCanvasGroup
	{
		public delegate void PrefixSignature(UIManager self, ref CanvasGroup cg, ref bool alwaysActive);

		public delegate void PostfixSignature(UIManager self, ref CanvasGroup cg, ref bool alwaysActive, ref IEnumerator returnValue);

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

		public delegate void PostfixMoveNextSignature(SpeakableEnumerator<object, UIManager> 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(UIManager).GetMethod("FadeInCanvasGroup", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(CanvasGroup),
				typeof(bool)
			}, null) ?? throw new MissingMethodException("UIManager", "FadeInCanvasGroup");
		}

		public static MethodInfo StateMachineTarget()
		{
			return Extensions.GetStateMachineTarget((MethodInfo)Target());
		}
	}
	internal static class FadeOutCanvasGroup
	{
		public delegate void PrefixSignature(UIManager self, ref CanvasGroup cg, ref bool disable, ref bool stopBlocking);

		public delegate void PostfixSignature(UIManager self, ref CanvasGroup cg, ref bool disable, ref bool stopBlocking, ref IEnumerator returnValue);

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

		public delegate void PostfixMoveNextSignature(SpeakableEnumerator<object, UIManager> 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(UIManager).GetMethod("FadeOutCanvasGroup", (BindingFlags)(-1), null, new Type[3]
			{
				typeof(CanvasGroup),
				typeof(bool),
				typeof(bool)
			}, null) ?? throw new MissingMethodException("UIManager", "FadeOutCanvasGroup");
		}

		public static MethodInfo StateMachineTarget()
		{
			return Extensions.GetStateMachineTarget((MethodInfo)Target());
		}
	}
	internal static class Awake
	{
		public delegate void PrefixSignature(UIManager self);

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

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

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

		public delegate void PostfixSignature(CollectableItemPickup self, ref bool breakIfAtMax, 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 typeof(CollectableItemPickup).GetMethod("DoPickupAction", (BindingFlags)(-1), null, new Type[1] { typeof(bool) }, null) ?? throw new MissingMethodException("CollectableItemPickup", "DoPickupAction");
		}
	}
	internal static class Awake
	{
		public delegate void PrefixSignature(CollectableItemPickup self);

		public delegate void PostfixSignature(CollectableItemPickup 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(CollectableItemPickup).GetMethod("Awake", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("CollectableItemPickup", "Awake");
		}
	}
}
namespace Md.CollectableItemManager
{
	internal static class ItemAffectingDelegate
	{
		internal static class Invoke
		{
			public delegate void PrefixSignature(ItemAffectingDelegate self, ref Data data);

			public delegate void PostfixSignature(ItemAffectingDelegate self, ref Data data);

			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(ItemAffectingDelegate).GetMethod("Invoke", (BindingFlags)(-1), null, new Type[1] { typeof(Data).MakeByRefType() }, null) ?? throw new MissingMethodException("CollectableItemManager+ItemAffectingDelegate", "Invoke");
			}
		}
	}
	internal static class AffectItemData
	{
		public delegate void PrefixSignature(CollectableItemManager self, ref string itemName, ref ItemAffectingDelegate affector);

		public delegate void PostfixSignature(CollectableItemManager self, ref string itemName, ref ItemAffectingDelegate affector);

		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(CollectableItemManager).GetMethod("AffectItemData", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(string),
				typeof(ItemAffectingDelegate)
			}, null) ?? throw new MissingMethodException("CollectableItemManager", "AffectItemData");
		}
	}
	internal static class InternalAddItem
	{
		public delegate void PrefixSignature(CollectableItemManager self, ref CollectableItem item, ref int amount);

		public delegate void PostfixSignature(CollectableItemManager self, ref CollectableItem item, 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 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(CollectableItemManager).GetMethod("InternalAddItem", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(CollectableItem),
				typeof(int)
			}, null) ?? throw new MissingMethodException("CollectableItemManager", "InternalAddItem");
		}
	}
	internal static class InternalRemoveItem
	{
		public delegate void PrefixSignature(CollectableItemManager self, ref CollectableItem item, ref int amount);

		public delegate void PostfixSignature(CollectableItemManager self, ref CollectableItem item, 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 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(CollectableItemManager).GetMethod("InternalRemoveItem", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(CollectableItem),
				typeof(int)
			}, null) ?? throw new MissingMethodException("CollectableItemManager", "InternalRemoveItem");
		}
	}
	internal static class AddItem
	{
		public delegate void PrefixSignature(ref CollectableItem item, ref int amount);

		public delegate void PostfixSignature(ref CollectableItem item, 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 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(CollectableItemManager).GetMethod("AddItem", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(CollectableItem),
				typeof(int)
			}, null) ?? throw new MissingMethodException("CollectableItemManager", "AddItem");
		}
	}
	internal static class RemoveItem
	{
		public delegate void PrefixSignature(ref CollectableItem item, ref int amount);

		public delegate void PostfixSignature(ref CollectableItem item, 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 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(CollectableItemManager).GetMethod("RemoveItem", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(CollectableItem),
				typeof(int)
			}, null) ?? throw new MissingMethodException("CollectableItemManager", "RemoveItem");
		}
	}
	internal static class Awake
	{
		public delegate void PrefixSignature(CollectableItemManager self);

		public delegate void PostfixSignature(CollectableItemManager 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(CollectableItemManager).GetMethod("Awake", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("CollectableItemManager", "Awake");
		}
	}
}
namespace Md.HeroController
{
	internal static class HeroSetDelegate
	{
		internal static class Invoke
		{
			public delegate void PrefixSignature(HeroSetDelegate self, ref HeroController heroController);

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

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

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

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

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

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

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

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

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

			public static MethodBase Target()
			{
				return typeof(HeroInPosition).GetMethod("Invoke", (BindingFlags)(-1), null, new Type[1] { typeof(bool) }, null) ?? throw new MissingMethodException("HeroController+HeroInPosition", "Invoke");
			}
		}
	}
	internal static class DamageTakenDelegate
	{
		internal static class Invoke
		{
			public delegate void PrefixSignature(DamageTakenDelegate self, ref DamageInfo damageInfo);

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

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

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

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

			public static MethodBase Target()
			{
				return typeof(DamageTakenDelegate).GetMethod("Invoke", (BindingFlags)(-1), null, new Type[1] { typeof(DamageInfo) }, null) ?? throw new MissingMethodException("HeroController+DamageTakenDelegate", "Invoke");
			}
		}
	}
	internal static class ConfigGroup
	{
		internal static class Setup
		{
			public delegate void PrefixSignature(ConfigGroup self);

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

		public delegate void PostfixSignature(HeroController self);

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

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

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

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

		public delegate void PostfixSignature(HeroController self);

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

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

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

		public static MethodBase Target()
		{
			return typeof(HeroController).GetMethod("Awake", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("HeroController", "Awake");
		}
	}
}
namespace MonoDetour.HookGen
{
	internal static class DefaultMonoDetourManager
	{
		internal static MonoDetourManager Instance { get; } = New();


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

		public bool IncludeNestedTypes { get; set; }

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

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

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

		public bool GenerateControlFlowVariants { get; set; }

		public MonoDetourTargetsAttribute(Type? targetType = null)
		{
			TargetType = targetType;
			IncludeNestedTypes = true;
			base..ctor();
		}
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace BingoUI
{
	public abstract class AbstractCounter
	{
		public string SpriteName { get; private set; }

		protected virtual bool CounterDisplayEnabled => true;

		internal bool IsCounterDisplayEnabled
		{
			get
			{
				if (!CounterDisplayEnabled)
				{
					return false;
				}
				Dictionary<string, ConfigEntry<bool>>? counterSettings = ConfigSettings.CounterSettings;
				if (counterSettings != null && counterSettings.TryGetValue(SpriteName, out ConfigEntry<bool> value))
				{
					return value.Value;
				}
				return true;
			}
		}

		internal static event Action<string, ShowRule>? OnUpdateText;

		protected AbstractCounter(string spriteName)
		{
			SpriteName = spriteName;
			base..ctor();
		}

		public abstract string GetText();

		public abstract void SetupHooks();

		protected internal void UpdateText(ShowRule showRule = ShowRule.Default)
		{
			AbstractCounter.OnUpdateText?.Invoke(SpriteName, showRule);
		}

		protected void UpdateTextNextFrame(ShowRule showRule = ShowRule.Default)
		{
			UnityExtensions.InvokeNextFrame((MonoBehaviour)(object)BingoUIPlugin.Instance, (Action)delegate
			{
				UpdateText(showRule);
			});
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[MonoDetourTargets(typeof(UIManager))]
	[MonoDetourTargets(typeof(HeroController))]
	[BepInPlugin("io.github.flibber-hk.bingoui", "BingoUI", "1.2.5")]
	public class BingoUIPlugin : BaseUnityPlugin, ISaveDataMod<SaveData>, ISaveDataMod, IModMenuCustomMenu, IModMenuInterface
	{
		[CompilerGenerated]
		private sealed class <<AfterPause>g__Wrapped|13_0>d : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public IEnumerator orig;

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

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

			[DebuggerHidden]
			public <<AfterPause>g__Wrapped|13_0>d(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = orig;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (ConfigSettings.AlwaysDisplayCounters || ConfigSettings.NeverDisplayCounters)
					{
						return false;
					}
					if (Instance._canvasManager != null)
					{
						Instance._canvasManager.FadeInAll();
					}
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <<TakedownCanvas>g__Wrapped|11_0>d : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public IEnumerator orig;

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

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

			[DebuggerHidden]
			public <<TakedownCanvas>g__Wrapped|11_0>d(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = orig;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					Instance._canvasManager?.Dispose();
					Instance._canvasManager = null;
					return false;
				}
			}

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

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

		internal CounterManager CounterManager;

		private CanvasManager? _canvasManager;

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

		public static BingoUIPlugin Instance { get; private set; }

		SaveData? ISaveDataMod<SaveData>.SaveData
		{
			get
			{
				return SaveData.Instance;
			}
			set
			{
				SaveData.Instance = value;
			}
		}

		public static string Name => "BingoUI";

		public static string Version => "1.2.5";

		private void Awake()
		{
			Instance = this;
			CounterManager = new CounterManager();
			ConfigSettings.Setup(((BaseUnityPlugin)this).Config, CounterManager);
			CurrencyTracker.Hook();
			Md.HeroController.Start.Postfix(SetupCanvas);
			GoToPauseMenu.Postfix(AfterPause);
			UIClosePauseMenu.Postfix(AfterUnpause);
			ReturnToMainMenu.Postfix(TakedownCanvas);
			SceneManager.sceneLoaded += OnSceneLoaded;
			((BaseUnityPlugin)this).Config.SettingChanged += OnConfigSettingChanged;
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Plugin " + Name + " (io.github.flibber-hk.bingoui) has loaded!"));
		}

		private void OnConfigSettingChanged(object sender, SettingChangedEventArgs e)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Invalid comparison between Unknown and I4
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Invalid comparison between Unknown and I4
			if (e.ChangedSetting.Definition.Section.StartsWith("Counters") && ((int)UIManager.instance.uiState == 5 || (int)UIManager.instance.uiState == 4))
			{
				SetupCanvas();
			}
		}

		private void TakedownCanvas(UIManager self, ref IEnumerator returnValue)
		{
			returnValue = Wrapped(returnValue);
			[IteratorStateMachine(typeof(<<TakedownCanvas>g__Wrapped|11_0>d))]
			static IEnumerator Wrapped(IEnumerator orig)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <<TakedownCanvas>g__Wrapped|11_0>d(0)
				{
					orig = orig
				};
			}
		}

		private void AfterUnpause(UIManager self)
		{
			if (!ConfigSettings.AlwaysDisplayCounters && _canvasManager != null)
			{
				_canvasManager.FadeOutAll();
			}
		}

		private void AfterPause(UIManager self, ref IEnumerator returnValue)
		{
			returnValue = Wrapped(returnValue);
			[IteratorStateMachine(typeof(<<AfterPause>g__Wrapped|13_0>d))]
			static IEnumerator Wrapped(IEnumerator orig)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <<AfterPause>g__Wrapped|13_0>d(0)
				{
					orig = orig
				};
			}
		}

		private void SetupCanvas(HeroController self)
		{
			SetupCanvas();
		}

		private void SetupCanvas()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			_canvasManager?.Dispose();
			_canvasManager = new CanvasManager();
			if (!ConfigSettings.NeverDisplayCounters && (int)UIManager.instance.uiState == 5)
			{
				_canvasManager.FadeInAll();
			}
		}

		private void OnSceneLoaded(Scene arg0, LoadSceneMode arg1)
		{
			if (_canvasManager != null && !ConfigSettings.AlwaysDisplayCounters)
			{
				_canvasManager.FadeOutAll();
			}
		}

		AbstractMenuScreen IModMenuCustomMenu.BuildCustomMenu()
		{
			return Menu.GenerateMenu();
		}

		string IModMenuInterface.ModMenuName()
		{
			return "BingoUI";
		}
	}
	internal class CanvasManager : IDisposable
	{
		private class CounterData
		{
			public required CanvasGroup CanvasGroup { get; set; }

			public required Text Text { get; set; }

			public DateTime NextCanvasFade { get; set; } = DateTime.MinValue;

		}

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

			private object <>2__current;

			public CanvasGroup cg;

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

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

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

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

			private bool MoveNext()
			{
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (ConfigSettings.AlwaysDisplayCounters || ConfigSettings.NeverDisplayCounters)
					{
						return false;
					}
					if (!((Component)cg).gameObject.activeSelf)
					{
						FadeIn(cg);
					}
					<>2__current = (object)new WaitForSeconds(4f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					FadeOut(cg);
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <GetDefaultPositions>d__4 : IEnumerable<Vector2>, IEnumerable, IEnumerator<Vector2>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private Vector2 <>2__current;

			private int <>l__initialThreadId;

			private float <y>5__2;

			private int <x>5__3;

			Vector2 IEnumerator<Vector2>.Current
			{
				[DebuggerHidden]
				get
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					return <>2__current;
				}
			}

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

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

			private bool MoveNext()
			{
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					<x>5__3--;
					goto IL_006c;
				}
				<>1__state = -1;
				<y>5__2 = 0.01f;
				goto IL_0087;
				IL_006c:
				if (<x>5__3 >= 0)
				{
					<>2__current = new Vector2((float)<x>5__3 / 15f, <y>5__2);
					<>1__state = 1;
					return true;
				}
				<y>5__2 += 0.11f;
				goto IL_0087;
				IL_0087:
				if (<y>5__2 < 0.9f)
				{
					<x>5__3 = 14;
					goto IL_006c;
				}
				return false;
			}

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

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

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

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

		private GameObject _canvas;

		private Dictionary<string, CounterData> _canvasPanels;

		public CanvasManager()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			_canvas = CanvasUtil.CreateCanvas((RenderMode)1, new Vector2(1920f, 1080f));
			Object.DontDestroyOnLoad((Object)(object)_canvas);
			AbstractCounter.OnUpdateText += OnUpdateText;
			_canvasPanels = new Dictionary<string, CounterData>();
			using IEnumerator<Vector2> enumerator2 = GetDefaultPositions().GetEnumerator();
			foreach (AbstractCounter value2 in BingoUIPlugin.Instance.CounterManager.Counters.Values)
			{
				if (value2.IsCounterDisplayEnabled)
				{
					enumerator2.MoveNext();
					Vector2 current2 = enumerator2.Current;
					CounterData value = SetupCanvasIcon(value2, current2);
					_canvasPanels[value2.SpriteName] = value;
				}
			}
		}

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

		public void Dispose()
		{
			AbstractCounter.OnUpdateText -= OnUpdateText;
			Object.Destroy((Object)(object)_canvas);
		}

		private CounterData SetupCanvasIcon(AbstractCounter counter, Vector2 position)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Expected O, but got Unknown
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CanvasUtil.CreateImagePanel(_canvas, SpriteUtil.LoadEmbeddedSprite(GetType().Assembly, "BingoUI.Resources.Images." + counter.SpriteName + ".png", 64f, (Vector2?)null, false), new RectData(Vector2.zero, Vector2.zero, position, position + new Vector2(1f / 15f, 0.1f)));
			CanvasGroup val = obj.AddComponent<CanvasGroup>();
			val.blocksRaycasts = false;
			val.interactable = false;
			if (!ConfigSettings.AlwaysDisplayCounters)
			{
				((Component)val).gameObject.SetActive(false);
			}
			Text component = CanvasUtil.CreateTextPanel(obj, string.Empty, 23, (TextAnchor)7, new RectData(Vector2.zero, Vector2.zero, Vector2.zero, Vector2.one), true).GetComponent<Text>();
			((Graphic)component).color = Color.black;
			return new CounterData
			{
				CanvasGroup = val,
				Text = component
			};
		}

		public void OnUpdateText(string key, ShowRule showRule)
		{
			if (!BingoUIPlugin.Instance.CounterManager.Counters.TryGetValue(key, out AbstractCounter value) || !_canvasPanels.TryGetValue(value.SpriteName, out CounterData value2))
			{
				return;
			}
			string text = value.GetText();
			if (!(value2.Text.text == text) || showRule == ShowRule.ForceShow)
			{
				value2.Text.text = text;
				if (showRule != ShowRule.DontShow && DateTime.Now >= value2.NextCanvasFade)
				{
					((MonoBehaviour)BingoUIPlugin.Instance).StartCoroutine(FadeCanvas(value2.CanvasGroup));
					value2.NextCanvasFade = DateTime.Now.AddSeconds(0.5);
				}
			}
		}

		public void FadeInAll()
		{
			foreach (var (key, counterData2) in _canvasPanels)
			{
				counterData2.Text.text = BingoUIPlugin.Instance.CounterManager.Counters[key].GetText();
				FadeIn(counterData2.CanvasGroup);
			}
		}

		public void FadeOutAll()
		{
			foreach (CounterData value in _canvasPanels.Values)
			{
				FadeOut(value.CanvasGroup);
			}
		}

		[IteratorStateMachine(typeof(<FadeCanvas>d__10))]
		private static IEnumerator FadeCanvas(CanvasGroup cg)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FadeCanvas>d__10(0)
			{
				cg = cg
			};
		}

		private static void FadeIn(CanvasGroup cg)
		{
			((MonoBehaviour)BingoUIPlugin.Instance).StartCoroutine(CanvasUtil.FadeInCanvasGroup(cg));
		}

		private static void FadeOut(CanvasGroup cg)
		{
			((MonoBehaviour)BingoUIPlugin.Instance).StartCoroutine(CanvasUtil.FadeOutCanvasGroup(cg));
		}
	}
	public class CounterManager
	{
		public Dictionary<string, AbstractCounter> Counters { get; }

		public static string GetDisplayName(string spriteKey)
		{
			return spriteKey switch
			{
				"flea" => "Fleas", 
				"maps" => "Maps", 
				"lockets" => "Lockets", 
				"alltools" => "All Tools", 
				"redtools" => "Red Tools", 
				"yellowtools" => "Yellow Tools", 
				"bluetools" => "Blue Tools", 
				"allquest" => "All Quests", 
				"deliveryquest" => "Delivery Quests", 
				"donationquest" => "Donation Quests", 
				"huntquest" => "Hunt Quests", 
				"gatherquest" => "Gather Quests", 
				"wayfarerquest" => "Wayfarer Quests", 
				"shardbundles" => "Shard Bundles", 
				"beastshards" => "Beast Shards", 
				"strings" => "Rosary Strings", 
				"necklaces" => "Rosary Necklaces", 
				"mapper" => "Shakra Scenes", 
				"silkeater" => "Silkeaters", 
				"bonescroll" => "Bone Scrolls", 
				"choralcommandment" => "Choral Commandments", 
				"craftmetal" => "Craftmetal", 
				"psalmcylinder" => "Psalm Cylinders", 
				"relics" => "Relics", 
				"runeharp" => "Rune Harps", 
				"weavereffigy" => "Weaver Effigies", 
				"rosaries" => "Spent Rosaries", 
				_ => spriteKey, 
			};
		}

		private static List<AbstractCounter> GenerateDefaultCounters()
		{
			return new List<AbstractCounter>(27)
			{
				new FleaCounter("flea"),
				new MapCounter("maps"),
				new LocketCounter("lockets"),
				new ToolTypeCounter("alltools", (OwnToolsCheckFlags)7),
				new ToolTypeCounter("redtools", (OwnToolsCheckFlags)1),
				new ToolTypeCounter("yellowtools", (OwnToolsCheckFlags)4),
				new ToolTypeCounter("bluetools", (OwnToolsCheckFlags)2),
				new QuestCounter("allquest", "TYPE_"),
				new QuestCounter("donationquest", "TYPE_DONATE_"),
				new QuestCounter("huntquest", "TYPE_HUNT_"),
				new QuestCounter("gatherquest", "TYPE_GATHER_"),
				new QuestCounter("wayfarerquest", "TYPE_WAYFARER_"),
				new DeliveryQuestCounter("deliveryquest"),
				new PickedConsumableCounter("shardbundles", new HashSet<string> { "Shard Pouch" }),
				new PickedConsumableCounter("beastshards", new HashSet<string> { "Great Shard" }),
				new PickedConsumableCounter("strings", new HashSet<string> { "Rosary_Set_Small", "Rosary_Set_Frayed" }),
				new PickedConsumableCounter("necklaces", new HashSet<string> { "Rosary_Set_Huge_White", "Rosary_Set_Medium", "Rosary_Set_Large" }),
				new ShakraLocationsCounter("mapper"),
				new RelicCounter("relics", RelicTypes.AnyRelic, showDistinct: true),
				new RelicCounter("bonescroll", RelicTypes.BoneScroll, showDistinct: false),
				new RelicCounter("choralcommandment", RelicTypes.ChoralCommandment, showDistinct: false),
				new RelicCounter("runeharp", RelicTypes.RuneHarp, showDistinct: false),
				new RelicCounter("weavereffigy", RelicTypes.WeaverEffigy, showDistinct: false),
				new RelicCounter("psalmcylinder", RelicTypes.AnyCylinder, showDistinct: false),
				new TrackedItemCounter("craftmetal", "Tool Metal"),
				new TrackedItemCounter("silkeater", "Silk Grub"),
				new RosaryCounter("rosaries")
			};
		}

		public CounterManager()
		{
			Counters = new Dictionary<string, AbstractCounter>();
			foreach (AbstractCounter item in GenerateDefaultCounters())
			{
				Counters[item.SpriteName] = item;
			}
			foreach (AbstractCounter value in Counters.Values)
			{
				value.SetupHooks();
				value.UpdateText();
			}
		}
	}
	[MonoDetourTargets(typeof(CurrencyCounterBase))]
	[MonoDetourTargets(typeof(CurrencyCounter))]
	public static class CurrencyTracker
	{
		private static readonly MonoDetourManager currencyMgr = new MonoDetourManager("BingoUI.Currency");

		internal static void Hook()
		{
			Take.Postfix(RecordSpentCurrency, null, applyByDefault: true, currencyMgr);
			Md.CurrencyCounter.Awake.Postfix(AddCurrencyTrackers, null, applyByDefault: true, currencyMgr);
		}

		private static void AddCurrencyTrackers(CurrencyCounter self)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if ((int)self.currencyType == 0)
			{
				((Component)self).gameObject.AddComponent<CurrencyCounterModifier>();
			}
		}

		private static void RecordSpentCurrency(ref int amount, ref CurrencyType type)
		{
			int currencySpent = GetCurrencySpent(type);
			currencySpent += amount;
			SaveData.Instance.SpentCurrency[type] = currencySpent;
		}

		internal static int GetCurrencySpent(CurrencyType type)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!SaveData.Instance.SpentCurrency.TryGetValue(type, out var value))
			{
				return 0;
			}
			return value;
		}
	}
	public enum ShowRule
	{
		Default,
		ForceShow,
		DontShow
	}
	public enum DisplayMode
	{
		[Description("Show and hide counters")]
		Default,
		[Description("Show counters when possible")]
		AlwaysDisplay,
		[Description("Never show counters")]
		NeverDisplay
	}
	[Flags]
	public enum RelicTypes
	{
		Unknown = 0,
		ArcaneEgg = 1,
		BoneScroll = 2,
		ChoralCommandment = 4,
		RuneHarp = 8,
		WeaverEffigy = 0x10,
		PsalmCylinder = 0x20,
		SacredCylinder = 0x40,
		AnyRelic = 0x1F,
		AnyCylinder = 0x60,
		Any = 0x7F
	}
	internal static class Extensions
	{
		public static void Increment<TKey>(this Dictionary<TKey, int> data, TKey key, int value = 1)
		{
			int amount = data.GetAmount(key);
			data[key] = amount + value;
		}

		public static int GetAmount<TKey>(this Dictionary<TKey, int> data, TKey key)
		{
			if (data.TryGetValue(key, out var value))
			{
				return value;
			}
			return 0;
		}

		public static int GetTotalAmount<TKey>(this Dictionary<TKey, int> data, IEnumerable<TKey> keys)
		{
			Dictionary<TKey, int> data2 = data;
			return keys.Select((TKey key) => data2.GetAmount(key)).Sum();
		}
	}
}
namespace BingoUI.Data
{
	public static class ConfigSettings
	{
		public static ConfigEntry<bool>? ShowSpentRosariesInHud;

		public static ConfigEntry<bool>? ShowSpentRosariesInInventory;

		public static ConfigEntry<DisplayMode>? CounterDisplayMode;

		public static Dictionary<string, ConfigEntry<bool>>? CounterSettings;

		public static bool AlwaysDisplayCounters
		{
			get
			{
				ConfigEntry<DisplayMode>? counterDisplayMode = CounterDisplayMode;
				if (counterDisplayMode == null)
				{
					return false;
				}
				return counterDisplayMode.Value == DisplayMode.AlwaysDisplay;
			}
		}

		public static bool NeverDisplayCounters
		{
			get
			{
				ConfigEntry<DisplayMode>? counterDisplayMode = CounterDisplayMode;
				if (counterDisplayMode == null)
				{
					return false;
				}
				return counterDisplayMode.Value == DisplayMode.NeverDisplay;
			}
		}

		public static void Setup(ConfigFile config, CounterManager counterManager)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			ShowSpentRosariesInHud = config.Bind<bool>("Currency", "ShowSpentRosariesInHud", true, "Show spent rosaries in HUD");
			ShowSpentRosariesInInventory = config.Bind<bool>("Currency", "ShowSpentRosariesInInventory", true, "Show spent rosaries in inventory");
			CounterDisplayMode = config.Bind<DisplayMode>("Counters", "CounterDisplayMode", DisplayMode.Default, new ConfigDescription("When to display counters", (AcceptableValueBase)null, new object[1] { MenuElementGenerators.CreateRightDescGenerator(true) }));
			CounterSettings = new Dictionary<string, ConfigEntry<bool>>();
			foreach (string key in counterManager.Counters.Keys)
			{
				string displayName = CounterManager.GetDisplayName(key);
				CounterSettings[key] = config.Bind<bool>("Counters.Individual", displayName, key != "rosaries", "Show counter: " + displayName);
			}
		}
	}
	internal static class Menu
	{
		public static AbstractMenuScreen GenerateMenu()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Expected O, but got Unknown
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Expected O, but got Unknown
			ConfigEntryFactory val = new ConfigEntryFactory();
			List<MenuElement> list = new List<MenuElement>();
			List<MenuElement> list2 = new List<MenuElement>();
			MenuElement val6 = default(MenuElement);
			foreach (var (val4, val5) in ((BaseUnityPlugin)BingoUIPlugin.Instance).Config)
			{
				if (val.GenerateMenuElement(val5, ref val6) && val6 != null)
				{
					if (val4.Section == "Counters.Individual")
					{
						list2.Add(val6);
					}
					else
					{
						list.Add(val6);
					}
				}
			}
			PaginatedMenuScreenBuilder val7 = new PaginatedMenuScreenBuilder("Counter Toggles", 8);
			val7.AddRange((IEnumerable<MenuElement>)list2);
			AbstractMenuScreen subPage = (AbstractMenuScreen)(object)val7.Build();
			MenuElement item = (MenuElement)new TextButton("Counter Toggles")
			{
				OnSubmit = delegate
				{
					MenuScreenNavigation.Show(subPage, (HistoryMode)0);
				}
			};
			list.Add(item);
			SimpleMenuScreen val8 = new SimpleMenuScreen("BingoUI");
			val8.AddRange((IEnumerable<MenuElement>)list);
			return (AbstractMenuScreen)val8;
		}
	}
	public class SaveData
	{
		private static SaveData? _instance;

		public static SaveData Instance
		{
			get
			{
				if (_instance == null)
				{
					_instance = new SaveData();
				}
				return _instance;
			}
			[param: AllowNull]
			internal set
			{
				_instance = value;
			}
		}

		public Dictionary<CurrencyType, int> SpentCurrency { get; set; } = new Dictionary<CurrencyType, int>
		{
			[(CurrencyType)0] = 0,
			[(CurrencyType)1] = 0
		};


		public Dictionary<string, int> PickedShinies { get; set; } = new Dictionary<string, int>();


		public Dictionary<string, int> ItemsEverObtained { get; set; } = new Dictionary<string, int>();


		public HashSet<string> ShakraScenes { get; set; } = new HashSet<string>();


		public Dictionary<string, int> DeliveryQuestsCompleted { get; set; } = new Dictionary<string, int>();

	}
}
namespace BingoUI.Counters
{
	[MonoDetourTargets(typeof(FullQuestBase))]
	public class DeliveryQuestCounter : AbstractCounter
	{
		public DeliveryQuestCounter(string spriteName)
			: base(spriteName)
		{
		}

		public override void SetupHooks()
		{
			TryEndQuest.Postfix(OnCompleteQuest);
		}

		private void OnCompleteQuest(FullQuestBase self, ref Action afterPrompt, ref bool consumeCurrency, ref bool forceEnd, ref bool showPrompt, ref bool returnValue)
		{
			if (returnValue && ((BasicQuestBase)self).QuestType.displayName.Key.StartsWith("TYPE_COURIER_"))
			{
				string name = ((Object)self).name;
				int value;
				int num = (SaveData.Instance.DeliveryQuestsCompleted.