using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
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 CrestOptimizer.Settings;
using DanielSteginkUtils.Utilities;
using GlobalSettings;
using HarmonyLib;
using HutongGames.PlayMaker;
using HutongGames.PlayMaker.Actions;
using Microsoft.CodeAnalysis;
using TeamCherry.Localization;
using UnityEngine;

[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("CrestOptimizer")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("2.1.0.0")]
[assembly: AssemblyInformationalVersion("2.1.0+bd5ffaeb09e76683a6f79043e6f2839011d4c2e9")]
[assembly: AssemblyProduct("CrestOptimizer")]
[assembly: AssemblyTitle("CrestOptimizer")]
[assembly: NeutralResourcesLanguage("EN")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.1.0.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 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 CrestOptimizer
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("io.github.danielstegink.crestoptimizer", "CrestOptimizer", "2.1.0")]
	public class CrestOptimizer : BaseUnityPlugin
	{
		public const string Id = "io.github.danielstegink.crestoptimizer";

		internal static CrestOptimizer Instance { get; private set; }

		public static string Name => "CrestOptimizer";

		public static string Version => "2.1.0";

		private void Awake()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			new Harmony("io.github.danielstegink.crestoptimizer").PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Plugin " + Name + " (io.github.danielstegink.crestoptimizer) has loaded!"));
		}

		private void Start()
		{
			ConfigSettings.Initialize(((BaseUnityPlugin)this).Config);
		}

		internal void Log(string message)
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)message);
		}
	}
}
namespace CrestOptimizer.Settings
{
	public static class ConfigSettings
	{
		public static ConfigEntry<int> focusHits;

		public static ConfigEntry<float> focusDamage;

		public static ConfigEntry<int> focusHits2;

		public static ConfigEntry<float> focusDamage2;

		public static ConfigEntry<int> focusHits2S;

		public static ConfigEntry<float> focusDamage2S;

		public static ConfigEntry<int> silkCountMultiplier;

		public static ConfigEntry<int> silkValueMultiplier;

		public static ConfigEntry<float> critChance;

		public static ConfigEntry<float> critDamage;

		public static ConfigEntry<bool> replaceTool;

		public static ConfigEntry<bool> downSlashIFrames;

		public static ConfigEntry<int> furyCap;

		public static ConfigEntry<bool> beastDash;

		public static ConfigEntry<bool> beastPogo;

		public static ConfigEntry<Vector3> biggerUpSlash;

		public static ConfigEntry<float> fotfMultiplier;

		public static ConfigEntry<float> bindSizeMultiplier;

		public static ConfigEntry<float> longclawBindSizeMultiplier;

		public static ConfigEntry<int> witchCap;

		public static ConfigEntry<bool> refundSilk;

		public static ConfigEntry<bool> doubleMirror;

		public static ConfigEntry<int> scavengerChance;

		public static ConfigEntry<int> craftMaskCount;

		public static ConfigEntry<bool> craftBindDefault;

		public static ConfigEntry<bool> noDropBind;

		public static ConfigEntry<bool> spellNail;

		public static ConfigEntry<float> punchBonus;

		public static ConfigEntry<float> punchSpeedBonus;

		public static ConfigEntry<float> speedBonus;

		public static ConfigEntry<float> healTime;

