using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GlobalEnums;
using Md.AudioManager;
using Md.GameManager;
using Md.QuitToMenu;
using Microsoft.CodeAnalysis;
using MonoDetour;
using MonoDetour.Cil;
using MonoDetour.DetourTypes;
using MonoDetour.HookGen;
using MonoDetour.Reflection.Unspeakable;
using MonoMod.Utils;
using MusicRando.Cache;
using MusicRando.MusicSelectionStrategies;
using Newtonsoft.Json;
using Silksong.AssetHelper.Core;
using Silksong.AssetHelper.ManagedAssets;
using Silksong.ModMenu.Plugin;
using UnityEngine;
using UnityEngine.ResourceManagement.ResourceLocations;

[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("MusicRando")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.2.0")]
[assembly: AssemblyInformationalVersion("0.1.2+6beca92a7da41451cc7a5ba55100ed84813d1b59")]
[assembly: AssemblyProduct("MusicRando")]
[assembly: AssemblyTitle("MusicRando")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/flibber-hk/Silksong.MusicRando")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.2.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.AudioManager
{
	internal static class Start
	{
		public delegate void PrefixSignature(AudioManager self);

		public delegate void PostfixSignature(AudioManager 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(AudioManager).GetMethod("Start", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("AudioManager", "Start");
		}
	}
	internal static class ApplyMusicCue
	{
		public delegate void PrefixSignature(AudioManager self, ref MusicCue musicCue, ref float delayTime, ref float transitionTime, ref bool applySnapshot);

		public delegate void PostfixSignature(AudioManager self, ref MusicCue musicCue, ref float delayTime, ref float transitionTime, ref bool applySnapshot);

		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(AudioManager).GetMethod("ApplyMusicCue", (BindingFlags)(-1), null, new Type[4]
			{
				typeof(MusicCue),
				typeof(float),
				typeof(float),
				typeof(bool)
			}, null) ?? throw new MissingMethodException("AudioManager", "ApplyMusicCue");
		}
	}
}
namespace Md.QuitToMenu
{
	internal static class Start
	{
		public delegate void PrefixSignature(QuitToMenu self);

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

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

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

		public static MethodInfo StateMachineTarget()
		{
			return Extensions.GetStateMachineTarget((MethodInfo)Target());
		}
	}
}
namespace Md.GameManager
{
	internal static class ContinueGame
	{
		public delegate void PrefixSignature(GameManager self);

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

		public delegate void PostfixSignature(GameManager self, ref bool permadeathMode, ref bool bossRushMode);

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

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

			public delegate void PostfixSignature(PausedEvent self, ref bool isPaused);

			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(PausedEvent).GetMethod("Invoke", (BindingFlags)(-1), null, new Type[1] { typeof(bool) }, null) ?? throw new MissingMethodException("GameManager+PausedEvent", "Invoke");
			}
		}
	}
	internal static class GameStateEvent
	{
		internal static class Invoke
		{
			public delegate void PrefixSignature(GameStateEvent self, ref GameState gameState);

			public delegate void PostfixSignature(GameStateEvent self, ref GameState gameState);

			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(GameStateEvent).GetMethod("Invoke", (BindingFlags)(-1), null, new Type[1] { typeof(GameState) }, null) ?? throw new MissingMethodException("GameManager+GameStateEvent", "Invoke");
			}
		}
	}
	internal static class BossLoad
	{
		internal static class Invoke
		{
			public delegate void PrefixSignature(BossLoad self);

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

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

			public delegate void PostfixSignature(SceneTransitionFinishEvent 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(SceneTransitionFinishEvent).GetMethod("Invoke", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("GameManager+SceneTransitionFinishEvent", "Invoke");
			}
		}
	}
	internal static class SceneTransitionBeganDelegate
	{
		internal static class Invoke
		{
			public delegate void PrefixSignature(SceneTransitionBeganDelegate self, ref SceneLoad sceneLoad);

			public delegate void PostfixSignature(SceneTransitionBeganDelegate self, ref SceneLoad sceneLoad);

			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(SceneTransitionBeganDelegate).GetMethod("Invoke", (BindingFlags)(-1), null, new Type[1] { typeof(SceneLoad) }, null) ?? throw new MissingMethodException("GameManager+SceneTransitionBeganDelegate", "Invoke");
			}
		}
	}
}
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 MusicRando
{
	internal static class ConfigSettings
	{
		public static ConfigEntry<RandomizationStrategyOption>? MusicRandomization;

		public static void Init(ConfigFile config)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			MusicRandomization = config.Bind<RandomizationStrategyOption>("General", "MusicRandomization", RandomizationStrategyOption.OnChange, new ConfigDescription("When to randomize the music", (AcceptableValueBase)null, new object[1] { MenuElementGenerators.CreateRightDescGenerator(false) }));
		}
	}
	public enum RandomizationStrategyOption
	{
		[Description("Randomize whenever the music changes")]
		OnChange,
		[Description("Randomize more often than usual")]
		Chaos,
		[Description("Select a song dependent on the vanilla song")]
		Consistent,
		[Description("Randomly decide when to randomize the music")]
		RandoRando,
		[Description("Do not randomize music")]
		Disabled
	}
	public enum MusicAction
	{
		Ignore,
		Replay,
		Randomize
	}
	[MonoDetourTargets(typeof(GameManager))]
	[MonoDetourTargets(typeof(QuitToMenu))]
	internal static class GameEvents
	{
		private static readonly string Id = "MusicRando.GameEvents";

		private static readonly MonoDetourManager mgr = new MonoDetourManager(Id);

		public static bool IsInGame { get; private set; }

		public static event Action? OnEnterGame;

		public static event Action? OnQuitToMenu;

		internal static void Hook()
		{
			ContinueGame.Postfix(AfterContinueGame, null, applyByDefault: true, mgr);
			StartNewGame.Postfix(AfterStartNewGame, null, applyByDefault: true, mgr);
			Md.QuitToMenu.Start.Postfix(AfterQuitGame, null, applyByDefault: true, mgr);
		}

		private static void AfterQuitGame(QuitToMenu self, ref IEnumerator returnValue)
		{
			AfterGameExit();
		}

		private static void AfterStartNewGame(GameManager self, ref bool permadeathMode, ref bool bossRushMode)
		{
			AfterGameEnter();
		}

		private static void AfterContinueGame(GameManager self)
		{
			AfterGameEnter();
		}

		private static void AfterGameEnter()
		{
			IsInGame = true;
			Delegate[] array = GameEvents.OnEnterGame?.GetInvocationList() ?? Array.Empty<Action>();
			for (int i = 0; i < array.Length; i++)
			{
				((Action)array[i])?.Invoke();
			}
		}

		private static void AfterGameExit()
		{
			IsInGame = false;
			Delegate[] array = GameEvents.OnQuitToMenu?.GetInvocationList() ?? Array.Empty<Action>();
			for (int i = 0; i < array.Length; i++)
			{
				((Action)array[i])?.Invoke();
			}
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[MonoDetourTargets(typeof(AudioManager))]
	[BepInPlugin("io.github.flibber-hk.musicrando", "MusicRando", "0.1.2")]
	public class MusicRandoPlugin : BaseUnityPlugin
	{
		private ManagedResourceLocation<MusicCue>? _lastMusicCueLocation;

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

		private static Dictionary<RandomizationStrategyOption, SelectionStrategy> Strategies { get; set; }

		internal static ManualLogSource InstanceLogger { get; private set; }

		public static string Name => "MusicRando";

		public static string Version => "0.1.2";

		private void Awake()
		{
			InstanceLogger = ((BaseUnityPlugin)this).Logger;
			ConfigSettings.Init(((BaseUnityPlugin)this).Config);
			GameEvents.Hook();
			Strategies = new Dictionary<RandomizationStrategyOption, SelectionStrategy>
			{
				[RandomizationStrategyOption.OnChange] = new OnChangeSelectionStrategy(),
				[RandomizationStrategyOption.Chaos] = new ChaosSelectionStrategy(),
				[RandomizationStrategyOption.Consistent] = new ConsistentSelectionStrategy(),
				[RandomizationStrategyOption.RandoRando] = new RandoRandoSelectionStrategy(),
				[RandomizationStrategyOption.Disabled] = new DisabledSelectionStrategy()
			};
			ConfigEntry<RandomizationStrategyOption>? musicRandomization = ConfigSettings.MusicRandomization;
			if (musicRandomization != null)
			{
				musicRandomization.SettingChanged += delegate
				{
					SelectionStrategy.Reset();
					_lastMusicCueLocation = null;
					if (Strategies.TryGetValue(ConfigSettings.MusicRandomization.Value, out SelectionStrategy value))
					{
						value.InitStrategy();
					}
				};
			}
			AddressablesData.InvokeAfterAddressablesLoaded((Action)FindAudioCues);
			ApplyMusicCue.Prefix(OnApplyMusicCue);
			GameEvents.OnQuitToMenu += OnQuitToMenu;
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Plugin " + Name + " (io.github.flibber-hk.musicrando) has loaded!"));
		}

		private void OnApplyMusicCue(AudioManager self, ref MusicCue musicCue, ref float delayTime, ref float transitionTime, ref bool applySnapshot)
		{
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			RandomizationStrategyOption key = ConfigSettings.MusicRandomization?.Value ?? RandomizationStrategyOption.OnChange;
			ManagedResourceLocation<MusicCue> location;
			MusicAction musicAction = Strategies[key].Select(musicCue, out location);
			if (location != null && !location.IsLoaded)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Failed to apply music cue: not loaded");
				musicAction = MusicAction.Ignore;
			}
			if (musicAction == MusicAction.Replay)
			{
				if (_lastMusicCueLocation != null)
				{
					((BaseUnityPlugin)this).Logger.LogInfo((object)("Re-applying " + ((Object)_lastMusicCueLocation.Handle.Result).name + ", over " + ((Object)musicCue).name));
					musicCue = _lastMusicCueLocation.Handle.Result;
					return;
				}
				musicAction = MusicAction.Ignore;
			}
			if (musicAction != 0)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)("Applying " + ((Object)location.Handle.Result).name + " over " + ((Object)musicCue).name));
				_lastMusicCueLocation = location;
				musicCue = location.Handle.Result;
			}
		}

		private void OnQuitToMenu()
		{
			SelectionStrategy.Reset();
			_lastMusicCueLocation = null;
			foreach (SelectionStrategy value in Strategies.Values)
			{
				value.InitStrategy();
			}
		}

		private void FindAudioCues()
		{
			Stopwatch stopwatch = Stopwatch.StartNew();
			List<string> cached = CacheManager.GetCached("musicrando.musiccues.json", Version, "0.1.0", GetMusicCuePrimaryKeys);
			List<IResourceLocation> list = new List<IResourceLocation>();
			IList<IResourceLocation> collection = default(IList<IResourceLocation>);
			foreach (string item in cached)
			{
				if (AddressablesData.MainLocator.Locate((object)item, typeof(MusicCue), ref collection))
				{
					list.AddRange(collection);
				}
			}
			SelectionStrategy.SetResourceLocations(list);
			stopwatch.Stop();
			((BaseUnityPlugin)this).Logger.LogInfo((object)$"Prepared music cue locations in {stopwatch.ElapsedMilliseconds} ms");
		}

		private List<string> GetMusicCuePrimaryKeys()
		{
			List<string> list = new List<string>();
			IList<IResourceLocation> list2 = default(IList<IResourceLocation>);
			foreach (string item in AddressablesData.MainLocator.Keys.OfType<string>())
			{
				if (AddressablesData.MainLocator.Locate((object)item, typeof(MusicCue), ref list2))
				{
					list.Add(item);
				}
			}
			return list;
		}
	}
	internal static class RngExt
	{
		public static T Choose<T>(this Random rng, IList<T> things)
		{
			int index = rng.Next(things.Count);
			return things[index];
		}

		public static T Choose<T>(this Random rng, IList<T> things, Func<T, bool> predicate)
		{
			List<T> things2 = things.Where(predicate).ToList();
			return rng.Choose(things2);
		}
	}
}
namespace MusicRando.MusicSelectionStrategies
{
	internal class ChaosSelectionStrategy : SelectionStrategy
	{
		protected override bool TrySelect(MusicCue origToPlay, out string? selected)
		{
			selected = SelectionStrategy.rng.Choose(SelectionStrategy.DifferentLocationKeys);
			return true;
		}
	}
	internal class ConsistentSelectionStrategy : SelectionStrategy
	{
		private readonly Dictionary<string, string> _previouslySelected = new Dictionary<string, string>();

