using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using IL.RoR2;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using On.RoR2;
using R2API;
using RiskOfOptions;
using RiskOfOptions.OptionConfigs;
using RiskOfOptions.Options;
using RoR2;
using RoR2.Projectile;
using SeekersoftheStormNerfs.items;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Networking;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("SeekersoftheStormNerfs")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+170c7c7e4370cce2c0dc29212ac02c47f93e04c5")]
[assembly: AssemblyProduct("SeekersoftheStormNerfs")]
[assembly: AssemblyTitle("SeekersoftheStormNerfs")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace SeekersoftheStormNerfs
{
	internal static class Log
	{
		private static ManualLogSource _logSource;

		internal static void Init(ManualLogSource logSource)
		{
			_logSource = logSource;
		}

		internal static void Debug(object data)
		{
			_logSource.LogDebug(data);
		}

		internal static void Error(object data)
		{
			_logSource.LogError(data);
		}

		internal static void Fatal(object data)
		{
			_logSource.LogFatal(data);
		}

		internal static void Info(object data)
		{
			_logSource.LogInfo(data);
		}

		internal static void Message(object data)
		{
			_logSource.LogMessage(data);
		}

		internal static void Warning(object data)
		{
			_logSource.LogWarning(data);
		}
	}
	internal static class PluginConfig
	{
		public static ConfigEntry<float> CEBaseKillDamage { get; set; }

		public static ConfigEntry<float> CEStackKillDamage { get; set; }

		public static ConfigEntry<float> CEBaseMaxKills { get; set; }

		public static ConfigEntry<float> CEStackMaxKills { get; set; }

		public static ConfigEntry<float> CEBaseTime { get; set; }

		public static ConfigEntry<float> CEStackTime { get; set; }

		public static ConfigEntry<bool> CERefreshMethod { get; set; }

		public static ConfigEntry<bool> CEBeepBoop { get; set; }

		public static ConfigEntry<float> EABaseMoveSpeed { get; set; }

		public static ConfigEntry<float> EAStackMoveSpeed { get; set; }

		public static ConfigEntry<float> EABaseWispInterval { get; set; }

		public static ConfigEntry<float> EAStackWispIntervalReduction { get; set; }

		public static ConfigEntry<float> EABaseWispMoveSpeed { get; set; }

		public static ConfigEntry<float> EAStackWispMoveSpeed { get; set; }

		public static ConfigEntry<float> EABaseMaxWisps { get; set; }

		public static ConfigEntry<float> EAStackMaxWisps { get; set; }

		public static ConfigEntry<float> EANoStackWispMoveSpeed { get; set; }

		public static ConfigEntry<float> EANoStackMaxWisps { get; set; }

		public static ConfigEntry<float> EABaseBuffDuration { get; set; }

		public static ConfigEntry<float> EAStackBuffDuration { get; set; }

		public static ConfigEntry<float> BLBaseBodyAttackSpeed { get; set; }

		public static ConfigEntry<float> BLStackBodyAttackSpeed { get; set; }

		public static ConfigEntry<float> BLBaseAttackSpeed { get; set; }

		public static ConfigEntry<float> BLStackAttackSpeed { get; set; }

		public static ConfigEntry<float> BLBaseMaxBodies { get; set; }

		public static ConfigEntry<float> BLStackMaxBodies { get; set; }

		public static ConfigEntry<float> BLBaseRadius { get; set; }

		public static ConfigEntry<float> BLStackRadius { get; set; }

		public static ConfigEntry<bool> BLHyperbolicScaling { get; set; }

		public static ConfigEntry<bool> BLEnableUnconditionalAS { get; set; }

		public static ConfigEntry<float> WEBaseDamageReduction { get; set; }

		public static ConfigEntry<float> WEStackDamageReduction { get; set; }

		public static ConfigEntry<float> WEBaseEchoes { get; set; }

		public static ConfigEntry<float> WEStackEchoes { get; set; }

		public static ConfigEntry<float> WEBaseCooldown { get; set; }

		public static ConfigEntry<float> WEStackCooldownReduction { get; set; }

		public static ConfigEntry<float> WEInitialDelay { get; set; }

		public static ConfigEntry<bool> WEEnableDamageThreshold { get; set; }

		public static ConfigEntry<float> WEDamageThreshold { get; set; }

		public static ConfigEntry<float> WEInterval { get; set; }

		public static ConfigEntry<float> BFBaseLaunchesAfterFirst { get; set; }

		public static ConfigEntry<float> BFStackLaunchesAfterFirst { get; set; }

		public static ConfigEntry<float> BFBaseDamageBonus { get; set; }

		public static ConfigEntry<float> BFStackDamageBonus { get; set; }

		public static ConfigEntry<float> BFBaseCooldown { get; set; }

		public static ConfigEntry<float> BFCooldownFloor { get; set; }

		public static ConfigEntry<float> BFStackCooldownReduction { get; set; }

		public static ConfigEntry<float> CDBaseChance { get; set; }

		public static ConfigEntry<float> CDStackChance { get; set; }

		public static ConfigEntry<float> LSBaseMaxCharges { get; set; }

		public static ConfigEntry<float> LSStackMaxCharges { get; set; }

		public static ConfigEntry<float> LSChargeThreshold { get; set; }

		public static ConfigEntry<float> LSBaseDamage { get; set; }

		public static ConfigEntry<float> LSStackDamage { get; set; }

		public static ConfigEntry<float> LSBaseCDR { get; set; }

		public static ConfigEntry<float> LSStackCDR { get; set; }

		public static ConfigEntry<float> LSProcCoeff { get; set; }

		public static ConfigEntry<float> LSStrikeDelay { get; set; }

		public static ConfigEntry<float> LSRadius { get; set; }

		public static ConfigEntry<bool> LSAllSkillsCharge { get; set; }

		public static ConfigEntry<float> NTBaseBleedChance { get; set; }

		public static ConfigEntry<float> NTStackBleedChance { get; set; }

		public static ConfigEntry<bool> NTEnableBurn { get; set; }

		public static ConfigEntry<float> NTBaseBurnChance { get; set; }

		public static ConfigEntry<float> NTStackBurnChance { get; set; }

		public static ConfigEntry<float> NTBaseDebuffTransfer { get; set; }

		public static ConfigEntry<float> NTStackDebuffTransfer { get; set; }

		public static ConfigEntry<float> NTBaseBodies { get; set; }

		public static ConfigEntry<float> NTStackBodies { get; set; }

		public static ConfigEntry<float> NTBaseRange { get; set; }

		public static ConfigEntry<float> NTStackRange { get; set; }

		public static ConfigEntry<float> PBBaseExpGain { get; set; }

		public static ConfigEntry<float> PBStackExpGain { get; set; }

		public static ConfigEntry<float> PBBaseStatBonus { get; set; }

		public static ConfigEntry<float> PBStackStatBonus { get; set; }

		public static ConfigEntry<bool> PBCalcBasedOnBeadsRemoved { get; set; }

		public static ConfigEntry<float> SSBaseItemCount { get; set; }

		public static ConfigEntry<float> SSStackExtraItemChance { get; set; }

		public static ConfigEntry<float> SSOneExtraItemChance { get; set; }

		public static ConfigEntry<float> SSTwoExtraItemsChance { get; set; }

		public static ConfigEntry<float> SSThreeExtraItemsChance { get; set; }

		public static ConfigEntry<float> UTBaseTempHealth { get; set; }

		public static ConfigEntry<float> UTStackTempHealth { get; set; }

		public static ConfigEntry<float> UTBuffTime { get; set; }

		public static ConfigEntry<float> UTStackBuffTime { get; set; }

		public static ConfigEntry<float> UTBaseCooldown { get; set; }

		public static ConfigEntry<float> UTStackCooldownReduction { get; set; }

		public static ConfigEntry<float> UTBuffExtension { get; set; }

		public static ConfigEntry<float> UTMaxBuffExtension { get; set; }

		public static ConfigEntry<float> UTBaseBleedStacks { get; set; }

		public static ConfigEntry<float> UTStackBleedStacks { get; set; }

		public static ConfigEntry<float> EBTravelSpeed { get; set; }

		public static ConfigEntry<float> EBHitProcCoeff { get; set; }

		public static ConfigEntry<float> EBSpinProcCoeff { get; set; }

		public static ConfigEntry<float> EBBaseHitDamage { get; set; }

		public static ConfigEntry<float> EBStackHitDamage { get; set; }

		public static ConfigEntry<float> EBPercSpinDamage { get; set; }

		public static ConfigEntry<float> EBBaseHitChance { get; set; }

		public static ConfigEntry<float> EBStackHitChance { get; set; }

		public static ConfigEntry<bool> EBDisableBleed { get; set; }

		public static ConfigEntry<float> GNBaseBuffs { get; set; }

		public static ConfigEntry<float> GNStackBuffs { get; set; }

		public static ConfigEntry<float> GNBaseStatBuff { get; set; }

		public static ConfigEntry<float> GNStackStatBuff { get; set; }

		public static ConfigEntry<float> RLBaseChance { get; set; }

		public static ConfigEntry<float> RLStackChance { get; set; }

		public static ConfigEntry<float> RLBaseDamage { get; set; }

		public static ConfigEntry<float> RLStackDamage { get; set; }

		public static ConfigEntry<float> RLThreshold { get; set; }

		public static ConfigEntry<float> RLBaseThresholdChance { get; set; }

		public static ConfigEntry<float> RLStackThresholdChance { get; set; }

		public static ConfigEntry<float> RLChanceCap { get; set; }

		public static ConfigEntry<float> RLBaseThresholdDamage { get; set; }

		public static ConfigEntry<float> RLStackThresholdDamage { get; set; }

		public static ConfigEntry<float> RLDamageCap { get; set; }

		public static ConfigEntry<float> RLAoE { get; set; }

		public static ConfigEntry<float> RLProcCoeff { get; set; }

		public static ConfigEntry<float> SWBaseChampionDropChance { get; set; }

		public static ConfigEntry<float> SWStackChampionDropChance { get; set; }

		public static ConfigEntry<float> SWBaseEliteDropChance { get; set; }

		public static ConfigEntry<float> SWStackEliteDropChance { get; set; }

		public static ConfigEntry<float> WBBaseBossHP { get; set; }

		public static ConfigEntry<float> WBStackBossHP { get; set; }

		public static ConfigEntry<float> WBInitialCount { get; set; }

		public static ConfigEntry<float> WBBaseMaxMissiles { get; set; }

		public static ConfigEntry<float> WBStackMaxMissiles { get; set; }

		public static ConfigEntry<float> WBGoldReq { get; set; }

		public static ConfigEntry<float> WBNormalEnemyDamageRatio { get; set; }

		public static ConfigEntry<float> WBProjectileDamageCoeff { get; set; }

		public static ConfigEntry<float> WBProcCoeff { get; set; }

		public static ConfigEntry<float> WBStartDelay { get; set; }

		public static ConfigEntry<float> WBInterval { get; set; }

		public static ConfigEntry<bool> WBEnemyCollision { get; set; }

		public static ConfigEntry<bool> WBDisableDuringTPEvent { get; set; }

		public static ConfigEntry<bool> BLEnableChanges { get; set; }

		public static ConfigEntry<bool> BFEnableChanges { get; set; }

		public static ConfigEntry<bool> CDEnableChanges { get; set; }

		public static ConfigEntry<bool> CEEnableChanges { get; set; }

		public static ConfigEntry<bool> EBEnableChanges { get; set; }

		public static ConfigEntry<bool> EAEnableChanges { get; set; }

		public static ConfigEntry<bool> GNEnableChanges { get; set; }

		public static ConfigEntry<bool> LSEnableChanges { get; set; }

		public static ConfigEntry<bool> NTEnableChanges { get; set; }

		public static ConfigEntry<bool> PBEnableChanges { get; set; }

		public static ConfigEntry<bool> RLEnableChanges { get; set; }

		public static ConfigEntry<bool> SSEnableChanges { get; set; }

		public static ConfigEntry<bool> SWEnableChanges { get; set; }

		public static ConfigEntry<bool> UTEnableChanges { get; set; }

		public static ConfigEntry<bool> WBEnableChanges { get; set; }

		public static ConfigEntry<bool> WEEnableChanges { get; set; }

		public static void Init(ConfigFile cfg)
		{
			if (SeekersoftheStormNerfs.RooInstalled)
			{
				InitRoO();
			}
			BLEnableChanges = cfg.BindOption("Bolstering Lantern", "Enable Changes", defaultValue: true, "Enable changes for this item." + Environment.NewLine + "If set to false, hooks for this item will not apply, none of the below settings will apply, and the item will be reverted to it's vanilla functionality.", restartRequired: true);
			BLBaseBodyAttackSpeed = cfg.BindOptionSteppedSlider("Bolstering Lantern", "Base AS", 0.1f, 0.01f, "Bonus attack speed per nearby ally/enemy with 1 stack. Vanilla is 0.1 = 10%.", 0f, 0.5f, restartRequired: true, 1);
			BLStackBodyAttackSpeed = cfg.BindOptionSteppedSlider("Bolstering Lantern", "Stack AS", 0f, 0.01f, "Extra bonus attack speed per nearby enemy/ally, per stack. Vanilla is 0 = 0%.", 0f, 0.5f, restartRequired: true, 1);
			BLBaseMaxBodies = cfg.BindOptionSteppedSlider("Bolstering Lantern", "Base Max Enemies/Allies", 1f, 1f, "Max number of nearby allies/enemies with 1 stack. Vanilla is 4.", 0f, 10f, restartRequired: true);
			BLStackMaxBodies = cfg.BindOptionSteppedSlider("Bolstering Lantern", "Stack Max Enemies/Allies", 1f, 1f, "Extra max number of nearby allies/enemies, per stack. Vanilla is 2.", 0f, 10f, restartRequired: true);
			BLBaseRadius = cfg.BindOptionSteppedSlider("Bolstering Lantern", "Base Radius", 10f, 1f, "Enemy/ally detection radius in metres at 1 stack. Vanilla is 20.", 5f, 50f, restartRequired: true, 3);
			BLStackRadius = cfg.BindOptionSteppedSlider("Bolstering Lantern", "Stack Radius", 5f, 1f, "Extra enemy/ally detection radius in metres, per stack. Vanilla is 5.", 0f, 20f, restartRequired: true, 3);
			BLHyperbolicScaling = cfg.BindOption("Bolstering Lantern", "Hyperbolic Range Scaling", defaultValue: false, "Enables hyperbolic scaling for the range of Bolstering Lantern. Will yield diminishing returns on the radius.", restartRequired: true);
			BLEnableUnconditionalAS = cfg.BindOption("Bolstering Lantern", "Enable Unconditional Attack Speed", defaultValue: false, "Grants a certain amount of attack speed just for having the item.", restartRequired: true);
			BLBaseAttackSpeed = cfg.BindOptionSteppedSlider("Bolstering Lantern", "Unconditional Base AS", 0.1f, 0.01f, "The amount of attack speed this item grants unconditionally at 1 stack of the item. Vanilla is 0 = 0%.", 0f, 1f, restartRequired: true, 1);
			BLStackAttackSpeed = cfg.BindOptionSteppedSlider("Bolstering Lantern", "Unconditional Stack AS", 0.1f, 0.01f, "The amount of attack speed this item grants unconditionally, per stack of the item. Vanilla is 0 = 0%.", 0f, 1f, restartRequired: true, 1);
			CEEnableChanges = cfg.BindOption("Chronic Expansion", "Enable Changes", defaultValue: true, "Enable changes for this item." + Environment.NewLine + "If set to false, hooks for this item will not apply, none of the below settings will apply, and the item will be reverted to it's vanilla functionality.", restartRequired: true);
			CEBaseKillDamage = cfg.BindOptionSteppedSlider("Chronic Expansion", "Base Damage Bonus", 0.05f, 0.001f, "Damage bonus per kill with 1 stack. Vanilla is 0.035 = 3.5%.", 0f, 0.1f, restartRequired: true, 1);
			CEStackKillDamage = cfg.BindOptionSteppedSlider("Chronic Expansion", "Stack Damage Bonus", 0f, 0.001f, "Extra damage bonus per kill, per stack. Vanilla is 0.01 = 1%.", 0f, 0.02f, restartRequired: true, 1);
			CEBaseMaxKills = cfg.BindOptionSteppedSlider("Chronic Expansion", "Base Max Kills", 5f, 1f, "The maximum number of kills at 1 stack. Vanilla is 10.", 1f, 20f, restartRequired: true);
			CEStackMaxKills = cfg.BindOptionSteppedSlider("Chronic Expansion", "Stack Max Kills", 5f, 1f, "Extra number of maximum kills added per stack. Vanilla is 5.", 0f, 20f, restartRequired: true);
			CEBaseTime = cfg.BindOptionSteppedSlider("Chronic Expansion", "Base Timer", 7f, 0.1f, "Time in seconds before the buff wears off at 1 stack. Vanilla is 7s.", 0f, 20f, restartRequired: true, 2);
			CEStackTime = cfg.BindOptionSteppedSlider("Chronic Expansion", "Stack Timer", 0.5f, 0.1f, "Extra time in seconds before the buff wears off, per stack. Vanilla is 0s.", 0f, 20f, restartRequired: true, 2);
			CERefreshMethod = cfg.BindOption("Chronic Expansion", "Refresh only on kill", defaultValue: true, "True only refreshes the timer on kill. False refreshers the timer on damage dealt. Vanilla is False.", restartRequired: true);
			CEBeepBoop = cfg.BindOption("Chronic Expansion", "Enable Timeout Sound Cue", defaultValue: false, "True retains the potentially annoying timeout sound effect. False removes it. Vanilla is True.", restartRequired: true);
			EAEnableChanges = cfg.BindOption("Elusive Antlers", "Enable Changes", defaultValue: true, "Enable changes for this item." + Environment.NewLine + "If set to false, hooks for this item will not apply, none of the below settings will apply, and the item will be reverted to it's vanilla functionality.", restartRequired: true);
			EABaseMoveSpeed = cfg.BindOptionSteppedSlider("Elusive Antlers", "Base MS", 0.06f, 0.01f, "Bonus move speed at 1 stack, with no collected wisps. Vanilla is 0.07 = 7%", 0f, 0.5f, restartRequired: true, 1);
			EAStackMoveSpeed = cfg.BindOptionSteppedSlider("Elusive Antlers", "Stack MS", 0.06f, 0.01f, "Extra bonus move speed with no collected wisps, per stack. Vanilla is 0.07 = 7%", 0f, 0.5f, restartRequired: true, 1);
			EABaseWispMoveSpeed = cfg.BindOptionSteppedSlider("Elusive Antlers", "Base Wisp MS", 0.12f, 0.01f, "Bonus movespeed per collected wisp at 1 stack. Vanilla is 0.12 = 12%.", 0f, 0.5f, restartRequired: true, 1);
			EAStackWispMoveSpeed = cfg.BindOptionSteppedSlider("Elusive Antlers", "Stack Wisp MS", 0f, 0.01f, "Extra bonus movespeed per collected wisp, per stack. Vanilla is 0 = 0%.", 0f, 0.5f, restartRequired: true, 1);
			EABaseMaxWisps = cfg.BindOptionSteppedSlider("Elusive Antlers", "Base Max Wisps", 1f, 1f, "The maximum number of wisps collected at 1 stack. Vanilla is 3.", 1f, 10f, restartRequired: true);
			EAStackMaxWisps = cfg.BindOptionSteppedSlider("Elusive Antlers", "Stack Max Wisps", 1f, 1f, "Extra maximum number of wisps collected, per stack. Vanilla is 1.", 1f, 10f, restartRequired: true);
			EABaseBuffDuration = cfg.BindOptionSteppedSlider("Elusive Antlers", "Base Buff Time", 15f, 0.1f, "Duration of Movespeed buff in seconds from collecting wisps at 1 stack. Vanilla is 12s.", 1f, 20f, restartRequired: true, 2);
			EAStackBuffDuration = cfg.BindOptionSteppedSlider("Elusive Antlers", "Stack Buff Time", 0f, 0.1f, "Extra duration of movespeed buff in seconds from collecting wisps, per stack. Vanilla is 0.", 0f, 20f, restartRequired: true, 2);
			EABaseWispInterval = cfg.BindOptionSteppedSlider("Elusive Antlers", "Interval", 10f, 0.1f, "Duration in seconds between wisp spawns at 1 stack.", 1f, 20f, restartRequired: true, 2);
			EAStackWispIntervalReduction = cfg.BindOptionSteppedSlider("Elusive Antlers", "Interval Reduction", 0f, 0.01f, "Percentage interval reduction for the second stack of this item. This function is hyperbolic, so stacks beyond 2 will yield diminishing returns (like tougher times)." + Environment.NewLine + "WARNING: If this value is set to more than 1 - (floor/interval), unusual behaviour will occur!", 0f, 0.5f, restartRequired: true, 1);
			EANoStackWispMoveSpeed = cfg.BindOptionSteppedSlider("Elusive Antlers", "Zero-Stack Wisp MS", 0.1f, 0.01f, "Movespeed bonus with 0 stacks of ELusive Antlers. Vanilla is 0.12 = 12%." + Environment.NewLine + "(Allies with no stacks of elusive antlers can still pick up wisps spawned by other players. They will inherit the buff duration, but movespeed and max stacks can be defined seperately). Vanilla is 0.12 = 12%", 0f, 0.5f, restartRequired: true, 1);
			EANoStackMaxWisps = cfg.BindOptionSteppedSlider("Elusive Antlers", "Zero-Stack Max Wisps", 1f, 1f, "Max number of collected wisps with 0 stacks of Elusive Antlers. Vanilla is 3." + Environment.NewLine + "(Allies with no stacks of elusive antlers can still pick up wisps spawned by other players. They will inherit the buff duration, but movespeed and max stacks can be defined seperately).", 1f, 10f, restartRequired: true);
			WEEnableChanges = cfg.BindOption("Warped Echo", "Enable Changes", defaultValue: true, "Enable changes for this item." + Environment.NewLine + "If set to false, hooks for this item will not apply, none of the below settings will apply, and the item will be reverted to it's vanilla functionality.", restartRequired: true);
			WEBaseDamageReduction = cfg.BindOptionSteppedSlider("Warped Echo", "Base Damage Reduction", 0.04f, 0.01f, "The percentage amount that the triggering hit is reduced by. Vanilla is 0.3 = 30%.", 0f, 0.5f, restartRequired: true, 1);
			WEStackDamageReduction = cfg.BindOptionSteppedSlider("Warped Echo", "Stack Damage Reduction", 0.04f, 0.01f, "The percentage amount per stack that the triggering hit is reduced by. Scaling is hyperbolic. Vanilla is 0%.", 0f, 0.25f, restartRequired: true, 1);
			WEBaseEchoes = cfg.BindOptionSteppedSlider("Warped Echo", "Base Echoes", 4f, 1f, "The amount of echoes that the triggering hit is split up into with 1 stack. Vanilla is 3.", 1f, 10f, restartRequired: true);
			WEStackEchoes = cfg.BindOptionSteppedSlider("Warped Echo", "Stack Echoes", 2f, 1f, "The amount of echoes that the triggering hit is split up into, per stack. Vanilla is 1.", 1f, 10f, restartRequired: true);
			WEBaseCooldown = cfg.BindOptionSteppedSlider("Warped Echo", "Base Cooldown", 30f, 0.1f, "The time in seconds it takes the item to recharge. Vanilla is 15s.", 5f, 50f, restartRequired: true, 2);
			WEStackCooldownReduction = cfg.BindOptionSteppedSlider("Warped Echo", "Stack Cooldown Reduction", 0f, 0.01f, "The percentage amount by which the cooldown is decreased, per stack. This scales hyperbolically. Vanilla is 0.03 = 3%", 0f, 0.1f, restartRequired: true, 1);
			WEInitialDelay = cfg.BindOptionSteppedSlider("Warped Echo", "Initial Delay", 2.5f, 0.1f, "The delay between the instance of damage and the first echo arriving. Setting this too low will cause the first (and potentially further) instance of damage to be ignored. Vanilla is 0s.", 0.3f, 5f, restartRequired: true, 2);
			WEInterval = cfg.BindOptionSteppedSlider("Warped Echo", "Damage Interval", 0.25f, 0.01f, "The rate in seconds at which echoes are applied beyond the first. Setting this too low will cause some echoes to be ignored. Vanilla is 0.75s.", 0f, 3f, restartRequired: true, 2);
			WEEnableDamageThreshold = cfg.BindOption("Warped Echo", "Enable Damage Threshold", defaultValue: true, "Enables a threshold of the wielder's health over which Warped Echo will trigger. Vanilla is False.", restartRequired: true);
			WEDamageThreshold = cfg.BindOptionSteppedSlider("Warped Echo", "Damage Threshold", 0.25f, 0.01f, "Percentage of wielder's health lost to trigger the item. Vanilla is 0.", 0f, 0.75f, restartRequired: true, 1);
			BFEnableChanges = cfg.BindOption("Breaching Fin", "Enable Changes", defaultValue: true, "Enable changes for this item." + Environment.NewLine + "If set to false, hooks for this item will not apply, none of the below settings will apply, and the item will be reverted to it's vanilla functionality.", restartRequired: true);
			BFBaseLaunchesAfterFirst = cfg.BindOptionSteppedSlider("Breaching Fin", "Base Launches after first", 2f, 1f, "Number of additional launches past the first at 1 stack. Vanilla is 2.", 0f, 10f, restartRequired: true);
			BFStackLaunchesAfterFirst = cfg.BindOptionSteppedSlider("Breaching Fin", "Stack Launches after first", 1f, 1f, "Number of additional launches past the first, per stack of the item. Vanilla is 1.", 0f, 5f, restartRequired: true);
			BFBaseDamageBonus = cfg.BindOptionSteppedSlider("Breaching Fin", "Base Damage Bonus", 0.2f, 0.01f, "The percentage damage bonus applied to enemies per launch at 1 stack. Vanilla is 0.2 = 20%.", 0f, 1f, restartRequired: true, 1);
			BFStackDamageBonus = cfg.BindOptionSteppedSlider("Breaching Fin", "Stack Damage Bonus", 0f, 0.01f, "The additional percentage damage bonus applied to enemies per launch, per stack. Vanilla is 0 = 0%.", 0f, 0.5f, restartRequired: true, 1);
			BFBaseCooldown = cfg.BindOptionSteppedSlider("Breaching Fin", "Base Cooldown", 15f, 0.1f, "The time in seconds that it takes to recharge this item at 1 stack. Vanilla is 10s.", 5f, 60f, restartRequired: true, 2);
			BFStackCooldownReduction = cfg.BindOptionSteppedSlider("Breaching Fin", "Stack Cooldown Reduction", 0f, 0.01f, "The percentage cooldown reduction for each stack beyond the first. Scaling is hyperbolic. Vanilla is 0 = 0%.", 0f, 0.5f, restartRequired: true, 1);
			BFCooldownFloor = cfg.BindOptionSteppedSlider("Breaching Fin", "Cooldown Floor", 15f, 0.1f, "The minimum cooldown of this as stacks increase. Scaling is hyperbolic. Vanilla is 10s.", 5f, 60f, restartRequired: true, 2);
			CDEnableChanges = cfg.BindOption("Chance Doll", "Enable Changes", defaultValue: true, "Enable changes for this item." + Environment.NewLine + "If set to false, hooks for this item will not apply, none of the below settings will apply, and the item will be reverted to it's vanilla functionality.", restartRequired: true);
			CDBaseChance = cfg.BindOptionSteppedSlider("Chance Doll", "Base Chance to Improve", 0.4f, 0.01f, "The chance to increase the rarity of an item acquired from a shrine of chance at 1 stack of the item. Vanilla is 0.3 = 30%", 0f, 1f, restartRequired: true, 1);
			CDStackChance = cfg.BindOptionSteppedSlider("Chance Doll", "Stack Chance to Improve", 0.1f, 0.01f, "The bonus chance to increase the rarity of an item acquired from a shrine of chance, per stack. Vanilla is 0.1 = 10%", 0f, 1f, restartRequired: true, 1);
			LSEnableChanges = cfg.BindOption("Luminous Shot", "Enable Changes", defaultValue: true, "Enable changes for this item." + Environment.NewLine + "If set to false, hooks for this item will not apply, none of the below settings will apply, and the item will be reverted to it's vanilla functionality.", restartRequired: true);
			LSBaseMaxCharges = cfg.BindOptionSteppedSlider("Luminous Shot", "Base Max Charges", 5f, 1f, "The max number of charges Luminous Shot can store at 1 stack. Vanilla is 5.", 1f, 10f, restartRequired: true);
			LSStackMaxCharges = cfg.BindOptionSteppedSlider("Luminous Shot", "Stack Max Charges", 1f, 1f, "The additional max number of charges Luminous Shot can store per stack. Vanilla is 1.", 1f, 5f, restartRequired: true);
			LSChargeThreshold = cfg.BindOptionSteppedSlider("Luminous Shot", "Charge Threshold", 3f, 1f, "The amount of charges required before Luminous Shot activates. Vanilla is 3. If set higher than base, will require more than 1 stack of the item to actually activate.", 1f, 5f, restartRequired: true);
			LSBaseDamage = cfg.BindOptionSteppedSlider("Luminous Shot", "Base Damage", 1.25f, 0.01f, "The amount of TOTAL damage, per lightning strike, that Luminous Shot deals. Vanilla is 1.75 = 175%.", 0f, 5f, restartRequired: true, 1);
			LSStackDamage = cfg.BindOptionSteppedSlider("Luminous Shot", "Stack Damage", 0.5f, 0.01f, "The additional amount of TOTAL damage, per lightning strike, that Luminous deals, per stack. Vanilla is 0.5 = 50%.", 0f, 2f, restartRequired: true, 1);
			LSBaseCDR = cfg.BindOptionSteppedSlider("Luminous Shot", "Base Secondary Cooldown Reduction", 0.25f, 0.01f, "The percentage reduction in secondary cooldown at 1 stack. Vanilla is 0.2 = 20%.", 0f, 0.8f, restartRequired: true, 1);
			LSStackCDR = cfg.BindOptionSteppedSlider("Luminous Shot", "Stack Secondary Cooldown Reduction", 0f, 0.01f, "The extra percentage reduction in secondary cooldown, per stack. Vanilla is 0 = 0%.", 0f, 0.2f, restartRequired: true, 1);
			LSProcCoeff = cfg.BindOptionSteppedSlider("Luminous Shot", "Proc Coefficient", 0.7f, 0.01f, "The proc coefficient attached to each individual lightning strike. Vanilla is 1 = 100%.", 0f, 1f, restartRequired: true, 1);
			LSStrikeDelay = cfg.BindOptionSteppedSlider("Luminous Shot", "Strike Delay", 0.1f, 0.01f, "The delay in seconds between lightning strikes. Vanilla is 0.2s", 0.1f, 1f, restartRequired: true, 2);
			LSRadius = cfg.BindOptionSteppedSlider("Luminous Shot", "Strike Radius", 7f, 0.1f, "The radius of effect that Luminous deals it's damage in around the target, in metres. Vanilla is 7m. Note that the visual radius does not increase to reflect this.", 1f, 20f, restartRequired: true, 3);
			LSAllSkillsCharge = cfg.BindOption("Luminous Shot", "Utility and Special Add Charge", defaultValue: false, "Allows both special and utility skills to contribute charges towards Luminous Shot. Vanilla is false.", restartRequired: true);
			NTEnableChanges = cfg.BindOption("Noxious Thorn", "Enable Changes", defaultValue: true, "Enable changes for this item." + Environment.NewLine + "If set to false, hooks for this item will not apply, none of the below settings will apply, and the item will be reverted to it's vanilla functionality.", restartRequired: true);
			NTBaseBleedChance = cfg.BindOptionSteppedSlider("Noxious Thorn", "Base Bleed Chance", 0.1f, 0.01f, "The chance of applying 1 stack of bleed with 1 stack. Vanilla is 0.1 = 10%.", 0f, 1f, restartRequired: true, 1);
			NTStackBleedChance = cfg.BindOptionSteppedSlider("Noxious Thorn", "Stack Bleed Chance", 0f, 0.01f, "The extra chance of applying 1 stack of bleed, per stack. Vanilla is 0 = 0%.", 0f, 0.2f, restartRequired: true, 1);
			NTBaseDebuffTransfer = cfg.BindOptionSteppedSlider("Noxious Thorn", "Base Debuff Transfer Percentage", 0.33f, 0.01f, "The percentage amount of debuff stacks that Noxious Thorn applies to nearby enemies. Vanilla is 0.33 = 33%.", 0f, 2f, restartRequired: true, 1);
			NTStackDebuffTransfer = cfg.BindOptionSteppedSlider("Noxious Thorn", "Stack Debuff Transfer Percentage", 0f, 0.01f, "The extra percentage amount of debuff stacks that Noxious Thorn applies to nearby enemies, per stack. Vanilla is 0 = 0%.", 0f, 0.5f, restartRequired: true, 1);
			NTBaseBodies = cfg.BindOptionSteppedSlider("Noxious Thorn", "Base Number of Enemies", 1f, 1f, "The number of enemies that transferred debuff stacks are applied to, with 1 stack. Vanilla is 1.", 1f, 10f, restartRequired: true);
			NTStackBodies = cfg.BindOptionSteppedSlider("Noxious Thorn", "Stack Number of Enemies", 1f, 1f, "The extra number of enemies that transferred debuff stacks are applied to, per stack. Vanilla is 1.", 0f, 5f, restartRequired: true);
			NTBaseRange = cfg.BindOptionSteppedSlider("Noxious Thorn", "Base Range", 20f, 1f, "The maximum range in metres at which debuffs can be transferred, with 1 stack. Vanilla is 20m.", 5f, 30f, restartRequired: true, 3);
			NTStackRange = cfg.BindOptionSteppedSlider("Noxious Thorn", "Stack Range", 5f, 1f, "The range in metres at which debuffs can be transferred, per stack. Vanilla is 5m.", 0f, 30f, restartRequired: true, 3);
			NTEnableBurn = cfg.BindOption("Noxious Thorn", "Enable Independent Burn Chance", defaultValue: false, "Enables a chance to burn that is checked seperately to the chance to apply bleed. Vanilla is false.", restartRequired: true);
			NTBaseBurnChance = cfg.BindOptionSteppedSlider("Noxious Thorn", "Base Burn Chance", 0f, 0.01f, "The percentage chance to inflict burn on a target with 1 stack. Vanilla is 0 = 0%.", 0f, 1f, restartRequired: true, 1);
			NTStackBurnChance = cfg.BindOptionSteppedSlider("Noxious Thorn", "Stack Burn Chance", 0f, 0.01f, "The additional percentage chance to inflict burn on a target, per stack. Vanilla is 0 = 0%.", 0f, 0.2f, restartRequired: true, 1);
			PBEnableChanges = cfg.BindOption("Prayer Beads", "Enable Changes", defaultValue: true, "Enable changes for this item." + Environment.NewLine + "If set to false, hooks for this item will not apply, none of the below settings will apply, and the item will be reverted to it's vanilla functionality.", restartRequired: true);
			PBBaseExpGain = cfg.BindOptionSteppedSlider("Prayer Beads", "Base Exp Gain", 1f, 0.01f, "The amount of experience Prayer Beads earns as a percentage of your own experience gain. Vanilla is 1 = 100%.", 0.1f, 2f, restartRequired: true, 1);
			PBStackExpGain = cfg.BindOptionSteppedSlider("Prayer Beads", "Stack Exp Gain", 0.25f, 0.01f, "The additional amount of experience Prayer Beads earns as a percentage of your own experience gain, per stack. Vanilla is 0.25 = 25%.", 0f, 1f, restartRequired: true, 1);
			PBBaseStatBonus = cfg.BindOptionSteppedSlider("Prayer Beads", "Base Stat Bonus", 0.1f, 0.01f, "The stats that Prayer Beads yields upon removal, as a percentage of your level-up Damage, Health and Regeneration. Vanilla is 0.2 = 20%", 0.05f, 1f, restartRequired: true, 1);
			PBStackStatBonus = cfg.BindOptionSteppedSlider("Prayer Beads", "Stack Stat Bonus", 0.1f, 0.01f, "The additional stats that Prayer Beads yields upon removal, as a percentage of your level-up Damage, Health and Regeneration, per stack. Vanilla is 0.05 = 5%", 0f, 1f, restartRequired: true, 1);
			PBCalcBasedOnBeadsRemoved = cfg.BindOption("Prayer Beads", "Calculated based on Removed Stacks", defaultValue: true, "Calculates stat boost based on the number of removed stacks, rather than the number of stacks upon removal. Vanilla is false.", restartRequired: true);
			SSEnableChanges = cfg.BindOption("Sale Star", "Enable Changes", defaultValue: true, "Enable changes for this item." + Environment.NewLine + "If set to false, hooks for this item will not apply, none of the below settings will apply, and the item will be reverted to it's vanilla functionality.", restartRequired: true);
			SSBaseItemCount = cfg.BindOptionSteppedSlider("Sale Star", "Base Items", 2f, 1f, "The number of items granted from using Sale Star at 1 stack of the item. Vanilla is 2", 1f, 10f, restartRequired: true);
			SSStackExtraItemChance = cfg.BindOptionSteppedSlider("Sale Star", "Stack Chance of Extra Items", 0.05f, 0.01f, "The extra chance of getting additional items, per stack beyond the first. Vanilla is 0.05 = 5%.", 0f, 1f, restartRequired: true, 1);
			SSOneExtraItemChance = cfg.BindOptionSteppedSlider("Sale Star", "+1 Item Chance Modifier", 0.3f, 0.01f, "The base modifier for gaining 1 extra item. Does not apply at 1 stack. Vanilla is 0.3 = 30%.", 0f, 1f, restartRequired: true, 1);
			SSTwoExtraItemsChance = cfg.BindOptionSteppedSlider("Sale Star", "+2 Items Chance Modifier", 0.15f, 0.01f, "The base modifier for gaining 2 extra items, assuming the check for 1 extra item succeeds. Vanilla is 0.15 = 15%.", 0f, 1f, restartRequired: true, 1);
			SSThreeExtraItemsChance = cfg.BindOptionSteppedSlider("Sale Star", "+3 Items Chance Modifier", 0.01f, 0.01f, "The base modifier for gaining 3 extra items, assuming the check for both 1 and 2 extra items succeeds. Vanilla is 0.01 = 1%.", 0f, 1f, restartRequired: true, 1);
			UTEnableChanges = cfg.BindOption("Unstable Transmitter", "Enable Changes", defaultValue: true, "Enable changes for this item." + Environment.NewLine + "If set to false, hooks for this item will not apply, none of the below settings will apply, and the item will be reverted to it's vanilla functionality.", restartRequired: true);
			UTBaseTempHealth = cfg.BindOptionSteppedSlider("Unstable Transmitter", "Base Temp Health", 0.25f, 0.01f, "The amount of temporary health applied on activation, as a percentage of your maximum health, at 1 stack. Vanilla is 0.75 = 75%.", 0f, 2f, restartRequired: true, 1);
			UTStackTempHealth = cfg.BindOptionSteppedSlider("Unstable Transmitter", "Stack Temp Health", 0.05f, 0.01f, "The extra amount of temporary health applied on activation, as a percentage of your maximum health, per stack. Vanilla is 0 = 0%.", 0f, 0.5f, restartRequired: true, 1);
			UTBuffTime = cfg.BindOptionSteppedSlider("Unstable Transmitter", "Buff Duration", 8f, 0.1f, "The duration of the teleport aura buff, in seconds. Vanilla is 8s.", 1f, 20f, restartRequired: true, 2);
			UTStackBuffTime = cfg.BindOptionSteppedSlider("Unstable Transmitter", "Stack Buff Time", 0f, 0.1f, "The amount of additional time, per stack, that Unstable Transmitter buffs the player for. Vanilla is 0s.", 0f, 2f, restartRequired: true, 2);
			UTBuffExtension = cfg.BindOptionSteppedSlider("Unstable Transmitter", "Buff Extension on Kill", 1f, 0.1f, "The duration by which the teleporter aura buff is extended upon killing an enemy with it's bleed effect. Vanilla is 1s.", 0f, 5f, restartRequired: true, 2);
			UTMaxBuffExtension = cfg.BindOptionSteppedSlider("Unstable Transmitter", "Max Buff Extension", 10f, 0.1f, "The maximum time that the teleporter aura buff can be extended by. Vanilla is 10s.", 0f, 20f, restartRequired: true, 2);
			UTBaseCooldown = cfg.BindOptionSteppedSlider("Unstable Transmitter", "Base Cooldown", 75f, 0.1f, "The time in seconds it takes to recharge. Vanilla is 45s.", 30f, 120f, restartRequired: true, 2);
			UTStackCooldownReduction = cfg.BindOptionSteppedSlider("Unstable Transmitter", "Stack Cooldown Reduction", 0f, 0.01f, "The cooldown reduction percentage per stack. This function is hyperbolic. Vanilla is 0.1 = 10%.", 0f, 0.3f, restartRequired: true, 1);
			UTBaseBleedStacks = cfg.BindOptionSteppedSlider("Unstable Transmitter", "Base Bleed Stacks", 1f, 1f, "The base number of bleed stacks applied to teleported enemies at 1 stack. Vanilla is 3.", 0f, 10f, restartRequired: true);
			UTStackBleedStacks = cfg.BindOptionSteppedSlider("Unstable Transmitter", "Stack Bleed Stacks", 1f, 1f, "The extra number of bleed stacks applied to teleported enemies per stack. Vanilla is 1.", 0f, 5f, restartRequired: true);
			EBEnableChanges = cfg.BindOption("Electric Boomerang", "Enable Changes", defaultValue: true, "Enable changes for this item." + Environment.NewLine + "If set to false, hooks for this item will not apply, none of the below settings will apply, and the item will be reverted to it's vanilla functionality.", restartRequired: true);
			EBBaseHitChance = cfg.BindOptionSteppedSlider("Electric Boomerang", "Base Chance", 0.15f, 0.01f, "Percentage chance to activate electric boomerang at 1 stack of the item. Vanilla is 0.15 = 15%.", 0f, 1f, restartRequired: true, 1);
			EBStackHitChance = cfg.BindOptionSteppedSlider("Electric Boomerang", "Stack Chance", 0f, 0.01f, "Extra percentage chance to activate electric boomerang, per stack of the item. Vanilla is 0.00 = 0%.", 0f, 0.5f, restartRequired: true, 1);
			EBBaseHitDamage = cfg.BindOptionSteppedSlider("Electric Boomerang", "Base Contact Damage", 1f, 0.01f, "The contact damage dealt to enemies as a percentage of your BASE damage, at 1 stack of the item. Vanilla is 1.2 = 120%.", 0f, 5f, restartRequired: true, 1);
			EBStackHitDamage = cfg.BindOptionSteppedSlider("Electric Boomerang", "Stack Contact Damage", 1f, 0.01f, "The extra contact damage dealt to enemies as a percentage of your BASE damage, per stack of the item. Vanilla is 1.2 = 120%.", 0f, 2f, restartRequired: true, 1);
			EBPercSpinDamage = cfg.BindOptionSteppedSlider("Electric Boomerang", "Spin Damage Percentage", 0.25f, 0.01f, "The tick damage dealt whilst the boomerang is intersecting with an enemy's hitbox, as a percentage of the contact damage. (e.g, if contact damage is 12, 25% spin damage will be 3). Vanilla is 0.35 = 35%.", 0f, 1f, restartRequired: true, 1);
			EBHitProcCoeff = cfg.BindOptionSteppedSlider("Electric Boomerang", "Contact Proc Coefficient", 1f, 0.01f, "The proc coefficient attached to the contact portion of electric boomerang's damage. Vanilla is 1 = 100%", 0f, 2f, restartRequired: true, 1);
			EBSpinProcCoeff = cfg.BindOptionSteppedSlider("Electric Boomerang", "Spin Proc Coefficient", 0.1f, 0.01f, "The proc coefficient attached to the hitbox-intersection portion of electric boomerang's damage. Vanilla is 0.2 = 20%", 0f, 2f, restartRequired: true, 1);
			EBTravelSpeed = cfg.BindOptionSteppedSlider("Electric Boomerang", "Travel Speed", 60f, 1f, "The maximum speed of electric boomerang's projectiles in m/s. Note that tweaking this will also change the effective range of the boomerang. Vanilla is 60m/s.", 30f, 120f, restartRequired: true, 4);
			EBDisableBleed = cfg.BindOption("Electric Boomerang", "Disable Bleed", defaultValue: true, "Disables the bug where electric boomerang will apply bleed whilst you have Sawmerang in your inventory. Vanilla is false.", restartRequired: true);
			GNEnableChanges = cfg.BindOption("Growth Nectar", "Enable Changes", defaultValue: true, "Enable changes for this item." + Environment.NewLine + "If set to false, hooks for this item will not apply, none of the below settings will apply, and the item will be reverted to it's vanilla functionality.", restartRequired: true);
			GNBaseBuffs = cfg.BindOptionSteppedSlider("Growth Nectar", "Base Max Buffs", 5f, 1f, "The maximum number of buffs that apply Growth Nectar's buff at stack 1 of the item. Vanilla is 2.", 0f, 10f, restartRequired: true);
			GNStackBuffs = cfg.BindOptionSteppedSlider("Growth Nectar", "Stack Max Buffs", 0f, 1f, "The extra maximum number of buffs that apply Growth Nectar's buff, per stack. Vanilla is 4.", 0f, 10f, restartRequired: true);
			GNBaseStatBuff = cfg.BindOptionSteppedSlider("Growth Nectar", "Base Stat Boost", 0.05f, 0.001f, "The stat boost applied to Health, Health Regen, Movement Speed, Damage, Attack Speed, Crit Chance and Armour Multiplier per buff at 1 stack. Vanilla is 0.07 = 7%.", 0f, 1f, restartRequired: true, 1);
			GNStackStatBuff = cfg.BindOptionSteppedSlider("Growth Nectar", "Stack Stat Boost", 0.05f, 0.001f, "The extra stat boost applied to Health, Health Regen, Movement Speed, Damage, Attack Speed, Crit Chance and Armour Multiplier per buff, per stack. Vanilla is 0.07 = 7%.", 0f, 0.5f, restartRequired: true, 1);
			RLEnableChanges = cfg.BindOption("Runic Lens", "Enable Changes", defaultValue: true, "Enable changes for this item." + Environment.NewLine + "If set to false, hooks for this item will not apply, none of the below settings will apply, and the item will be reverted to it's vanilla functionality.", restartRequired: true);
			RLBaseChance = cfg.BindOptionSteppedSlider("Runic Lens", "Base Chance to Hit", 0.02f, 0.001f, "The base percentage chance to activate upon damaging an enemy, at 1 stack. Vanilla is 0.03 = 3%.", 0f, 1f, restartRequired: true, 1);
			RLStackChance = cfg.BindOptionSteppedSlider("Runic Lens", "Stack Chance to Hit", 0f, 0.001f, "The extra percentage chance to activate upon damaging an enemy, per stack. Vanilla is 0 = 0%.", 0f, 1f, restartRequired: true, 1);
			RLBaseDamage = cfg.BindOptionSteppedSlider("Runic Lens", "Base Damage", 20f, 0.01f, "The damage dealt on impact as a percentage of your BASE damage at 1 stack. Vanilla is 20 = 2000%.", 5f, 100f, restartRequired: true, 1);
			RLStackDamage = cfg.BindOptionSteppedSlider("Runic Lens", "Stack Damage", 0f, 0.01f, "The extra damage dealt on impact as a percentage of your BASE damage, per stack. Vanilla is 0 = 0%.", 0f, 50f, restartRequired: true, 1);
			RLThreshold = cfg.BindOptionSteppedSlider("Runic Lens", "Threshold", 1f, 0.01f, "Threshold is a percentage of your BASE damage. For every threshold% damage the inflicting attack deals, Runic Lens boosts the damage and activation chance.", 0f, 10f, restartRequired: true, 1);
			RLBaseThresholdChance = cfg.BindOptionSteppedSlider("Runic Lens", "Base Threshold Extra Chance to Hit", 0.02f, 0.001f, "Base additional chance to hit for every threshold% damage that the inflicting attack deals. Vanilla is 0.03 = 3%.", 0f, 0.2f, restartRequired: true, 1);
			RLStackThresholdChance = cfg.BindOptionSteppedSlider("Runic Lens", "Stack Threshold Extra Chance to Hit (Threshold)", 0.02f, 0.001f, "Extra additional chance to hit for every threshold% damage that the inflicting attack deals, per stack. Vanilla is 0.03 = 3%.", 0f, 0.2f, restartRequired: true, 1);
			RLChanceCap = cfg.BindOptionSteppedSlider("Runic Lens", "Chance to Hit Cap", 0.75f, 0.01f, "Maximum chance to hit through both base chance, stacking and thresholding scaling. Vanilla is 0.75 = 75%.", 0.25f, 1f, restartRequired: true, 1);
			RLBaseThresholdDamage = cfg.BindOptionSteppedSlider("Runic Lens", "Base Threshold Extra Damage", 1.5f, 0.01f, "Additional damage as a percentage of BASE damage, for every threshold% damage that the inflicting attack deals. Vanilla is 1.5 = 150%.", 0f, 3f, restartRequired: true, 1);
			RLStackThresholdDamage = cfg.BindOptionSteppedSlider("Runic Lens", "Stack Threshold Extra Damage", 0.5f, 0.01f, "Extra additional damage as a percentage of BASE damage, for every threshold% damage that the inflicting attack deals, per stack. Vanilla is 0.5 = 50%.", 0f, 1f, restartRequired: true, 1);
			RLDamageCap = cfg.BindOptionSteppedSlider("Runic Lens", "Damage Cap", 75f, 0.01f, "Maximum damage as a percentage of BASE damage, through both base damage and threshold scaling. Vanilla is 75 = 7500%.", 50f, 100f, restartRequired: true, 1);
			RLAoE = cfg.BindOptionSteppedSlider("Runic Lens", "Area of Effect", 10f, 0.1f, "Area of Effect of the Meteor. Vanilla is 10m.", 5f, 50f, restartRequired: true, 3);
			RLProcCoeff = cfg.BindOptionSteppedSlider("Runic Lens", "Proc Coefficient", 0.5f, 0.01f, "Proc Coefficient of the Meteor. Vanilla is 0.5 = 50%.", 0f, 1f, restartRequired: true, 1);
			SWEnableChanges = cfg.BindOption("Sonorous Whispers", "Enable Changes", defaultValue: true, "Enable changes for this item." + Environment.NewLine + "If set to false, hooks for this item will not apply, none of the below settings will apply, and the item will be reverted to it's vanilla functionality.", restartRequired: true);
			SWBaseChampionDropChance = cfg.BindOptionSteppedSlider("Sonorous Whispers", "Base Boss Drop Chance", 0.75f, 0.01f, "The chance of a boss dropping an item on kill at 1 stack. Vanilla is 1.00 = 100%.", 0f, 1f, restartRequired: true, 1);
			SWStackChampionDropChance = cfg.BindOptionSteppedSlider("Sonorous Whispers", "Stack Boss Drop Chance", 0.05f, 0.01f, "The extra chance of a boss dropping an item on kill per stack. Vanilla is 0.00 = 0%.", 0f, 1f, restartRequired: true, 1);
			SWBaseEliteDropChance = cfg.BindOptionSteppedSlider("Sonorous Whispers", "Base Elite Drop Chance", 0.02f, 0.001f, "The chance of an elite dropping an item on kill at 1 stack. Vanilla is 0.04 = 4%.", 0f, 1f, restartRequired: true, 1);
			SWStackEliteDropChance = cfg.BindOptionSteppedSlider("Sonorous Whispers", "Stack Elite Drop Chance", 0.01f, 0.001f, "The extra chance of an elite dropping an item on kill per stack. Vanilla is 0.01 = 1%.", 0f, 1f, restartRequired: true, 1);
			WBEnableChanges = cfg.BindOption("War Bonds", "Enable Changes", defaultValue: true, "Enable changes for this item." + Environment.NewLine + "If set to false, hooks for this item will not apply, none of the below settings will apply, and the item will be reverted to it's vanilla functionality.", restartRequired: true);
			WBBaseBossHP = cfg.BindOptionSteppedSlider("War Bonds", "Base Boss %HP Damage", 0.1f, 0.001f, "Damage per missile as a percentage of the receiving boss' health, at 1 stack. Vanilla is 0.025 = 2.5%.", 0f, 1f, restartRequired: true, 1);
			WBStackBossHP = cfg.BindOptionSteppedSlider("War Bonds", "Stack Boss %HP Damage", 0f, 0.001f, "The extra damage per missile as a percentage of the receiving boss' health, per stack. Vanilla is 0.025", 0f, 1f, restartRequired: true, 1);
			WBInitialCount = cfg.BindOptionSteppedSlider("War Bonds", "Initial Missile Count", 2f, 1f, "The number of war bonds missiles granted to the player at the start of each stage. Vanilla is 5.", 0f, 20f, restartRequired: true);
			WBBaseMaxMissiles = cfg.BindOptionSteppedSlider("War Bonds", "Base Max Missiles", 10f, 1f, "The maximum number of missiles a player can have, at 1 stack. Vanilla is 20.", 0f, 20f, restartRequired: true);
			WBStackMaxMissiles = cfg.BindOptionSteppedSlider("War Bonds", "Stack Max Missiles", 5f, 1f, "The extra maximum number of missiles a player can have, per stack. Vanilla is 5.", 0f, 20f, restartRequired: true);
			WBGoldReq = cfg.BindOptionSteppedSlider("War Bonds", "Gold Requirement", 150f, 5f, "The collected gold required to load another missile. Vanilla is 25.", 0f, 1000f, restartRequired: true);
			WBNormalEnemyDamageRatio = cfg.BindOptionSteppedSlider("War Bonds", "Normal Enemy Damage", 32f, 0.01f, "The damage dealt to non-boss enemies by war bonds, as a percentage of the wielder's BASE damage. Vanilla is 32 = 3200%", 0f, 50f, restartRequired: true, 1);
			WBProjectileDamageCoeff = cfg.BindOptionSteppedSlider("War Bonds", "Overlap Projectile Damage Coefficient", 0f, 0.01f, "The damage that the projectile portion (not the explosion) of war bonds deals as it passes through enemies, as a percentage of War Bonds' explosion damage. Vanilla is 1 = 100%.", 0f, 3f, restartRequired: true, 1);
			WBProcCoeff = cfg.BindOptionSteppedSlider("War Bonds", "Proc Coefficient", 0f, 0.01f, "The proc coefficient of War Bonds' missiles. Vanilla is 1.", 0f, 3f, restartRequired: true, 1);
			WBStartDelay = cfg.BindOptionSteppedSlider("War Bonds", "Missile Start Delay", 5f, 0.1f, "The delay between the boss spawning and the first missile being launched in seconds. Vanilla is 5s.", 0f, 10f, restartRequired: true, 2);
			WBInterval = cfg.BindOptionSteppedSlider("War Bonds", "Missile Interval", 0.75f, 0.01f, "The time between subsequent launches of missiles in seconds. Vanilla is 0.3s.", 0f, 5f, restartRequired: true, 2);
			WBEnemyCollision = cfg.BindOption("War Bonds", "Explode on Enemy Collision", defaultValue: true, "Causes War Bonds missiles to explode on contact with enemies, in addition to hitting terrain.", restartRequired: true);
			WBDisableDuringTPEvent = cfg.BindOption("War Bonds", "Disable Charging during TP Event", defaultValue: true, "Prevents additional War Bonds missiles from being earned once the teleporter is activated, until the player leaves the stage.", restartRequired: true);
		}

		public static void InitRoO()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				ModSettingsManager.SetModDescription("SOTS Items saving too many of your otherwise doomed runs? Not anymore!", "Skeletogne.SeekersoftheStormNerfs", "SeekersoftheStormNerfs");
				byte[] array = File.ReadAllBytes(Path.Combine(SeekersoftheStormNerfs.Instance.DirectoryName, "icon.png"));
				Texture2D val = new Texture2D(256, 256);
				ImageConversion.LoadImage(val, array);
				Sprite modIcon = Sprite.Create(val, new Rect(0f, 0f, 256f, 256f), new Vector2(0.5f, 0.5f));
				ModSettingsManager.SetModIcon(modIcon);
			}
			catch (Exception ex)
			{
				Log.Debug(ex.ToString());
			}
		}

		public static ConfigEntry<T> BindOption<T>(this ConfigFile myConfig, string section, string name, T defaultValue, string description = "", bool restartRequired = false)
		{
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Expected O, but got Unknown
			bool flag = ((defaultValue is int || defaultValue is float) ? true : false);
			if (flag && !typeof(T).IsEnum)
			{
				Log.Warning("Config entry " + name + " in section " + section + " is a numeric " + typeof(T).Name + " type, but has been registered without using BindOptionSlider. Lower and upper bounds will be set to the defaults [0, 20]. Was this intentional?");
				return myConfig.BindOptionSlider(section, name, defaultValue, description, 0f, 20f, restartRequired);
			}
			if (string.IsNullOrEmpty(description))
			{
				description = name;
			}
			if (restartRequired)
			{
				description += " (restart required)";
			}
			AcceptableValueBase val = null;
			if (typeof(T).IsEnum)
			{
				val = (AcceptableValueBase)(object)new AcceptableValueList<string>(Enum.GetNames(typeof(T)));
			}
			ConfigEntry<T> val2 = myConfig.Bind<T>(section, name, defaultValue, new ConfigDescription(description, val, Array.Empty<object>()));
			if (SeekersoftheStormNerfs.RooInstalled)
			{
				TryRegisterOption<T>(val2, restartRequired);
			}
			return val2;
		}

		public static ConfigEntry<T> BindOptionSlider<T>(this ConfigFile myConfig, string section, string name, T defaultValue, string description = "", float min = 0f, float max = 20f, bool restartRequired = false)
		{
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Expected O, but got Unknown
			bool flag = ((defaultValue is int || defaultValue is float) ? true : false);
			if (!flag || typeof(T).IsEnum)
			{
				Log.Warning("Config entry " + name + " in section " + section + " is a not a numeric " + typeof(T).Name + " type, but has been registered as a slider option using BindOptionSlider. Was this intentional?");
				return myConfig.BindOption(section, name, defaultValue, description, restartRequired);
			}
			if (string.IsNullOrEmpty(description))
			{
				description = name;
			}
			string text = description;
			T val = defaultValue;
			description = text + " (Default: " + val?.ToString() + ")";
			if (restartRequired)
			{
				description += " (restart required)";
			}
			AcceptableValueBase val2 = (AcceptableValueBase)((typeof(T) == typeof(int)) ? ((object)new AcceptableValueRange<int>((int)min, (int)max)) : ((object)new AcceptableValueRange<float>(min, max)));
			ConfigEntry<T> val3 = myConfig.Bind<T>(section, name, defaultValue, new ConfigDescription(description, val2, Array.Empty<object>()));
			if (SeekersoftheStormNerfs.RooInstalled)
			{
				TryRegisterOptionSlider<T>(val3, min, max, restartRequired);
			}
			return val3;
		}

		public static ConfigEntry<T> BindOptionSteppedSlider<T>(this ConfigFile myConfig, string section, string name, T defaultValue, float increment = 1f, string description = "", float min = 0f, float max = 20f, bool restartRequired = false, int type = 0)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			if (string.IsNullOrEmpty(description))
			{
				description = name;
			}
			string text = description;
			T val = defaultValue;
			description = text + " (Default: " + val?.ToString() + ")";
			if (restartRequired)
			{
				description += " (restart required)";
			}
			ConfigEntry<T> val2 = myConfig.Bind<T>(section, name, defaultValue, new ConfigDescription(description, (AcceptableValueBase)(object)new AcceptableValueRange<float>(min, max), Array.Empty<object>()));
			if (SeekersoftheStormNerfs.RooInstalled)
			{
				TryRegisterOptionSteppedSlider<T>(val2, increment, min, max, restartRequired, type);
			}
			return val2;
		}

		public static void TryRegisterOption<T>(ConfigEntry<T> entry, bool restartRequired)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			if (entry is ConfigEntry<string> val)
			{
				ModSettingsManager.AddOption((BaseOption)new StringInputFieldOption(val, new InputFieldConfig
				{
					submitOn = (SubmitEnum)6,
					restartRequired = restartRequired
				}));
				return;
			}
			if (entry is ConfigEntry<bool> val2)
			{
				ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(val2, restartRequired));
				return;
			}
			if (entry is ConfigEntry<KeyboardShortcut> val3)
			{
				ModSettingsManager.AddOption((BaseOption)new KeyBindOption(val3, restartRequired));
				return;
			}
			if (typeof(T).IsEnum)
			{
				ModSettingsManager.AddOption((BaseOption)new ChoiceOption((ConfigEntryBase)(object)entry, restartRequired));
				return;
			}
			Log.Warning("Config entry " + ((ConfigEntryBase)entry).Definition.Key + " in section " + ((ConfigEntryBase)entry).Definition.Section + " with type " + typeof(T).Name + " could not be registered in Risk Of Options using TryRegisterOption.");
		}

		public static void TryRegisterOptionSlider<T>(ConfigEntry<T> entry, float min, float max, bool restartRequired)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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_003e: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			if (entry is ConfigEntry<int> val)
			{
				ModSettingsManager.AddOption((BaseOption)new IntSliderOption(val, new IntSliderConfig
				{
					min = (int)min,
					max = (int)max,
					formatString = "{0:0}",
					restartRequired = restartRequired
				}));
			}
			else if (entry is ConfigEntry<float> val2)
			{
				ModSettingsManager.AddOption((BaseOption)new SliderOption(val2, new SliderConfig
				{
					min = min,
					max = max,
					FormatString = "{0:0.000}",
					restartRequired = restartRequired
				}));
			}
			else
			{
				Log.Warning("Config entry " + ((ConfigEntryBase)entry).Definition.Key + " in section " + ((ConfigEntryBase)entry).Definition.Section + " with type " + typeof(T).Name + " could not be registered in Risk Of Options using TryRegisterOptionSlider.");
			}
		}

		public static void TryRegisterOptionSteppedSlider<T>(ConfigEntry<T> entry, float increment, float min, float max, bool restartRequired, int type)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: 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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			if (entry is ConfigEntry<float> val)
			{
				ModSettingsManager.AddOption((BaseOption)new StepSliderOption(val, new StepSliderConfig
				{
					increment = increment,
					min = min,
					max = max,
					FormatString = GetStepSizePrecision((decimal)increment, type),
					restartRequired = restartRequired
				}));
			}
			else
			{
				Log.Warning("Config entry " + ((ConfigEntryBase)entry).Definition.Key + " in section " + ((ConfigEntryBase)entry).Definition.Section + " with type " + typeof(T).Name + " could not be registered in Risk Of Options using TryRegisterOptionSteppedSlider.");
			}
		}

		private static string GetStepSizePrecision(decimal n, int type)
		{
			n = Math.Abs(n);
			n -= (decimal)(int)n;
			int num = 0;
			string text = "{0:";
			while (n > 0m)
			{
				num++;
				n *= 10m;
				n -= (decimal)(int)n;
			}
			if (type == 1)
			{
				return text + "P" + (num - 2) + "}";
			}
			if (num == 0)
			{
				return text + "0}" + AppendSuffix(type);
			}
			if (num > 0)
			{
				text += "0.";
				for (int i = 0; i < num; i++)
				{
					text += "0";
				}
				text += "}";
				return text + AppendSuffix(type);
			}
			Log.Error("Could not determine string format!");
			return "{0:000}";
		}

		private static string AppendSuffix(int type)
		{
			return type switch
			{
				1 => "%", 
				2 => "s", 
				3 => "m", 
				4 => "m/s", 
				_ => "", 
			};
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("Skeletogne.SeekersoftheStormNerfs", "SeekersoftheStormNerfs", "1.0.0")]
	public class SeekersoftheStormNerfs : BaseUnityPlugin
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_OnSkillActivated <0>__UtilityAndSpecialCharge;

			public static hook_TakeDamageProcess <1>__CheckForNoxiousThornBurn;

			public static hook_TrackBeadExperience <2>__ChangeBeadExpGain;
		}

		public const string PluginGUID = "Skeletogne.SeekersoftheStormNerfs";

		public const string PluginAuthor = "Skeletogne";

		public const string PluginName = "SeekersoftheStormNerfs";

		public const string PluginVersion = "1.0.0";

		private static readonly Dictionary<string, string> DefaultLanguage = new Dictionary<string, string>();

		internal static bool RooInstalled => Chainloader.PluginInfos.ContainsKey("com.rune580.riskofoptions");

		public static SeekersoftheStormNerfs Instance { get; private set; }

		internal string DirectoryName => Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);

		public void OnEnable()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Expected O, but got Unknown
			if (PluginConfig.LSEnableChanges.Value && PluginConfig.LSAllSkillsCharge.Value)
			{
				object obj = <>O.<0>__UtilityAndSpecialCharge;
				if (obj == null)
				{
					hook_OnSkillActivated val = LuminousShot.UtilityAndSpecialCharge;
					<>O.<0>__UtilityAndSpecialCharge = val;
					obj = (object)val;
				}
				CharacterBody.OnSkillActivated += (hook_OnSkillActivated)obj;
			}
			if (PluginConfig.NTEnableChanges.Value && PluginConfig.NTEnableBurn.Value)
			{
				object obj2 = <>O.<1>__CheckForNoxiousThornBurn;
				if (obj2 == null)
				{
					hook_TakeDamageProcess val2 = NoxiousThorn.CheckForNoxiousThornBurn;
					<>O.<1>__CheckForNoxiousThornBurn = val2;
					obj2 = (object)val2;
				}
				HealthComponent.TakeDamageProcess += (hook_TakeDamageProcess)obj2;
			}
			if (PluginConfig.PBEnableChanges.Value)
			{
				object obj3 = <>O.<2>__ChangeBeadExpGain;
				if (obj3 == null)
				{
					hook_TrackBeadExperience val3 = PrayerBeads.ChangeBeadExpGain;
					<>O.<2>__ChangeBeadExpGain = val3;
					obj3 = (object)val3;
				}
				CharacterMaster.TrackBeadExperience += (hook_TrackBeadExperience)obj3;
			}
		}

		public void OnDisable()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Expected O, but got Unknown
			if (PluginConfig.LSEnableChanges.Value && PluginConfig.LSAllSkillsCharge.Value)
			{
				object obj = <>O.<0>__UtilityAndSpecialCharge;
				if (obj == null)
				{
					hook_OnSkillActivated val = LuminousShot.UtilityAndSpecialCharge;
					<>O.<0>__UtilityAndSpecialCharge = val;
					obj = (object)val;
				}
				CharacterBody.OnSkillActivated -= (hook_OnSkillActivated)obj;
			}
			if (PluginConfig.NTEnableChanges.Value && PluginConfig.NTEnableBurn.Value)
			{
				object obj2 = <>O.<1>__CheckForNoxiousThornBurn;
				if (obj2 == null)
				{
					hook_TakeDamageProcess val2 = NoxiousThorn.CheckForNoxiousThornBurn;
					<>O.<1>__CheckForNoxiousThornBurn = val2;
					obj2 = (object)val2;
				}
				HealthComponent.TakeDamageProcess -= (hook_TakeDamageProcess)obj2;
			}
			if (PluginConfig.PBEnableChanges.Value)
			{
				object obj3 = <>O.<2>__ChangeBeadExpGain;
				if (obj3 == null)
				{
					hook_TrackBeadExperience val3 = PrayerBeads.ChangeBeadExpGain;
					<>O.<2>__ChangeBeadExpGain = val3;
					obj3 = (object)val3;
				}
				CharacterMaster.TrackBeadExperience -= (hook_TrackBeadExperience)obj3;
			}
		}

		public void Awake()
		{
			Instance = this;
			Log.Init(((BaseUnityPlugin)this).Logger);
			PluginConfig.Init(((BaseUnityPlugin)this).Config);
			if (PluginConfig.CEEnableChanges.Value)
			{
				ChronicExpansion.ApplyChanges();
			}
			if (PluginConfig.EAEnableChanges.Value)
			{
				ElusiveAntlers.ApplyChanges();
			}
			if (PluginConfig.BLEnableChanges.Value)
			{
				BolsteringLantern.ApplyChanges();
			}
			if (PluginConfig.WEEnableChanges.Value)
			{
				WarpedEcho.ApplyChanges();
			}
			if (PluginConfig.BFEnableChanges.Value)
			{
				BreachingFin.ApplyChanges();
			}
			if (PluginConfig.CDEnableChanges.Value)
			{
				ChanceDoll.ApplyChanges();
			}
			if (PluginConfig.LSEnableChanges.Value)
			{
				LuminousShot.ApplyChanges();
			}
			if (PluginConfig.NTEnableChanges.Value)
			{
				NoxiousThorn.ApplyChanges();
			}
			if (PluginConfig.PBEnableChanges.Value)
			{
				PrayerBeads.ApplyChanges();
			}
			if (PluginConfig.SSEnableChanges.Value)
			{
				SaleStar.ApplyChanges();
			}
			if (PluginConfig.UTEnableChanges.Value)
			{
				UnstableTransmitter.ApplyChanges();
			}
			if (PluginConfig.EBEnableChanges.Value)
			{
				ElectricBoomerang.ApplyChanges();
			}
			if (PluginConfig.GNEnableChanges.Value)
			{
				GrowthNectar.ApplyChanges();
			}
			if (PluginConfig.RLEnableChanges.Value)
			{
				RunicLens.ApplyChanges();
			}
			if (PluginConfig.SWEnableChanges.Value)
			{
				SonorousWhispers.ApplyChanges();
			}
			if (PluginConfig.WBEnableChanges.Value)
			{
				WarBonds.ApplyChanges();
			}
		}

		public static void ReplaceItemDesc(string itemToken, string itemDescription)
		{
			try
			{
				DefaultLanguage[itemToken] = itemDescription;
				LanguageAPI.Add(itemToken, itemDescription);
			}
			catch
			{
				Log.Error("Failed to update item description for " + itemToken);
			}
		}
	}
}
namespace SeekersoftheStormNerfs.items
{
	internal static class BolsteringLantern
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<Instruction, bool> <>9__10_4;