		public static void Initialize(ConfigFile config)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0440: Unknown result type (might be due to invalid IL or missing references)
			//IL_0447: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0524: Unknown result type (might be due to invalid IL or missing references)
			//IL_052c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0596: Unknown result type (might be due to invalid IL or missing references)
			//IL_059d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0607: Unknown result type (might be due to invalid IL or missing references)
			//IL_060f: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_067a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0682: Unknown result type (might be due to invalid IL or missing references)
			//IL_0716: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0767: Unknown result type (might be due to invalid IL or missing references)
			//IL_076e: Unknown result type (might be due to invalid IL or missing references)
			//IL_07db: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_084f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0856: Unknown result type (might be due to invalid IL or missing references)
			//IL_08bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0930: Unknown result type (might be due to invalid IL or missing references)
			//IL_0938: Unknown result type (might be due to invalid IL or missing references)
			//IL_09a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a15: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a1c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a85: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a8c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0af6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0afe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b69: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b71: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bdc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0be4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c52: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c59: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cc6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ccd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d3a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d41: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dae: Unknown result type (might be due to invalid IL or missing references)
			//IL_0db5: Unknown result type (might be due to invalid IL or missing references)
			LocalisedString val = default(LocalisedString);
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "FOCUS_1_NAME");
			LocalisedString val2 = default(LocalisedString);
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "FOCUS_1_DESC");
			int num = 6;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				focusHits = config.Bind<int>("Hunter", LocalisedString.op_Implicit(val), num, LocalisedString.op_Implicit(val2));
			}
			else
			{
				focusHits = config.Bind<int>("Hunter", "FOCUS_1_NAME", num, "FOCUS_1_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "FOCUS_D1_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "FOCUS_D1_DESC");
			float num2 = 1.3f;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				focusDamage = config.Bind<float>("Hunter", LocalisedString.op_Implicit(val), num2, LocalisedString.op_Implicit(val2));
			}
			else
			{
				focusDamage = config.Bind<float>("Hunter", "FOCUS_D1_NAME", num2, "FOCUS_D1_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "FOCUS_2_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "FOCUS_2_DESC");
			num = 6;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				focusHits2 = config.Bind<int>("Hunter", LocalisedString.op_Implicit(val), num, LocalisedString.op_Implicit(val2));
			}
			else
			{
				focusHits2 = config.Bind<int>("Hunter", "FOCUS_2_NAME", num, "FOCUS_2_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "FOCUS_D2_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "FOCUS_D2_DESC");
			num2 = 1.3f;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				focusDamage2 = config.Bind<float>("Hunter", LocalisedString.op_Implicit(val), num2, LocalisedString.op_Implicit(val2));
			}
			else
			{
				focusDamage2 = config.Bind<float>("Hunter", "FOCUS_D2_NAME", num2, "FOCUS_D2_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "FOCUS_2S_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "FOCUS_2S_DESC");
			num = 6;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				focusHits2S = config.Bind<int>("Hunter", LocalisedString.op_Implicit(val), num, LocalisedString.op_Implicit(val2));
			}
			else
			{
				focusHits2S = config.Bind<int>("Hunter", "FOCUS_2S_NAME", num, "FOCUS_2S_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "FOCUS_D2S_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "FOCUS_D2S_DESC");
			num2 = 1.5f;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				focusDamage2S = config.Bind<float>("Hunter", LocalisedString.op_Implicit(val), num2, LocalisedString.op_Implicit(val2));
			}
			else
			{
				focusDamage2S = config.Bind<float>("Hunter", "FOCUS_D2S_NAME", num2, "FOCUS_D2S_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "SILK_COUNT_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "SILK_COUNT_DESC");
			num = 1;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				silkCountMultiplier = config.Bind<int>("Reaper", LocalisedString.op_Implicit(val), num, LocalisedString.op_Implicit(val2));
			}
			else
			{
				silkCountMultiplier = config.Bind<int>("Reaper", "SILK_COUNT_NAME", num, "SILK_COUNT_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "SILK_VALUE_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "SILK_VALUE_DESC");
			num = 1;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				silkValueMultiplier = config.Bind<int>("Reaper", LocalisedString.op_Implicit(val), num, LocalisedString.op_Implicit(val2));
			}
			else
			{
				silkValueMultiplier = config.Bind<int>("Reaper", "SILK_VALUE_NAME", num, "SILK_VALUE_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "CRIT_CHANCE_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "CRIT_CHANCE_DESC");
			num2 = 2f;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				critChance = config.Bind<float>("Wanderer", LocalisedString.op_Implicit(val), num2, LocalisedString.op_Implicit(val2));
			}
			else
			{
				critChance = config.Bind<float>("Wanderer", "CRIT_CHANCE_NAME", num2, "CRIT_CHANCE_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "CRIT_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "CRIT_DESC");
			num2 = 3f;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				critDamage = config.Bind<float>("Wanderer", LocalisedString.op_Implicit(val), num2, LocalisedString.op_Implicit(val2));
			}
			else
			{
				critDamage = config.Bind<float>("Wanderer", "CRIT_NAME", num2, "CRIT_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "WANDERER_SLOT_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "WANDERER_SLOT_DESC");
			bool flag = false;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				replaceTool = config.Bind<bool>("Wanderer", LocalisedString.op_Implicit(val), flag, LocalisedString.op_Implicit(val2));
			}
			else
			{
				replaceTool = config.Bind<bool>("Wanderer", "WANDERER_SLOT_NAME", flag, "WANDERER_SLOT_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "POGO_INV_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "POGO_INV_DESC");
			flag = false;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				downSlashIFrames = config.Bind<bool>("Beast", LocalisedString.op_Implicit(val), flag, LocalisedString.op_Implicit(val2));
			}
			else
			{
				downSlashIFrames = config.Bind<bool>("Beast", "POGO_INV_NAME", flag, "POGO_INV_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "FURY_CAP_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "FURY_CAP_DESC");
			num = 3;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				furyCap = config.Bind<int>("Beast", LocalisedString.op_Implicit(val), num, LocalisedString.op_Implicit(val2));
			}
			else
			{
				furyCap = config.Bind<int>("Beast", "FURY_CAP_NAME", num, "FURY_CAP_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "BEAST_DASH_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "BEAST_DASH_DESC");
			flag = false;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				beastDash = config.Bind<bool>("Beast", LocalisedString.op_Implicit(val), flag, LocalisedString.op_Implicit(val2));
			}
			else
			{
				beastDash = config.Bind<bool>("Beast", "BEAST_DASH_NAME", flag, "BEAST_DASH_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "BEAST_POGO_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "BEAST_POGO_DESC");
			flag = false;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				beastPogo = config.Bind<bool>("Beast", LocalisedString.op_Implicit(val), flag, LocalisedString.op_Implicit(val2));
			}
			else
			{
				beastPogo = config.Bind<bool>("Beast", "BEAST_POGO_NAME", flag, "BEAST_POGO_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "BEAST_UP_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "BEAST_UP_DESC");
			Vector3 one = Vector3.one;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				biggerUpSlash = config.Bind<Vector3>("Beast", LocalisedString.op_Implicit(val), one, LocalisedString.op_Implicit(val2));
			}
			else
			{
				biggerUpSlash = config.Bind<Vector3>("Beast", "BEAST_UP_NAME", one, "BEAST_UP_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "CURSED_FURY_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "CURSED_FURY_DESC");
			num2 = 1f;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				fotfMultiplier = config.Bind<float>("Cursed", LocalisedString.op_Implicit(val), num2, LocalisedString.op_Implicit(val2));
			}
			else
			{
				fotfMultiplier = config.Bind<float>("Cursed", "CURSED_FURY_NAME", num2, "CURSED_FURY_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "BIND_SIZE_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "BIND_SIZE_DESC");
			num2 = 1f;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				bindSizeMultiplier = config.Bind<float>("Witch", LocalisedString.op_Implicit(val), num2, LocalisedString.op_Implicit(val2));
			}
			else
			{
				bindSizeMultiplier = config.Bind<float>("Witch", "BIND_SIZE_NAME", num2, "BIND_SIZE_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "LN_BIND_SIZE_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "LN_BIND_SIZE_DESC");
			num2 = 1f;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				longclawBindSizeMultiplier = config.Bind<float>("Witch", LocalisedString.op_Implicit(val), num2, LocalisedString.op_Implicit(val2));
			}
			else
			{
				longclawBindSizeMultiplier = config.Bind<float>("Witch", "LN_BIND_SIZE_NAME", num2, "LN_BIND_SIZE_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "WITCH_CAP_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "WITCH_CAP_DESC");
			num = 3;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				witchCap = config.Bind<int>("Witch", LocalisedString.op_Implicit(val), num, LocalisedString.op_Implicit(val2));
			}
			else
			{
				witchCap = config.Bind<int>("Witch", "WITCH_CAP_NAME", num, "WITCH_CAP_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "WITCH_REFUND_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "WITCH_REFUND_DESC");
			flag = false;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				refundSilk = config.Bind<bool>("Witch", LocalisedString.op_Implicit(val), flag, LocalisedString.op_Implicit(val2));
			}
			else
			{
				refundSilk = config.Bind<bool>("Witch", "WITCH_REFUND_NAME", flag, "WITCH_REFUND_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "DOUBLE_MIRROR_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "DOUBLE_MIRROR_DESC");
			flag = false;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				doubleMirror = config.Bind<bool>("Witch", LocalisedString.op_Implicit(val), flag, LocalisedString.op_Implicit(val2));
			}
			else
			{
				doubleMirror = config.Bind<bool>("Witch", "DOUBLE_MIRROR_NAME", flag, "DOUBLE_MIRROR_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "SHARD_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "SHARD_DESC");
			num = 0;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				scavengerChance = config.Bind<int>("Architect", LocalisedString.op_Implicit(val), num, LocalisedString.op_Implicit(val2));
			}
			else
			{
				scavengerChance = config.Bind<int>("Architect", "SHARD_NAME", num, "SHARD_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "CRAFT_MASK_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "CRAFT_MASK_DESC");
			num = 0;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				craftMaskCount = config.Bind<int>("Architect", LocalisedString.op_Implicit(val), num, LocalisedString.op_Implicit(val2));
			}
			else
			{
				craftMaskCount = config.Bind<int>("Architect", "CRAFT_MASK_NAME", num, "CRAFT_MASK_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "CRAFT_DEFAULT_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "CRAFT_DEFAULT_DESC");
			flag = false;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				craftBindDefault = config.Bind<bool>("Architect", LocalisedString.op_Implicit(val), flag, LocalisedString.op_Implicit(val2));
			}
			else
			{
				craftBindDefault = config.Bind<bool>("Architect", "CRAFT_DEFAULT_NAME", flag, "CRAFT_DEFAULT_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "NO_DROP_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "NO_DROP_DESC");
			flag = false;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				noDropBind = config.Bind<bool>("Shaman", LocalisedString.op_Implicit(val), flag, LocalisedString.op_Implicit(val2));
			}
			else
			{
				noDropBind = config.Bind<bool>("Shaman", "NO_DROP_NAME", flag, "NO_DROP_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "SPELL_NEEDLE_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "SPELL_NEEDLE_DESC");
			flag = false;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				spellNail = config.Bind<bool>("Shaman", LocalisedString.op_Implicit(val), flag, LocalisedString.op_Implicit(val2));
			}
			else
			{
				spellNail = config.Bind<bool>("Shaman", "SPELL_NEEDLE_NAME", flag, "SPELL_NEEDLE_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "PUNCH_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "PUNCH_DESC");
			num2 = 1f;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				punchBonus = config.Bind<float>("Cloakless", LocalisedString.op_Implicit(val), num2, LocalisedString.op_Implicit(val2));
			}
			else
			{
				punchBonus = config.Bind<float>("Cloakless", "PUNCH_NAME", num2, "PUNCH_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "UNARMED_ATTACK_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "UNARMED_ATTACK_DESC");
			num2 = 1f;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				punchSpeedBonus = config.Bind<float>("Cloakless", LocalisedString.op_Implicit(val), num2, LocalisedString.op_Implicit(val2));
			}
			else
			{
				punchSpeedBonus = config.Bind<float>("Cloakless", "UNARMED_ATTACK_NAME", num2, "UNARMED_ATTACK_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "UNARMED_MOVE_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "UNARMED_MOVE_DESC");
			num2 = 1f;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				speedBonus = config.Bind<float>("Cloakless", LocalisedString.op_Implicit(val), num2, LocalisedString.op_Implicit(val2));
			}
			else
			{
				speedBonus = config.Bind<float>("Cloakless", "UNARMED_MOVE_NAME", num2, "UNARMED_MOVE_DESC");
			}
			((LocalisedString)(ref val))..ctor("Mods.io.github.danielstegink.crestoptimizer", "UNARMED_HEAL_NAME");
			((LocalisedString)(ref val2))..ctor("Mods.io.github.danielstegink.crestoptimizer", "UNARMED_HEAL_DESC");
			num2 = -1f;
			if (((LocalisedString)(ref val)).Exists && ((LocalisedString)(ref val2)).Exists)
			{
				healTime = config.Bind<float>("Cloakless", LocalisedString.op_Implicit(val), num2, LocalisedString.op_Implicit(val2));
			}
			else
			{
				healTime = config.Bind<float>("Cloakless", "UNARMED_HEAL_NAME", num2, "UNARMED_HEAL_DESC");
			}
		}
	}
	public static class SharedData
	{
		public static float witchBindMultiplier = 1f;
	}
}
namespace CrestOptimizer.Helpers
{
	[HarmonyPatch(typeof(BoolTest), "OnEnter")]
	public static class BoolTest_OnEnter
	{
		private static bool upKeyPressed;

