using System;
using System.Collections;
using System.Collections.Generic;
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.VagrantNovaItem;
using HG;
using HarmonyLib;
using IL.EntityStates.Drone.Command;
using IL.EntityStates.Drone.DroneWeapon;
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.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]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BloonItemRebalance
{
	[BepInPlugin("com.Bloonjitsu7.BloonItemRebalance", "BloonItemRebalance", "1.3.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.3.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 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_IgniteOnKill.IgniteExplosionVFX_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 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)
		{
			//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_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: 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;
			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 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 = default(FireProjectileInfo);
				val.crit = base.body.RollCrit();
				val.owner = ((Component)this).gameObject;
				val.position = ((Component)characterBody).gameObject.transform.position + heightOffset;
				val.projectilePrefab = missilePrefab;
				val.rotation = Util.QuaternionSafeLookRotation(Vector3.down);
				val.damage = damage;
				val.maxDistance = maxDistance;
				FireProjectileInfo val2 = val;
				ProjectileManager.instance.FireProjectile(val2);
				if (num > 0)
				{
					val2.damage *= 0.5f;
					val2.position = ((Component)characterBody).gameObject.transform.position + heightOffset;
					ProjectileManager.instance.FireProjectile(val2);
				}
			}

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

		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 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> 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> 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.");
			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).");
			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_0dde: Unknown result type (might be due to invalid IL or missing references)
			//IL_0de8: Expected O, but got Unknown
			//IL_0db6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dc0: Expected O, but got Unknown
			//IL_0e74: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e7e: Expected O, but got Unknown
			//IL_0e86: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e90: Expected O, but got Unknown
			//IL_0e98: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ea2: Expected O, but got Unknown
			//IL_0eaa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0eb4: Expected O, but got Unknown
			//IL_0ebc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ec6: Expected O, but got Unknown
			//IL_0fbe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fc8: Expected O, but got Unknown
			//IL_0efc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f06: 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_103f: Unknown result type (might be due to invalid IL or missing references)
			//IL_1049: Expected O, but got Unknown
			//IL_10d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_10dc: Expected O, but got Unknown
			//IL_10ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_10bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_10c5: 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 <style=cIsHealing>health</style> every second to all allies within <style=cIsHealing>3m</style> <style=cStack>(+1.5m per stack)</style>.";
				LanguageAPI.Add("ITEM_MUSHROOM_DESC", text7);
				string text8 = $"Heal all nearby allies while standing still.";
				LanguageAPI.Add("ITEM_MUSHROOM_PICKUP", text8);
			}
			if (chanceDollEnable.Value)
			{
				ShrineChanceBehavior.AddShrineStack += new Manipulator(IL_ChanceShrine);
				string text9 = string.Format("Whenever a Shrine of Chance succeeds, gain a <style=cIsUtility>{0}%</style> chance to increase the <style=cIsDamage>rarity</style> of the item. Whenever a Shrine of Chance fails, gain a <style=cIsUtility>{1}%</style> <style=cStack>(+{1}% per stack)</style> chance for free <style=cIsUtility>White Scrap</style> to drop.", chanceDollUpgrade.Value, chanceDollScrap.Value);
				LanguageAPI.Add("ITEM_EXTRASHRINEITEM_DESC", text9);
				string text10 = $"50% of items dropped from Shrines of Chance have boosted rarity. Gain a small chance for free scrap when a Shrine of Chance fails.";
				LanguageAPI.Add("ITEM_EXTRASHRINEITEM_PICKUP", text10);
			}
			if (duplicatorEnable.Value)
			{
				GlobalEventManager.onCharacterDeathGlobal += OnDuplicatorDeath;
				ItemDef.AttemptGrant += new Manipulator(IL_GrantTempItem);
				if (!duplicatorCompat.Value)
				{
					DuplicatorBehavior.CalculateNewItemDecayDuration += new Manipulator(IL_Duplicator);
				}
				string text11 = string.Format("<style=cIsDamage>{0}% chance</style> on kill for a random <style=cIsUtility>temporary item</style> to drop. You get an <style=cIsHealing>extra copy</style> of any <style=cIsTemporary>temporary items</style> you pick up, and your <style=cIsUtility>temporary items</style> last an additional <style=cIsDamage>{1}s</style> <style=cStack>(+{1}s per stack)</style>.", duplicatorDropChance.Value, duplicatorDuration.Value);
				LanguageAPI.Add("ITEM_DUPLICATOR_DESC", text11);
				string text12 = $"Duplicate all temporary items you pick up. Monsters drop temporary items on death.";
				LanguageAPI.Add("ITEM_DUPLICATOR_PICKUP", text12);
			}
			if (vultureEnable.Value)
			{
				GlobalEventManager.OnCharacterDeath += new Manipulator(IL_EliteDeath);
				GlobalEventManager.onCharacterDeathGlobal += OnEliteDeath;
				string text13 = string.Format("You deal <style=cIsDamage>{0}%</style> <style=cStack>(+{0}% per stack)</style> more damage to <style=cIsDamage>elites</style> above <style=cIsDamage>50% health</style>. Upon killing an <style=cIsDamage>elite monster</style>, heal for <style=cIsHealing>{1}% of your total health</style> and gain a <style=cIsUtility>{2}%</style> <style=cStack>(+{2}% per stack)</style> chance for the monster's <style=cIsDamage>elite aspect</style> to drop.", vultureEliteDamage.Value * 100f, vultureHealPercent.Value * 100f, vultureDropChance.Value);
				LanguageAPI.Add("ITEM_HEADHUNTER_DESC", text13);
				string text14 = $"Deal more damage to elites above half health. Chance for elites to drop their powers on death.";
				LanguageAPI.Add("ITEM_HEADHUNTER_PICKUP", text14);
			}
			if (apRoundsEnable.Value)
			{
				string text15 = string.Format("Deal <style=cIsDamage>20%</style> <style=cStack>(+20% per stack)</style> more damage to bosses, and <style=cIsDamage>{0}%</style> <style=cStack>(+{0}% per stack)</style> more damage to elites.", apRoundsEliteDamage.Value * 100f);
				LanguageAPI.Add("ITEM_BOSSDAMAGEBONUS_DESC", text15);
				string text16 = $"Deal extra damage to bosses and elites.";
				LanguageAPI.Add("ITEM_BOSSDAMAGEBONUS_PICKUP", text16);
			}
			if (chronicEnable.Value)
			{
				CharacterBody.AddIncreasedDamageMultiKillTime += new Manipulator(IL_MultikillTimer);
				CharacterBody.RecalculateStats += new Manipulator(IL_MultikillStats);
				string stackDesc5 = GetStackDesc(multikillDamageStack.Value * 100f, "%");
				string text17 = $"Killing an enemy increases your damage by <style=cIsDamage>{multikillDamage.Value * 100f}%</style>{stackDesc5} for <style=cIsUtility>{multikillDuration.Value}s</style>, up to <style=cIsUtility>10</style> <style=cStack>(+5 per stack)</style> times. Dealing damage refreshes the timer.";
				LanguageAPI.Add("ITEM_INCREASEDAMAGEONMULTIKILL_DESC", text17);
			}
			if (meatEnable.Value)
			{
				CharacterBody.UpdateAllTemporaryVisualEffects += new Manipulator(IL_MeatEffect);
				GlobalEventManager.onCharacterDeathGlobal += OnMeatDeath;
				string stackDesc6 = GetStackDesc(meatDurationStack.Value, "s");
				float num = meatRegen.Value * (float)meatMax.Value;
				float num2 = meatRegen.Value * (float)meatMaxStack.Value;
				string stackDesc7 = GetStackDesc(num2, " hp/s");
				string text18 = string.Format("Increases <style=cIsHealing>max health</style> by <style=cIsHealing>{0}</style> <style=cStack>(+{0} per stack)</style>. Increases <style=cIsHealing>health regeneration</style> by <style=cIsHealing>{1} hp/s</style> for <style=cIsUtility>{2}s</style>{3} after killing an enemy, up to a maximum of <style=cIsHealing>{4} hp/s</style>{5}.", meatHealth.Value, meatRegen.Value, meatDuration.Value, stackDesc6, num, stackDesc7);
				LanguageAPI.Add("ITEM_FLATHEALTH_DESC", text18);
				string text19 = $"Gain {meatHealth.Value} max health. Gain health regeneration on kill.";
				LanguageAPI.Add("ITEM_FLATHEALTH_PICKUP", text19);
			}
			if (warpedEchoEnable.Value)
			{
				CharacterBody.UpdateDelayedDamage += new hook_UpdateDelayedDamage(OnUpdateDelayedDamage);
				CharacterBody.SecondHalfOfDelayedDamage += new hook_SecondHalfOfDelayedDamage(OnSecondHalfOfDelayedDamage);
				HealthComponent.TakeDamageProcess += new Manipulator(IL_WarpedEchoProcess);
				float num3 = warpedEchoDurationStack.Value / warpedEchoDuration.Value * 100f;
				string stackDesc8 = GetStackDesc(num3, "%");
				string text20 = string.Format("When hit, <style=cIsHealth>50%</style> of the damage you take is delayed for <style=cIsUtility>{0}s</style>{3}, up to a maximum of <style=cIsHealing>{1}</style> <style=cStack>(+{1} per stack)</style> hit(s) at a time. For each hit being delayed, gain <style=cIsUtility>+{2}%</style> <style=cIsUtility>movement speed</style>, <style=cIsDamage>attack speed</style>, and <style=cIsHealing>cooldown speed</style>.", warpedEchoDuration.Value, warpedEchoCap.Value, warpedEchoStats.Value * 100f, stackDesc8);
				LanguageAPI.Add("ITEM_DELAYEDDAMAGE_DESC", text20);
				string text21 = $"Delay half of incoming damage. While damage is being delayed, increase attack speed, move speed, and cooldown speed.";
				LanguageAPI.Add("ITEM_DELAYEDDAMAGE_PICKUP", text21);
			}
			if (ignitionEnable.Value)
			{
				StrengthenBurnUtils.CheckDotForUpgrade += new Manipulator(IL_StrengthenBurn);
				string stackDesc9 = GetStackDesc(0f - ignitionCooldownStack.Value, "%");
				string text22 = string.Format("Hitting an enemy ignites them for <style=cIsDamage>{0}% TOTAL damage</style>, once every <style=cIsUtility>{1}s</style>{2}. Ignite effects deal <style=cIsDamage>{3}%</style> <style=cStack>(+{3}% per stack)</style> more damage over time.", ignitionBurnDamage.Value * 100f, ignitionCooldownTime.Value, stackDesc9, ignitionBurnBonus.Value * 100);
				LanguageAPI.Add("ITEM_STRENGTHENBURN_DESC", text22);
				string text23 = $"Ignite enemies on hit. Your ignite effects deal {ignitionBurnBonus.Value * 100}% more damage.";
				LanguageAPI.Add("ITEM_STRENGTHENBURN_PICKUP", text23);
			}
			if (scytheEnable.Value)
			{
				GlobalEventManager.OnCrit += new Manipulator(IL_OnCritHeal);
				string text24 = $"Gain <style=cIsDamage>+5% crit chance</style>. <style=cIsDamage>Critical strikes</style> <style=cIsHealing>heal</style> you for <style=cIsHealing>{scytheHeal.Value}</style> <style=cStack>(+{scytheHealStack.Value} per stack)</style> <style=cIsHealing>health</style>, with a <style=cIsUtility>{scytheCooldownTime.Value}s</style> cooldown between uses.";
				LanguageAPI.Add("ITEM_HEALONCRIT_DESC", text24);
			}
			if (infusionEnable.Value)
			{
				string text25 = string.Format("Killing an enemy permanently increases your <style=cIsHealing>health</style> by <style=cIsHealing>1</style> <style=cStack>(+1 per stack)</style> and <style=cIsUtility>movement speed</style> by <style=cIsUtility>{0}%</style> <style=cStack>(+{0}% per stack)</style>, up to a <style=cIsHealing>maximum</style> of <style=cIsHealing>100 <style=cStack>(+100 per stack)</style> health</style> and <style=cIsUtility>{1}% <style=cStack>(+{1}% per stack)</style> movement speed</style>.", infusionSpeed.Value, infusionSpeed.Value * 100f);
				LanguageAPI.Add("ITEM_INFUSION_DESC", text25);
				string text26 = $"Killing an enemy permanently increases your maximum health and movement speed.";
				LanguageAPI.Add("ITEM_INFUSION_PICKUP", text26);
			}
			if (faradayEnable.Value)
			{
				UpdateFaradayStats();
				JumpDamageStrikeBodyBehavior.UpdateCharge += new Manipulator(IL_FaradayCharge);
				JumpDamageStrikeBodyBehavior.DischargeEffects += new Manipulator(IL_FaradayDischarge);
				JumpDamageStrikeBodyBehavior.GetRadius += new hook_GetRadius(OnFaradayGetRadius);
				string stackDesc10 = GetStackDesc(faradayChargeStack.Value * 100f, "%");
				string stackDesc11 = GetStackDesc(faradayDamageStack.Value * 100f, "%");
				string stackDesc12 = GetStackDesc(faradayRadiusStack.Value, "m");
				string text27 = $"For every <style=cIsUtility>{4f / faradayCharge.Value}m</style> traveled, gain <style=cIsUtility>+{faradaySpeedJumpCap.Value}%</style>{stackDesc10} <style=cIsUtility>movement speed</style> and <style=cIsUtility>jump height</style>, up to a maximum of <style=cIsUtility>{faradaySpeedJumpCap.Value * 100f}%</style>. Jumping at <style=cIsUtility>25%</style> charge or higher creates an <style=cIsDamage>explosive discharge</style> for up to <style=cIsDamage>{faradayDamage.Value * 100f}%{stackDesc11} damage</style> in up to a <style=cIsUtility>{faradayRadius.Value}m</style>{stackDesc12} radius, based on the amount of charge consumed.";
				LanguageAPI.Add("ITEM_JUMPDAMAGESTRIKE_DESC", text27);
			}
			if (transmitterEnable.Value)
			{
				CharacterBody.OnInventoryChanged += new hook_OnInventoryChanged(AddNewTransmitterBehaviour);
				TeleportOnLowHealthBehavior.Start += new hook_Start(RemoveOldTransmitterBehaviour1);
				TeleportOnLowHealthBehavior.TryAdd += new hook_TryAdd(RemoveOldTransmitterBehaviour2);
				TeleportOnLowHealthBehavior.Update += new hook_Update(RemoveOldTransmitterBehaviour3);
				TeleportOnLowHealthBehavior.TryProc += new hook_TryProc(RemoveOldTransmitterBehaviour4);
				TeleportOnLowHealthBehavior.OnDisable += new hook_OnDisable(RemoveOldTransmitterBehaviour5);
				HealthComponent.TakeDamageProcess += new Manipulator(IL_TransmitterProcess);
				HealthComponent.DoWarp += new Manipulator(IL_TransmitterWarp);
				string text28 = "";
				if (transmitterPulseBarrier.Value > 0f)
				{
					text28 = $" Gain an additional <style=cIsHealing>{transmitterPulseBarrier.Value * 100f}% barrier</style> for each enemy hit by the pulse.";
				}
				string text29 = $"Upon dropping below <style=cIsHealth>25% health</style>, release a pulse within <style=cIsUtility>{transmitterPulseRadius.Value}m</style> that grants you <style=cIsHealing>{transmitterBarrier.Value * 100f}% barrier</style> and <style=cIsUtility>teleports enemies away</style>.{text28} Can be used <style=cIsUtility>1 <style=cStack>(+1 per stack)</style> times</style> every <style=cIsUtility>{transmitterCooldown.Value}s</style>.";
				LanguageAPI.Add("ITEM_TELEPORTONLOWHEALTH_DESC", text29);
				string text30 = "On low health, release a pulse that teleports enemies and grants you a barrier. ";
				LanguageAPI.Add("ITEM_TELEPORTONLOWHEALTH_PICKUP", text30);
				string text31 = $"After {transmitterCooldown.Value}s, transforms into an Unstable Transmitter.";
				LanguageAPI.Add("ITEM_TELEPORTONLOWHEALTHCONSUMED_PICKUP", text31);
			}
			if (raincoatEnable.Value)
			{
				ImmuneToDebuffBehavior.TryApplyOverride += new hook_TryApplyOverride(OnRaincoatOverride);
				ImmuneToDebuffBehavior.FixedUpdate += new hook_FixedUpdate(OnRaincoatUpdate);
				string text32 = $"After getting inflicted with a <style=cIsDamage>debuff</style>, gain <style=cIsHealing>{raincoatBarrier.Value * 100f}% barrier</style> and <style=cIsUtility>{raincoatDuration.Value}s</style> of <style=cIsUtility>invulnerability</style>. Repeatable once every <style=cIsUtility>{raincoatCooldownTime.Value}s</style> <style=cStack>(-{raincoatCooldownStack.Value * 100f}% per stack)</style>.";
				LanguageAPI.Add("ITEM_IMMUNETODEBUFF_DESC", text32);
				string text33 = "Whenever you get debuffed, gain temporary barrier and invulnerability.";
				LanguageAPI.Add("ITEM_IMMUNETODEBUFF_PICKUP", text33);
				if (!HasBubbetsItems)
				{
					HealthComponent.GetBarrierDecayRate += new hook_GetBarrierDecayRate(OnGetBarrierDecayRate);
				}
			}
			if (warbondsEnable.Value)
			{
				CharacterBody.OnInventoryChanged += new Manipulator(IL_AddNewWarbondBehaviour);
				string stackDesc13 = GetStackDesc(warbondsDamageStack.Value * 100f, "%");
				string text34 = $"For every <style=cIsDamage>{warbondsGoldCost.Value} gold</style> that you spend, load <style=cIsDamage>1 <style=cStack>(+1 per stack)</style> barrage</style>. Whenever an elite or boss monster spawns, one of your <style=cIsDamage>barrages</style> automatically fires at them for <style=cIsDamage>{warbondsDamage.Value * 100f}%{stackDesc13}</style> base damage. <style=cIsUtility>Gold requirement scales over time</style>.";
				LanguageAPI.Add("ITEM_BARRAGEONBOSS_DESC", text34);
				string text35 = "Spending gold loads barrages that launch at powerful targets.";
				LanguageAPI.Add("ITEM_BARRAGEONBOSS_PICKUP", text35);
			}
			if (icbmEnable.Value)
			{
				FireMissileBarrage.FireMissile += new Manipulator(IL_DroneWeaponFireMissile);
				CommandFireMissiles.FireMissile += new Manipulator(IL_DroneCommandFireMissile);
				GlobalEventManager.ProcessHitEnemy += new Manipulator(IL_VoidFireMissile);
				MissileUtils.FireMissile_Vector3_CharacterBody_ProcChainMask_GameObject_float_bool_GameObject_DamageColorIndex_Vector3_float_bool += new Manipulator(IL_FireMissile);
				CharacterBody.OnInventoryChanged += new hook_OnInventoryChanged(AddNewICBMBehaviour);
				MethodInfo methodInfo = AccessTools.Method(typeof(MissileUtils), "GetMoreMissileDamageMultiplier", (Type[])null, (Type[])null);
				missileHook = new Hook((MethodBase)methodInfo, (Delegate)new Func<Func<int, float>, int, float>(OnMissileDamage));
				string stackDesc14 = GetStackDesc(icbmCooldownStack.Value * -100f, "%");
				string stackDesc15 = GetStackDesc(icbmDamageStack.Value * 100f, "%");
				string text36 = $"Any <style=cIsDamage>missiles</style> that you fire are <style=cIsDamage>doubled</style>. Every <style=cIsUtility>{icbmCooldown.Value}s{stackDesc14}</style> while in combat, automatically fire a <style=cIsDamage>seeking missile</style> that deals <style=cIsDamage>{icbmDamage.Value * 100f}%{stackDesc15}</style> base damage.";
				LanguageAPI.Add("ITEM_MOREMISSILE_DESC", text36);
				string text37 = "Missiles are doubled. Automatically fire missiles while in combat.";
				LanguageAPI.Add("ITEM_MOREMISSILE_PICKUP", text37);
			}
			if (knurlEnable.Value)
			{
				CharacterBody.RecalculateStats += new Manipulator(IL_RemoveKnurlStats);
				string text38 = string.Format("Gain <style=cIsHealing>{0} <style=cStack>(+{0} per stack)</style> maximum health</style> and <style=cIsHealing>{1} hp/s <style=cStack>(+{1} hp/s per stack)</sty