using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using AK.Wwise;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using BloonItemRebalance.Changes;
using BloonItemRebalance.Modules;
using BubbetsItems;
using BubbetsItems.Items.BarrierItems;
using BubbetsItems.Items.VoidLunar;
using EntityStates;
using EntityStates.Drone.DroneJunk;
using EntityStates.TeleporterHealNovaController;
using EntityStates.VagrantNovaItem;
using HG;
using HarmonyLib;
using IL.EntityStates.Drone.Command;
using IL.EntityStates.Drone.DroneWeapon;
using IL.EntityStates.TeleporterHealNovaController;
using IL.RoR2;
using IL.RoR2.Items;
using Meltdown;
using Meltdown.Items;
using Meltdown.Items.Green;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using Nautilus.Items;
using On.EntityStates.TeleporterHealNovaController;
using On.EntityStates.VagrantNovaItem;
using On.RoR2;
using On.RoR2.Items;
using On.RoR2.UI;
using R2API;
using RigsArsenal;
using RigsArsenal.Items;
using RigsArsenal.Items.VoidItems;
using RoR2;
using RoR2.Audio;
using RoR2.ContentManagement;
using RoR2.ExpansionManagement;
using RoR2.Items;
using RoR2.Orbs;
using RoR2.Projectile;
using RoR2.UI;
using RoR2BepInExPack.GameAssetPathsBetter;
using SS2;
using SS2.Components;
using SS2.Items;
using SeekingTheVoid;
using TooManyItems.Items.Lunar;
using TooManyItems.Items.Tier1;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Networking;
using UnityEngine.ResourceManagement.AsyncOperations;
using vanillaVoid;
using vanillaVoid.Items;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: IgnoresAccessChecksTo("BubbetsItems")]
[assembly: IgnoresAccessChecksTo("EclipseRevamped")]
[assembly: IgnoresAccessChecksTo("EnemyAbilities")]
[assembly: IgnoresAccessChecksTo("FlatItemBuff")]
[assembly: IgnoresAccessChecksTo("GrooveSaladSpikestripContent")]
[assembly: IgnoresAccessChecksTo("Meltdown")]
[assembly: IgnoresAccessChecksTo("Nautilus")]
[assembly: IgnoresAccessChecksTo("RigsArsenal")]
[assembly: IgnoresAccessChecksTo("RoR2")]
[assembly: IgnoresAccessChecksTo("SeekingTheVoid")]
[assembly: IgnoresAccessChecksTo("Starstorm2")]
[assembly: IgnoresAccessChecksTo("SuperCyanTweaks")]
[assembly: IgnoresAccessChecksTo("TooManyItems")]
[assembly: IgnoresAccessChecksTo("VanillaVoid")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("BloonItemRebalance")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BloonItemRebalance")]
[assembly: AssemblyTitle("BloonItemRebalance")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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 BloonItemRebalance
{
	[BepInPlugin("com.Bloonjitsu7.BloonItemRebalance", "BloonItemRebalance", "1.5.3")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class BaseMain : BaseUnityPlugin
	{
		public void Awake()
		{
			Log.Init(((BaseUnityPlugin)this).Logger);
			new ContentPacks().Initialize();
			Main main = new Main();
			main.SetupConfig(((BaseUnityPlugin)this).Config);
			main.Initialize();
		}
	}
	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);
		}
	}
}
namespace BloonItemRebalance.Modules
{
	public static class DamageTypes
	{
		public static ModdedDamageType breachingFinProc = DamageAPI.ReserveDamageType();
	}
	public static class Buffs
	{
		internal static List<BuffDef> buffDefs = new List<BuffDef>();

		internal static BuffDef AddNewBuff(string buffName, Sprite buffIcon, Color buffColor, bool canStack, bool isDebuff, bool isCooldown, bool isHidden)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			BuffDef val = ScriptableObject.CreateInstance<BuffDef>();
			((Object)val).name = buffName;
			val.buffColor = buffColor;
			val.canStack = canStack;
			val.isDebuff = isDebuff;
			val.eliteDef = null;
			val.iconSprite = buffIcon;
			val.isCooldown = isCooldown;
			val.isHidden = isHidden;
			buffDefs.Add(val);
			return val;
		}
	}
	public static class Effects
	{
		private static GameObject finder = Addressables.LoadAssetAsync<GameObject>((object)RoR2_Base_Mushroom.MushroomWard_prefab).WaitForCompletion();

		public static List<EffectDef> effectDefs = new List<EffectDef>();

		internal static void RegisterEffects()
		{
			Main.transmitterPrefab = CreateTransmitterEffect();
		}

		private static GameObject CreateTransmitterEffect()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			return CloneObject("RoR2/DLC3/Items/ShieldBooster/ShieldEMPPulseEffectVoid.prefab", "BloonUnstableTransmitterPulse", new Color(1f, 0.2f, 0f, 1f), new Color(1f, 0.3f, 0f, 1f), 1f, 50f, colorMesh: false);
		}

		private static GameObject CreateBurdenWaveEffect()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			return CloneObject("RoR2/Base/IgniteOnKill/IgniteExplosionVFX.prefab", "BloonBurdenWave", new Color(1f, 0f, 1f, 1f), new Color(1f, 0f, 1f, 1f), 1f, 0f, colorMesh: false);
		}

		private static GameObject CreateDaisyFieldEffect()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CloneObject("RoR2/Base/Mushroom/MushroomWard.prefab", "BloonDaisyField", Color.green, Color.green, 1f, 0f, colorMesh: false, "", parentToTransform: false, recolor: false);
			GameObject gameObject = ((Component)val.transform.Find("Indicator")).gameObject;
			if ((Object)(object)gameObject != (Object)null)
			{
				int childCount = gameObject.transform.childCount;
				Log.Message(childCount);
				for (int i = 0; i < childCount; i++)
				{
					Transform child = gameObject.transform.GetChild(i);
					if ((Object)(object)child != (Object)null && ((Object)child).name == "MushroomMeshes")
					{
						Object.Destroy((Object)(object)((Component)child).gameObject);
					}
				}
			}
			return val;
		}

		private static GameObject CreateTracer()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CloneTracer("RoR2/Base/Huntress/TracerHuntressSnipe.prefab", "TracerStormboundAurelioniteLaser", Color.red, new Color(1f, 0.04f, 0.04f, 1f), 2f);
			Object.Destroy((Object)(object)((Component)val.transform.Find("TracerHead")).gameObject);
			return val;
		}

		private static GameObject CloneObject(string originalObjectName, string newObjectName, Color color1, Color color2, float scaleMult = 1f, float colorTemp = 0f, bool colorMesh = true, string soundName = "", bool parentToTransform = false, bool recolor = true)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Addressables.LoadAssetAsync<GameObject>((object)originalObjectName).WaitForCompletion();
			if ((Object)(object)val == (Object)null)
			{
				Log.Warning(originalObjectName + " is null!");
				return null;
			}
			Component[] componentsInChildren = val.GetComponentsInChildren(typeof(Component));
			foreach (Component data in componentsInChildren)
			{
				Log.Message(data);
			}
			GameObject val2 = PrefabAPI.InstantiateClone(val, newObjectName, false);
			if ((Object)(object)val2.GetComponent<EffectComponent>() == (Object)null)
			{
				val2.AddComponent<EffectComponent>();
			}
			if ((Object)(object)val2.GetComponent<VFXAttributes>() == (Object)null)
			{
				val2.AddComponent<VFXAttributes>();
			}
			val2.GetComponent<VFXAttributes>().vfxPriority = (VFXPriority)2;
			val2.GetComponent<VFXAttributes>().DoNotPool = true;
			if (recolor)
			{
				val2.Recolor(color1, color2, scaleMult, colorTemp, colorMesh);
			}
			CreateEffectFromObject(val2, soundName, parentToTransform);
			return val2;
		}

		private static GameObject CloneTracer(string originalTracerName, string newTracerName, Color color1, Color color2, float widthMult = 1f, float? speed = null, float? length = null)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Addressables.LoadAssetAsync<GameObject>((object)originalTracerName).WaitForCompletion();
			if ((Object)(object)val == (Object)null)
			{
				Log.Warning(originalTracerName + " is null!");
				return null;
			}
			GameObject val2 = PrefabAPI.InstantiateClone(val, newTracerName, false);
			if (!Object.op_Implicit((Object)(object)val2.GetComponent<EffectComponent>()))
			{
				val2.AddComponent<EffectComponent>();
			}
			if (!Object.op_Implicit((Object)(object)val2.GetComponent<VFXAttributes>()))
			{
				val2.AddComponent<VFXAttributes>();
			}
			val2.GetComponent<VFXAttributes>().vfxPriority = (VFXPriority)2;
			val2.GetComponent<VFXAttributes>().DoNotPool = true;
			if (!Object.op_Implicit((Object)(object)val2.GetComponent<NetworkIdentity>()))
			{
				val2.AddComponent<NetworkIdentity>();
			}
			val2.GetComponent<Tracer>().speed = (speed.HasValue ? speed.Value : val2.GetComponent<Tracer>().speed);
			val2.GetComponent<Tracer>().length = (length.HasValue ? length.Value : val2.GetComponent<Tracer>().length);
			val2.Recolor(color1, color2, widthMult);
			CreateAndAddEffectDef(val2);
			return val2;
		}

		private static void Recolor(this GameObject thingToColor, Color color1, Color color2, float widthMult = 1f, float colorTemp = 0f, bool colorMesh = true)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			bool flag = true;
			LineRenderer[] componentsInChildren = thingToColor.GetComponentsInChildren<LineRenderer>();
			foreach (LineRenderer val in componentsInChildren)
			{
				bool flag2 = true;
				val.startColor = color1;
				val.endColor = color2;
				if (widthMult != 1f)
				{
					val.widthMultiplier *= widthMult;
				}
			}
			ParticleSystem[] componentsInChildren2 = thingToColor.GetComponentsInChildren<ParticleSystem>();
			foreach (ParticleSystem val2 in componentsInChildren2)
			{
				MainModule main = val2.main;
				MinMaxCurve startSize = ((MainModule)(ref main)).startSize;
				((MainModule)(ref main)).startSize = new MinMaxCurve(((MinMaxCurve)(ref startSize)).constant * widthMult);
				((MainModule)(ref main)).startColor = new MinMaxGradient(color1);
				TrailModule trails = val2.trails;
				if (((TrailModule)(ref trails)).enabled)
				{
					Gradient val3 = new Gradient();
					GradientColorKey[] array = (GradientColorKey[])(object)new GradientColorKey[2];
					array[0].color = color1;
					array[0].time = 0f;
					array[1].color = color2;
					array[1].time = 1f;
					GradientAlphaKey[] array2 = (GradientAlphaKey[])(object)new GradientAlphaKey[2];
					array2[0].alpha = color1.a;
					array2[0].time = 0f;
					array2[1].alpha = color2.a;
					array2[1].time = 1f;
					val3.SetKeys(array, array2);
					((TrailModule)(ref trails)).colorOverLifetime = new MinMaxGradient(val3);
				}
			}
			Light[] componentsInChildren3 = thingToColor.GetComponentsInChildren<Light>();
			foreach (Light val4 in componentsInChildren3)
			{
				if (colorTemp > 0f)
				{
					val4.colorTemperature = colorTemp;
					val4.useColorTemperature = true;
				}
				else
				{
					val4.useColorTemperature = false;
				}
				val4.color = color1;
				Transform transform = ((Component)val4).transform;
				transform.localScale *= widthMult;
			}
			ParticleSystemRenderer[] componentsInChildren4 = thingToColor.GetComponentsInChildren<ParticleSystemRenderer>();
			foreach (ParticleSystemRenderer val5 in componentsInChildren4)
			{
				((Renderer)val5).material.SetColor("_MainColor", color1);
				((Renderer)val5).material.SetColor("_Color", color1);
				((Renderer)val5).material.SetColor("_TintColor", color2);
			}
			if (colorMesh)
			{
				MeshRenderer[] componentsInChildren5 = thingToColor.GetComponentsInChildren<MeshRenderer>();
				foreach (MeshRenderer val6 in componentsInChildren5)
				{
					((Renderer)val6).material.SetColor("_MainColor", color1);
					((Renderer)val6).material.SetColor("_Color", color1);
					((Renderer)val6).material.SetColor("_TintColor", color2);
				}
			}
		}

		internal static void AddEffectDef(EffectDef effectDef)
		{
			effectDefs.Add(effectDef);
		}

		internal static EffectDef CreateAndAddEffectDef(GameObject effectPrefab, bool donotPool = false)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			if (donotPool)
			{
				VFXAttributes val = effectPrefab.GetComponent<VFXAttributes>();
				if ((Object)(object)val == (Object)null)
				{
					val = effectPrefab.AddComponent<VFXAttributes>();
				}
				val.DoNotPool = true;
			}
			EffectDef val2 = new EffectDef(effectPrefab);
			AddEffectDef(val2);
			return val2;
		}

		internal static void CreateEffectFromObject(GameObject newEffect, string soundName, bool parentToTransform)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			newEffect.AddComponent<DestroyOnTimer>().duration = 6f;
			newEffect.AddComponent<NetworkIdentity>();
			if (!Object.op_Implicit((Object)(object)newEffect.GetComponent<VFXAttributes>()))
			{
				newEffect.AddComponent<VFXAttributes>().vfxPriority = (VFXPriority)2;
			}
			EffectComponent component = newEffect.GetComponent<EffectComponent>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				component = newEffect.AddComponent<EffectComponent>();
				component.applyScale = true;
				component.effectIndex = (EffectIndex)(-1);
				component.parentToReferencedTransform = parentToTransform;
				component.positionAtReferencedTransform = true;
				component.soundName = soundName;
			}
			CreateAndAddEffectDef(newEffect);
		}
	}
	internal class ContentPacks : IContentPackProvider
	{
		internal ContentPack contentPack = new ContentPack();

		public string identifier => "com.Bloonjitsu7.BloonModpackBaseMod";

		public void Initialize()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			Effects.RegisterEffects();
			ContentManager.collectContentPackProviders += new CollectContentPackProvidersDelegate(ContentManager_collectContentPackProviders);
		}

		private void ContentManager_collectContentPackProviders(AddContentPackProviderDelegate addContentPackProvider)
		{
			addContentPackProvider.Invoke((IContentPackProvider)(object)this);
		}

		public IEnumerator LoadStaticContentAsync(LoadStaticContentAsyncArgs args)
		{
			contentPack.identifier = identifier;
			contentPack.effectDefs.Add(Effects.effectDefs.ToArray());
			contentPack.buffDefs.Add(Buffs.buffDefs.ToArray());
			args.ReportProgress(1f);
			yield break;
		}

		public IEnumerator GenerateContentPackAsync(GetContentPackAsyncArgs args)
		{
			ContentPack.Copy(contentPack, args.output);
			args.ReportProgress(1f);
			yield break;
		}

		public IEnumerator FinalizeAsync(FinalizeAsyncArgs args)
		{
			args.ReportProgress(1f);
			yield break;
		}
	}
}
namespace BloonItemRebalance.Changes
{
	public class MeatBuffVFX : MonoBehaviour
	{
		public TemporaryVisualEffect effect;
	}
	public class Main
	{
		public class NewPlanulaBehaviour : ItemBehavior
		{
			public float interval = 2f;