		[HarmonyPrefix]
		public static void Prefix(BoolTest __instance)
		{
			if (IsShamanDropCheck(__instance) && ConfigSettings.noDropBind.Value)
			{
				__instance.boolVariable.Value = false;
			}
			if (IsCraftBindCheck(__instance))
			{
				upKeyPressed = __instance.boolVariable.Value;
				if (ConfigSettings.craftBindDefault.Value)
				{
					__instance.boolVariable.Value = !__instance.boolVariable.Value;
				}
			}
		}

		[HarmonyPostfix]
		public static void Postfix(BoolTest __instance)
		{
			if (IsShamanDropCheck(__instance))
			{
				__instance.boolVariable.Value = HeroController.instance.IsShamanCrestEquipped();
			}
			if (IsCraftBindCheck(__instance))
			{
				__instance.boolVariable.Value = upKeyPressed;
			}
		}

		private static bool IsShamanDropCheck(BoolTest __instance)
		{
			if ((((FsmStateAction)__instance).State.Name.Equals("Bind Air") || ((FsmStateAction)__instance).State.Name.Equals("Shaman Silk?")) && ((FsmStateAction)__instance).Fsm.Name.Equals("Bind"))
			{
				return ((NamedVariable)__instance.boolVariable).Name.Equals("Is Shaman Equipped");
			}
			return false;
		}

