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 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.ContentManagement;
using RoR2.ExpansionManagement;
using RoR2.Items;
using RoR2.Projectile;
using RoR2.UI;
using RoR2BepInExPack.GameAssetPaths.Version_1_39_0;
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("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.4.0")]
	[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 const string PluginGUID = "Bloonjitsu7.BloonItemRebalance";

		public const string PluginAuthor = "Bloonjitsu7";

		public const string PluginName = "BloonItemRebalance";

		public const string PluginVersion = "1.4.0";

		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 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 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 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<int, float>, int, float> <0>__OnMissileDamage;

			public static hook_ProcessHitEnemy <1>__OnProcessSingularityBand;
		}

		private static Hook missileHook;

		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;

		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();

		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> 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> 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> 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> lampEnable { get; set; }

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

		public static ConfigEntry<float> lampDamageStack { 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<float> toxicoStack { 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).");
			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", 25f, "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.");
			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.");
			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.");
			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>("Toxicodendron Brine Buff", "Enable Changes", true, "Enables the changes to toxicodendronbrine. Requires SeekingTheVoid.");
			toxicoStack = cfg.Bind<float>("Toxicodendron Brine Buff", "Cooldown Stacking", 0.1f, "Bonus ability cooldown reduction for each additional stack of the item. (1 = 100% recharge)");
			coreEnable = cfg.Bind<bool>("Corrosive Core Buff", "Enable Changes", true, "Enables the changes to corrosive core. Requires VanillaVoid.");
			coreDuration = cfg.Bind<float>("Corrosive Core Buff", "Tar Duration", 2f, "Base duration of the tar debuff (in seconds) from the item.");
			coreDurationStack = cfg.Bind<float>("Corrosive Core Buff", "Tar Duration Stacking", 0.5f, "Bonus duration of the tar debuff (in seconds) for each additional stack of the item.");
			coreSlowChance = cfg.Bind<float>("Corrosive Core Buff", "Tar Chance", 6f, "Percent chance to apply Tar on hit. (100 = 100% chance)");
			burdenEnable = cfg.Bind<bool>("Executioners Burden Rework", "Enable Changes", true, "Enables the changes to exectioners burden. Requires VanillaVoid.");
			burdenDamage = cfg.Bind<float>("Executioners Burden Rework", "Damage", 5f, "Base damage coefficient of the item. (1 = 100% damage)");
			burdenDamageStack = cfg.Bind<float>("Executioners Burden Rework", "Damage Stacking", 3.5f, "Bonus damage coefficient for each additional stack of the item.");
			burdenRadius = cfg.Bind<float>("Executioners Burden Rework", "Radius", 30f, "Base area of effect size of the item. (1 = 1m)");
			burdenRadiusStack = cfg.Bind<float>("Executioners Burden Rework", "Radius Stacking", 5f, "Bonus area of effect size for each additional stack of the item.");
			burdenDuration = cfg.Bind<float>("Executioners Burden Rework", "Dread Duration", 8f, "Duration of the dread debuff (in seconds) applied by this item.");
			burdenThreshold = cfg.Bind<float>("Executioners Burden Rework", "Dread Execute Threshold", 0.25f, "Percentage of max hp for enemies to be executed at while afflicted by dread. (1 = 100%)");
			opticsEnable = cfg.Bind<bool>("Obervers Optics Rework", "Enable Changes", true, "Enables the changes to observers optics. Requires Nautilus.");
			opticsDuration = cfg.Bind<float>("Obervers Optics Rework", "Voidtouched Duration", 30f, "Base duration of the voidtouched buff (in seconds) upon activating an equipment.");
			opticsDurationStack = cfg.Bind<float>("Obervers Optics Rework", "Voidtouched Duration Stacking", 30f, "Bonus duration of the voidtouched buff (in seconds) for each additional stack of the item.");
			opticsChance = cfg.Bind<float>("Obervers Optics Rework", "Collapse Chance", 5f, "Percent chance to collapse on hit per buff stack. (100 = 100% chance)");
			opticsDamage = cfg.Bind<float>("Obervers Optics Rework", "Collapse Damage", 0.25f, "Bonus collapse damage granted per puff stack. (1 = 100% bonus damage)");
			solitudeEnable = cfg.Bind<bool>("Longstanding Solitude Rebalance", "Enable Changes", true, "Enables the changes to longstanding solitude.");
			solitudeCost = cfg.Bind<float>("Longstanding Solitude Rebalance", "Cost Increase", 0.25f, "Percent increase in interactable prices for each stack of the item. (1 = 100%)");
			solitudeExp = cfg.Bind<float>("Longstanding Solitude Rebalance", "Exp Decrease", 0.25f, "Percent decrease in exp gains for each stack of the item. (1 = 100%)");
			crucifixEnable = cfg.Bind<bool>("Crucifix Rework", "Enable Changes", true, "Enables the changes to crucifix. Requires TooManyItems.");
			crucifixHealReduction = cfg.Bind<float>("Crucifix Rework", "Healing Reduction", 0.5f, "Healing reduction while on fire for each stack of the item. (1 = 100% reduction)");
			crucifixResist = cfg.Bind<float>("Crucifix Rework", "Damage Resistance", 0.95f, "Damage resistance granted by the item. (1 = 100% resistance)");
			crucifixBurnPercent = cfg.Bind<float>("Crucifix Rework", "Burn Damage", 0.2f, "Percentage of max hp to take as burn damage. (1 = 100% hp)");
			crucifixBurnStack = cfg.Bind<float>("Crucifix Rework", "Burn Damage Stacking", 0.1f, "Burn damage reduction per additional stack of the item. (1 = 100% reduction)");
			seepingEnable = cfg.Bind<bool>("Seeping Ocean Rework", "Enable Changes", true, "Enables the changes to seeping ocean. Requires BubbetsItems.");
			seepingChance = cfg.Bind<float>("Seeping Ocean Rework", "Conversion Chance", 0.04f, "Base percent chance to convert items into random void items. (1 = 100% chance)");
			seepingChanceStack = cfg.Bind<float>("Seeping Ocean Rework", "Conversion Chance Stacking", 0.02f, "Bonus percent chance to convert items for each additional stack of the item. (1 = 100% chance)");
		}

		public void Initialize()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: 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_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Expected O, but got Unknown
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Expected O, but got Unknown
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Expected O, but got Unknown
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: Expected O, but got Unknown
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c9: Expected O, but got Unknown
			//IL_044d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0457: Expected O, but got Unknown
			//IL_04f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fa: Expected O, but got Unknown
			//IL_0473: Unknown result type (might be due to invalid IL or missing references)
			//IL_047d: Expected O, but got Unknown
			//IL_05f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0601: Expected O, but got Unknown
			//IL_0609: Unknown result type (might be due to invalid IL or missing references)
			//IL_0613: Expected O, but got Unknown
			//IL_068b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0695: Expected O, but got Unknown
			//IL_07a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b3: Expected O, but got Unknown
			//IL_07bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c5: Expected O, but got Unknown
			//IL_07cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d7: Expected O, but got Unknown
			//IL_089d: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a7: Expected O, but got Unknown
			//IL_0966: Unknown result type (might be due to invalid IL or missing references)
			//IL_0970: Expected O, but got Unknown
			//IL_0a47: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a51: Expected O, but got Unknown
			//IL_0a59: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a63: Expected O, but got Unknown
			//IL_0a6b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a75: Expected O, but got Unknown
			//IL_0b7a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b84: Expected O, but got Unknown
			//IL_0b8c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b96: Expected O, but got Unknown
			//IL_0b9e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ba8: Expected O, but got Unknown
			//IL_0bb0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bba: Expected O, but got Unknown
			//IL_0bc2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bcc: Expected O, but got Unknown
			//IL_0bd4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bde: Expected O, but got Unknown
			//IL_0be6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bf0: Expected O, but got Unknown
			//IL_0bf8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c02: Expected O, but got Unknown
			//IL_0cfc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d06: Expected O, but got Unknown
			//IL_0d0e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d18: Expected O, but got Unknown
			//IL_0d20: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d2a: Expected O, but got Unknown
			//IL_0dd5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ddf: Expected O, but got Unknown
			//IL_0de7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0df1: Expected O, but got Unknown
			//IL_0df9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e03: Expected O, but got Unknown
			//IL_0e9e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ea8: Expected O, but got Unknown
			//IL_0eb0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0eba: Expected O, but got Unknown
			//IL_0f28: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f32: Expected O, but got Unknown
			//IL_0f3a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f44: Expected O, but got Unknown
			//IL_0f4c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f56: Expected O, but got Unknown
			//IL_101b: Unknown result type (might be due to invalid IL or missing references)
			//IL_1025: Expected O, but got Unknown
			//IL_102d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1037: Expected O, but got Unknown
			//IL_10c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_10cd: Expected O, but got Unknown
			//IL_1126: Unknown result type (might be due to invalid IL or missing references)
			//IL_1130: Expected O, but got Unknown
			//IL_1138: Unknown result type (might be due to invalid IL or missing references)
			//IL_1142: Expected O, but got Unknown
			//IL_114a: Unknown result type (might be due to invalid IL or missing references)
			//IL_1154: Expected O, but got Unknown
			//IL_115c: Unknown result type (might be due to invalid IL or missing references)
			//IL_1166: Expected O, but got Unknown
			//IL_11da: Unknown result type (might be due to invalid IL or missing references)
			//IL_11e4: Expected O, but got Unknown
			//IL_11ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_11f6: Expected O, but got Unknown
			//IL_12bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_12c6: Expected O, but got Unknown
			//IL_1294: Unknown result type (might be due to invalid IL or missing references)
			//IL_129e: Expected O, but got Unknown
			//IL_1352: Unknown result type (might be due to invalid IL or missing references)
			//IL_135c: Expected O, but got Unknown
			//IL_1364: Unknown result type (might be due to invalid IL or missing references)
			//IL_136e: Expected O, but got Unknown
			//IL_1376: Unknown result type (might be due to invalid IL or missing references)
			//IL_1380: Expected O, but got Unknown
			//IL_1388: Unknown result type (might be due to invalid IL or missing references)
			//IL_1392: Expected O, but got Unknown
			//IL_139a: Unknown result type (might be due to invalid IL or missing references)
			//IL_13a4: Expected O, but got Unknown
			//IL_149c: Unknown result type (might be due to invalid IL or missing references)
			//IL_14a6: Expected O, but got Unknown
			//IL_13da: Unknown result type (might be due to invalid IL or missing references)
			//IL_13e4: Expected O, but got Unknown
			//IL_150b: Unknown result type (might be due to invalid IL or missing references)
			//IL_1515: Expected O, but got Unknown
			//IL_151d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1527: Expected O, but got Unknown
			//IL_15b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_15ba: Expected O, but got Unknown
			//IL_1598: Unknown result type (might be due to invalid IL or missing references)
			//IL_159d: Unknown result type (might be due to invalid IL or missing references)
			//IL_15a3: Expected O, but got Unknown
			CreateBuffs();
			RecalculateStatsAPI.GetStatCoefficients += new StatHookEventHandler(OnRecalcStats);
			HealthComponent.TakeDamage += new hook_TakeDamage(OnTakeDamage);
			if (!HasVanillaVoid || !coreEnable.Value)
			{
				GlobalEventManager.ProcessHitEnemy += new Manipulator(IL_ProcessHit);
			}
			HealthComponent.TakeDamageProcess += new Manipulator(IL_EliteDamage);
			GenericSkill.RunRecharge += new hook_RunRecharge(OnSkillRecharge);
			if (solitudeEnable.Value)
			{
				TeamManager.GetLongstandingSolitudeItemCostScale += new hook_GetLongstandingSolitudeItemCostScale(OnItemCostScale);
				ExperienceManager.AwardExperience += new hook_AwardExperience(OnAwardExperience);
				string text = string.Format("<style=cIsUtility>On level up</style> gain <style=cIsDamage>1</style> <style=cStack>(+1 per stack)</style> <style=cIsDamage>free unlock</style> for the next purchase, but all gold is converted to experience. All gold prices are <style=cIsHealth>increased by {0}%</style> <style=cStack>(+{0}% per stack)</style>, and all experience gained is <style=cIsHealth>reduced by {1}%</style> <style=cStack>(+{1}% per stack)</style>.", solitudeCost.Value * 100f, solitudeExp.Value * 100f);
				LanguageAPI.Add("ITEM_ONLEVELUPFREEUNLOCK_DESC", text);
			}
			if (lanternEnable.Value)
			{
				AttackSpeedPerNearbyCollider.UpdateValues += new hook_UpdateValues(OnLanternUpdate);
				AttackSpeedPerNearbyCollider.Start += new hook_Start(OnLanternStart);
				CharacterBody.RecalculateStats += new Manipulator(IL_Lantern);
				string stackDesc = GetStackDesc(lanternSpeedStack.Value * 100f, "%");
				string stackDesc2 = GetStackDesc(lanternRegenStack.Value, " hp/s");
				string stackDesc3 = GetStackDesc(lanternRadiusStack.Value / 2f, "m");
				string stackDesc4 = GetStackDesc(lanternAllyStack.Value, "");
				if (lanternRegen.Value > 0f)
				{
					string text2 = $"Increases <style=cIsDamage>attack speed</style> by <style=cIsDamage>{lanternSpeed.Value * 100f}%</style>{stackDesc} and <style=cIsHealing>health regeneration</style> by <style=cIsHealing>{lanternRegen.Value} hp/s</style>{stackDesc2} for each enemy and ally within <style=cIsUtility>{lanternRadius.Value / 2f}m</style>{stackDesc3}, up to <style=cIsUtility>{lanternAlly.Value}</style>{stackDesc4} times.";
					LanguageAPI.Add("ITEM_ATTACKSPEEDPERNEARBYALLYORENEMY_DESC", text2);
					string text3 = "Increases your attack speed and health regen for every nearby enemy and ally.";
					LanguageAPI.Add("ITEM_ATTACKSPEEDPERNEARBYALLYORENEMY_DESC", text3);
				}
				else
				{
					string text4 = string.Format("Increases <style=cIsDamage>attack speed</style> by <style=cIsDamage>{0}%</style>{1} for each enemy and ally within <style=cIsUtility>{4}m</style>{5}, up to <style=cIsUtility>{6}</style>{7} times.", lanternSpeed.Value * 100f, stackDesc, lanternRadius.Value / 2f, stackDesc3, lanternAlly.Value, stackDesc4);
					LanguageAPI.Add("ITEM_ATTACKSPEEDPERNEARBYALLYORENEMY_DESC", text4);
				}
			}
			if (stunGrenadeEnable.Value)
			{
				SetStateOnHurt.OnTakeDamageServer += new Manipulator(IL_StunDamage);
				string text5 = $"<style=cIsUtility>5%</style> <style=cStack>(+5% per stack)</style> chance on hit to deal <style=cIsDamage>{stunGrenadeDamage.Value * 100f}% damage</style> and <style=cIsUtility>stun</style> enemies for <style=cIsUtility>2s</style>.";
				LanguageAPI.Add("ITEM_STUNCHANCEONHIT_DESC", text5);
				string text6 = $"Chance to damage and stun on hit.";
				LanguageAPI.Add("ITEM_STUNCHANCEONHIT_PICKUP", text6);
			}
			if (bungusEnable.Value)
			{
				CharacterBody.GetNotMoving += new Manipulator(IL_NotMoving);
				string text7 = $"After standing still for <style=cIsHealing>{bungusTimer.Value}s</style>, create a zone that <style=cIsHealing>heals</style> for <style=cIsHealing>4.5%</style> <style=cStack>(+2.25% per stack)</style> of your