		private string? _lastOrigMusicCue;

		public override void InitStrategy()
		{
			_previouslySelected.Clear();
			_lastOrigMusicCue = null;
		}

		protected override bool TrySelect(MusicCue origToPlay, out string? selected)
		{
			if (_lastOrigMusicCue == ((Object)origToPlay).name)
			{
				selected = null;
				return false;
			}
			if (_previouslySelected.TryGetValue(((Object)origToPlay).name, out selected))
			{
				return true;
			}
			selected = SelectionStrategy.rng.Choose(SelectionStrategy.DifferentLocationKeys);
			_previouslySelected[((Object)origToPlay).name] = selected;
			return true;
		}
	}
	internal class DisabledSelectionStrategy : SelectionStrategy
	{
		protected override bool TrySelect(MusicCue origToPlay, out string? selected)
		{
			selected = null;
			return false;
		}
	}
	internal class OnChangeSelectionStrategy : SelectionStrategy
	{
		private string? _lastOrigMusicCue;

		public override void InitStrategy()
		{
			_lastOrigMusicCue = null;
		}

		protected override bool TrySelect(MusicCue origToPlay, out string? selected)
		{
			if (((Object)origToPlay).name == _lastOrigMusicCue)
			{
				selected = null;
				return false;
			}
			_lastOrigMusicCue = ((Object)origToPlay).name;
			selected = SelectionStrategy.rng.Choose(SelectionStrategy.DifferentLocationKeys);
			return true;
		}
	}
	internal class RandoRandoSelectionStrategy : SelectionStrategy
	{
		protected override bool TrySelect(MusicCue origToPlay, out string? selected)
		{
			if (SelectionStrategy.rng.Next(8) != 5)
			{
				selected = null;
				return false;
			}
			selected = SelectionStrategy.rng.Choose(SelectionStrategy.DifferentLocationKeys);
			return true;
		}
	}
	internal abstract class SelectionStrategy
	{
		protected static Random rng = new Random();