		private static bool IsCraftBindCheck(BoolTest __instance)
		{
			if (((FsmStateAction)__instance).State.Name.Equals("Quick Craft?"))
			{
				return ((FsmStateAction)__instance).Fsm.Name.Equals("Bind");
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(DamageEnemies), "DoDamage", new Type[]
	{
		typeof(GameObject),
		typeof(bool)
	})]
	public static class DamageEnemies_DoDamage
	{
		[HarmonyPrefix]
		public static void Prefix(DamageEnemies __instance, ref GameObject target, ref bool isFirstHit)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (HeroController.instance.IsShamanCrestEquipped() && ConfigSettings.spellNail.Value && (int)__instance.attackType == 0)
			{
				__instance.attackType = (AttackTypes)2;
				__instance.representingTool = (ToolItem)(object)new SpellTool();
				__instance.isNailAttack = false;
				__instance.DamageMultiplier = 1.4f;
			}
		}
	}
	[HarmonyPatch(typeof(FsmState), "OnExit")]
	public static class FsmState_OnExit
	{
		[CompilerGenerated]
		private sealed class <SpawnFlash>d__3 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if ((Object)(object)HeroController.instance != (Object)null && (Object)(object)((Component)HeroController.instance).gameObject != (Object)null && (Object)(object)mirrorBurst != (Object)null)
					{
						ObjectPoolExtensions.Spawn(mirrorBurst, HeroController.instance.transform.position);
					}
					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 static bool masksHealed;