			public static Func<int, int, int> <>9__10_2;

			public static Func<Instruction, bool> <>9__10_5;

			public static Func<Instruction, bool> <>9__10_6;

			public static Manipulator <>9__10_0;

			public static Func<Instruction, bool> <>9__10_9;

			public static Func<Instruction, bool> <>9__10_10;

			public static Func<Instruction, bool> <>9__10_11;

			public static Func<Instruction, bool> <>9__10_12;

			public static Func<Instruction, bool> <>9__10_13;

			public static Func<float, CharacterBody, float> <>9__10_7;

			public static Func<Instruction, bool> <>9__10_14;

			public static Func<Instruction, bool> <>9__10_15;

			public static Func<Instruction, bool> <>9__10_16;

			public static Func<Instruction, bool> <>9__10_17;

			public static Func<float, CharacterBody, float> <>9__10_8;

			public static Manipulator <>9__10_1;

			internal void <ApplyChanges>b__10_0(ILContext il)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Expected O, but got Unknown
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Expected O, but got Unknown
				//IL_0104: Unknown result type (might be due to invalid IL or missing references)
				<>c__DisplayClass10_0 CS$<>8__locals0 = new <>c__DisplayClass10_0();
				ILCursor val = new ILCursor(il);
				if (val.TryGotoNext(new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchStfld(x, typeof(LowerHealthCollider), "maxCharacterCount")
				}))
				{
					val.Emit(OpCodes.Ldarg_1);
					val.EmitDelegate<Func<int, int, int>>((Func<int, int, int>)((int originalValue, int itemCount) => baseMaxBodies + (itemCount - 1) * stackMaxBodies));
				}
				else
				{
					Log.Error("IL Hook for Bolstering Lantern Max Character Count failed!");
				}
				CS$<>8__locals0.stackDiam = stackRadius * 2f;
				CS$<>8__locals0.baseStackDiam = baseRadius * 2f;
				ILCursor val2 = new ILCursor(il);
				if (val2.TryGotoNext(new Func<Instruction, bool>[2]
				{
					(Instruction x) => ILPatternMatchingExt.MatchStindR4(x),
					(Instruction x) => ILPatternMatchingExt.MatchRet(x)
				}))
				{
					val2.Emit(OpCodes.Ldarg_1);
					val2.EmitDelegate<Func<float, int, float>>((Func<float, int, float>)((float originalValue, int itemCount) => hyperbolicScaling ? (CS$<>8__locals0.baseStackDiam + Util.ConvertAmplificationPercentageIntoReductionPercentage(CS$<>8__locals0.stackDiam) * (float)(itemCount - 1)) : (CS$<>8__locals0.baseStackDiam + CS$<>8__locals0.stackDiam * (float)(itemCount - 1))));
				}
				else
				{
					Log.Error("IL Hook for Bolstering Lantern Effect Radius failed!");
				}
			}

			internal bool <ApplyChanges>b__10_4(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld(x, typeof(LowerHealthCollider), "maxCharacterCount");
			}

			internal int <ApplyChanges>b__10_2(int originalValue, int itemCount)
			{
				return baseMaxBodies + (itemCount - 1) * stackMaxBodies;
			}

			internal bool <ApplyChanges>b__10_5(Instruction x)
			{
				return ILPatternMatchingExt.MatchStindR4(x);
			}

			internal bool <ApplyChanges>b__10_6(Instruction x)
			{
				return ILPatternMatchingExt.MatchRet(x);
			}

			internal void <ApplyChanges>b__10_1(ILContext il)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0106: Unknown result type (might be due to invalid IL or missing references)
				//IL_010c: Expected O, but got Unknown
				//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
				ILCursor val = new ILCursor(il);
				if (val.TryGotoNext(new Func<Instruction, bool>[5]
				{
					(Instruction x) => ILPatternMatchingExt.MatchMul(x),
					(Instruction x) => ILPatternMatchingExt.MatchAdd(x),
					(Instruction x) => ILPatternMatchingExt.MatchStloc(x, 97),
					(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 97),
					(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 0.1f)
				}))
				{
					val.Emit(OpCodes.Ldarg_0);
					val.EmitDelegate<Func<float, CharacterBody, float>>((Func<float, CharacterBody, float>)delegate(float originalValue, CharacterBody self)
					{
						if (Object.op_Implicit((Object)(object)self.inventory))
						{
							int itemCount2 = self.inventory.GetItemCount(Items.LowerHealthHigherDamage);
							if (itemCount2 > 0)
							{
								return baseBodyAttackSpeed + stackBodyAttackSpeed * (float)(itemCount2 - 1);
							}
						}
						return 0f;
					});
				}
				else
				{
					Log.Error("IL Hook for Bolstering Lantern Attack Speed failed!");
				}
				ILCursor val2 = new ILCursor(il);
				if (!val2.TryGotoNext(new Func<Instruction, bool>[4]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 97),
					(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 0.1f),
					(Instruction x) => ILPatternMatchingExt.MatchCall<Mathf>(x, "Max"),
					(Instruction x) => ILPatternMatchingExt.MatchStloc(x, 97)
				}))
				{
					return;
				}
				val2.Emit(OpCodes.Ldloc, 97);
				val2.Emit(OpCodes.Ldarg_0);
				val2.EmitDelegate<Func<float, CharacterBody, float>>((Func<float, CharacterBody, float>)delegate(float attackSpeed, CharacterBody body)
				{
					if ((Object)(object)body == (Object)null)
					{
						return attackSpeed;
					}
					if ((Object)(object)body.inventory == (Object)null)
					{
						return attackSpeed;
					}
					int itemCount = body.inventory.GetItemCount(Items.LowerHealthHigherDamage);
					return attackSpeed + (baseAttackSpeed + stackAttackSpeed * (float)(itemCount - 1));
				});
				val2.Emit(OpCodes.Stloc, 97);
			}

			internal bool <ApplyChanges>b__10_9(Instruction x)
			{
				return ILPatternMatchingExt.MatchMul(x);
			}

			internal bool <ApplyChanges>b__10_10(Instruction x)
			{
				return ILPatternMatchingExt.MatchAdd(x);
			}

			internal bool <ApplyChanges>b__10_11(Instruction x)
			{
				return ILPatternMatchingExt.MatchStloc(x, 97);
			}

			internal bool <ApplyChanges>b__10_12(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdloc(x, 97);
			}

			internal bool <ApplyChanges>b__10_13(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 0.1f);
			}

			internal float <ApplyChanges>b__10_7(float originalValue, CharacterBody self)
			{
				if (Object.op_Implicit((Object)(object)self.inventory))
				{
					int itemCount = self.inventory.GetItemCount(Items.LowerHealthHigherDamage);
					if (itemCount > 0)
					{
						return baseBodyAttackSpeed + stackBodyAttackSpeed * (float)(itemCount - 1);
					}
				}
				return 0f;
			}

			internal bool <ApplyChanges>b__10_14(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdloc(x, 97);
			}

			internal bool <ApplyChanges>b__10_15(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 0.1f);
			}

			internal bool <ApplyChanges>b__10_16(Instruction x)
			{
				return ILPatternMatchingExt.MatchCall<Mathf>(x, "Max");
			}

			internal bool <ApplyChanges>b__10_17(Instruction x)
			{
				return ILPatternMatchingExt.MatchStloc(x, 97);
			}

			internal float <ApplyChanges>b__10_8(float attackSpeed, CharacterBody body)
			{
				if ((Object)(object)body == (Object)null)
				{
					return attackSpeed;
				}
				if ((Object)(object)body.inventory == (Object)null)
				{
					return attackSpeed;
				}
				int itemCount = body.inventory.GetItemCount(Items.LowerHealthHigherDamage);
				return attackSpeed + (baseAttackSpeed + stackAttackSpeed * (float)(itemCount - 1));
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass10_0
		{
			public float baseStackDiam;

			public float stackDiam;

			internal float <ApplyChanges>b__3(float originalValue, int itemCount)
			{
				if (hyperbolicScaling)
				{
					return baseStackDiam + Util.ConvertAmplificationPercentageIntoReductionPercentage(stackDiam) * (float)(itemCount - 1);
				}
				return baseStackDiam + stackDiam * (float)(itemCount - 1);
			}
		}

		private static readonly int baseMaxBodies = (int)PluginConfig.BLBaseMaxBodies.Value;

		private static readonly int stackMaxBodies = (int)PluginConfig.BLStackMaxBodies.Value;

		private static readonly float baseRadius = PluginConfig.BLBaseRadius.Value;

		private static readonly float stackRadius = PluginConfig.BLStackRadius.Value;

		private static readonly bool hyperbolicScaling = PluginConfig.BLHyperbolicScaling.Value;

		private static readonly float baseBodyAttackSpeed = PluginConfig.BLBaseBodyAttackSpeed.Value;

		private static readonly float stackBodyAttackSpeed = PluginConfig.BLStackBodyAttackSpeed.Value;

		private static readonly bool enableUnconditionalAS = PluginConfig.BLEnableUnconditionalAS.Value;

		private static readonly float baseAttackSpeed = PluginConfig.BLBaseAttackSpeed.Value;

		private static readonly float stackAttackSpeed = PluginConfig.BLStackAttackSpeed.Value;

		public static void ApplyChanges()
		{
			//IL_0020: 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_002b: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			Log.Info("Bolstering Lantern hooks initialised.");
			object obj = <>c.<>9__10_0;
			if (obj == null)
			{
				Manipulator val = delegate(ILContext il)
				{
					//IL_0008: Unknown result type (might be due to invalid IL or missing references)
					//IL_000e: Expected O, but got Unknown
					//IL_0042: Unknown result type (might be due to invalid IL or missing references)
					//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ac: Expected O, but got Unknown
					//IL_0104: Unknown result type (might be due to invalid IL or missing references)
					ILCursor val5 = new ILCursor(il);
					if (val5.TryGotoNext(new Func<Instruction, bool>[1]
					{
						(Instruction x) => ILPatternMatchingExt.MatchStfld(x, typeof(LowerHealthCollider), "maxCharacterCount")
					}))
					{
						val5.Emit(OpCodes.Ldarg_1);
						val5.EmitDelegate<Func<int, int, int>>((Func<int, int, int>)((int originalValue, int itemCount) => baseMaxBodies + (itemCount - 1) * stackMaxBodies));
					}
					else
					{
						Log.Error("IL Hook for Bolstering Lantern Max Character Count failed!");
					}
					float stackDiam = stackRadius * 2f;
					float baseStackDiam = baseRadius * 2f;
					ILCursor val6 = new ILCursor(il);
					if (val6.TryGotoNext(new Func<Instruction, bool>[2]
					{
						(Instruction x) => ILPatternMatchingExt.MatchStindR4(x),
						(Instruction x) => ILPatternMatchingExt.MatchRet(x)
					}))
					{
						val6.Emit(OpCodes.Ldarg_1);
						val6.EmitDelegate<Func<float, int, float>>((Func<float, int, float>)((float originalValue, int itemCount) => hyperbolicScaling ? (baseStackDiam + Util.ConvertAmplificationPercentageIntoReductionPercentage(stackDiam) * (float)(itemCount - 1)) : (baseStackDiam + stackDiam * (float)(itemCount - 1))));
					}
					else
					{
						Log.Error("IL Hook for Bolstering Lantern Effect Radius failed!");
					}
				};
				<>c.<>9__10_0 = val;
				obj = (object)val;
			}
			LowerHealthCollider.UpdateValues += (Manipulator)obj;
			object obj2 = <>c.<>9__10_1;
			if (obj2 == null)
			{
				Manipulator val2 = delegate(ILContext il)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Expected O, but got Unknown
					//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
					//IL_0106: Unknown result type (might be due to invalid IL or missing references)
					//IL_010c: Expected O, but got Unknown
					//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
					//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
					//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
					ILCursor val3 = new ILCursor(il);
					if (val3.TryGotoNext(new Func<Instruction, bool>[5]
					{
						(Instruction x) => ILPatternMatchingExt.MatchMul(x),
						(Instruction x) => ILPatternMatchingExt.MatchAdd(x),
						(Instruction x) => ILPatternMatchingExt.MatchStloc(x, 97),
						(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 97),
						(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 0.1f)
					}))
					{
						val3.Emit(OpCodes.Ldarg_0);
						val3.EmitDelegate<Func<float, CharacterBody, float>>((Func<float, CharacterBody, float>)delegate(float originalValue, CharacterBody self)
						{
							if (Object.op_Implicit((Object)(object)self.inventory))
							{
								int itemCount3 = self.inventory.GetItemCount(Items.LowerHealthHigherDamage);
								if (itemCount3 > 0)
								{
									return baseBodyAttackSpeed + stackBodyAttackSpeed * (float)(itemCount3 - 1);
								}
							}
							return 0f;
						});
					}
					else
					{
						Log.Error("IL Hook for Bolstering Lantern Attack Speed failed!");
					}
					ILCursor val4 = new ILCursor(il);
					if (val4.TryGotoNext(new Func<Instruction, bool>[4]
					{
						(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 97),
						(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 0.1f),
						(Instruction x) => ILPatternMatchingExt.MatchCall<Mathf>(x, "Max"),
						(Instruction x) => ILPatternMatchingExt.MatchStloc(x, 97)
					}))
					{
						val4.Emit(OpCodes.Ldloc, 97);
						val4.Emit(OpCodes.Ldarg_0);
						val4.EmitDelegate<Func<float, CharacterBody, float>>((Func<float, CharacterBody, float>)delegate(float attackSpeed, CharacterBody body)
						{
							if ((Object)(object)body == (Object)null)
							{
								return attackSpeed;
							}
							if ((Object)(object)body.inventory == (Object)null)
							{
								return attackSpeed;
							}
							int itemCount2 = body.inventory.GetItemCount(Items.LowerHealthHigherDamage);
							return attackSpeed + (baseAttackSpeed + stackAttackSpeed * (float)(itemCount2 - 1));
						});
						val4.Emit(OpCodes.Stloc, 97);
					}
				};
				<>c.<>9__10_1 = val2;
				obj2 = (object)val2;
			}
			CharacterBody.RecalculateStats += (Manipulator)obj2;
			SeekersoftheStormNerfs.ReplaceItemDesc("ITEM_LOWERHEALTHHIGHERDAMAGE_DESC", "Increase your attack speed by " + $"<style=cIsDamage>{baseAttackSpeed * 100f:0.##}%</style> " + ((stackAttackSpeed != 0f) ? $"<style=cStack>(+{stackAttackSpeed * 100f:0.##}% per stack)</style> " : "") + "plus an additional " + $"<style=cIsDamage>{baseBodyAttackSpeed * 100f:0.##}%</style> " + ((stackBodyAttackSpeed != 0f) ? $"<style=cStack>(+{stackBodyAttackSpeed * 100f:0.##}% per stack)</style> " : "") + $"for up to <style=cIsUtility>{baseMaxBodies}</style> " + ((stackMaxBodies != 0) ? $"<style=cStack>(+{stackMaxBodies} per stack)</style> " : "") + $"enemies and allies within <style=cIsUtility>{baseRadius:0.##}</style> " + ((stackRadius != 0f) ? $"<style=cStack>(+{stackRadius:0.##} per stack)</style> " : "") + "meters.");
		}
	}
	internal static class BreachingFin
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<Instruction, bool> <>9__7_4;

			public static Func<float, int, float> <>9__7_3;

			public static Manipulator <>9__7_0;

			public static Func<Instruction, bool> <>9__7_6;

			public static Func<Instruction, bool> <>9__7_7;

			public static Func<float, DamageInfo, CharacterBody, CharacterBody, float> <>9__7_5;

			public static Manipulator <>9__7_1;

			public static Func<Instruction, bool> <>9__7_9;

			public static Func<Instruction, bool> <>9__7_10;

			public static Func<int, DamageInfo, int> <>9__7_8;

			public static Manipulator <>9__7_2;

			internal void <ApplyChanges>b__7_0(ILContext il)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				ILCursor val = new ILCursor(il);
				if (val.TryGotoNext(new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchRet(x)
				}))
				{
					val.Emit(OpCodes.Ldarg_0);
					val.EmitDelegate<Func<float, int, float>>((Func<float, int, float>)delegate(float originalValue, int itemCount)
					{
						float num = Util.ConvertAmplificationPercentageIntoReductionNormalized((float)(itemCount - 1) * stackCooldownReduction);
						return Mathf.Lerp(baseCooldown, cooldownFloor, num);
					});
				}
				else
				{
					Log.Error("IL Hook for Breaching Fin cooldown failed!");
				}
			}

			internal bool <ApplyChanges>b__7_4(Instruction x)
			{
				return ILPatternMatchingExt.MatchRet(x);
			}

			internal float <ApplyChanges>b__7_3(float originalValue, int itemCount)
			{
				float num = Util.ConvertAmplificationPercentageIntoReductionNormalized((float)(itemCount - 1) * stackCooldownReduction);
				return Mathf.Lerp(baseCooldown, cooldownFloor, num);
			}

			internal void <ApplyChanges>b__7_1(ILContext il)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				ILCursor val = new ILCursor(il);
				if (val.TryGotoNext(new Func<Instruction, bool>[2]
				{
					(Instruction x) => ILPatternMatchingExt.MatchAdd(x),
					(Instruction x) => ILPatternMatchingExt.MatchStfld(x, typeof(DamageInfo), "damage")
				}))
				{
					val.Emit(OpCodes.Ldarg_0);
					val.Emit(OpCodes.Ldind_Ref);
					val.Emit(OpCodes.Ldarg_1);
					val.Emit(OpCodes.Ldarg_2);
					val.EmitDelegate<Func<float, DamageInfo, CharacterBody, CharacterBody, float>>((Func<float, DamageInfo, CharacterBody, CharacterBody, float>)delegate(float originalValue, DamageInfo damageInfo, CharacterBody attacker, CharacterBody victim)
					{
						if ((Object)(object)attacker == (Object)null)
						{
							return 0f;
						}
						int itemCount = attacker.inventory.GetItemCount(Items.KnockBackHitEnemies);
						int buffCount = victim.GetBuffCount(Buffs.KnockUpHitEnemiesJuggleCount);
						return damageInfo.damage * Mathf.Max(1f, (float)buffCount) * (baseDamageBonus + stackDamageBonus * (float)(itemCount - 1));
					});
				}
				else
				{
					Log.Error("IL Hook for Breaching Fin damage bonus failed!");
				}
			}

			internal bool <ApplyChanges>b__7_6(Instruction x)
			{
				return ILPatternMatchingExt.MatchAdd(x);
			}

			internal bool <ApplyChanges>b__7_7(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld(x, typeof(DamageInfo), "damage");
			}

			internal float <ApplyChanges>b__7_5(float originalValue, DamageInfo damageInfo, CharacterBody attacker, CharacterBody victim)
			{
				if ((Object)(object)attacker == (Object)null)
				{
					return 0f;
				}
				int itemCount = attacker.inventory.GetItemCount(Items.KnockBackHitEnemies);
				int buffCount = victim.GetBuffCount(Buffs.KnockUpHitEnemiesJuggleCount);
				return damageInfo.damage * Mathf.Max(1f, (float)buffCount) * (baseDamageBonus + stackDamageBonus * (float)(itemCount - 1));
			}

			internal void <ApplyChanges>b__7_2(ILContext il)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				ILCursor val = new ILCursor(il);
				if (val.TryGotoNext(new Func<Instruction, bool>[2]
				{
					(Instruction x) => ILPatternMatchingExt.MatchStloc(x, 22),
					(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0)
				}))
				{
					val.Emit(OpCodes.Ldarg_1);
					val.EmitDelegate<Func<int, DamageInfo, int>>((Func<int, DamageInfo, int>)delegate(int originalValue, DamageInfo damageInfo)
					{
						if ((Object)(object)damageInfo.attacker.GetComponent<CharacterBody>() == (Object)null)
						{
							return 0;
						}
						if ((Object)(object)damageInfo.attacker.GetComponent<CharacterBody>().inventory == (Object)null)
						{
							return 0;
						}
						int itemCount = damageInfo.attacker.GetComponent<CharacterBody>().inventory.GetItemCount(Items.KnockBackHitEnemies);
						return baselaunchesAfterFirst + stackLaunchesAfterFirst * (itemCount - 1);
					});
				}
				else
				{
					Log.Error("IL Hook for Breaching Fin number of additional launches beyond first failed!");
				}
			}

			internal bool <ApplyChanges>b__7_9(Instruction x)
			{
				return ILPatternMatchingExt.MatchStloc(x, 22);
			}

			internal bool <ApplyChanges>b__7_10(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdarg(x, 0);
			}

			internal int <ApplyChanges>b__7_8(int originalValue, DamageInfo damageInfo)
			{
				if ((Object)(object)damageInfo.attacker.GetComponent<CharacterBody>() == (Object)null)
				{
					return 0;
				}
				if ((Object)(object)damageInfo.attacker.GetComponent<CharacterBody>().inventory == (Object)null)
				{
					return 0;
				}
				int itemCount = damageInfo.attacker.GetComponent<CharacterBody>().inventory.GetItemCount(Items.KnockBackHitEnemies);
				return baselaunchesAfterFirst + stackLaunchesAfterFirst * (itemCount - 1);
			}
		}

		public static readonly int baselaunchesAfterFirst = (int)PluginConfig.BFBaseLaunchesAfterFirst.Value;

		public static readonly int stackLaunchesAfterFirst = (int)PluginConfig.BFStackLaunchesAfterFirst.Value;

		public static readonly float baseDamageBonus = PluginConfig.BFBaseDamageBonus.Value;

		public static readonly float stackDamageBonus = PluginConfig.BFStackDamageBonus.Value;

		public static readonly float baseCooldown = PluginConfig.BFBaseCooldown.Value;

		public static readonly float cooldownFloor = PluginConfig.BFCooldownFloor.Value;

		public static readonly float stackCooldownReduction = PluginConfig.BFStackCooldownReduction.Value;

		public static void ApplyChanges()
		{
			//IL_0020: 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_002b: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			Log.Info("Breaching Fin hooks initialised.");
			object obj = <>c.<>9__7_0;
			if (obj == null)
			{
				Manipulator val = delegate(ILContext il)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Expected O, but got Unknown
					//IL_003c: Unknown result type (might be due to invalid IL or missing references)
					ILCursor val6 = new ILCursor(il);
					if (val6.TryGotoNext(new Func<Instruction, bool>[1]
					{
						(Instruction x) => ILPatternMatchingExt.MatchRet(x)
					}))
					{
						val6.Emit(OpCodes.Ldarg_0);
						val6.EmitDelegate<Func<float, int, float>>((Func<float, int, float>)delegate(float originalValue, int itemCount)
						{
							float num = Util.ConvertAmplificationPercentageIntoReductionNormalized((float)(itemCount - 1) * stackCooldownReduction);
							return Mathf.Lerp(baseCooldown, cooldownFloor, num);
						});
					}
					else
					{
						Log.Error("IL Hook for Breaching Fin cooldown failed!");
					}
				};
				<>c.<>9__7_0 = val;
				obj = (object)val;
			}
			KnockbackFinUtil.GetCooldown += (Manipulator)obj;
			object obj2 = <>c.<>9__7_1;
			if (obj2 == null)
			{
				Manipulator val2 = delegate(ILContext il)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Expected O, but got Unknown
					//IL_005e: Unknown result type (might be due to invalid IL or missing references)
					//IL_006a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0076: Unknown result type (might be due to invalid IL or missing references)
					//IL_0082: Unknown result type (might be due to invalid IL or missing references)
					ILCursor val5 = new ILCursor(il);
					if (val5.TryGotoNext(new Func<Instruction, bool>[2]
					{
						(Instruction x) => ILPatternMatchingExt.MatchAdd(x),
						(Instruction x) => ILPatternMatchingExt.MatchStfld(x, typeof(DamageInfo), "damage")
					}))
					{
						val5.Emit(OpCodes.Ldarg_0);
						val5.Emit(OpCodes.Ldind_Ref);
						val5.Emit(OpCodes.Ldarg_1);
						val5.Emit(OpCodes.Ldarg_2);
						val5.EmitDelegate<Func<float, DamageInfo, CharacterBody, CharacterBody, float>>((Func<float, DamageInfo, CharacterBody, CharacterBody, float>)delegate(float originalValue, DamageInfo damageInfo, CharacterBody attacker, CharacterBody victim)
						{
							if ((Object)(object)attacker == (Object)null)
							{
								return 0f;
							}
							int itemCount3 = attacker.inventory.GetItemCount(Items.KnockBackHitEnemies);
							int buffCount = victim.GetBuffCount(Buffs.KnockUpHitEnemiesJuggleCount);
							return damageInfo.damage * Mathf.Max(1f, (float)buffCount) * (baseDamageBonus + stackDamageBonus * (float)(itemCount3 - 1));
						});
					}
					else
					{
						Log.Error("IL Hook for Breaching Fin damage bonus failed!");
					}
				};
				<>c.<>9__7_1 = val2;
				obj2 = (object)val2;
			}
			KnockbackFinUtil.ModifyDamageInfo += (Manipulator)obj2;
			object obj3 = <>c.<>9__7_2;
			if (obj3 == null)
			{
				Manipulator val3 = delegate(ILContext il)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Expected O, but got Unknown
					//IL_005e: Unknown result type (might be due to invalid IL or missing references)
					ILCursor val4 = new ILCursor(il);
					if (val4.TryGotoNext(new Func<Instruction, bool>[2]
					{
						(Instruction x) => ILPatternMatchingExt.MatchStloc(x, 22),
						(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0)
					}))
					{
						val4.Emit(OpCodes.Ldarg_1);
						val4.EmitDelegate<Func<int, DamageInfo, int>>((Func<int, DamageInfo, int>)delegate(int originalValue, DamageInfo damageInfo)
						{
							if ((Object)(object)damageInfo.attacker.GetComponent<CharacterBody>() == (Object)null)
							{
								return 0;
							}
							if ((Object)(object)damageInfo.attacker.GetComponent<CharacterBody>().inventory == (Object)null)
							{
								return 0;
							}
							int itemCount2 = damageInfo.attacker.GetComponent<CharacterBody>().inventory.GetItemCount(Items.KnockBackHitEnemies);
							return baselaunchesAfterFirst + stackLaunchesAfterFirst * (itemCount2 - 1);
						});
					}
					else
					{
						Log.Error("IL Hook for Breaching Fin number of additional launches beyond first failed!");
					}
				};
				<>c.<>9__7_2 = val3;
				obj3 = (object)val3;
			}
			HealthComponent.TakeDamageProcess += (Manipulator)obj3;
			SeekersoftheStormNerfs.ReplaceItemDesc("ITEM_KNOCKBACKHITENEMIES_DESC", "Grounded enemies hit with any <style=cIsUtility>skill</style> are <style=cIsUtility>launched</style>, and <style=cIsUtility>stunned</style> for <style=cIsUtility>3.2s</style>. Enemies hit while airborne are <style=cIsUtility>launched</style> again up to " + $"<style=cIsUtility>{baselaunchesAfterFirst} times</style>" + (((float)stackLaunchesAfterFirst != 0f) ? $" <style=cStack>(+{stackLaunchesAfterFirst} per stack)</style>. " : ". ") + $"Launched enemies take increased damage by <style=cIsDamage>{baseDamageBonus * 100f:0.##}%</style> " + ((stackDamageBonus != 0f) ? $"<style=cStack>(+{stackDamageBonus * 100f:0.##}% per stack)</style> " : "") + "from all sources per launch. Recharges after " + $"<style=cIsUtility>{baseCooldown}s</style>" + ((stackCooldownReduction != 0f) ? $" <style=cStack>(-{stackCooldownReduction * 100f:0.##}% per stack)</style>." : "."));
		}
	}
	internal static class ChanceDoll
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<Instruction, bool> <>9__2_2;

			public static Func<Instruction, bool> <>9__2_3;

			public static Func<int, Interactor, int> <>9__2_1;

			public static Manipulator <>9__2_0;

			internal void <ApplyChanges>b__2_0(ILContext il)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				ILCursor val = new ILCursor(il);
				if (val.TryGotoNext(new Func<Instruction, bool>[2]
				{
					(Instruction x) => ILPatternMatchingExt.MatchConvR4(x),
					(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 1)
				}))
				{
					val.Emit(OpCodes.Ldarg_1);
					val.EmitDelegate<Func<int, Interactor, int>>((Func<int, Interactor, int>)delegate(int originalValue, Interactor activator)
					{
						if ((Object)(object)((Component)activator).GetComponent<CharacterBody>() == (Object)null)
						{
							Log.Info("Activator is null!");
							return 0;
						}
						if ((Object)(object)((Component)activator).GetComponent<CharacterBody>().inventory == (Object)null)
						{
							Log.Info("Activator inventory is null!");
							return 0;
						}
						int itemCount = ((Component)activator).GetComponent<CharacterBody>().inventory.GetItemCount(Items.ExtraShrineItem);
						return baseChance + stackChance * (itemCount - 1);
					});
				}
				else
				{
					Log.Error("IL Hook for Chance Doll item rarity increase chance failed!");
				}
			}

			internal bool <ApplyChanges>b__2_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchConvR4(x);
			}

			internal bool <ApplyChanges>b__2_3(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdloc(x, 1);
			}

			internal int <ApplyChanges>b__2_1(int originalValue, Interactor activator)
			{
				if ((Object)(object)((Component)activator).GetComponent<CharacterBody>() == (Object)null)
				{
					Log.Info("Activator is null!");
					return 0;
				}
				if ((Object)(object)((Component)activator).GetComponent<CharacterBody>().inventory == (Object)null)
				{
					Log.Info("Activator inventory is null!");
					return 0;
				}
				int itemCount = ((Component)activator).GetComponent<CharacterBody>().inventory.GetItemCount(Items.ExtraShrineItem);
				return baseChance + stackChance * (itemCount - 1);
			}
		}

		public static readonly int baseChance = (int)(PluginConfig.CDBaseChance.Value * 100f);

		public static readonly int stackChance = (int)(PluginConfig.CDStackChance.Value * 100f);

		public static void ApplyChanges()
		{
			//IL_0020: 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_002b: Expected O, but got Unknown
			Log.Info("Chance Doll hooks initialised.");
			object obj = <>c.<>9__2_0;
			if (obj == null)
			{
				Manipulator val = delegate(ILContext il)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Expected O, but got Unknown
					//IL_005e: Unknown result type (might be due to invalid IL or missing references)
					ILCursor val2 = new ILCursor(il);
					if (val2.TryGotoNext(new Func<Instruction, bool>[2]
					{
						(Instruction x) => ILPatternMatchingExt.MatchConvR4(x),
						(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 1)
					}))
					{
						val2.Emit(OpCodes.Ldarg_1);
						val2.EmitDelegate<Func<int, Interactor, int>>((Func<int, Interactor, int>)delegate(int originalValue, Interactor activator)
						{
							if ((Object)(object)((Component)activator).GetComponent<CharacterBody>() == (Object)null)
							{
								Log.Info("Activator is null!");
								return 0;
							}
							if ((Object)(object)((Component)activator).GetComponent<CharacterBody>().inventory == (Object)null)
							{
								Log.Info("Activator inventory is null!");
								return 0;
							}
							int itemCount = ((Component)activator).GetComponent<CharacterBody>().inventory.GetItemCount(Items.ExtraShrineItem);
							return baseChance + stackChance * (itemCount - 1);
						});
					}
					else
					{
						Log.Error("IL Hook for Chance Doll item rarity increase chance failed!");
					}
				};
				<>c.<>9__2_0 = val;
				obj = (object)val;
			}
			ShrineChanceBehavior.AddShrineStack += (Manipulator)obj;
			SeekersoftheStormNerfs.ReplaceItemDesc("ITEM_EXTRASHRINEITEM_DESC", "On Shrine of Chance success, " + $"<style=cIsUtility>{baseChance:0.##}%</style> " + (((float)stackChance != 0f) ? $"<style=cStack>(+{stackChance:0.##}% per stack)</style> " : "") + "chance to get higher rarity items.");
		}
	}
	internal static class ChronicExpansion
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<Instruction, bool> <>9__8_7