		protected static Dictionary<string, ManagedResourceLocation<MusicCue>>? MusicResourceLocations;

		protected static List<string> DifferentLocationKeys => MusicResourceLocations?.Keys.Where((string x) => (LastSelectedLocationKey ?? string.Empty) != x).ToList() ?? new List<string>();

		protected static string? LastSelectedLocationKey { get; private set; }

		internal static void SetResourceLocations(IEnumerable<IResourceLocation> locs)
		{
			if (MusicResourceLocations != null)
			{
				throw new InvalidOperationException("Can't set locs more than once!");
			}
			MusicResourceLocations = new Dictionary<string, ManagedResourceLocation<MusicCue>>();
			Dictionary<string, IResourceLocation> dictionary = new Dictionary<string, IResourceLocation>();
			foreach (IResourceLocation loc in locs)
			{
				if (!loc.InternalId.EndsWith("None.asset") && !MusicResourceLocations.ContainsKey(loc.InternalId))
				{
					MusicResourceLocations.Add(loc.InternalId, new ManagedResourceLocation<MusicCue>(loc));
					dictionary.Add(loc.InternalId, loc);
				}
			}
			MusicRandoPlugin.InstanceLogger.LogInfo((object)$"Found {MusicResourceLocations.Count} distinct music cues");
			GameEvents.OnEnterGame += delegate
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				foreach (ManagedResourceLocation<MusicCue> value in MusicResourceLocations.Values)
				{
					value.Load();
				}
			};
			GameEvents.OnQuitToMenu += delegate
			{
				foreach (ManagedResourceLocation<MusicCue> value2 in MusicResourceLocations.Values)
				{
					value2.Unload();
				}
			};
		}