		private static GameObject? mirrorBurst;

		[HarmonyPostfix]
		public static void Postfix(FsmState __instance)
		{
			if (__instance.Name.Equals("SpinBall Antic") && __instance.Fsm.Name.Equals("Crest Attacks") && ConfigSettings.downSlashIFrames.Value)
			{
				HeroController.instance.StartDownspikeInvulnerabilityLong();
			}
			if (__instance.Name.Equals("Bind Start") && __instance.Fsm.Name.Equals("Bind"))
			{
				masksHealed = false;
			}
			if (__instance.Name.Equals("End Bind") && __instance.Fsm.Name.Equals("Bind") && !masksHealed && ConfigSettings.refundSilk.Value && ((ToolBase)Gameplay.WitchCrest).IsEquipped)
			{
				HeroController.instance.AddSilk(5, true);
			}
			if (__instance.Name.Equals("Quick Craft Burst") && __instance.Fsm.Name.Equals("Bind") && ConfigSettings.craftMaskCount.Value > 0)
			{
				HeroController.instance.AddHealth(ConfigSettings.craftMaskCount.Value);
			}
			if (__instance.Name.Equals("Dazzle?") && __instance.Fsm.Name.Equals("Bind") && ((ToolBase)Gameplay.WitchCrest).IsEquipped && ((ToolBase)Gameplay.MultibindTool).IsEquipped && __instance.Fsm.Variables.GetFsmBool("Is Dazzle Equipped").Value && ConfigSettings.doubleMirror.Value)
			{
				mirrorBurst = __instance.Fsm.Variables.GetFsmGameObject("Dazzle Flash").Value;
				((MonoBehaviour)GameManager.instance).StartCoroutine(SpawnFlash());
			}
		}