			public float stopwatch;

			public void Start()
			{
				UpdateInterval();
			}

			public void FixedUpdate()
			{
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				int stackedStatsInt = GetStackedStatsInt(planulaMax.Value, planulaMaxStack.Value, base.stack);
				if ((Object)(object)base.body != (Object)null && base.body.GetBuffCount(EmbryoBuff) < stackedStatsInt && base.stack > 0)
				{
					stopwatch += Time.fixedDeltaTime;
					if (stopwatch >= interval)
					{
						base.body.SetBuffCount(EmbryoBuff.buffIndex, base.body.GetBuffCount(EmbryoBuff) + 1);
						stopwatch = 0f;
						UpdateInterval();
					}
				}
			}

			public void UpdateInterval()
			{
				float num = ConvertReductionIntoStackingDivision(planulaIntervalStack.Value, base.stack);
				interval = planulaInterval.Value / num;
			}
		}

		public class NewChronoBehaviour : ItemBehavior
		{
			private static float interval = 0.25f;

			private float stopwatch;

			private SphereSearch sphereSearch;

			private void Start()
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected O, but got Unknown
				sphereSearch = new SphereSearch();
				stopwatch = 0f;
			}

			public void FixedUpdate()
			{
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_017c: Unknown result type (might be due to invalid IL or missing references)
				stopwatch += Time.fixedDeltaTime;
				if (!(stopwatch >= interval) || base.stack <= 0)
				{
					return;
				}
				stopwatch = 0f;
				List<HurtBox> list = CollectionPool<HurtBox, List<HurtBox>>.RentCollection();
				if (sphereSearch != null)
				{
					sphereSearch.radius = chronoRadius.Value;
					sphereSearch.mask = ((LayerIndex)(ref LayerIndex.entityPrecise)).mask;
					sphereSearch.origin = ((Component)this).transform.position;
					sphereSearch.RefreshCandidates();
					TeamMask enemyTeams = TeamMask.GetEnemyTeams(base.body.teamComponent.teamIndex);
					sphereSearch.FilterCandidatesByDistinctHurtBoxEntities();
					sphereSearch.OrderCandidatesByDistance();
					sphereSearch.FilterCandidatesByHurtBoxTeam(enemyTeams);
					sphereSearch.GetHurtBoxes(list);
					sphereSearch.ClearCandidates();
				}
				int num = 0;
				foreach (HurtBox item in list)
				{
					if (Object.op_Implicit((Object)(object)item.healthComponent) && Object.op_Implicit((Object)(object)item.healthComponent.body) && item.healthComponent.body.HasBuff(Buffs.Slow60))
					{
						num++;
					}
				}
				base.body.SetBuffCount(ChronoRechargeBuff.buffIndex, num);
				CollectionPool<HurtBox, List<HurtBox>>.ReturnCollection(list);
			}
		}

		public class WarbannerToken : MonoBehaviour
		{
			public float stopwatch;

			public TeamIndex index;

			public void FixedUpdate()
			{
				stopwatch += Time.deltaTime;
			}
		}

		public class DaisyFieldToken : MonoBehaviour
		{
			public HoldoutZoneController zoneController;

			public float stopwatch;

			public static float interval = 1f;

			public bool healReady;

			public void FixedUpdate()
			{
				stopwatch += Time.deltaTime;
				if (stopwatch >= interval)
				{
					stopwatch -= interval;
					healReady = true;
				}
			}
		}

		public class NewConductorBehaviour : ItemBehavior
		{
			private SphereSearch sphereSearch;

			private void Start()
			{
				base.body.onSkillActivatedAuthority += OnActivateSkill;
			}

			private void OnDisable()
			{
				base.body.onSkillActivatedAuthority -= OnActivateSkill;
			}

			private void OnActivateSkill(GenericSkill genericSkill)
			{
				if ((Object)(object)genericSkill != (Object)null && (Object)(object)genericSkill != (Object)(object)base.body.skillLocator.primary && genericSkill.baseRechargeInterval > 0f)
				{
					int num = Math.Min(genericSkill.maxStock, genericSkill.rechargeStock);
					float num2 = genericSkill.baseRechargeInterval * conductorChance.Value;
					num2 /= (float)num;
					if (Util.CheckRoll(num2, base.body.master))
					{
						TriggerEnergize();
					}
				}
			}