		protected abstract bool TrySelect(MusicCue origToPlay, out string? selected);

		public virtual void InitStrategy()
		{
		}

		private MusicAction RunSelection(MusicCue origToPlay, out string? location)
		{
			location = null;
			if ((MusicResourceLocations?.Count ?? 0) <= 0)
			{
				return MusicAction.Ignore;
			}
			if (!GameEvents.IsInGame)
			{
				return MusicAction.Ignore;
			}
			if (((Object)origToPlay).name == "None")
			{
				return MusicAction.Ignore;
			}
			if (!TrySelect(origToPlay, out location))
			{
				return MusicAction.Replay;
			}
			return MusicAction.Randomize;
		}

		internal MusicAction Select(MusicCue origToPlay, out ManagedResourceLocation<MusicCue>? location)
		{
			string location2;
			MusicAction musicAction = RunSelection(origToPlay, out location2);
			if (musicAction == MusicAction.Ignore || musicAction == MusicAction.Replay)
			{
				location = null;
				return musicAction;
			}
			LastSelectedLocationKey = location2;
			location = MusicResourceLocations[location2];
			return musicAction;
		}

		public static void Reset()
		{
			LastSelectedLocationKey = null;
		}
	}
}
namespace MusicRando.Cache
{
	internal class CachedObject<T> where T : class
	{
		public string? SilksongVersion { get; set; }