		[IteratorStateMachine(typeof(<SpawnFlash>d__3))]
		private static IEnumerator SpawnFlash()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SpawnFlash>d__3(0);
		}
	}
	[HarmonyPatch(typeof(HealthManager), "TakeDamage")]
	public static class HealthManager_TakeDamage
	{
		[HarmonyPrefix]
		public static void Prefix(HealthManager __instance, ref HitInstance hitInstance)
		{
			int damageDealt = hitInstance.DamageDealt;
			if (((ToolBase)Gameplay.CursedCrest).IsEquipped && PlayerData.instance.health + PlayerData.instance.healthBlue <= 2)
			{
				int num = (int)((ConfigSettings.fotfMultiplier.Value - 1f) * (float)damageDealt);
				hitInstance.DamageDealt += num;
			}
			if (((ToolBase)Gameplay.CloaklessCrest).IsEquipped)
			{
				int num2 = (int)((ConfigSettings.punchBonus.Value - 1f) * (float)damageDealt);
				hitInstance.DamageDealt += num2;
			}
		}

		[HarmonyPostfix]
		public static void Postfix(HealthManager __instance, ref HitInstance hitInstance)
		{
			//IL_0049: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			if (HeroController.instance.IsArchitectCrestEquipped() && hitInstance.DamageDealt > 0)
			{
				int num = 0;
				int num2;
				for (num2 = ConfigSettings.scavengerChance.Value; num2 >= 100; num2 -= 100)
				{
					num++;
				}
				if (Random.Range(1, 101) <= num2)
				{
					num++;
				}
				Config val = default(Config);
				val.Prefab = Gameplay.ShellShardPrefab;
				val.AmountMin = num;
				val.AmountMax = num;
				val.SpeedMin = 15f;
				val.SpeedMax = 30f;
				val.AngleMin = 80f;
				val.AngleMax = 100f;
				FlingUtils.SpawnAndFlingShellShards(val, ((Component)__instance).transform, Vector3.zero, (List<GameObject>)null);
			}
		}
	}
	[HarmonyPatch(typeof(HeroController), "AddSilkParts", new Type[] { typeof(int) })]
	public static class HeroController_AddSilkParts
	{
		[HarmonyPrefix]
		public static void Prefix(HeroController __instance, ref int amount)
		{
			amount *= ConfigSettings.silkValueMultiplier.Value;
		}
	}
	[HarmonyPatch(typeof(HeroController), "DidAttack")]
	public static class HeroController_DidAttack
	{
		[HarmonyPostfix]
		public static void Postfix(HeroController __instance)
		{
			if (((ToolBase)Gameplay.CloaklessCrest).IsEquipped)
			{
				__instance.attack_cooldown /= ConfigSettings.punchSpeedBonus.Value;
			}
		}
	}
	[HarmonyPatch(typeof(HeroController), "Move")]
	public static class HeroController_Move
	{
		[HarmonyPrefix]
		public static void Prefix(HeroController __instance, ref float moveDirection, ref bool useInput)
		{
			if (((ToolBase)Gameplay.CloaklessCrest).IsEquipped)
			{
				moveDirection *= ConfigSettings.speedBonus.Value;
			}
		}
	}
	[HarmonyPatch(typeof(HeroController), "Start")]
	public static class HeroController_Start
	{
		[HarmonyPostfix]
		public static void Postfix(HeroController __instance)
		{
			SharedData.witchBindMultiplier = 1f;
		}
	}
	[HarmonyPatch(typeof(HeroController), "Update")]
	public static class HeroController_Update
	{
		internal static Stopwatch cloaklessHealTimer = new Stopwatch();

		[HarmonyPostfix]
		public static void Postfix(HeroController __instance)
		{
			//IL_0089: 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)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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)
			ToolCrest crestByName = ToolItemManager.GetCrestByName("Wanderer");
			if ((Object)(object)crestByName != (Object)null)
			{
				ToolItemType val = (ToolItemType)((!ConfigSettings.replaceTool.Value) ? 2 : 0);
				if (val != crestByName.Slots[4].Type)
				{
					crestByName.Slots[4].Type = val;
					__instance.UpdateConfig();
				}
			}
			BuffTentacles();
			if (((ToolBase)Gameplay.WarriorCrest).IsEquipped && __instance.crestAttacksFSM.FsmVariables.GetFsmBool("In Crest Attack").Value)
			{
				Rigidbody2D rb2d = __instance.rb2d;
				float value = rb2d.linearVelocity.x;
				float value2 = rb2d.linearVelocity.y;
				if (ConfigSettings.beastDash.Value)
				{
					value2 = 0f;
				}
				if (ConfigSettings.beastPogo.Value)
				{
					value = 0f;
				}
				Extensions.SetVelocity(rb2d, (float?)value, (float?)value2);
				ClassIntegrations.SetField<HeroController>(__instance, "rb2d", (object)rb2d, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (GameManager.instance.isPaused)
			{
				cloaklessHealTimer.Stop();
			}
			else if (((ToolBase)Gameplay.CloaklessCrest).IsEquipped && ConfigSettings.healTime.Value > 0f)
			{
				cloaklessHealTimer.Start();
				if ((float)cloaklessHealTimer.ElapsedMilliseconds >= ConfigSettings.healTime.Value * 1000f)
				{
					__instance.AddHealth(1);
					cloaklessHealTimer.Restart();
				}
			}
			else
			{
				cloaklessHealTimer.Stop();
			}
		}

		private static void BuffTentacles()
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			float value = ConfigSettings.bindSizeMultiplier.Value;
			if (((ToolBase)Gameplay.LongNeedleTool).IsEquipped)
			{
				value = ConfigSettings.longclawBindSizeMultiplier.Value;
			}
			if (SharedData.witchBindMultiplier == value || (Object)(object)GameObject.Find("Bind Effects") == (Object)null)
			{
				return;
			}
			GameObject val = GameObject.Find("Witch Bind");
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Transform[] componentsInChildren = val.GetComponentsInChildren<Transform>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				GameObject gameObject = ((Component)componentsInChildren[i]).gameObject;
				if (((Object)gameObject).name.Contains("Damager") || ((Object)gameObject).name.Contains("Tendril"))
				{
					GameObject gameObject2 = ((Component)gameObject.transform.parent).gameObject;
					if ((Object)(object)gameObject2 != (Object)null && ((Object)gameObject2).name.Equals("Witch Bind"))
					{
						_ = gameObject.transform.localScale;
						Transform transform = gameObject.transform;
						transform.localScale /= SharedData.witchBindMultiplier;
						Transform transform2 = gameObject.transform;
						transform2.localScale *= value;
					}
				}
			}
			SharedData.witchBindMultiplier = value;
		}
	}
	[HarmonyPatch(typeof(NailAttackBase), "OnSlashStarting")]
	public static class NailAttackBase_OnSlashStarting
	{
		[HarmonyPostfix]
		public static void Postfix(NailAttackBase __instance)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if (((ToolBase)Gameplay.WarriorCrest).IsEquipped && ((Object)__instance).name.Equals("UpSlash"))
			{
				Vector3 localScale = ((Component)__instance).transform.localScale;
				Vector3 value = ConfigSettings.biggerUpSlash.Value;
				((Component)__instance).transform.localScale = new Vector3(localScale.x * value.y, localScale.y * value.x, localScale.z);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerData), "AddHealth")]
	public static class PlayerData_AddHealth
	{
		[HarmonyPostfix]
		public static void Postfix(PlayerData __instance, int amount)
		{
			FsmState_OnExit.masksHealed = true;
		}
	}
	internal class SpellTool : ToolItem
	{
		public override UsageOptions Usage
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public override LocalisedString DisplayName
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public override LocalisedString Description
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public override Sprite GetHudSprite(IconVariants iconVariant)
		{
			throw new NotImplementedException();
		}

		public override Sprite GetInventorySprite(IconVariants iconVariant)
		{
			throw new NotImplementedException();
		}

		internal SpellTool()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			base.type = (ToolItemType)3;
			base.zapDamageTicks = 1;
		}
	}
}
namespace CrestOptimizer.Helpers.Getters_HeroController
{
	[HarmonyPatch(typeof(HeroController), "GetRageModeHealCap")]
	public static class HeroController_GetRageModeHealCap
	{
		[HarmonyPostfix]
		public static void Postfix(HeroController __instance, ref int __result)
		{
			int num = ConfigSettings.furyCap.Value;
			if (((ToolBase)Gameplay.MultibindTool).IsEquipped)
			{
				num++;
			}
			__result = num;
		}
	}
	[HarmonyPatch(typeof(HeroController), "GetReaperPayout")]
	public static class HeroController_GetReaperPayout
	{
		[HarmonyPostfix]
		public static void Postfix(HeroController __instance, ref int __result)
		{
			__result *= ConfigSettings.silkCountMultiplier.Value;
		}
	}
	[HarmonyPatch(typeof(HeroController), "GetWitchHealCap")]
	public static class HeroController_GetWitchHealCap
	{
		[HarmonyPostfix]
		public static void Postfix(HeroController __instance, ref int __result)
		{
			int num = ConfigSettings.witchCap.Value;
			if (((ToolBase)Gameplay.MultibindTool).IsEquipped)
			{
				num++;
			}
			__result = num;
		}
	}
}
namespace CrestOptimizer.Helpers.Getters_Gameplay
{
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public static class Gameplay_HunterCombo2DamageMult
	{
		[HarmonyPostfix]
		public static void Postfix(Gameplay __instance, ref float __result)
		{
			__result = ConfigSettings.focusDamage2.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public static class Gameplay_HunterCombo2ExtraDamageMult
	{
		[HarmonyPostfix]
		public static void Postfix(Gameplay __instance, ref float __result)
		{
			__result = ConfigSettings.focusDamage2S.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public static class Gameplay_HunterCombo2ExtraHits
	{
		[HarmonyPostfix]
		public static void Postfix(Gameplay __instance, ref int __result)
		{
			__result = ConfigSettings.focusHits2S.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public static class Gameplay_HunterCombo2Hits
	{
		[HarmonyPostfix]
		public static void Postfix(Gameplay __instance, ref int __result)
		{
			__result = ConfigSettings.focusHits2.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public static class Gameplay_HunterComboDamageMult
	{
		[HarmonyPostfix]
		public static void Postfix(Gameplay __instance, ref float __result)
		{
			__result = ConfigSettings.focusDamage.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public static class Gameplay_HunterComboHits
	{
		[HarmonyPostfix]
		public static void Postfix(Gameplay __instance, ref int __result)
		{
			__result = ConfigSettings.focusHits.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public static class Gameplay_WandererCritChance
	{
		[HarmonyPostfix]
		public static void Postfix(Gameplay __instance, ref float __result)
		{
			__result = ConfigSettings.critChance.Value / 100f;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public static class Gameplay_WandererCritMultiplier
	{
		[HarmonyPostfix]
		public static void Postfix(Gameplay __instance, ref float __result)
		{
			__result = ConfigSettings.critDamage.Value;
		}
	}
}
namespace CrestOptimizer.Helpers.Getters_DamageEnemies
{
	[HarmonyPatch(typeof(DamageEnemies), "IsNailAttackObject")]
	public static class DamageEnemies_IsNailAttackObject
	{
		[HarmonyPostfix]
		public static void Postfix(DamageEnemies __instance, ref GameObject gameObject, ref bool __result)
		{
			if (HeroController.instance.IsShamanCrestEquipped() && ConfigSettings.spellNail.Value)
			{
				__result = false;
			}
		}
	}
}