			private void TriggerEnergize()
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: 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_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Expected O, but got Unknown
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Expected O, but got Unknown
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
				EffectData val = new EffectData
				{
					origin = base.body.corePosition,
					start = base.body.corePosition,
					scale = base.body.radius
				};
				EffectManager.SpawnEffect(CommonAssets.shockDamagePulseEffect, val, true);
				List<HurtBox> list = CollectionPool<HurtBox, List<HurtBox>>.RentCollection();
				sphereSearch = new SphereSearch();
				sphereSearch.radius = 45f;
				sphereSearch.mask = ((LayerIndex)(ref LayerIndex.entityPrecise)).mask;
				sphereSearch.origin = ((Component)this).transform.position;
				sphereSearch.RefreshCandidates();
				TeamMask val2 = default(TeamMask);
				((TeamMask)(ref val2)).AddTeam(base.body.teamComponent.teamIndex);
				sphereSearch.FilterCandidatesByDistinctHurtBoxEntities();
				sphereSearch.OrderCandidatesByDistance();
				sphereSearch.FilterCandidatesByHurtBoxTeam(val2);
				sphereSearch.GetHurtBoxes(list);
				sphereSearch.ClearCandidates();
				foreach (HurtBox item in list)
				{
					if (!Object.op_Implicit((Object)(object)item.healthComponent))
					{
						continue;
					}
					CharacterBody body = item.healthComponent.body;
					if (!((Object)(object)body != (Object)null))
					{
						continue;
					}
					float stackedStats = GetStackedStats(conductorDuration.Value, conductorDurationStack.Value, base.stack);
					Buffs.ShockDamageEnergized.canStack = true;
					if (body.GetBuffCount(Buffs.ShockDamageEnergized) <= base.stack)
					{
						body.ClearTimedBuffs(Buffs.ShockDamageEnergized);
						body.AddTimedBuff(Buffs.ShockDamageEnergized, stackedStats, base.stack);
						continue;
					}
					foreach (TimedBuff timedBuff in body.timedBuffs)
					{
						if (timedBuff.buffIndex == Buffs.ShockDamageEnergized.buffIndex)
						{
							timedBuff.timer = Mathf.Max(stackedStats, timedBuff.timer);
						}
					}
				}
				CollectionPool<HurtBox, List<HurtBox>>.ReturnCollection(list);
			}
		}

		public class NewBandolierBehaviour : ItemBehavior
		{
			private void Start()
			{
				base.body.onSkillActivatedAuthority += OnActivateSkill;
			}

			private void OnDisable()
			{
				base.body.onSkillActivatedAuthority -= OnActivateSkill;
			}

			private void OnActivateSkill(GenericSkill genericSkill)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)genericSkill != (Object)null && base.body.HasBuff(SpareAmmunition.buffIndex) && genericSkill.baseRechargeInterval > 0f && genericSkill.skillDef.stockToConsume > 0 && genericSkill.stock <= 0)
				{
					for (int i = 0; i < genericSkill.maxStock; i++)
					{
						genericSkill.ApplyAmmoPack();
					}
					int num = base.body.GetBuffCount(SpareAmmunition.buffIndex) - 1;
					base.body.SetBuffCount(SpareAmmunition.buffIndex, num);
				}
			}
		}

		public class NewTransmitterBehaviour : ItemBehavior
		{
			private bool regenerating = false;

			private SphereSearch sphereSearch;

			private void Start()
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected O, but got Unknown
				sphereSearch = new SphereSearch();
			}

			public bool TryProc()
			{
				if (base.stack > 0)
				{
					HandleActivateTransmitter();
					return true;
				}
				return false;
			}

			public void HandleActivateTransmitter()
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: 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_0053: 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_010b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0117: Unknown result type (might be due to invalid IL or missing references)
				//IL_0122: Unknown result type (might be due to invalid IL or missing references)
				//IL_0139: Expected O, but got Unknown
				//IL_0174: Unknown result type (might be due to invalid IL or missing references)
				//IL_0179: Unknown result type (might be due to invalid IL or missing references)
				//IL_018a: Unknown result type (might be due to invalid IL or missing references)
				//IL_018f: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
				if (base.stack <= 0)
				{
					return;
				}
				ItemTransformation val = default(ItemTransformation);
				((ItemTransformation)(ref val)).originalItemIndex = Items.TeleportOnLowHealth.itemIndex;
				((ItemTransformation)(ref val)).newItemIndex = Items.TeleportOnLowHealthConsumed.itemIndex;
				((ItemTransformation)(ref val)).minToTransform = 1;
				((ItemTransformation)(ref val)).maxToTransform = 1;
				val.transformationType = (ItemTransformationTypeIndex)7;
				TryTransformResult val2 = default(TryTransformResult);
				((ItemTransformation)(ref val)).TryTransform(base.body.inventory, ref val2);
				if (!base.body.HasBuff(TransmitterCooldown))
				{
					((MonoBehaviour)base.body).StartCoroutine(StartCooldown());
				}
				float num = base.body.maxHealth * transmitterBarrier.Value;
				base.body.healthComponent.AddBarrier(num);
				base.body.AddTimedBuff(Buffs.HiddenInvincibility, 0.2f);
				Util.PlaySound("Play_item_proc_teleportOnLowHealth", ((Component)base.body).gameObject);
				if ((Object)(object)transmitterPrefab != (Object)null)
				{
					EffectManager.SpawnEffect(transmitterPrefab, new EffectData
					{
						origin = base.body.transform.position,
						scale = base.body.radius
					}, true);
				}
				List<HurtBox> list = CollectionPool<HurtBox, List<HurtBox>>.RentCollection();
				if (sphereSearch != null)
				{
					sphereSearch.radius = transmitterPulseRadius.Value;
					sphereSearch.mask = ((LayerIndex)(ref LayerIndex.entityPrecise)).mask;
					sphereSearch.origin = ((Component)this).transform.position;
					sphereSearch.RefreshCandidates();
					TeamMask enemyTeams = TeamMask.GetEnemyTeams(base.body.teamComponent.teamIndex);
					sphereSearch.FilterCandidatesByDistinctHurtBoxEntities();
					sphereSearch.OrderCandidatesByDistance();
					sphereSearch.FilterCandidatesByHurtBoxTeam(enemyTeams);
					sphereSearch.GetHurtBoxes(list);
					sphereSearch.ClearCandidates();
				}
				foreach (HurtBox item in list)
				{
					if (Object.op_Implicit((Object)(object)item.healthComponent))
					{
						if (NetworkServer.active)
						{
							item.healthComponent.DoWarp(((Component)base.body).gameObject, base.body);
						}
						base.body.healthComponent.AddBarrier(base.body.maxHealth * transmitterPulseBarrier.Value);
					}
				}
				CollectionPool<HurtBox, List<HurtBox>>.ReturnCollection(list);
			}

			public IEnumerator StartCooldown()
			{
				base.body.AddBuff(TransmitterCooldown);
				yield return (object)new WaitForSeconds(transmitterCooldown.Value);
				base.body.RemoveBuff(TransmitterCooldown);
				ItemTransformation val = default(ItemTransformation);
				((ItemTransformation)(ref val)).originalItemIndex = Items.TeleportOnLowHealthConsumed.itemIndex;
				((ItemTransformation)(ref val)).newItemIndex = Items.TeleportOnLowHealth.itemIndex;
				((ItemTransformation)(ref val)).maxToTransform = int.MaxValue;
				val.transformationType = (ItemTransformationTypeIndex)7;
				TryTransformResult tryTransformResult = default(TryTransformResult);
				((ItemTransformation)(ref val)).TryTransform(base.body.inventory, ref tryTransformResult);
			}
		}

		public class NewICBMBehaviour : ItemBehavior
		{
			public GameObject projectilePrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/Projectiles/MissileProjectile");

			public float interval;

			public float stopwatch;

			private void Start()
			{
				stopwatch = 0f;
				interval = icbmCooldown.Value / ConvertReductionIntoStackingDivision(icbmCooldownStack.Value, base.stack);
			}

			private void FixedUpdate()
			{
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				if (!base.body.outOfCombat || !base.body.outOfDanger)
				{
					stopwatch += Time.fixedDeltaTime;
					if (stopwatch >= interval)
					{
						stopwatch = 0f;
						interval = icbmCooldown.Value / ConvertReductionIntoStackingDivision(icbmCooldownStack.Value, base.stack);
						float stackedStats = GetStackedStats(icbmDamage.Value, icbmDamageStack.Value, base.stack);
						bool flag = Util.CheckRoll(base.body.crit, base.body.master);
						MissileUtils.FireMissile(base.body.corePosition, base.body, default(ProcChainMask), (GameObject)null, base.body.damage * stackedStats, flag, projectilePrefab, (DamageColorIndex)3, false);
					}
				}
			}
		}

		public class NewBarrageOnBossBehaviour : ItemBehavior
		{
			private int maxBuffCount = 50;

			public uint prevMoney = 0u;

			private float totalMoney;

			public float gainedMoney;

			public int missileBarrageCount = 0;

			public float fireDelay = 1f;

			public float cooldownDelay = 0f;

			public static float MissileOriginHeight = 80f;

			private static GameObject missilePrefab;

			private static GameObject missileStartPrefab;

			private float timer;

			public float searchRange = 200f;

			private BullseyeSearch bullseyeSearch = new BullseyeSearch();

			private static Vector3 heightOffset = new Vector3(0f, BarrageOnBossBehaviour.MissileOriginHeight, 0f);

			private static Vector3 traceDirection = new Vector3(0f, -1f, 0f);

			private static readonly LayerMask missileCollisionMask = ((LayerIndex)(ref LayerIndex.noCollision)).mask;

			private static RaycastHit[] hits = (RaycastHit[])(object)new RaycastHit[8];

			[SystemInitializer(new Type[] { typeof(ItemCatalog) })]
			private static void Init()
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				AsyncOperationHandle<GameObject> val = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC2/Items/BarrageOnBoss/BossMissileProjectile.prefab");
				val.Completed += delegate(AsyncOperationHandle<GameObject> x)
				{
					missilePrefab = x.Result;
				};
				val = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC2/Items/BarrageOnBoss/BossMissileStart.prefab");
				val.Completed += delegate(AsyncOperationHandle<GameObject> x)
				{
					missileStartPrefab = x.Result;
				};
			}

			private void Awake()
			{
				Init();
			}

			private void OnEnable()
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Expected O, but got Unknown
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				CharacterBody.Start += new hook_Start(CheckBarrageEnemy);
				totalMoney = 0f;
				bullseyeSearch.teamMaskFilter = TeamMask.allButNeutral;
				((TeamMask)(ref bullseyeSearch.teamMaskFilter)).RemoveTeam((TeamIndex)1);
				bullseyeSearch.maxDistanceFilter = searchRange;
				bullseyeSearch.sortMode = (SortMode)1;
				bullseyeSearch.filterByLoS = false;
			}

			private void OnDisable()
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Expected O, but got Unknown
				CharacterBody.Start -= new hook_Start(CheckBarrageEnemy);
			}

			private void Start()
			{
				CharacterMaster master = base.body.master;
				prevMoney = master.money;
				master.OnGoldCollected += CollectedMoney;
			}

			private void CollectedMoney(float amount)
			{
				gainedMoney += amount;
			}

			private void Update()
			{
				uint num = (uint)((float)base.body.master.money - gainedMoney);
				if (num < prevMoney)
				{
					UpdateExtraMissileMoneyCount(prevMoney - num);
				}
				prevMoney = base.body.master.money;
				gainedMoney = 0f;
			}

			private void CheckBarrageEnemy(orig_Start orig, CharacterBody self)
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: 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)
				orig.Invoke(self);
				if ((self.isElite || self.isBoss) && base.body.HasBuff(Buffs.ExtraBossMissile) && self.teamComponent.teamIndex != (TeamIndex)(base.body.teamComponent.teamIndex | 0))
				{
					base.body.SetBuffCount(Buffs.ExtraBossMissile.buffIndex, base.body.GetBuffCount(Buffs.ExtraBossMissile) - 1);
					((MonoBehaviour)this).StartCoroutine(BarrageEnemy(self));
				}
			}

			public IEnumerator BarrageEnemy(CharacterBody characterBody)
			{
				yield return (object)new WaitForSeconds(fireDelay);
				FireMissile(characterBody);
			}

			private void UpdateExtraMissileMoneyCount(float amount)
			{
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				totalMoney += amount;
				uint difficultyScaledCost = (uint)Run.instance.GetDifficultyScaledCost(warbondsGoldCost.Value);
				while (totalMoney >= (float)difficultyScaledCost && base.body.GetBuffCount(Buffs.ExtraBossMissile) < maxBuffCount)
				{
					for (int i = 0; i < base.stack; i++)
					{
						base.body.AddBuff(Buffs.ExtraBossMissile.buffIndex);
					}
					totalMoney -= difficultyScaledCost;
				}
			}

			private Vector3 MoveTargetToGround(Vector3 target)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				int num = Physics.RaycastNonAlloc(target, traceDirection, hits, 350f, LayerMask.op_Implicit(missileCollisionMask), (QueryTriggerInteraction)1);
				if (num > 0)
				{
					Vector3 point = ((RaycastHit)(ref hits[0])).point;
					for (int i = 1; i < num; i++)
					{
						if (point.y < ((RaycastHit)(ref hits[i])).point.y)
						{
							point = ((RaycastHit)(ref hits[i])).point;
						}
					}
					return point;
				}
				return target;
			}

			private void FireMissile(CharacterBody characterBody)
			{
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_0118: Unknown result type (might be due to invalid IL or missing references)
				//IL_012d: Unknown result type (might be due to invalid IL or missing references)
				//IL_012f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0135: Unknown result type (might be due to invalid IL or missing references)
				//IL_0164: Unknown result type (might be due to invalid IL or missing references)
				//IL_0169: Unknown result type (might be due to invalid IL or missing references)
				//IL_016e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0173: Unknown result type (might be due to invalid IL or missing references)
				//IL_017d: Unknown result type (might be due to invalid IL or missing references)
				if (!Object.op_Implicit((Object)(object)characterBody))
				{
					characterBody = base.body;
				}
				int num = (Object.op_Implicit((Object)(object)base.body.inventory) ? base.body.inventory.GetItemCountEffective(Items.MoreMissile) : 0);
				float damage = base.body.damage * GetStackedStats(warbondsDamage.Value, warbondsDamageStack.Value, base.stack);
				float maxDistance = MissileOriginHeight - 4f;
				Component[] componentsInChildren = missilePrefab.GetComponentsInChildren(typeof(Component));
				foreach (Component data in componentsInChildren)
				{
					Log.Message(data);
				}
				FireProjectileInfo val = new FireProjectileInfo
				{
					crit = base.body.RollCrit(),
					owner = ((Component)this).gameObject,
					position = ((Component)characterBody).gameObject.transform.position + heightOffset,
					projectilePrefab = missilePrefab,
					rotation = Util.QuaternionSafeLookRotation(Vector3.down),
					damage = damage,
					maxDistance = maxDistance
				};
				ProjectileManager.instance.FireProjectile(val);
				if (num > 0)
				{
					val.damage *= 0.5f;
					val.position = ((Component)characterBody).gameObject.transform.position + heightOffset;
					ProjectileManager.instance.FireProjectile(val);
				}
			}

			private Vector3 CalculateHitPosition(GameObject target)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: 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_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: 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)
				Vector3 val = MoveTargetToGround(target.transform.position);
				Vector2 insideUnitCircle = Random.insideUnitCircle;
				Vector2 normalized = ((Vector2)(ref insideUnitCircle)).normalized;
				return val + new Vector3(normalized.x, 0f, normalized.y);
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static Func<Func<HealthComponent, int, bool, bool>, HealthComponent, int, bool, bool> <0>__RemoveOldTransmitterBehaviour4;

			public static Func<Func<int, float>, int, float> <1>__OnMissileDamage;

			public static hook_ProcessHitEnemy <2>__OnProcessSingularityBand;

			public static Action<CharacterBody> <3>__OnCharacterLevelUp;
		}

		public static List<WarbannerToken> warbannerInstances = new List<WarbannerToken>();

		public static GameObject seerHitPrefab = PrefabAPI.InstantiateClone(Addressables.LoadAssetAsync<GameObject>((object)RoR2_DLC1_CritGlassesVoid.CritGlassesVoidExecuteEffect_prefab).WaitForCompletion(), "BloonLostSeerEffect");

		public static List<Hook> hooks = new List<Hook>();

		public static GameObject MeatBuffVFX = Addressables.LoadAssetAsync<GameObject>((object)RoR2_Junk_RegenOnKill.RegenBoostEffect_prefab).WaitForCompletion();

		public static GameObject transmitterPrefab;

		public static GameObject daisyFieldPrefab;

		public static BuffDef MeatBuff = Buffs.MeatRegenBoost;

		public static BuffDef IgnitionCooldown;

		public static BuffDef ScytheCooldown;

		public static BuffDef OpticsBuff;

		public static BuffDef TransmitterCooldown;

		public static BuffDef GenesisBuff;

		public static BuffDef GenesisBuffPrecise;

		public static BuffDef SpareAmmunition;

		public static BuffDef StealthDamageBuff;

		public static BuffDef ChronoRechargeBuff;

		public static BuffDef EmbryoBuff;

		private static Sprite opticsIcon = Addressables.LoadAssetAsync<Sprite>((object)RoR2_Base_Merc.texBuffMercExposeIcon_tif).WaitForCompletion();

		private static Sprite transmitterIcon = Addressables.LoadAssetAsync<Sprite>((object)RoR2_DLC2_Items_TeleportOnLowHealth.texBuffTeleportOnLowHealthIcon_png).WaitForCompletion();

		private static Sprite genesisIcon = Addressables.LoadAssetAsync<Sprite>((object)RoR2_Base_ShockNearby.texBuffTeslaIcon_tif).WaitForCompletion();

		private static Sprite ammoIcon = Addressables.LoadAssetAsync<Sprite>((object)RoR2_Base_Bandolier.texBandolierIcon_png).WaitForCompletion();

		private static Sprite stealthIcon = Addressables.LoadAssetAsync<Sprite>((object)RoR2_Base_Common.texBuffCloakIcon_tif).WaitForCompletion();

		private static Sprite chronoIcon = Addressables.LoadAssetAsync<Sprite>((object)RoR2_Base_SlowOnHit.texBaubleIcon_png).WaitForCompletion();

		private static Sprite embryoIcon = Addressables.LoadAssetAsync<Sprite>((object)RoR2_Base_ParentEgg.texParentEggIcon_png).WaitForCompletion();

		public static GameObject ammoPack = LegacyResourcesAPI.Load<GameObject>("Prefabs/NetworkedObjects/AmmoPack");

		private Xoroshiro128Plus rng;

		internal static bool HasFlatItemBuff => Chainloader.PluginInfos.ContainsKey("com.kking117.FlatItemBuff");

		internal static bool HasBubbetsItems => Chainloader.PluginInfos.ContainsKey("bubbet.bubbetsitems");

		internal static bool HasStarstorm => Chainloader.PluginInfos.ContainsKey("com.TeamMoonstorm");

		internal static bool HasSeekingTheVoid => Chainloader.PluginInfos.ContainsKey("acanthi.SeekingTheVoid");

		internal static bool HasTooManyItems => Chainloader.PluginInfos.ContainsKey("shirograhm.TooManyItems");

		internal static bool HasVanillaVoid => Chainloader.PluginInfos.ContainsKey("com.Zenithrium.vanillaVoid");

		internal static bool HasMeltdown => Chainloader.PluginInfos.ContainsKey("com.pittabread.Meltdown");

		internal static bool HasNautilus => Chainloader.PluginInfos.ContainsKey("com.Hex3.Nautilus");

		internal static bool HasRigsArsenal => Chainloader.PluginInfos.ContainsKey("RigsInRags.RigsArsenal");

		internal static bool HasSpikestrip => Chainloader.PluginInfos.ContainsKey("com.groovesalad.GrooveSaladSpikestripContent");

		internal static bool HasSuperCyan => Chainloader.PluginInfos.ContainsKey("Samuel17.SuperCyanTweaks");

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

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

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

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

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

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

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

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

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

		public static ConfigEntry<int> lanternAlly { get; set; }

		public static ConfigEntry<int> lanternAllyStack { get; set; }

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

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

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

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

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

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

		public static ConfigEntry<int> warpedEchoCap { get; set; }

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

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

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

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

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

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

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

		public static ConfigEntry<int> meatMax { get; set; }

		public static ConfigEntry<int> meatMaxStack { get; set; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public static ConfigEntry<int> warbannerMax { get; set; }

		public static ConfigEntry<int> warbannerMaxStack { get; set; }

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

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

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

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

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

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

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

		public static ConfigEntry<int> penniesGold { get; set; }

		public static ConfigEntry<int> penniesGoldStack { get; set; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public static ConfigEntry<int> ignitionBurnBonus { get; set; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public static ConfigEntry<int> bandolierStocks { get; set; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public static ConfigEntry<int> harpoonCount { get; set; }

		public static ConfigEntry<int> harpoonCountStack { get; set; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public static ConfigEntry<int> duplicatorDuration { get; set; }

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

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

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

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

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

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

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

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

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

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

		public static ConfigEntry<int> warbondsGoldCost { get; set; }

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

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

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

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

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

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

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

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

		public static ConfigEntry<int> sonorousHP { get; set; }

		public static ConfigEntry<int> sonorousDamage { get; set; }

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

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

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

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

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

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

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

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

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

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

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

		public static ConfigEntry<int> glandBonus { get; set; }

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

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

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

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

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

		public static ConfigEntry<int> planulaMax { get; set; }

		public static ConfigEntry<int> planulaMaxStack { get; set; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public static ConfigEntry<int> coolantFrostCount { get; set; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public static ConfigEntry<int> toxicoTargets { get; set; }

		public static ConfigEntry<int> toxicoTargetsStack { get; set; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public static ConfigEntry<int> opticsSlots { get; set; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public void SetupConfig(ConfigFile cfg)
		{
			stunGrenadeEnable = cfg.Bind<bool>("Stun Grenade Buff", "Enable Changes", true, "Enables the changes to stun grenade.");
			stunGrenadeDamage = cfg.Bind<float>("Stun Grenade Buff", "Damage", 2f, "The damage coefficient of the proc. (1 = 100% damage)");
			apRoundsEnable = cfg.Bind<bool>("AP Rounds Buff", "Enable Changes", true, "Enables the changes to armor piercing rounds.");
			apRoundsEliteDamage = cfg.Bind<float>("AP Rounds Buff", "Elite Damage Bonus", 0.05f, "Damage bonus granted against elites for each stack of the item. (1 = 100% bonus damage)");
			lanternEnable = cfg.Bind<bool>("Bolstering Lantern Rework", "Enable Changes", true, "Enables the changes to bolstering lantern.");
			lanternSpeed = cfg.Bind<float>("Bolstering Lantern Rework", "Attack Speed", 0.07f, "Base attack speed bonus granted per buff stack. (1 = 100% attack speed)");
			lanternSpeedStack = cfg.Bind<float>("Bolstering Lantern Rework", "Attack Speed Stacking", 0f, "Attack speed bonus granted for each additional stack of the item, per buff stack.");
			lanternRegen = cfg.Bind<float>("Bolstering Lantern Rework", "Health Regen", 0.7f, "Base health regen bonus granted per buff stack. (1 = 1 hp/s)");
			lanternRegenStack = cfg.Bind<float>("Bolstering Lantern Rework", "Health Regen Stacking", 0f, "Health regen bonus granted for each additional stack of the item, per buff stack.");
			lanternAlly = cfg.Bind<int>("Bolstering Lantern Rework", "Max Buffs", 4, "Maximum number of buffs you can have with one stack of the item.");
			lanternAllyStack = cfg.Bind<int>("Bolstering Lantern Rework", "Max Buff Stacking", 2, "Maximum number of buffs you can have with each additional stack of the item.");
			lanternRadius = cfg.Bind<float>("Bolstering Lantern Rework", "Radius", 40f, "Base area of effect size of the item. (1 = 0.5m)");
			lanternRadiusStack = cfg.Bind<float>("Bolstering Lantern Rework", "Radius Stacking", 4f, "Bonus area of effect size for each additional stack of the item.");
			warpedEchoEnable = cfg.Bind<bool>("Warped Echo Rework", "Enable Changes", true, "Enables the changes to stun grenade. Requires FlatItemBuff.");
			warpedEchoDuration = cfg.Bind<float>("Warped Echo Rework", "Delayed Damage Duration", 2.5f, "Base duration of the delayed damage (in seconds) before it hits.");
			warpedEchoDurationStack = cfg.Bind<float>("Warped Echo Rework", "Duration Stacking", 0.25f, "Bonus duration of the delayed damage (in seconds) for each additional stack of the item.");
			warpedEchoStats = cfg.Bind<float>("Warped Echo Rework", "Stat Bonuses", 0.15f, "Base increase to attack, movement, and cooldown speed per delayed hit. (1 = 100% increase)");
			warpedEchoCap = cfg.Bind<int>("Warped Echo Rework", "Max Buffs", 1, "Maximum amount of hits that can be delayed for each stack of the item.");
			bungusEnable = cfg.Bind<bool>("Bungus Buff", "Enable Changes", true, "Enables the changes to bustling fungus.");
			bungusTimer = cfg.Bind<float>("Bungus Buff", "Timer", 0.25f, "Amount of time (in seconds) while standing still that it takes for bustling fungus to activate.");
			meatEnable = cfg.Bind<bool>("Bison Steak Buff", "Enable Changes", true, "Enables the changes to bison steak.");
			meatHealth = cfg.Bind<float>("Bison Steak Buff", "Health Increase", 30f, "Amount of HP gained for each stack of the item.");
			meatRegen = cfg.Bind<float>("Bison Steak Buff", "Health Regen", 1.5f, "Amount of health regeneration gained per buff stack. (1 = 1 hp/s)");
			meatDuration = cfg.Bind<float>("Bison Steak Buff", "Regen Duration", 3f, "Base duration (in seconds) of the regeneration buff on kill.");
			meatDurationStack = cfg.Bind<float>("Bison Steak Buff", "Regen Duration Stacking", 1f, "Duration of the regeneration buff on kill for each additional stack of the item.");
			meatMax = cfg.Bind<int>("Bison Steak Buff", "Max Buffs", 2, "Maximum number of buffs you can have with one stack of the item.");
			meatMaxStack = cfg.Bind<int>("Bison Steak Buff", "Max Buff Stacking", 1, "Maximum number of buffs you can have with each additional stack of the item.");
			chronicEnable = cfg.Bind<bool>("Chronic Expansion Rebalance", "Enable Changes", true, "Enables the changes to chronic expansion.");
			multikillDamage = cfg.Bind<float>("Chronic Expansion Rebalance", "Damage", 0.03f, "Base damage bonus granted per buff stack. (1 = 100% bonus damage)");
			multikillDamageStack = cfg.Bind<float>("Chronic Expansion Rebalance", "Damage Stacking", 0.005f, "Damage bonus granted for each additional stack of the item, per buff stack.");
			multikillDuration = cfg.Bind<float>("Chronic Expansion Rebalance", "Buff Duration", 9f, "Duration of the buff (in seconds).");
			warbannerEnable = cfg.Bind<bool>("Warbanner Rework", "Enable Changes", true, "Enables the changes to warbanner.");
			warbannerStats = cfg.Bind<float>("Warbanner Rework", "Stat Bonus", 0.15f, "Base percent increase to attack speed, movement speed, and damage with the warbanner buff. (1 = 100% increase)");
			warbannerStatsStack = cfg.Bind<float>("Warbanner Rework", "Stat Bonus Stacking", 0.075f, "Bonus percent increase to attack speed, movement speed, and damage for each additional warbanner stack on your team. (1 = 100% increase)");
			warbannerMax = cfg.Bind<int>("Warbanner Rework", "Banner Count", 1, "Max number of banners that can be placed at once.");
			warbannerMaxStack = cfg.Bind<int>("Warbanner Rework", "Banner Count Stacking", 1, "Max number of banners that can be placed at once for each additional warbanner stack on your team.");
			warbannerRadius = cfg.Bind<float>("Warbanner Rework", "Buff Radius", 20f, "Size (in meters) of the warbanner effect.");
			antlersEnable = cfg.Bind<bool>("Elusive Antlers Rework", "Enable Changes", true, "Enables the changes to elusive antlers.");
			antlersSpeed = cfg.Bind<float>("Elusive Antlers Rework", "Speed Bonus", 0.1f, "Base percent increase to movement speed for each stack of the elusive antlers buff. (1 = 100% speed)");
			antlersInterval = cfg.Bind<float>("Elusive Antlers Rework", "Spawn Interval", 7f, "Base time (in seconds) between energy orb spawns.");
			antlersIntervalStack = cfg.Bind<float>("Elusive Antlers Rework", "Spawn Interval Stacking", 0.1f, "Spawn interval time reduction for each additional stack of the item. (1 = 100% reduction)");
			antlersDuration = cfg.Bind<float>("Elusive Antlers Rework", "Buff Duration", 10f, "Base duration (in seconds) of the elusive antlers buff.");
			antlersDurationStack = cfg.Bind<float>("Elusive Antlers Rework", "Buff Duration Stacking", 1f, "Bonus duration (in seconds) of the elusive antlers buff for each additional stack of the item.");
			antlersDurationReduction = cfg.Bind<float>("Elusive Antlers Rework", "Buff Duration Reduction", 0.1f, "Percent decrease to the buff duration time for each stack of the elusive antlers buff that you have (excluding the first stack).");
			antlersDecayRate = cfg.Bind<float>("Elusive Antlers Rework", "Buff Decay Rate", 1f, "Time (in seconds) between buff reductions.");
			milkEnable = cfg.Bind<bool>("Milk Carton Buff", "Enable Changes", true, "Enables the changes to milk carton. Requires TooManyItems.");
			milkHealth = cfg.Bind<float>("Milk Carton Buff", "Health Increase", 20f, "Amount of HP gained for each stack of the item.");
			milkRetaliate = cfg.Bind<float>("Milk Carton Buff", "Elite Retaliation", 2f, "Amount of damage retaliated from elites for each stack of the item. (1 = 100%)");
			loafEnable = cfg.Bind<bool>("Loaf of Bread Buff", "Enable Changes", true, "Enables the changes to loaf of bread. Requires TooManyItems.");
			loafRegenChance = cfg.Bind<float>("Loaf of Bread Buff", "Regen Chance", 20f, "Percent chance to regain a loaf of bread after it scraps itself. (100 = 100% chance)");
			coffeeEnable = cfg.Bind<bool>("Coffee Bag Rework", "Enable Changes", true, "Enables the changes to coffee bag. Requires Starstorm2.");
			coffeeBuffDuration = cfg.Bind<float>("Coffee Bag Rework", "Duration", 5f, "Base duration (in seconds) of the coffee buff.");
			coffeeMoveSpeed = cfg.Bind<float>("Coffee Bag Rework", "Move Speed", 0.07f, "Move speed bonus granted for each stack of the item, per buff stack. (1 = 100% move speed)");
			coffeeAttackSpeed = cfg.Bind<float>("Coffee Bag Rework", "Attack Speed", 0.075f, "Attack speed bonus granted for each stack of the item, per buff stack. (1 = 100% attack speed)");
			horseshoeEnable = cfg.Bind<bool>("Uranium Horseshoe Buff", "Enable Changes", true, "Enables the changes to uranium horseshoe. Requires Starstorm2 and Meltdown.");
			uraniumHorseshoeDamage = cfg.Bind<float>("Uranium Horseshoe Buff", "Radiation Damage", 0.05f, "Radiation damage bonus granted for each stack of the item. (1 = 100% bonus damage)");
			boneVisorEnable = cfg.Bind<bool>("Bone Visor Rework", "Enable Changes", true, "Enables the changes to bone visor. Requires BubbetsItems.");
			boneDuration = cfg.Bind<float>("Bone Visor Rework", "Duration", 5f, "Base duration (in seconds) of the barrier regeneration buff.");
			boneDurationStack = cfg.Bind<float>("Bone Visor Rework", "Duration Stacking", 1f, "Duration of the barrier regeneration buff for each additional stack of the item.");
			boneProcChance = cfg.Bind<float>("Bone Visor Rework", "Proc Chance", 6f, "Base percent chance to drop a bone shard on hit. (100 = 100% chance)");
			boneProcStack = cfg.Bind<float>("Bone Visor Rework", "Proc Chance Stacking", 1.5f, "Percent chance to drop a bone shard for each additional stack of the item.");
			chanceDollEnable = cfg.Bind<bool>("Chance Doll Rework", "Enable Changes", true, "Enables the changes to chance doll.");
			chanceDollScrap = cfg.Bind<float>("Chance Doll Rework", "Scrap Chance", 10f, "Percent chance to gain white scrap when a chance shrine fails, for each stack of the item. (100 = 100% chance)");
			chanceDollUpgrade = cfg.Bind<float>("Chance Doll Rework", "Upgrade Chance", 50f, "Percent chance to upgrade a chance shrine reward.");
			ignitionEnable = cfg.Bind<bool>("Ignition Tank Rework", "Enable Changes", true, "Enables the changes to ignition tank.");
			ignitionBurnBonus = cfg.Bind<int>("Ignition Tank Rework", "Ignite Multiplier", 2, "Ignite damage multiplier for each stack of the item. (1 = 100% more damage)");
			ignitionCooldownTime = cfg.Bind<float>("Ignition Tank Rework", "Cooldown", 5f, "Cooldown time (in seconds) for the ignite on hit effect.");
			ignitionCooldownStack = cfg.Bind<float>("Ignition Tank Rework", "Cooldown Stacking", 0.15f, "Cooldown reduction for each additional stack of the item. (1 = 100% reduction)");
			ignitionBurnDamage = cfg.Bind<float>("Ignition Tank Rework", "Ignite Damage", 0.5f, "Total damage of the ignite on hit effect. (1 = 100% damage)");
			scytheEnable = cfg.Bind<bool>("Harvesters Scythe Rework", "Enable Changes", true, "Enables the changes to harvesters scythe.");
			scytheHeal = cfg.Bind<float>("Harvesters Scythe Rework", "Heal Amount", 20f, "Base healing recieved from the item.");
			scytheHealStack = cfg.Bind<float>("Harvesters Scythe Rework", "Heal Amount Stacking", 20f, "Healing recieved from each additional stack of the item.");
			scytheCooldownTime = cfg.Bind<float>("Harvesters Scythe Rework", "Cooldown", 2f, "Cooldown time (in seconds) between uses of the item.");
			infusionEnable = cfg.Bind<bool>("Infusion Buff", "Enable Changes", true, "Enables the changes to infusion.");
			infusionSpeed = cfg.Bind<float>("Infusion Buff", "Speed Boost", 0.1f, "Maximum speed boost to recieve from each stack of the item. (1 = 100% bonus speed)");
			faradayEnable = cfg.Bind<bool>("Faraday Spur Rebalance", "Enable Changes", true, "Enables the changes to faraday spur.");
			faradaySpeedJumpCap = cfg.Bind<float>("Faraday Spur Rebalance", "Speed & Jump Height Cap", 1f, "Speed/jump bonus granted by this item at max charge. (1 = 100% bonus speed)");
			faradayCharge = cfg.Bind<float>("Faraday Spur Rebalance", "Charge Rate", 1.25f, "Base charge rate multiplier for faraday spur. Flat buff to the vanilla charge rate. (1 = no changes)");
			faradayChargeStack = cfg.Bind<float>("Faraday Spur Rebalance", "Charge Rate Stacking", 0.5f, "Bonus charge speed granted for each additional stack of the item. (1 = 100% faster charge rate)");
			faradayDamage = cfg.Bind<float>("Faraday Spur Rebalance", "Max Damage", 8f, "Damage coeffecient of the blast at max charge. (1 = 100% base damage)");
			faradayDamageStack = cfg.Bind<float>("Faraday Spur Rebalance", "Max Damage Stacking", 4f, "Max damage coeffecient of the blast for each additional stack of the item.");
			faradayRadius = cfg.Bind<float>("Faraday Spur Rebalance", "Max Radius Base", 40f, "Radius of the blast at max charge. (1 = 1m radius)");
			faradayRadiusStack = cfg.Bind<float>("Faraday Spur Rebalance", "Max Radius Stacking", 0f, "Max radius of the blast for each additional stack of the item.");
			transmitterEnable = cfg.Bind<bool>("Unstable Transmitter Rework", "Enable Changes", true, "Enables the changes to unstable transmitter.");
			transmitterBarrier = cfg.Bind<float>("Unstable Transmitter Rework", "Barrier Amount", 0.3f, "Barrier amount to recieve on activation, proportional to max HP. (1 = 100% barrier)");
			transmitterPulseBarrier = cfg.Bind<float>("Unstable Transmitter Rework", "Barrier Per Hit", 0.05f, "Additional barrier to recieve for each enemy within the radius, proportional to max HP.");
			transmitterPulseRadius = cfg.Bind<float>("Unstable Transmitter Rework", "Pulse Radius", 30f, "Radius of the unstable transmitter pulse. (1 = 1m radius)");
			transmitterCooldown = cfg.Bind<float>("Unstable Transmitter Rework", "Cooldown", 200f, "Cooldown time (in seconds) before this item regenerates.");
			bandolierEnable = cfg.Bind<bool>("Bandolier Rework", "Enable Changes", true, "Enables the changes to bandolier.");
			bandolierSpeed = cfg.Bind<float>("Bandolier Rework", "Attack Speed", 0.2f, "Attack speed bonus per stack of spare ammunition. (1 = 100% attack speed)");
			bandolierChance = cfg.Bind<float>("Bandolier Rework", "Drop Chance", 20f, "Chance for ammo packs to drop on kill. (100 = 100% chance)");
			bandolierStocks = cfg.Bind<int>("Bandolier Rework", "Recharge Stocks", 1, "The amount of spare ammunition to get per ammo pack, for each stack of the item.");
			markEnable = cfg.Bind<bool>("Death Mark Rework", "Enable Changes", true, "Enables the changes to death mark.");
			markDamage = cfg.Bind<float>("Death Mark Rework", "Damage Bonus", 0.15f, "Amount of bonus damage to deal to enemies that are marked for death, for each debuff applied to them. (1 = 100% bonus damage)");
			markDuration = cfg.Bind<float>("Death Mark Rework", "Duration", 4f, "Base duration (in seconds) of the death mark debuff.");
			markDurationStack = cfg.Bind<float>("Death Mark Rework", "Duration Stacking", 2f, "Bonus duration (in seconds) of the death mark debuff, for each additional stack of the item.");
			markChance = cfg.Bind<float>("Death Mark Rework", "Proc Chance", 10f, "Chance on hit to mark enemies for death. (100 = 100% chance)");
			finEnable = cfg.Bind<bool>("Breaching Fin Rework", "Enable Changes", true, "Enables the changes to breaching fin.");
			finDamage = cfg.Bind<float>("Breaching Fin Rework", "Damage Bonus", 0.75f, "Damage bonus for each stack of the item. (1 = 100% damage)");
			finChance = cfg.Bind<float>("Breaching Fin Rework", "Proc Chance", 25f, "Chance on hit for the item to activate, unaffected by proc coefficient. (100 = 100% chance)");
			finForce = cfg.Bind<float>("Breaching Fin Rework", "Base Knockback Force", 1250f, "Base knockback force applied by the item.");
			finForceScale = cfg.Bind<float>("Breaching Fin Rework", "Scaling Knockback Force", 250f, "Additional knockback force applied by the item, multiplied by the damage coefficient of the hit.");
			stealthEnable = cfg.Bind<bool>("Old War Stealthkit Buff", "Enable Changes", true, "Enables the changes to old war stealthkit.");
			stealthDamage = cfg.Bind<float>("Old War Stealthkit Buff", "Damage Bonus", 0.25f, "Damage bonus gained while invisible for each stack of the item. (1 = 100% damage)");
			stealthWindow = cfg.Bind<float>("Old War Stealthkit Buff", "Damage Window", 2f, "Amount of time (in seconds) that the damage bonus lasts for after losing invisibility.");
			stealthThreshold = cfg.Bind<float>("Old War Stealthkit Buff", "Health Threshold", 0.5f, "Amount of health that must be lost before the item activates. (1 = 100% health)");
			stealthCooldown = cfg.Bind<float>("Old War Stealthkit Buff", "Cooldown", 20f, "Base cooldown time (in seconds) between activations of the item.");
			stealthCooldownStack = cfg.Bind<float>("Old War Stealthkit Buff", "Cooldown Stacking", 0.25f, "Cooldown time reduction for each additional stack of the item. (1 = 100% time reduction)");
			chronoEnable = cfg.Bind<bool>("Chronobauble Buff", "Enable Changes", true, "Enables the changes to chronobauble.");
			chronoDuration = cfg.Bind<float>("Chronobauble Buff", "Slow Duration", 4f, "Slow debuff duration (in seconds) of the item.");
			chronoRecharge = cfg.Bind<float>("Chronobauble Buff", "Recharge Amount", 0.06f, "Skill recharge rate increase per slowed enemy, for each stack of the item. (1 = 100% Recharge Speed)");
			chronoRadius = cfg.Bind<float>("Chronobauble Buff", "Radius", 30f, "Radius of the recharge effect (in meters).");
			tomeEnable = cfg.Bind<bool>("Ghors Tome Buff", "Enable Changes", true, "Enables the changes to ghor's tome.");
			tomeChance = cfg.Bind<float>("Ghors Tome Buff", "Slow Duration", 6f, "Gold drop chance on kill or interactable activation for each stack of the item. (100 = 100% chance)");
			daisyEnable = cfg.Bind<bool>("Lepton Daisy Rework", "Enable Changes", true, "Enables the changes to lepton daisy.");
			daisyHeal = cfg.Bind<float>("Lepton Daisy Rework", "Heal Fraction", 0.07f, "Base percentage of missing health to heal per second. (1 = 100% missing health)");
			daisyHealStack = cfg.Bind<float>("Lepton Daisy Rework", "Heal Fraction Stacking", 0.03f, "Bonus percentage of missing health to heal for each additional stack of the item.");
			harpoonEnable = cfg.Bind<bool>("Hunters Harpoon Rework", "Enable Changes", true, "Enables the changes to hunters harpoon.");
			harpoonBonus = cfg.Bind<float>("Hunters Harpoon Rework", "Speed Bonus", 0.2f, "Percent increase to utility skill recharge speed and movement speed for each stack of the buff. (1 = 100% increase)");
			harpoonDuration = cfg.Bind<float>("Hunters Harpoon Rework", "Buff Duration", 0.4f, "Duration of each stack of the buff (in seconds). The buff decays one stack at a time.");
			harpoonCount = cfg.Bind<int>("Hunters Harpoon Rework", "Buff Count", 5, "Base amount of buff stacks to recieve when killing an enemy.");
			harpoonCountStack = cfg.Bind<int>("Hunters Harpoon Rework", "Buff Count Stacking", 1, "Bonus amount of buff stacks to recieve for each additional stack of the item.");
			jetBootsEnable = cfg.Bind<bool>("Prototype Jet Boots Rebalance", "Enable Changes", true, "Enables the changes to prototype jet boots. Requires Starstorm2.");
			jetBootsDamage = cfg.Bind<float>("Prototype Jet Boots Rebalance", "Damage", 4.5f, "Base damage coefficient of the item. (1 = 100% damage)");
			jetBootsDamageStack = cfg.Bind<float>("Prototype Jet Boots Rebalance", "Damage Stacking", 1.5f, "Bonus damage coefficient for each additional stack of the item.");
			batteryEnable = cfg.Bind<bool>("Volatile Thorium Battery Rebalance", "Enable Changes", true, "Enables the changes to volatile thorium battery. Requires Meltdown.");
			batteryDamage = cfg.Bind<float>("Volatile Thorium Battery Rebalance", "Damage", 2f, "Base damage coefficient of the radiation wave. (1 = 100% damage)");
			batteryDamageStack = cfg.Bind<float>("Volatile Thorium Battery Rebalance", "Damage Stacking", 0.8f, "Bonus damage coefficient granted for each additional stack of the item.");
			batteryDamageChance = cfg.Bind<float>("Volatile Thorium Battery Rebalance", "Radiation Wave Proc Chance", 20f, "Percent chance per radiation damage tick for the item to proc. (100 = 100% chance)");
			duplicatorEnable = cfg.Bind<bool>("Substandard Duplicator Rework", "Enable Changes", true, "Enables the changes to substandard duplicator.");
			duplicatorCompat = cfg.Bind<bool>("Substandard Duplicator Rework", "TempItemsTooShort Compat", false, "Enable this if TempItemsTooShort is installed or else the game will blow itself up.");
			duplicatorDropChance = cfg.Bind<float>("Substandard Duplicator Rework", "Proc Chance", 8f, "Percent chance to drop a temporary item on kill. (100 = 100% chance)");
			duplicatorDuration = cfg.Bind<int>("Substandard Duplicator Rework", "Duration", 30, "Duration increase (in seconds) for temporary items per stack of the item.");
			vultureEnable = cfg.Bind<bool>("Wake Of Vultures Rework", "Enable Changes", true, "Enables the changes to wake of vultures.");
			vultureEliteDamage = cfg.Bind<float>("Wake Of Vultures Rework", "Elite Damage Bonus", 0.5f, "Damage bonus granted against elites above half health for each stack of the item. (1 = 100% bonus damage)");
			vultureDropChance = cfg.Bind<float>("Wake Of Vultures Rework", "Elite Aspect Drop Chance", 5f, "Flat percent chance for an elite aspect to drop on kill for each stack of the item. (100 = 100% chance)");
			vultureHealPercent = cfg.Bind<float>("Wake Of Vultures Rework", "Heal Percent", 0.2f, "Max HP fraction to heal upon killing an elite. (1 = 100% heal)");
			raincoatEnable = cfg.Bind<bool>("Bens Raincoat Rework", "Enable Changes", true, "Enables the changes to bens raincoat.");
			raincoatCooldownTime = cfg.Bind<float>("Bens Raincoat Rework", "Cooldown", 15f, "Cooldown time (in seconds) between uses of the item.");
			raincoatCooldownStack = cfg.Bind<float>("Bens Raincoat Rework", "Cooldown Stacking", 0.2f, "Cooldown reduction for each additional stack of the item. (1 = 100% reduction)");
			raincoatBarrier = cfg.Bind<float>("Bens Raincoat Rework", "Barrier Amount", 0.25f, "Barrier amount to recieve on activation, proportional to max HP. (1 = 100% barrier)");
			raincoatDuration = cfg.Bind<float>("Bens Raincoat Rework", "Invulnerability Time", 3f, "Duration of the invulnerability (in seconds) to recieve on activation.");
			warbondsEnable = cfg.Bind<bool>("War Bonds Rework", "Enable Changes", true, "Enables the changes to war bonds.");
			warbondsGoldCost = cfg.Bind<int>("War Bonds Rework", "Gold Rewuirement", 15, "Required amount of gold to spend per barrage stack (scales over time).");
			warbondsDamage = cfg.Bind<float>("War Bonds Rework", "Barrage Damage", 15f, "Base damage coefficient of the barrage. (1 = 100% damage)");
			warbondsDamageStack = cfg.Bind<float>("War Bonds Rework", "Barrage Damage Stacking", 3f, "Bonus damage coefficient of the barrage for each additional stack of the item.");
			icbmEnable = cfg.Bind<bool>("Pocket ICBM Rework", "Enable Changes", true, "Enables the changes to pocket icbm.");
			icbmDamage = cfg.Bind<float>("Pocket ICBM Rework", "Auto-Missile Damage", 5f, "Base damage coefficient of the auto-missiles. (1 = 100% damage)");
			icbmDamageStack = cfg.Bind<float>("Pocket ICBM Rework", "Auto-Missile Damage Stacking", 0.5f, "Bonus damage coefficient of the auto-missiles for each additional stack of the item.");
			icbmCooldown = cfg.Bind<float>("Pocket ICBM Rework", "Auto-Missile Interval", 10f, "Base time (in seconds) between auto-missiles.");
			icbmCooldownStack = cfg.Bind<float>("Pocket ICBM Rework", "Auto-Missile Interval Stacking", 0.25f, "Time reduction for each additional stack of the item.");
			knurlEnable = cfg.Bind<bool>("Titanic Knurl Rework", "Enable Changes", true, "Enables the changes to titanic knurl.");
			knurlHP = cfg.Bind<float>("Titanic Knurl Rework", "Level Health", 10f, "HP gained per level for each stack of the item.");
			knurlRegen = cfg.Bind<float>("Titanic Knurl Rework", "Level Regen", 0.5f, "Health regeneration gained per level for each stack of the item. (1 = 1 hp/s per level)");
			genesisEnable = cfg.Bind<bool>("Genesis Loop Rework", "Enable Changes", true, "Enables the changes to genesis loop.");
			genesisEnemyEnable = cfg.Bind<bool>("Genesis Loop Rework", "Enable Changes On Enemies", false, "Enables the changes to genesis loop on all enemies with the item. Off by default for compatibility with SimulacrumAdditions.");
			genesisCharge = cfg.Bind<float>("Genesis Loop Rework", "Charge Rate", 1f, "Amount of charge to gain per 1% health lost when damaged. (100 = 100% charge)");
			genesisChargeStack = cfg.Bind<float>("Genesis Loop Rework", "Charge Rate Stacking", 0.5f, "Bonus charge to gain per 1% health lost for each additional stack of the item.");
			glandEnable = cfg.Bind<bool>("Queens Gland Buff", "Enable Changes", true, "Enables the changes to queen's gland.");
			glandBonus = cfg.Bind<int>("Queens Gland Buff", "Stat Bonus", 2, "Extra health and damage bonuses granted to the spawned beetles. (1 = 10% bonus)");
			planulaEnable = cfg.Bind<bool>("Planula Rework", "Enable Changes", true, "Enables the changes to planula.");
			planulaInterval = cfg.Bind<float>("Planula Rework", "Embryo Interval", 2f, "Time (in seconds) between gaining stacks of the embryo buff.");
			planulaIntervalStack = cfg.Bind<float>("Planula Rework", "Embryo Interval Stacking", 0.15f, "Interval time reduction for each additional stack of the item. (1 = 100% reduction)");
			planulaMax = cfg.Bind<int>("Planula Rework", "Embryo Count", 5, "Maximum amount of embryo stacks you can have at once");
			planulaMaxStack = cfg.Bind<int>("Planula Rework", "Embryo Count Stacking", 2, "Maximum amount of embryo stacks you can have at once for each additional stack of the item");
			planulaFlatHeal = cfg.Bind<float>("Planula Rework", "Flat Healing", 10f, "Flat amount of health to heal for each embryo stack consumed.");
			planulaPercentHeal = cfg.Bind<float>("Planula Rework", "Fraction Healing", 0.01f, "Percentage of your maximum health to heal for each embryo stack consumed. (1 = 100% health)");
			conductorEnable = cfg.Bind<bool>("Faulty Conductor Rework", "Enable Changes", true, "Enables the changes to faulty conductor.");
			conductorChance = cfg.Bind<float>("Faulty Conductor Rework", "Proc Chance", 2.5f, "Percent chance for faulty conductor to activate for each second of the skill's recharge time. (100 = 100% chance)");
			conductorDuration = cfg.Bind<float>("Faulty Conductor Rework", "Duration", 6f, "Base duration (in seconds) of the energized buff.");
			conductorDurationStack = cfg.Bind<float>("Faulty Conductor Rework", "Duration Stacking", 2f, "Bonus duration (in seconds) of the energized buff for each additional stack of the item.");
			conductorBoost = cfg.Bind<float>("Faulty Conductor Rework", "Stat Boost", 0.5f, "Base increase to attack speed, movement speed, and electrical damage while energized. (1 = 100% increase)");
			conductorBoostStack = cfg.Bind<float>("Faulty Conductor Rework", "Stat Boost Stacking", 0.1f, "Bonus increase to attack speed, movement speed, and electrical damage for each additional stack of the item. (1 = 100% increase)");
			lampEnable = cfg.Bind<bool>("Shackled Lamp Buff", "Enable Changes", true, "Enables the changes to shackled lamp. Requires Starstorm2.");
			lampDamage = cfg.Bind<float>("Shackled Lamp Buff", "Damage", 3.5f, "Base damage coeffecient of the item. (1 = 100% damage)");
			lampDamageStack = cfg.Bind<float>("Shackled Lamp Buff", "Damage Stacking", 1.5f, "Bonus damage coeffecient for each additional stack of the item.");
			seerEnable = cfg.Bind<bool>("Lost Seers Lenses Rework", "Enable Changes", true, "Enables the changes to lost seer's lenses.");
			seerChance = cfg.Bind<float>("Lost Seers Lenses Rework", "Eradicate Chance", 0.4f, "Base percent chance on hit to eradicate enemies. (100 = 100% chance)");
			seerChanceStack = cfg.Bind<float>("Lost Seers Lenses Rework", "Eradicate Chance Stacking", 0.3f, "Bonus percent chance on hit to eradicate enemies for each additional stack of the item. (100 = 100% chance)");
			pyreEnable = cfg.Bind<bool>("Umbral Pyre Corruption", "Change Corruption", true, "Changes this item's corruption to bolstering lantern. For further configuration, use the config file from the original mod. Requires RigsArsenal.");
			welliesEnable = cfg.Bind<bool>("Waterlogged Wellies Rework", "Enable Changes", true, "Enables the changes to waterlogged wellies. Requires Nautilus.");
			welliesDamage = cfg.Bind<float>("Waterlogged Wellies Rework", "Grounded Crit Damage", 0.15f, "Crit damage bonus to gain for each stack of the item while grounded. (1 = 100% bonus damage)");
			welliesChance = cfg.Bind<float>("Waterlogged Wellies Rework", "Airborne Crit Chance", 15f, "Crit chance to gain for each stack of the item while airborne. (100 = 100% chance)");
			welliesDuration = cfg.Bind<float>("Waterlogged Wellies Rework", "Weak Duration", 2f, "Base duration of the weak debuff (in seconds) applied to airborne enemies whenever you land a critical hit.");
			welliesDurationStack = cfg.Bind<float>("Waterlogged Wellies Rework", "Weak Duration Stacking", 0.5f, "Bonus duration of the weak debuff (in seconds) for each additional stack of the item.");
			welliesForce = cfg.Bind<float>("Waterlogged Wellies Rework", "Downward Pull Force", 175f, "Amount of pull force to apply to airborne enemies whenever you land a critical hit.");
			coolantEnable = cfg.Bind<bool>("Supercritical Coolant Rebalance", "Enable Changes", true, "Enables the changes to supercritical coolant. Requires VanillaVoid.");
			coolantDamage = cfg.Bind<float>("Supercritical Coolant Rebalance", "Damage", 2f, "Base damage of the item. (1 = 100% damage)");
			coolantDamageStack = cfg.Bind<float>("Supercritical Coolant Rebalance", "Damage Stacking", 0.5f, "Bonus damage for each additional stack of the item.");
			coolantRadius = cfg.Bind<float>("Supercritical Coolant Rebalance", "Radius", 15f, "Base area of effect size of the item. (1 = 1m).");
			coolantRadiusStack = cfg.Bind<float>("Supercritical Coolant Rebalance", "Radius Stacking", 5f, "Bonus area of effect size for each additional stack of the item.");
			coolantDuration = cfg.Bind<float>("Supercritical Coolant Rebalance", "Frost Duration", 4f, "Base duration of the Frost debuff (in seconds) applied by the item.");
			coolantDurationStack = cfg.Bind<float>("Supercritical Coolant Rebalance", "Frost Duration Stacking", 1f, "Bonus duration of the Frost debuff (in seconds) for each additional stack of the item.");
			coolantFrostCount = cfg.Bind<int>("Supercritical Coolant Rebalance", "Frost Count", 2, "Amount of Frost debuff stacks that the item applies on hit (enemies freeze after 6 stacks).");
			lotusEnable = cfg.Bind<bool>("Crystalline Lotus Rework", "Enable Changes", true, "Enables the changes to crystalline lotus. Requires VanillaVoid.");
			lotusDuration = cfg.Bind<float>("Crystalline Lotus Rework", "Duration", 45f, "Base duration (in seconds) of the slowing field.");
			lotusDurationStack = cfg.Bind<float>("Crystalline Lotus Rework", "Duration Stacking", 15f, "Bonus duration (in seconds) of the slowing field for each additional stack of the item.");
			singularityEnable = cfg.Bind<bool>("Singularity Band Rebalance", "Enable Changes", true, "Enables the changes to singularity band.");
			singularityDamage = cfg.Bind<float>("Singularity Band Rebalance", "Damage Coefficient", 3f, "Base damage coefficient of the black hole. (1 = 100% TOTAL damage)");
			singularityDamageStack = cfg.Bind<float>("Singularity Band Rebalance", "Damage Coefficient Stacking", 1.5f, "Bonus damage coefficient of the black hole for each additional stack of the item.");
			singularityRadius = cfg.Bind<float>("Singularity Band Rebalance", "Radius", 15f, "Base area of effect size of the black hole. (1 = 1m).");
			singularityRadiusStack = cfg.Bind<float>("Singularity Band Rebalance", "Radius Stacking", 1.5f, "Bonus area of effect size for each additional stack of the item.");
			singularityThreshold = cfg.Bind<float>("Singularity Band Rebalance", "Damage Threshold", 6f, "Damage coefficient required to proc the item. (1 = 100% damage)");
			singularityProc = cfg.Bind<float>("Singularity Band Rebalance", "Proc Coefficient", 2f, "Proc coefficient of the black hole.");
			toxicoEnable = cfg.Bind<bool>("Drowning Ivy Rework", "Enable Changes", true, "Reverts drowning ivy back to a tweaked version of its old toxicodendron brine behaviour. Requires SeekingTheVoid.");
			toxicoName = cfg.Bind<bool>("Drowning Ivy Rework", "Revert Name", true, "Changes drowning ivy's name back to toxicodendron brine.");
			toxicoCooldown = cfg.Bind<float>("Drowning Ivy Rework", "Cooldown Time", 5f, "Cooldown time of the item.");
			toxicoTargets = cfg.Bind<int>("Drowning Ivy Rework", "Spread Targets", 2, "Base number of