		public string? PluginVersion { get; set; }

		public required T Value { get; set; }
	}
	public static class CacheManager
	{
		private static string? _silksongVersion;

		public static string SilksongVersion
		{
			get
			{
				if (_silksongVersion == null)
				{
					_silksongVersion = GetSilksongVersion();
				}
				return _silksongVersion;
			}
		}

		private static string GetSilksongVersion()
		{
			return (typeof(Constants).GetField("GAME_VERSION", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.GetRawConstantValue() as string) ?? "UNKNOWN";
		}

		private static bool MetadataMismatch<T>(CachedObject<T> cached, string earliestAcceptableVersion) where T : class
		{
			if (cached.SilksongVersion == null || cached.SilksongVersion != SilksongVersion)
			{
				return true;
			}
			if (!Version.TryParse(earliestAcceptableVersion, out Version result))
			{
				return true;
			}
			if (cached.PluginVersion == null || !Version.TryParse(cached.PluginVersion, out Version result2))
			{
				return true;
			}
			if (result2 < result)
			{
				return true;
			}
			return false;
		}

		public static T GetCached<T>(string fileName, string currentPluginVersion, string earliestAcceptableVersion, Func<T> getter) where T : class
		{
			if (!Version.TryParse(currentPluginVersion, out Version _))
			{
				throw new ArgumentException("Cannot parse current plugin version to Version");
			}
			string filePath = Path.Combine(Paths.CachePath, fileName);
			if (JsonHelper.TryLoadFromFile<CachedObject<T>>(filePath, out CachedObject<T> obj) && !MetadataMismatch(obj, earliestAcceptableVersion))
			{
				return obj.Value;
			}
			T val = getter();
			new CachedObject<T>
			{
				SilksongVersion = SilksongVersion,
				PluginVersion = currentPluginVersion,
				Value = val
			}.SerializeToFile(filePath);
			return val;
		}
	}
	internal static class JsonHelper
	{
		public static void SerializeToFile<T>(this T self, string filePath)
		{
			string contents = JsonConvert.SerializeObject((object)self, (Formatting)1);
			File.WriteAllText(filePath, contents);
		}

		public static bool TryLoadFromFile<T>(string filePath, [NotNullWhen(true)] out T? obj)
		{
			obj = default(T);
			if (string.IsNullOrEmpty(filePath) || !File.Exists(filePath))
			{
				return false;
			}
			try
			{
				string text = File.ReadAllText(filePath);
				obj = JsonConvert.DeserializeObject<T>(text);
				return obj != null;
			}
			catch (Exception)
			{
				return false;
			}
		}
	}
}