using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using EntityStates;
using HG;
using IL.RoR2;
using IL.RoR2.Items;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using On.RoR2;
using R2API;
using RoR2;
using RoR2.Items;
using SeekerItems;
using SeekingItemReworks;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Networking;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("SeekingItemReworks")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+9ad22ad452b378e0bb596307aa7fff158211ddfd")]
[assembly: AssemblyProduct("SeekingItemReworks")]
[assembly: AssemblyTitle("SeekingItemReworks")]
[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 SeekingItemReworks
{
	public static class ColorCode
	{
		public enum Color
		{
			cStack,
			cIsDamage,
			cIsHealth,
			cIsUtility,
			cIsHealing
		}

		public static string Style(this string self, Color style)
		{
			return "<style=" + style.ToString() + ">" + self + "</style>";
		}
	}
}
namespace SeekerItems
{
	public class LanternCountBuff
	{
		public static BuffDef LanternCounter;

		private static readonly Sprite spriteIcon = Addressables.LoadAssetAsync<Sprite>((object)"RoR2/DLC2/Items/LowerHealthHigherDamage/texBuffLowerHealthHigherDamageIcon.png").WaitForCompletion();

		public LanternCountBuff()
		{
			LanternCounter = ScriptableObject.CreateInstance<BuffDef>();
			((Object)LanternCounter).name = "AllyLanternCount";
			LanternCounter.canStack = true;
			LanternCounter.isCooldown = false;
			LanternCounter.isDebuff = false;
			LanternCounter.ignoreGrowthNectar = false;
			LanternCounter.iconSprite = spriteIcon;
			((Object)LanternCounter).name = ((Object)LanternCounter).name;
			ContentAddition.AddBuffDef(LanternCounter);
		}
	}
	internal class AntlerShield : ItemTemplate
	{
		public static string StaticName = "Antler Shield";

		public static ConfigEntry<int> Rework;

		public static ConfigEntry<float> Armor_Percent_Base;

		public static ConfigEntry<float> Armor_Percent_Stack;

		public static ConfigEntry<float> Movement_Base;

		public static ConfigEntry<float> Movement_Stack;

		public AntlerShield(int descType)
		{
			ItemInternal = "NEGATEATTACK";
			if (descType == 1)
			{
				ItemInfo = "Gain armor from movement speed, and increase movement speed.";
				ItemDesc = string.Format("Increase " + "armor ".Style(ColorCode.Color.cIsHealing) + "by " + "{0}% ".Style(ColorCode.Color.cIsHealing) + "(+{1}% per stack) ".Style(ColorCode.Color.cStack) + "of " + "current movement speed".Style(ColorCode.Color.cIsUtility) + ". Increase " + "movement speed ".Style(ColorCode.Color.cIsUtility) + "by " + "{2}% ".Style(ColorCode.Color.cIsUtility) + "(+{3}% per stack)".Style(ColorCode.Color.cStack) + ".", Math.Round(Armor_Percent_Base.Value, ItemTemplate.roundVal), Math.Round(Armor_Percent_Stack.Value, ItemTemplate.roundVal), Math.Round(Movement_Base.Value, ItemTemplate.roundVal), Math.Round(Movement_Stack.Value, ItemTemplate.roundVal));
			}
		}
	}
	internal class BolsteringLantern : ItemTemplate
	{
		public static string StaticName = "Bolstering Lantern";

		public static ConfigEntry<int> Rework;

		public static ConfigEntry<int> LowHealth;

		public static ConfigEntry<int> HighHealth;

		public static ConfigEntry<float> Damage_Base;

		public static ConfigEntry<float> Damage_Stack;

		public static ConfigEntry<float> Chance_Base;

		public static ConfigEntry<float> Chance_Stack;

		public BolsteringLantern(int descType)
		{
			ItemInternal = "LOWERHEALTHHIGHERDAMAGE";
			switch (descType)
			{
			case 1:
				ItemInfo = $"Ignite enemies at low health until health is restored {HighHealth.Value}%.";
				ItemDesc = string.Format("Falling below " + "{0}% health".Style(ColorCode.Color.cIsHealth) + " grants a buff that " + "ignites ".Style(ColorCode.Color.cIsDamage) + "enemies for " + "{1}% ".Style(ColorCode.Color.cIsDamage) + "(+{2}% per stack) ".Style(ColorCode.Color.cStack) + "base damage on hit, until " + "health ".Style(ColorCode.Color.cIsHealing) + "is restored to " + "{3}%".Style(ColorCode.Color.cIsHealing) + ".", LowHealth.Value, Math.Round(Damage_Base.Value, ItemTemplate.roundVal), Math.Round(Damage_Stack.Value, ItemTemplate.roundVal), HighHealth.Value);
				break;
			case 2:
				ItemInfo = "Chance on hit to ignite. Inherited by allies.";
				ItemDesc = string.Format("{0}% ".Style(ColorCode.Color.cIsDamage) + "(+{1}% per stack) ".Style(ColorCode.Color.cStack) + "chance on hit to " + "ignite ".Style(ColorCode.Color.cIsDamage) + "enemies for " + "{2}% ".Style(ColorCode.Color.cIsDamage) + "(+{3}% per stack) ".Style(ColorCode.Color.cStack) + "base damage. This item is " + "inherited by allies ".Style(ColorCode.Color.cIsUtility) + "and is boosted with " + "Ignition Tank".Style(ColorCode.Color.cIsUtility) + ".", Math.Round(Chance_Base.Value, ItemTemplate.roundVal), Math.Round(Chance_Stack.Value, ItemTemplate.roundVal), Math.Round(Damage_Base.Value, ItemTemplate.roundVal), Math.Round(Damage_Stack.Value, ItemTemplate.roundVal));
				break;
			}
		}
	}
	internal class ChronicExpansion : ItemTemplate
	{
		public static string StaticName = "Chronic Expansion";

		public static ConfigEntry<int> Rework;

		public static ConfigEntry<float> Damage_Base;

		public static ConfigEntry<float> Damage_Stack;

		public ChronicExpansion(int descType)
		{
			ItemInternal = "INCREASEDAMAGEONMULTIKILL";
			if (descType == 1)
			{
				ItemInfo = "Gain stacking damage after killing 5 enemies while in combat.";
				ItemDesc = string.Format("Killing 5 enemies ".Style(ColorCode.Color.cIsDamage) + "in combat buffs damage by " + "{0}% ".Style(ColorCode.Color.cIsDamage) + "(+{1}% per stack) ".Style(ColorCode.Color.cStack) + "temporarily each time, until leaving combat.", Math.Round(Damage_Base.Value, ItemTemplate.roundVal), Math.Round(Damage_Stack.Value, ItemTemplate.roundVal));
			}
		}
	}
	internal class KnockbackFin : ItemTemplate
	{
		public static string StaticName = "Knockback Fin";

		public static ConfigEntry<int> Rework;

		public static ConfigEntry<bool> IsHyperbolic;

		public static ConfigEntry<float> Chance_Base;

		public static ConfigEntry<float> Chance_Stack;

		public static ConfigEntry<float> Damage_Base;

		public static ConfigEntry<float> Damage_Stack;

		public KnockbackFin(int descType)
		{
			ItemInternal = "KNOCKBACKHITENEMIES";
			switch (descType)
			{
			case 1:
				ItemInfo = "Chance on hit to knock enemies into the air.\nDeal bonus damage to airborne enemies.";
				ItemDesc = string.Format("{0}% ".Style(ColorCode.Color.cIsUtility) + "(+{1}% per stack) ".Style(ColorCode.Color.cStack) + "chance on hit to " + "knock up enemies".Style(ColorCode.Color.cIsUtility) + ". Deal " + "+{2}% ".Style(ColorCode.Color.cIsDamage) + "(+{3}% per stack) ".Style(ColorCode.Color.cStack) + "damage to " + "airborne ".Style(ColorCode.Color.cIsUtility) + "enemies.", Math.Round(Chance_Base.Value, ItemTemplate.roundVal), Math.Round(Chance_Stack.Value, ItemTemplate.roundVal), Math.Round(Damage_Base.Value, ItemTemplate.roundVal), Math.Round(Damage_Stack.Value, ItemTemplate.roundVal));
				break;
			case -1:
				ItemInfo = "Chance on hit to knock up enemies.\nDeal bonus damage to airborne enemies.";
				ItemDesc = string.Format("{0}% ".Style(ColorCode.Color.cIsUtility) + "(+{1}% per stack) ".Style(ColorCode.Color.cStack) + "chance on hit to " + "knock up enemies".Style(ColorCode.Color.cIsUtility) + ". Deal " + "+{2}% ".Style(ColorCode.Color.cIsDamage) + "(+{3}% per stack) ".Style(ColorCode.Color.cStack) + "damage to " + "airborne ".Style(ColorCode.Color.cIsUtility) + "enemies.", Math.Round(Chance_Base.Value, ItemTemplate.roundVal), Math.Round(Chance_Stack.Value, ItemTemplate.roundVal), Math.Round(Damage_Base.Value, ItemTemplate.roundVal), Math.Round(Damage_Stack.Value, ItemTemplate.roundVal));
				break;
			}
		}
	}
	internal class WarpedEcho : ItemTemplate
	{
		public static string StaticName = "Warped Echo";

		public static ConfigEntry<int> Rework;

		public static ConfigEntry<float> Delay_Base;

		public static ConfigEntry<int> Instance_Stack;

		public WarpedEcho(int descType)
		{
			ItemInternal = "DELAYEDDAMAGE";
			if (descType == 1)
			{
				ItemInfo = "Half of incoming damage is delayed.";
				ItemDesc = string.Format("Incoming damage ".Style(ColorCode.Color.cIsDamage) + "is split " + "50%".Style(ColorCode.Color.cIsDamage) + ", with the other " + "50% ".Style(ColorCode.Color.cIsDamage) + "delayed for " + "{0}s ".Style(ColorCode.Color.cIsDamage) + "(+{1} instances per stack)".Style(ColorCode.Color.cStack) + ". Recharges one instance after delayed damage.", Math.Round(Delay_Base.Value, ItemTemplate.roundVal), Instance_Stack.Value);
			}
		}
	}
	internal class SeedOfLife : ItemTemplate
	{
		public static string StaticName = "Seed of Life";

		public static ConfigEntry<int> Rework;

		public SeedOfLife(int descType)
		{
			ItemInternal = "HEALANDREVIVE";
			if (descType == 1)
			{
				ItemInfo = "Revives user or allies. Consume on use.";
				ItemDesc = "Returns ".Style(ColorCode.Color.cIsHealing) + "the user " + "to life ".Style(ColorCode.Color.cIsHealing) + "upon death ".Style(ColorCode.Color.cIsUtility) + "or dead allies on use. Equipment is " + "consumed ".Style(ColorCode.Color.cIsUtility) + "on use.";
			}
		}
	}
	internal class BensRaincoat : ItemTemplate
	{
		public static string StaticName = "Bens Raincoat";

		public static ConfigEntry<int> Rework;
	}
	internal class GrowthNectar : ItemTemplate
	{
		public static string StaticName = "Growth Nectar";

		public static ConfigEntry<int> Rework;

		public static ConfigEntry<float> Stat_Base;

		public static ConfigEntry<float> Stat_Stack;

		public static ConfigEntry<float> Charge_Stat_Increase;

		public static ConfigEntry<float> Charge_Cap_Base;

		public static ConfigEntry<float> Charge_Cap_Stack;

		public GrowthNectar(int descType)
		{
			ItemInternal = "BOOSTALLSTATS";
			if (descType == 1)
			{
				ItemInfo = "Not using an equipment increases ALL of your stats. Scales with equipment charges.";
				ItemDesc = string.Format("When your Equipment is off " + "cooldown".Style(ColorCode.Color.cIsUtility) + ", increase " + "ALL stats ".Style(ColorCode.Color.cIsUtility) + "by " + "{0}% ".Style(ColorCode.Color.cIsUtility) + "(+{1}% per stack)".Style(ColorCode.Color.cStack) + ", and by " + "{2}% ".Style(ColorCode.Color.cIsUtility) + "per " + "Equipment charge".Style(ColorCode.Color.cIsUtility) + ", up to a maximum of " + "{3}% ".Style(ColorCode.Color.cIsUtility) + "(+{4}% per stack)".Style(ColorCode.Color.cStack) + ".", Math.Round(Stat_Base.Value, ItemTemplate.roundVal), Math.Round(Stat_Stack.Value, ItemTemplate.roundVal), Math.Round(Charge_Stat_Increase.Value, ItemTemplate.roundVal), Math.Round(Charge_Cap_Base.Value, ItemTemplate.roundVal), Math.Round(Charge_Cap_Stack.Value, ItemTemplate.roundVal));
			}
		}
	}
	internal class WarBonds : ItemTemplate
	{
		public static string StaticName = "War Bonds";

		public static ConfigEntry<int> Rework;

		public static ConfigEntry<int> Purchase_Base;

		public static ConfigEntry<int> Purchase_Stack;

		public static ConfigEntry<float> Experience_Percent_Base;

		public static ConfigEntry<float> Experience_Percent_Stack;

		public WarBonds(int descType)
		{
			ItemInternal = "GOLDONSTAGESTART";
			if (descType == 1)
			{
				ItemInfo = $"Gain free purchases at the start of each stage.\nGain {Math.Round(Experience_Percent_Base.Value, ItemTemplate.roundVal)}% experience on cash spent on all purchases.";
				ItemDesc = string.Format("Gain " + "{0} ".Style(ColorCode.Color.cIsUtility) + "(+{1} per stack) ".Style(ColorCode.Color.cStack) + "free purchases ".Style(ColorCode.Color.cIsUtility) + "at the " + "start of each stage".Style(ColorCode.Color.cIsUtility) + ". When making a gold purchase, get " + "{2}% ".Style(ColorCode.Color.cIsUtility) + "(+{3}% per stack) ".Style(ColorCode.Color.cStack) + "of spent gold as " + "experience".Style(ColorCode.Color.cIsUtility) + ".", Purchase_Base.Value, Purchase_Stack.Value, Math.Round(Experience_Percent_Base.Value, ItemTemplate.roundVal), Math.Round(Experience_Percent_Stack.Value, ItemTemplate.roundVal));
			}
		}
	}
	internal class OldWarStealthKit : ItemTemplate
	{
		public static string StaticName = "Old War Stealthkit";

		public static ConfigEntry<int> Rework;

		public OldWarStealthKit(int descType)
		{
			ItemInternal = "PHASING";
			if (descType == 1)
			{
				ItemInfo = "Turn invisible and cleanse debuffs at low health.";
				ItemDesc = "Falling below " + "25% health ".Style(ColorCode.Color.cIsHealth) + "causes you to become " + "invisible ".Style(ColorCode.Color.cIsUtility) + "for " + "5s".Style(ColorCode.Color.cIsUtility) + ", boost " + "movement speed ".Style(ColorCode.Color.cIsUtility) + "by " + "40% ".Style(ColorCode.Color.cIsUtility) + "and " + "cleanse 2 ".Style(ColorCode.Color.cIsUtility) + "debuffs ".Style(ColorCode.Color.cIsDamage) + "(+1 per stack)".Style(ColorCode.Color.cStack) + ". Recharges every " + "30 ".Style(ColorCode.Color.cIsUtility) + "(-50% per stack) ".Style(ColorCode.Color.cStack) + "seconds.";
			}
		}
	}
	internal class SaleStar : ItemTemplate
	{
		public static string StaticName = "Sale Star";

		public static ConfigEntry<int> Rework;

		public static ConfigEntry<bool> IsHyperbolic;

		public static ConfigEntry<float> Consume_Base;

		public static ConfigEntry<float> Consume_Stack;

		public SaleStar(int descType)
		{
			ItemInternal = "LOWERPRICEDCHESTS";
			Consume_Base.Value = Math.Max(Math.Min(Consume_Base.Value, 100f), 0f);
			Consume_Stack.Value = Math.Max(Math.Min(Consume_Stack.Value, Consume_Base.Value), 0f);
			if (descType == 1)
			{
				ItemInfo = "Gain an extra item from chests. Chance to be consumed on use once per stage.";
				ItemDesc = string.Format("Gain an " + "extra item ".Style(ColorCode.Color.cIsUtility) + "when purchasing a " + "chest ".Style(ColorCode.Color.cIsUtility) + "with a " + "{0}% ".Style(ColorCode.Color.cIsUtility) + "(-{1}% per stack) ".Style(ColorCode.Color.cStack) + "chance to be " + "consumed ".Style(ColorCode.Color.cIsUtility) + "on use. At the start of each stage, it regenerates.", Math.Round(Consume_Base.Value, ItemTemplate.roundVal), Math.Round(Consume_Stack.Value, ItemTemplate.roundVal));
			}
		}
	}
	internal class UnstableTransmitter : ItemTemplate
	{
		public static string StaticName = "Unstable Transmitter";

		public static ConfigEntry<int> Rework;

		public static ConfigEntry<bool> IsFloat;

		public static ConfigEntry<int> LowHealth;

		public static ConfigEntry<float> Refresh;

		public static ConfigEntry<float> Range;

		public static ConfigEntry<float> Damage_Base;

		public static ConfigEntry<float> Damage_Stack;

		public static ConfigEntry<float> Duration_Base;

		public static ConfigEntry<float> Duration_Stack;

		public UnstableTransmitter(int descType)
		{
			ItemInternal = "TELEPORTONLOWHEALTH";
			if (descType == 1)
			{
				ItemInfo = "Become intangible and explode, bleeding nearby enemies at low health.";
				ItemDesc = string.Format("Falling below " + "{0}% health ".Style(ColorCode.Color.cIsHealth) + "causes you to fade away, becoming " + "intangible ".Style(ColorCode.Color.cIsUtility) + "and exploding, inflicting " + "bleed ".Style(ColorCode.Color.cIsDamage) + "to enemies within " + "{1}m ".Style(ColorCode.Color.cIsDamage) + "for " + "{2}% ".Style(ColorCode.Color.cIsDamage) + "(+{3}% per stack) ".Style(ColorCode.Color.cStack) + "base damage. Lasts " + "{4}s ".Style(ColorCode.Color.cIsUtility) + "(+{5}s per stack)".Style(ColorCode.Color.cStack) + ". Recharges every " + "{6} ".Style(ColorCode.Color.cIsUtility) + "seconds.", LowHealth.Value, Math.Round(Range.Value, ItemTemplate.roundVal), Math.Round(Damage_Base.Value, ItemTemplate.roundVal), Math.Round(Damage_Stack.Value, ItemTemplate.roundVal), Math.Round(Duration_Base.Value, ItemTemplate.roundVal), Math.Round(Duration_Stack.Value, ItemTemplate.roundVal), Math.Round(Refresh.Value));
			}
		}
	}
	public class ItemInfo
	{
		public ItemInfo()
		{
			if (WarpedEcho.Rework.Value == 1)
			{
				SetDesc(new WarpedEcho(WarpedEcho.Rework.Value));
			}
			if (ChronicExpansion.Rework.Value == 1)
			{
				SetDesc(new ChronicExpansion(ChronicExpansion.Rework.Value));
			}
			if (KnockbackFin.Rework.Value == 1 && !MainConfig.CursedRewrite.Value)
			{
				SetDesc(new KnockbackFin(KnockbackFin.Rework.Value));
				SetName(new KnockbackFin(KnockbackFin.Rework.Value), "Flying Fin");
			}
			if (KnockbackFin.Rework.Value == 1 && MainConfig.CursedRewrite.Value)
			{
				SetDesc(new KnockbackFin(KnockbackFin.Rework.Value * -1));
				SetName(new KnockbackFin(KnockbackFin.Rework.Value * -1), "Knockup Fin");
			}
			if (BolsteringLantern.Rework.Value == 1)
			{
				SetDesc(new BolsteringLantern(BolsteringLantern.Rework.Value));
			}
			if (BolsteringLantern.Rework.Value == 2)
			{
				SetDesc(new BolsteringLantern(BolsteringLantern.Rework.Value));
			}
			if (AntlerShield.Rework.Value == 1)
			{
				SetDesc(new AntlerShield(AntlerShield.Rework.Value));
			}
			if (SaleStar.Rework.Value == 1)
			{
				SetDesc(new SaleStar(SaleStar.Rework.Value));
			}
			if (UnstableTransmitter.Rework.Value == 1)
			{
				SetDesc(new UnstableTransmitter(UnstableTransmitter.Rework.Value));
			}
			if (WarBonds.Rework.Value == 1)
			{
				SetDesc(new WarBonds(WarBonds.Rework.Value));
			}
			if (GrowthNectar.Rework.Value == 1)
			{
				SetDesc(new GrowthNectar(GrowthNectar.Rework.Value));
			}
			if (SeedOfLife.Rework.Value == 1)
			{
				SetDesc(new SeedOfLife(SeedOfLife.Rework.Value), "EQUIPMENT_");
			}
			if (OldWarStealthKit.Rework.Value == 1)
			{
				SetDesc(new OldWarStealthKit(OldWarStealthKit.Rework.Value));
			}
		}

		private static void SetDesc(ItemTemplate ItemInfo, string forcedPrefix = "ITEM_")
		{
			LanguageAPI.Add(forcedPrefix + ItemInfo.ItemInternal + "_PICKUP", ItemInfo.ItemInfo);
			LanguageAPI.Add(forcedPrefix + ItemInfo.ItemInternal + "_DESC", ItemInfo.ItemDesc);
		}

		private static void SetName(ItemTemplate ItemInfo, string name, string forcedPrefix = "ITEM_")
		{
			LanguageAPI.Add(forcedPrefix + ItemInfo.ItemInternal + "_NAME", name);
		}
	}
	internal class ItemTemplate
	{
		public static int roundVal = MainConfig.RoundNumber.Value;

		public string ItemInternal;

		public string ItemInfo;

		public string ItemDesc;
	}
	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);
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("noodlegemo.SeekingItemReworks", "SeekingItemReworks", "1.3.1")]
	public class Main : BaseUnityPlugin
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

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

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

			public static Action<CharacterBody, DelayedDamageInfo> <>9__5_15;

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

			public static Action<CharacterBody> <>9__5_19;

			public static hook_UpdateDelayedDamage <>9__5_2;

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

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

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

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

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

			public static Action<CharacterBody, int> <>9__5_27;

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

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

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

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

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

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

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

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

			public static hook_ProcessHitEnemy <>9__5_5;

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

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

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

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

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

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

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

			public static Func<HealthComponent, DamageInfo, float, float> <>9__5_37;

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

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

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

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

			public static hook_UpdateLowerHealthHigherDamage <>9__5_8;

			public static hook_UpdateLowerHealthHigherDamage <>9__5_10;

			public static hook_FixedUpdate <>9__5_11;

			public static hook_ProcessHitEnemy <>9__5_12;

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

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

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

			public static Action<CharacterBody> <>9__5_50;

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

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

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

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

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

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

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

			public static hook_OnInteractionBegin <>9__6_1;

			public static hook_RpcTeleportCharacterToSafety <>9__6_2;

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

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

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

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

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

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

			public static hook_UpdateLastHitTime <>9__6_4;

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

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

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

			public static Action<PhasingBodyBehavior> <>9__6_16;

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

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

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

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

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

			public static hook_Start <>9__7_1;

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

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

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

			public static Action<PurchaseInteraction, Interactor> <>9__7_13;

			public static Manipulator <>9__7_2;

			public static hook_MyFixedUpdate <>9__7_3;

			public static hook_UpdateBoostAllStatsTimer <>9__7_4;

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

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

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

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

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

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

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

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

			public static Action<CharacterBody, int> <>9__7_23;

			internal bool <SetUpCommonItems>b__5_17(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdarg(x, 1);
			}

			internal bool <SetUpCommonItems>b__5_18(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld(x, typeof(DelayedDamageInfo), "halfDamage");
			}

			internal void <SetUpCommonItems>b__5_15(CharacterBody body, DelayedDamageInfo damageInfo)
			{
				damageInfo.timeUntilDamage = WarpedEcho.Delay_Base.Value;
			}

			internal bool <SetUpCommonItems>b__5_20(Instruction x)
			{
				return ILPatternMatchingExt.MatchCall<CharacterBody>(x, "RemoveBuff");
			}

			internal void <SetUpCommonItems>b__5_19(CharacterBody body)
			{
				body.AddBuff(Buffs.DelayedDamageBuff);
			}

			internal void <SetUpCommonItems>b__5_2(orig_UpdateDelayedDamage orig, CharacterBody self, float deltaTime)
			{
				if (!NetworkServer.active)
				{
					return;
				}
				int num = (Object.op_Implicit((Object)(object)self.inventory) ? self.inventory.GetItemCount(Items.DelayedDamage) : 0);
				if (num > 0)
				{
					num = 1 + WarpedEcho.Instance_Stack.Value * (num - 1);
					int buffCount = self.GetBuffCount(Buffs.DelayedDamageBuff);
					if (self.oldDelayedDamageCount != num)
					{
						int num2 = num - self.oldDelayedDamageCount;
						if (num2 > 0)
						{
							for (int i = 0; i < Math.Abs(num2); i++)
							{
								self.AddBuff(Buffs.DelayedDamageBuff);
							}
						}
						else
						{
							for (int j = 0; j < Math.Abs(num2); j++)
							{
								self.RemoveBuff(Buffs.DelayedDamageBuff);
							}
						}
					}
					self.oldDelayedDamageCount = num;
				}
				else
				{
					self.oldDelayedDamageCount = 0;
					self.RemoveBuff(Buffs.DelayedDamageBuff);
					self.RemoveBuff(Buffs.DelayedDamageDebuff);
					self.RemoveOldestTimedBuff(Buffs.DelayedDamageDebuff);
				}
			}

			internal bool <SetUpCommonItems>b__5_21(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, typeof(Items), "IncreaseDamageOnMultiKill");
			}

			internal bool <SetUpCommonItems>b__5_22(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallvirt<Inventory>(x, "GetItemCount");
			}

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

			internal bool <SetUpCommonItems>b__5_25(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, typeof(Buffs), "IncreaseDamageBuff");
			}

			internal bool <SetUpCommonItems>b__5_26(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<CharacterBody>(x, "GetBuffCount");
			}

			internal void <SetUpCommonItems>b__5_27(CharacterBody body, int itemCount)
			{
				int buffCount = body.GetBuffCount(Buffs.IncreaseDamageBuff);
				float num = (float)buffCount * (ChronicExpansion.Damage_Base.Value + ChronicExpansion.Damage_Stack.Value * (float)(itemCount - 1)) / 100f;
				body.damage *= 1f + num;
				if (body.oldComboMeter < buffCount)
				{
					body.oldComboMeter = buffCount;
				}
			}

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

			internal bool <SetUpCommonItems>b__5_29(Instruction x)
			{
				int num = default(int);
				return ILPatternMatchingExt.MatchLdloc(x, ref num);
			}

			internal bool <SetUpCommonItems>b__5_30(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<CharacterBody>(x, "oldComboMeter");
			}

			internal bool <SetUpCommonItems>b__5_33(Instruction x)
			{
				int num = default(int);
				return ILPatternMatchingExt.MatchLdcI4(x, ref num);
			}

			internal bool <SetUpCommonItems>b__5_34(Instruction x)
			{
				ILLabel val = default(ILLabel);
				return ILPatternMatchingExt.MatchBle(x, ref val);
			}

			internal bool <SetUpCommonItems>b__5_35(Instruction x)
			{
				int num = default(int);
				return ILPatternMatchingExt.MatchLdloc(x, ref num);
			}

			internal bool <SetUpCommonItems>b__5_36(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<CharacterBody>(x, "get_isBoss");
			}

			internal int <SetUpCommonItems>b__5_31(int itemCount)
			{
				return -1;
			}

			internal void <SetUpCommonItems>b__5_5(orig_ProcessHitEnemy orig, GlobalEventManager self, DamageInfo damageInfo, GameObject victim)
			{
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: Unknown result type (might be due to invalid IL or missing references)
				//IL_0138: Unknown result type (might be due to invalid IL or missing references)
				//IL_013a: Unknown result type (might be due to invalid IL or missing references)
				//IL_013c: Unknown result type (might be due to invalid IL or missing references)
				//IL_014f: Expected I4, but got Unknown
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_0182: Unknown result type (might be due to invalid IL or missing references)
				//IL_0187: Unknown result type (might be due to invalid IL or missing references)
				//IL_0193: Unknown result type (might be due to invalid IL or missing references)
				//IL_019e: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ac: Expected O, but got Unknown
				//IL_01d6: 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)
				orig.Invoke(self, damageInfo, victim);
				if (!Object.op_Implicit((Object)(object)damageInfo.attacker) || !(damageInfo.procCoefficient > 0f))
				{
					return;
				}
				CharacterBody component = damageInfo.attacker.GetComponent<CharacterBody>();
				CharacterBody component2 = victim.GetComponent<CharacterBody>();
				int num = (Object.op_Implicit((Object)(object)component.inventory) ? component.inventory.GetItemCount(Items.KnockBackHitEnemies) : 0);
				if (!Object.op_Implicit((Object)(object)component2) || num <= 0)
				{
					return;
				}
				CharacterMotor component3 = victim.GetComponent<CharacterMotor>();
				victim.GetComponent<RigidbodyMotor>();
				float num2 = (KnockbackFin.Chance_Base.Value + KnockbackFin.Chance_Stack.Value * (float)(num - 1)) * damageInfo.procCoefficient;
				if (KnockbackFin.IsHyperbolic.Value)
				{
					num2 = Util.ConvertAmplificationPercentageIntoReductionPercentage(num2);
				}
				if (Object.op_Implicit((Object)(object)component3) && component3.isGrounded && !component2.isChampion && (component2.bodyFlags & 1) == 0 && !component2.HasBuff(Buffs.KnockUpHitEnemies) && Util.CheckRoll(num2, 0f, (CharacterMaster)null))
				{
					component2.AddTimedBuff(Buffs.KnockUpHitEnemies, 5f);
					float scale = 1f;
					HullClassification hullClassification = component2.hullClassification;
					HullClassification val = hullClassification;
					switch ((int)val)
					{
					case 0:
						scale = 1f;
						break;
					case 1:
						scale = 5f;
						break;
					case 2:
						scale = 10f;
						break;
					}
					Util.PlaySound("Play_item_proc_knockBackHitEnemies", ((Component)component).gameObject);
					EffectManager.SpawnEffect(CommonAssets.knockbackFinEffect, new EffectData
					{
						origin = ((Component)component2).gameObject.transform.position,
						scale = scale
					}, true);
					Vector3 val2 = default(Vector3);
					((Vector3)(ref val2))..ctor(0f, 1f, 0f);
					float num3 = component3.mass * 25f;
					component3.ApplyForce(num3 * val2, false, false);
				}
			}

			internal bool <SetUpCommonItems>b__5_39(Instruction x)
			{
				int num = default(int);
				return ILPatternMatchingExt.MatchLdloc(x, ref num);
			}

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

			internal bool <SetUpCommonItems>b__5_41(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<HealthComponent>(x, "body");
			}

			internal bool <SetUpCommonItems>b__5_42(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<CharacterBody>(x, "get_teamComponent");
			}

			internal bool <SetUpCommonItems>b__5_43(Instruction x)
			{
				int num = default(int);
				return ILPatternMatchingExt.MatchLdloc(x, ref num);
			}

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

			internal bool <SetUpCommonItems>b__5_45(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<HealthComponent>(x, "get_fullCombinedHealth");
			}

			internal float <SetUpCommonItems>b__5_37(HealthComponent healthComponent, DamageInfo damageInfo, float damage)
			{
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				float num = damage;
				CharacterBody val = (Object.op_Implicit((Object)(object)damageInfo.attacker) ? damageInfo.attacker.GetComponent<CharacterBody>() : null);
				int num2 = ((Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)val.inventory)) ? val.inventory.GetItemCount(Items.KnockBackHitEnemies) : 0);
				if (num2 > 0 && (healthComponent.body.isFlying || ((Object)(object)healthComponent.body.characterMotor != (Object)null && !healthComponent.body.characterMotor.isGrounded)))
				{
					num *= 1f + (KnockbackFin.Damage_Base.Value + KnockbackFin.Damage_Stack.Value * (float)(num2 - 1)) / 100f;
					EffectManager.SimpleImpactEffect(AssetReferences.mercExposeConsumeEffectPrefab, damageInfo.position, Vector3.up, true);
				}
				return num;
			}

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

			internal bool <SetUpCommonItems>b__5_48(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, typeof(Buffs), "LowerHealthHigherDamageBuff");
			}

			internal bool <SetUpCommonItems>b__5_49(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<CharacterBody>(x, "HasBuff");
			}

			internal bool <SetUpCommonItems>b__5_46(Instruction x)
			{
				ILLabel val = default(ILLabel);
				return ILPatternMatchingExt.MatchBrfalse(x, ref val);
			}

			internal void <SetUpCommonItems>b__5_8(orig_UpdateLowerHealthHigherDamage orig, CharacterBody body)
			{
				if (!NetworkServer.active)
				{
					return;
				}
				int num = (Object.op_Implicit((Object)(object)body.inventory) ? body.inventory.GetItemCount(Items.LowerHealthHigherDamage) : 0);
				if (num > 0)
				{
					float normalizedHealth = body.healthComponent.GetNormalizedHealth();
					if (normalizedHealth <= (float)BolsteringLantern.LowHealth.Value / 100f && !body.HasBuff(Buffs.LowerHealthHigherDamageBuff))
					{
						body.AddBuff(Buffs.LowerHealthHigherDamageBuff);
						Util.PlaySound("Play_item_proc_lowerHealthHigherDamage_proc", ((Component)body).gameObject);
					}
					else if (normalizedHealth >= (float)BolsteringLantern.HighHealth.Value / 100f && body.HasBuff(Buffs.LowerHealthHigherDamageBuff))
					{
						body.RemoveBuff(Buffs.LowerHealthHigherDamageBuff);
					}
				}
				else if (num <= 0 && body.HasBuff(Buffs.LowerHealthHigherDamageBuff))
				{
					body.RemoveBuff(Buffs.LowerHealthHigherDamageBuff);
				}
			}

			internal void <SetUpCommonItems>b__5_10(orig_UpdateLowerHealthHigherDamage orig, CharacterBody body)
			{
			}

			internal void <SetUpCommonItems>b__5_11(orig_FixedUpdate orig, CharacterBody body)
			{
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(body);
				int num = ((Object.op_Implicit((Object)(object)body) && Object.op_Implicit((Object)(object)body.inventory)) ? body.inventory.GetItemCount(Items.LowerHealthHigherDamage) : 0);
				if (num <= 0)
				{
					return;
				}
				MinionGroup val = MinionGroup.FindGroup(body.masterObjectId);
				body.SetBuffCount(LanternCountBuff.LanternCounter.buffIndex, num);
				if (val == null)
				{
					return;
				}
				MinionOwnership[] members = val.members;
				foreach (MinionOwnership val2 in members)
				{
					if (!((Object)(object)val2 == (Object)null))
					{
						CharacterMaster component = ((Component)val2).GetComponent<CharacterMaster>();
						if (Object.op_Implicit((Object)(object)component) && Object.op_Implicit((Object)(object)component.inventory) && Object.op_Implicit((Object)(object)component.GetBody()))
						{
							component.GetBody().SetBuffCount(LanternCountBuff.LanternCounter.buffIndex, num);
						}
					}
				}
			}

			internal void <SetUpCommonItems>b__5_12(orig_ProcessHitEnemy orig, GlobalEventManager self, DamageInfo damageInfo, GameObject victim)
			{
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0143: Unknown result type (might be due to invalid IL or missing references)
				//IL_0148: Unknown result type (might be due to invalid IL or missing references)
				//IL_014a: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self, damageInfo, victim);
				if (Object.op_Implicit((Object)(object)damageInfo.attacker) && damageInfo.procCoefficient > 0f)
				{
					CharacterBody component = damageInfo.attacker.GetComponent<CharacterBody>();
					int buffCount = component.GetBuffCount(LanternCountBuff.LanternCounter);
					if (Object.op_Implicit((Object)(object)component) && buffCount > 0 && Util.CheckRoll(BolsteringLantern.Chance_Base.Value + BolsteringLantern.Chance_Stack.Value * (float)(buffCount - 1), 0f, (CharacterMaster)null))
					{
						Inventory val = ((component.master.minionOwnership.group != null && Object.op_Implicit((Object)(object)component.master.minionOwnership.group.resolvedOwnerMaster)) ? component.master.minionOwnership.group.resolvedOwnerMaster.inventory : component.inventory);
						InflictDotInfo val2 = default(InflictDotInfo);
						val2.attackerObject = damageInfo.attacker;
						val2.victimObject = victim;
						val2.totalDamage = damageInfo.damage * (BolsteringLantern.Damage_Base.Value + BolsteringLantern.Damage_Stack.Value * (float)(buffCount - 1)) / 100f;
						val2.damageMultiplier = 1f;
						val2.duration = 0.1f;
						val2.dotIndex = (DotIndex)1;
						InflictDotInfo val3 = val2;
						StrengthenBurnUtils.CheckDotForUpgrade(val, ref val3);
						DotController.InflictDot(ref val3);
					}
				}
			}

			internal bool <SetUpCommonItems>b__5_51(Instruction x)
			{
				return ILPatternMatchingExt.MatchCall<CharacterBody>(x, "set_armor");
			}

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

			internal bool <SetUpCommonItems>b__5_53(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, typeof(Buffs), "Cripple");
			}

			internal void <SetUpCommonItems>b__5_50(CharacterBody body)
			{
				int num = (Object.op_Implicit((Object)(object)body.inventory) ? body.inventory.GetItemCount(Items.NegateAttack) : 0);
				if (num > 0)
				{
					body.armor += (AntlerShield.Armor_Percent_Base.Value + AntlerShield.Armor_Percent_Stack.Value * (float)(num - 1)) / 100f * body.moveSpeed;
					body.moveSpeed *= 1f + (AntlerShield.Movement_Base.Value + AntlerShield.Movement_Stack.Value * (float)(num - 1)) / 100f;
				}
			}

			internal bool <SetUpCommonItems>b__5_55(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld(x, typeof(ItemCounts), "antlerShield");
			}

			internal bool <SetUpCommonItems>b__5_56(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcI4(x, 0);
			}

			internal int <SetUpCommonItems>b__5_54(int stack)
			{
				return int.MaxValue;
			}

			internal bool <SetUpUncommonItems>b__6_7(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, typeof(Items), "LowerPricedChests");
			}

			internal bool <SetUpUncommonItems>b__6_8(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<Inventory>(x, "GetItemCount");
			}

			internal bool <SetUpUncommonItems>b__6_9(Instruction x)
			{
				int num = default(int);
				return ILPatternMatchingExt.MatchLdcI4(x, ref num);
			}

			internal int <SetUpUncommonItems>b__6_6(int stack)
			{
				return int.MaxValue;
			}

			internal void <SetUpUncommonItems>b__6_1(orig_OnInteractionBegin orig, PurchaseInteraction self, Interactor activator)
			{
				//IL_0114: Unknown result type (might be due to invalid IL or missing references)
				//IL_011e: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self, activator);
				CharacterBody component = ((Component)activator).GetComponent<CharacterBody>();
				int num = (Object.op_Implicit((Object)(object)component.inventory) ? component.inventory.GetItemCount(Items.LowerPricedChests) : 0);
				if (num > 0 && self.saleStarCompatible)
				{
					if (Object.op_Implicit((Object)(object)((Component)self).GetComponent<ChestBehavior>()))
					{
						ChestBehavior component2 = ((Component)self).GetComponent<ChestBehavior>();
						component2.dropCount++;
					}
					else if (Object.op_Implicit((Object)(object)((Component)self).GetComponent<RouletteChestController>()))
					{
						RouletteChestController component3 = ((Component)self).GetComponent<RouletteChestController>();
						component3.dropCount++;
					}
					float num2 = (SaleStar.IsHyperbolic.Value ? Util.ConvertAmplificationPercentageIntoReductionPercentage(SaleStar.Consume_Stack.Value * (float)(num - 1)) : (SaleStar.Consume_Stack.Value * (float)(num - 1)));
					if (Util.CheckRoll(SaleStar.Consume_Base.Value - num2, component.master))
					{
						component.inventory.RemoveItem(Items.LowerPricedChests, num);
						component.inventory.GiveItem(Items.LowerPricedChestsConsumed, num);
						CharacterMasterNotificationQueue.SendTransformNotification(component.master, Items.LowerPricedChests.itemIndex, Items.LowerPricedChestsConsumed.itemIndex, (TransformationType)6);
					}
					Util.PlaySound("Play_item_proc_lowerPricedChest", ((Component)self).gameObject);
				}
			}

			internal void <SetUpUncommonItems>b__6_2(orig_RpcTeleportCharacterToSafety orig, CharacterBody self)
			{
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Expected O, but got Unknown
				//IL_0058: 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)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0115: Unknown result type (might be due to invalid IL or missing references)
				//IL_0139: Unknown result type (might be due to invalid IL or missing references)
				//IL_0178: Unknown result type (might be due to invalid IL or missing references)
				//IL_017a: Unknown result type (might be due to invalid IL or missing references)
				if (!self.hasEffectiveAuthority)
				{
					return;
				}
				self.hasTeleported = true;
				int itemCount = self.inventory.GetItemCount(Items.TeleportOnLowHealth);
				EntityStateMachine.FindByCustomName(((Component)self).gameObject, "Body").SetNextState((EntityState)(object)new IntangibleSkillState());
				List<HurtBox> list = CollectionPool<HurtBox, List<HurtBox>>.RentCollection();
				SphereSearch val = new SphereSearch();
				val.mask = ((LayerIndex)(ref LayerIndex.entityPrecise)).mask;
				val.origin = self.transform.position;
				val.radius = UnstableTransmitter.Range.Value;
				val.queryTriggerInteraction = (QueryTriggerInteraction)0;
				val.RefreshCandidates();
				val.FilterCandidatesByHurtBoxTeam(TeamMask.GetEnemyTeams(self.teamComponent.teamIndex));
				val.OrderCandidatesByDistance();
				val.FilterCandidatesByDistinctHurtBoxEntities();
				val.GetHurtBoxes(list);
				val.ClearCandidates();
				for (int i = 0; i < list.Count; i++)
				{
					HurtBox val2 = list[i];
					CharacterBody body = val2.healthComponent.body;
					if (Object.op_Implicit((Object)(object)val2) && Object.op_Implicit((Object)(object)val2.healthComponent) && val2.healthComponent.alive)
					{
						InflictDotInfo val3 = default(InflictDotInfo);
						val3.attackerObject = ((Component)self).gameObject;
						val3.victimObject = ((Component)body).gameObject;
						val3.dotIndex = (DotIndex)0;
						val3.damageMultiplier = self.damage * ((UnstableTransmitter.Damage_Base.Value + UnstableTransmitter.Damage_Stack.Value * (float)(itemCount - 1)) / 150f);
						val3.duration = 3f;
						InflictDotInfo val4 = val3;
						DotController.InflictDot(ref val4);
					}
				}
			}

			internal bool <SetUpUncommonItems>b__6_11(Instruction x)
			{
				int num = default(int);
				return ILPatternMatchingExt.MatchLdcI4(x, ref num);
			}

			internal bool <SetUpUncommonItems>b__6_12(Instruction x)
			{
				ILLabel val = default(ILLabel);
				return ILPatternMatchingExt.MatchBle(x, ref val);
			}

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

			internal bool <SetUpUncommonItems>b__6_14(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<HealthComponent>(x, "body");
			}

			internal bool <SetUpUncommonItems>b__6_15(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, typeof(Buffs), "TeleportOnLowHealth");
			}

			internal int <SetUpUncommonItems>b__6_10(int stack)
			{
				return int.MaxValue;
			}

			internal void <SetUpUncommonItems>b__6_4(orig_UpdateLastHitTime orig, HealthComponent self, float damageValue, Vector3 damagePosition, bool damageIsSilent, GameObject attacker)
			{
				//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
				if (NetworkServer.active && Object.op_Implicit((Object)(object)self.body) && damageValue > 0f)
				{
					float num = (self.health + self.shield) / self.combinedHealth;
					int num2 = (Object.op_Implicit((Object)(object)self.body.inventory) ? self.body.inventory.GetItemCount(Items.TeleportOnLowHealth) : 0);
					bool flag = Object.op_Implicit((Object)(object)self.body) && self.body.HasBuff(Buffs.TeleportOnLowHealth);
					if (num <= (float)UnstableTransmitter.LowHealth.Value / 100f && num2 > 0 && flag)
					{
						self.body.hasTeleported = true;
						self.body.RemoveBuff(Buffs.TeleportOnLowHealth);
						self.body.AddTimedBuff(Buffs.TeleportOnLowHealthCooldown, UnstableTransmitter.Refresh.Value);
						self.body.CallRpcTeleportCharacterToSafety();
					}
				}
				orig.Invoke(self, damageValue, damagePosition, damageIsSilent, attacker);
			}

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

			internal bool <SetUpUncommonItems>b__6_18(Instruction x)
			{
				return ILPatternMatchingExt.MatchCall(x, typeof(BaseItemBodyBehavior), "get_body");
			}

			internal bool <SetUpUncommonItems>b__6_19(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, typeof(Buffs), "Cloak");
			}

			internal void <SetUpUncommonItems>b__6_16(PhasingBodyBehavior itemBase)
			{
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Expected O, but got Unknown
				int activeBuffsListCount = ((BaseItemBodyBehavior)itemBase).body.activeBuffsListCount;
				int itemCount = ((BaseItemBodyBehavior)itemBase).body.inventory.GetItemCount(Items.Phasing);
				int num = 1 + itemCount;
				for (int i = 0; i < activeBuffsListCount; i++)
				{
					BuffDef buffDef = BuffCatalog.GetBuffDef(((BaseItemBodyBehavior)itemBase).body.activeBuffsList[i]);
					if (buffDef.isDebuff && num > 0)
					{
						num--;
						i--;
						((BaseItemBodyBehavior)itemBase).body.RemoveBuff(buffDef);
					}
					else if (num <= 0)
					{
						break;
					}
				}
				if (num < 1 + itemCount)
				{
					EffectManager.SpawnEffect(LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/CleanseEffect"), new EffectData
					{
						origin = ((BaseItemBodyBehavior)itemBase).body.transform.position
					}, true);
				}
			}

			internal bool <SetUpLegendaryItems>b__7_9(Instruction x)
			{
				int num = default(int);
				return ILPatternMatchingExt.MatchLdcI4(x, ref num);
			}

			internal bool <SetUpLegendaryItems>b__7_10(Instruction x)
			{
				ILLabel val = default(ILLabel);
				return ILPatternMatchingExt.MatchBle(x, ref val);
			}

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

			internal bool <SetUpLegendaryItems>b__7_12(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, typeof(Items), "GoldOnStageStart");
			}

			internal int <SetUpLegendaryItems>b__7_7(int stack)
			{
				return 0;
			}

			internal void <SetUpLegendaryItems>b__7_1(orig_Start orig, CharacterBody self)
			{
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self);
				int num = ((Object.op_Implicit((Object)(object)self.master) && Object.op_Implicit((Object)(object)self.master.inventory) && NetworkServer.active) ? self.master.inventory.GetItemCount(Items.GoldOnStageStart) : 0);
				if (num > 0)
				{
					self.SetBuffCount(Buffs.FreeUnlocks.buffIndex, WarBonds.Purchase_Base.Value + WarBonds.Purchase_Stack.Value * (num - 1));
				}
			}

			internal void <SetUpLegendaryItems>b__7_2(ILContext il)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Expected O, but got Unknown
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				<>c__DisplayClass7_1 CS$<>8__locals0 = new <>c__DisplayClass7_1();
				ILCursor val = new ILCursor(il);
				CS$<>8__locals0.costIndex = -1;
				if (val.TryGotoNext(new Func<Instruction, bool>[3]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
					(Instruction x) => ILPatternMatchingExt.MatchLdfld<PurchaseInteraction>(x, "cost"),
					(Instruction x) => ILPatternMatchingExt.MatchStloc(x, ref CS$<>8__locals0.costIndex)
				}))
				{
				}
				if (!val.TryGotoNext(new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0)
				}))
				{
					return;
				}
				val.Emit(OpCodes.Ldarg_0);
				val.Emit(OpCodes.Ldarg_1);
				val.EmitDelegate<Action<PurchaseInteraction, Interactor>>((Action<PurchaseInteraction, Interactor>)delegate(PurchaseInteraction interact, Interactor activator)
				{
					//IL_002e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0034: Invalid comparison between Unknown and I4
					//IL_0048: Unknown result type (might be due to invalid IL or missing references)
					//IL_00a3: 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_00af: Unknown result type (might be due to invalid IL or missing references)
					//IL_00c0: Expected O, but got Unknown
					CharacterBody component = ((Component)activator).GetComponent<CharacterBody>();
					int num = (Object.op_Implicit((Object)(object)component.inventory) ? component.inventory.GetItemCount(Items.GoldOnStageStart) : 0);
					if (num > 0 && (int)interact.costType == 1)
					{
						ExperienceManager.instance.AwardExperience(((Component)interact).transform.position, component, (ulong)((float)interact.cost * (WarBonds.Experience_Percent_Base.Value + WarBonds.Experience_Percent_Stack.Value * (float)(num - 1)) / 100f));
					}
					if (component.HasBuff(Buffs.FreeUnlocks))
					{
						Util.PlaySound("Play_item_proc_goldOnStageStart", ((Component)component).gameObject);
						EffectManager.SpawnEffect(AssetReferences.gainCoinsImpactEffectPrefab, new EffectData
						{
							origin = component.transform.position
						}, false);
					}
				});
			}

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

			internal bool <SetUpLegendaryItems>b__7_15(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<PurchaseInteraction>(x, "cost");
			}

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

			internal void <SetUpLegendaryItems>b__7_13(PurchaseInteraction interact, Interactor activator)
			{
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Invalid comparison between Unknown and I4
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: 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_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Expected O, but got Unknown
				CharacterBody component = ((Component)activator).GetComponent<CharacterBody>();
				int num = (Object.op_Implicit((Object)(object)component.inventory) ? component.inventory.GetItemCount(Items.GoldOnStageStart) : 0);
				if (num > 0 && (int)interact.costType == 1)
				{
					ExperienceManager.instance.AwardExperience(((Component)interact).transform.position, component, (ulong)((float)interact.cost * (WarBonds.Experience_Percent_Base.Value + WarBonds.Experience_Percent_Stack.Value * (float)(num - 1)) / 100f));
				}
				if (component.HasBuff(Buffs.FreeUnlocks))
				{
					Util.PlaySound("Play_item_proc_goldOnStageStart", ((Component)component).gameObject);
					EffectManager.SpawnEffect(AssetReferences.gainCoinsImpactEffectPrefab, new EffectData
					{
						origin = component.transform.position
					}, false);
				}
			}

			internal void <SetUpLegendaryItems>b__7_3(orig_MyFixedUpdate orig, EquipmentSlot equip, float deltaTime)
			{
				orig.Invoke(equip, deltaTime);
				if (NetworkServer.active && Object.op_Implicit((Object)(object)equip.characterBody.inventory))
				{
					int itemCount = equip.characterBody.inventory.GetItemCount(Items.BoostAllStats);
					bool flag = equip.cooldownTimer == float.PositiveInfinity || equip.cooldownTimer == float.NegativeInfinity;
					bool flag2 = equip.characterBody.HasBuff(Buffs.BoostAllStatsBuff);
					if (itemCount > 0 && !flag2 && (equip.cooldownTimer <= 0f || flag))
					{
						equip.characterBody.AddBuff(Buffs.BoostAllStatsBuff);
					}
					else if ((itemCount <= 0 || !flag) && flag2)
					{
						equip.characterBody.RemoveBuff(Buffs.BoostAllStatsBuff);
					}
				}
			}

			internal void <SetUpLegendaryItems>b__7_4(orig_UpdateBoostAllStatsTimer orig, CharacterBody self, float timer)
			{
			}

			internal bool <SetUpLegendaryItems>b__7_19(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcI4(x, 0);
			}

			internal bool <SetUpLegendaryItems>b__7_20(Instruction x)
			{
				ILLabel val = default(ILLabel);
				return ILPatternMatchingExt.MatchBle(x, ref val);
			}

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

			internal bool <SetUpLegendaryItems>b__7_22(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, typeof(Buffs), "BoostAllStatsBuff");
			}

			internal int <SetUpLegendaryItems>b__7_18(int stack)
			{
				return int.MaxValue;
			}

			internal bool <SetUpLegendaryItems>b__7_25(Instruction x)
			{
				return ILPatternMatchingExt.MatchConvR4(x);
			}

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

			internal bool <SetUpLegendaryItems>b__7_27(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<CharacterBody>(x, "boostAllStatsMultiplier");
			}

			internal void <SetUpLegendaryItems>b__7_23(CharacterBody body, int nectarCount)
			{
				EquipmentSlot equipmentSlot = body.equipmentSlot;
				float num = GrowthNectar.Stat_Base.Value + GrowthNectar.Stat_Stack.Value * (float)(nectarCount - 1);
				float num2 = Math.Min(GrowthNectar.Charge_Stat_Increase.Value * (float)(equipmentSlot.maxStock - 1), GrowthNectar.Charge_Cap_Base.Value + GrowthNectar.Charge_Cap_Stack.Value * (float)(nectarCount - 1));
				float num3 = (num + num2) / 100f;
				body.maxHealth += body.maxHealth * num3;
				body.moveSpeed += body.moveSpeed * num3;
				body.damage += body.damage * num3;
				body.attackSpeed += body.attackSpeed * num3;
				body.crit += body.crit * num3;
				body.regen += body.regen * num3;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass7_1
		{
			public int costIndex;

			internal bool <SetUpLegendaryItems>b__16(Instruction x)
			{
				return ILPatternMatchingExt.MatchStloc(x, ref costIndex);
			}
		}

		public const string PluginGUID = "noodlegemo.SeekingItemReworks";

		public const string PluginAuthor = "noodlegemo";

		public const string PluginName = "SeekingItemReworks";

		public const string PluginVersion = "1.3.1";

		public void Awake()
		{
			Log.Init(((BaseUnityPlugin)this).Logger);
			MainConfig.SetUpConfigs((BaseUnityPlugin)(object)this);
			new ItemInfo();
			SetUpCommonItems();
			SetUpUncommonItems();
			SetUpLegendaryItems();
		}

		private void SetUpCommonItems()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected O, but got Unknown
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Expected O, but got Unknown
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Expected O, but got Unknown
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Expected O, but got Unknown
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Expected O, but got Unknown
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Expected O, but got Unknown
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Expected O, but got Unknown
			if (WarpedEcho.Rework.Value == 1)
			{
				CharacterBody.SecondHalfOfDelayedDamage += (Manipulator)delegate(ILContext il)
				{
					//IL_0008: Unknown result type (might be due to invalid IL or missing references)
					//IL_000e: Expected O, but got Unknown
					//IL_007a: 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)
					ILCursor val27 = new ILCursor(il);
					int damageIndex2 = -1;
					if (val27.TryGotoNext(new Func<Instruction, bool>[3]
					{
						(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, ref damageIndex2),
						(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 1),
						(Instruction x) => ILPatternMatchingExt.MatchStfld(x, typeof(DelayedDamageInfo), "halfDamage")
					}))
					{
						val27.Emit(OpCodes.Ldarg_0);
						val27.Emit(OpCodes.Ldloc, damageIndex2);
						val27.EmitDelegate<Action<CharacterBody, DelayedDamageInfo>>((Action<CharacterBody, DelayedDamageInfo>)delegate(CharacterBody body, DelayedDamageInfo damageInfo)
						{
							damageInfo.timeUntilDamage = WarpedEcho.Delay_Base.Value;
						});
					}
					else
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)(WarpedEcho.StaticName + " #1 - IL Fail #1"));
					}
				};
				CharacterBody.UpdateSecondHalfOfDamage += (Manipulator)delegate(ILContext il)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Expected O, but got Unknown
					//IL_004d: Unknown result type (might be due to invalid IL or missing references)
					ILCursor val26 = new ILCursor(il);
					if (val26.TryGotoNext(new Func<Instruction, bool>[1]
					{
						(Instruction x) => ILPatternMatchingExt.MatchCall<CharacterBody>(x, "RemoveBuff")
					}))
					{
						int index2 = val26.Index;
						val26.Index = index2 + 1;
						val26.Emit(OpCodes.Ldarg_0);
						val26.EmitDelegate<Action<CharacterBody>>((Action<CharacterBody>)delegate(CharacterBody body)
						{
							body.AddBuff(Buffs.DelayedDamageBuff);
						});
					}
					else
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)(WarpedEcho.StaticName + " #1 - IL Fail #2"));
					}
				};
				object obj = <>c.<>9__5_2;
				if (obj == null)
				{
					hook_UpdateDelayedDamage val = delegate(orig_UpdateDelayedDamage orig, CharacterBody self, float deltaTime)
					{
						if (NetworkServer.active)
						{
							int num15 = (Object.op_Implicit((Object)(object)self.inventory) ? self.inventory.GetItemCount(Items.DelayedDamage) : 0);
							if (num15 > 0)
							{
								num15 = 1 + WarpedEcho.Instance_Stack.Value * (num15 - 1);
								int buffCount3 = self.GetBuffCount(Buffs.DelayedDamageBuff);
								if (self.oldDelayedDamageCount != num15)
								{
									int num16 = num15 - self.oldDelayedDamageCount;
									if (num16 > 0)
									{
										for (int j = 0; j < Math.Abs(num16); j++)
										{
											self.AddBuff(Buffs.DelayedDamageBuff);
										}
									}
									else
									{
										for (int k = 0; k < Math.Abs(num16); k++)
										{
											self.RemoveBuff(Buffs.DelayedDamageBuff);
										}
									}
								}
								self.oldDelayedDamageCount = num15;
							}
							else
							{
								self.oldDelayedDamageCount = 0;
								self.RemoveBuff(Buffs.DelayedDamageBuff);
								self.RemoveBuff(Buffs.DelayedDamageDebuff);
								self.RemoveOldestTimedBuff(Buffs.DelayedDamageDebuff);
							}
						}
					};
					<>c.<>9__5_2 = val;
					obj = (object)val;
				}
				CharacterBody.UpdateDelayedDamage += (hook_UpdateDelayedDamage)obj;
			}
			if (ChronicExpansion.Rework.Value == 1)
			{
				CharacterBody.RecalculateStats += (Manipulator)delegate(ILContext il)
				{
					//IL_0008: Unknown result type (might be due to invalid IL or missing references)
					//IL_000e: Expected O, but got Unknown
					//IL_0114: Unknown result type (might be due to invalid IL or missing references)
					//IL_0120: Unknown result type (might be due to invalid IL or missing references)
					//IL_0160: Unknown result type (might be due to invalid IL or missing references)
					ILCursor val24 = new ILCursor(il);
					int itemIndex2 = -1;
					if (!val24.TryGotoNext(new Func<Instruction, bool>[3]
					{
						(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, typeof(Items), "IncreaseDamageOnMultiKill"),
						(Instruction x) => ILPatternMatchingExt.MatchCallvirt<Inventory>(x, "GetItemCount"),
						(Instruction x) => ILPatternMatchingExt.MatchStloc(x, ref itemIndex2)
					}))
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)(ChronicExpansion.StaticName + " - IL Fail #1"));
					}
					if (val24.TryGotoNext(new Func<Instruction, bool>[3]
					{
						(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
						(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, typeof(Buffs), "IncreaseDamageBuff"),
						(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<CharacterBody>(x, "GetBuffCount")
					}))
					{
						val24.Emit(OpCodes.Ldarg_0);
						val24.Emit(OpCodes.Ldloc, itemIndex2);
						val24.EmitDelegate<Action<CharacterBody, int>>((Action<CharacterBody, int>)delegate(CharacterBody body, int itemCount)
						{
							int buffCount2 = body.GetBuffCount(Buffs.IncreaseDamageBuff);
							float num14 = (float)buffCount2 * (ChronicExpansion.Damage_Base.Value + ChronicExpansion.Damage_Stack.Value * (float)(itemCount - 1)) / 100f;
							body.damage *= 1f + num14;
							if (body.oldComboMeter < buffCount2)
							{
								body.oldComboMeter = buffCount2;
							}
						});
						ILLabel val25 = val24.DefineLabel();
						val24.Emit(OpCodes.Br_S, (object)val25);
						int num13 = default(int);
						if (val24.TryGotoNext(new Func<Instruction, bool>[3]
						{
							(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
							(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, ref num13),
							(Instruction x) => ILPatternMatchingExt.MatchStfld<CharacterBody>(x, "oldComboMeter")
						}))
						{
							val24.MarkLabel(val25);
						}
					}
					else
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)(ChronicExpansion.StaticName + " #1 - IL Fail #2"));
					}
				};
			}
			if (KnockbackFin.Rework.Value == 1)
			{
				GlobalEventManager.ProcessHitEnemy += (Manipulator)delegate(ILContext il)
				{
					//IL_0008: Unknown result type (might be due to invalid IL or missing references)
					//IL_000e: Expected O, but got Unknown
					//IL_00be: 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)
					ILCursor val22 = new ILCursor(il);
					int itemIndex = -1;
					int num12 = default(int);
					ILLabel val23 = default(ILLabel);
					int num11 = default(int);
					if (val22.TryGotoNext(new Func<Instruction, bool>[5]
					{
						(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, ref itemIndex),
						(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, ref num12),
						(Instruction x) => ILPatternMatchingExt.MatchBle(x, ref val23),
						(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, ref num11),
						(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<CharacterBody>(x, "get_isBoss")
					}))
					{
						val22.Emit(OpCodes.Ldloc, itemIndex);
						val22.EmitDelegate<Func<int, int>>((Func<int, int>)((int itemCount) => -1));
						val22.Emit(OpCodes.Stloc, itemIndex);
					}
					else
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)(KnockbackFin.StaticName + " #1 - IL Fail #1"));
					}
				};
				object obj2 = <>c.<>9__5_5;
				if (obj2 == null)
				{
					hook_ProcessHitEnemy val2 = delegate(orig_ProcessHitEnemy orig, GlobalEventManager self, DamageInfo damageInfo, GameObject victim)
					{
						//IL_0131: Unknown result type (might be due to invalid IL or missing references)
						//IL_0136: Unknown result type (might be due to invalid IL or missing references)
						//IL_0138: Unknown result type (might be due to invalid IL or missing references)
						//IL_013a: Unknown result type (might be due to invalid IL or missing references)
						//IL_013c: Unknown result type (might be due to invalid IL or missing references)
						//IL_014f: Expected I4, but got Unknown
						//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
						//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
						//IL_0182: Unknown result type (might be due to invalid IL or missing references)
						//IL_0187: Unknown result type (might be due to invalid IL or missing references)
						//IL_0193: Unknown result type (might be due to invalid IL or missing references)
						//IL_019e: Unknown result type (might be due to invalid IL or missing references)
						//IL_01ac: Expected O, but got Unknown
						//IL_01d6: 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)
						orig.Invoke(self, damageInfo, victim);
						if (Object.op_Implicit((Object)(object)damageInfo.attacker) && damageInfo.procCoefficient > 0f)
						{
							CharacterBody component4 = damageInfo.attacker.GetComponent<CharacterBody>();
							CharacterBody component5 = victim.GetComponent<CharacterBody>();
							int num8 = (Object.op_Implicit((Object)(object)component4.inventory) ? component4.inventory.GetItemCount(Items.KnockBackHitEnemies) : 0);
							if (Object.op_Implicit((Object)(object)component5) && num8 > 0)
							{
								CharacterMotor component6 = victim.GetComponent<CharacterMotor>();
								victim.GetComponent<RigidbodyMotor>();
								float num9 = (KnockbackFin.Chance_Base.Value + KnockbackFin.Chance_Stack.Value * (float)(num8 - 1)) * damageInfo.procCoefficient;
								if (KnockbackFin.IsHyperbolic.Value)
								{
									num9 = Util.ConvertAmplificationPercentageIntoReductionPercentage(num9);
								}
								if (Object.op_Implicit((Object)(object)component6) && component6.isGrounded && !component5.isChampion && (component5.bodyFlags & 1) == 0 && !component5.HasBuff(Buffs.KnockUpHitEnemies) && Util.CheckRoll(num9, 0f, (CharacterMaster)null))
								{
									component5.AddTimedBuff(Buffs.KnockUpHitEnemies, 5f);
									float scale = 1f;
									HullClassification hullClassification = component5.hullClassification;
									HullClassification val20 = hullClassification;
									switch ((int)val20)
									{
									case 0:
										scale = 1f;
										break;
									case 1:
										scale = 5f;
										break;
									case 2:
										scale = 10f;
										break;
									}
									Util.PlaySound("Play_item_proc_knockBackHitEnemies", ((Component)component4).gameObject);
									EffectManager.SpawnEffect(CommonAssets.knockbackFinEffect, new EffectData
									{
										origin = ((Component)component5).gameObject.transform.position,
										scale = scale
									}, true);
									Vector3 val21 = default(Vector3);
									((Vector3)(ref val21))..ctor(0f, 1f, 0f);
									float num10 = component6.mass * 25f;
									component6.ApplyForce(num10 * val21, false, false);
								}
							}
						}
					};
					<>c.<>9__5_5 = val2;
					obj2 = (object)val2;
				}
				GlobalEventManager.ProcessHitEnemy += (hook_ProcessHitEnemy)obj2;
				HealthComponent.TakeDamageProcess += (Manipulator)delegate(ILContext il)
				{
					//IL_0008: Unknown result type (might be due to invalid IL or missing references)
					//IL_000e: Expected O, but got Unknown
					//IL_018a: Unknown result type (might be due to invalid IL or missing references)
					//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
					//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
					//IL_021e: Unknown result type (might be due to invalid IL or missing references)
					ILCursor val18 = new ILCursor(il);
					int damageIndex = -1;
					int num7 = default(int);
					if (!val18.TryGotoNext(new Func<Instruction, bool>[5]
					{
						(Instruction x) => ILPatternMatchingExt.MatchStloc(x, ref damageIndex),
						(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, ref num7),
						(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
						(Instruction x) => ILPatternMatchingExt.MatchLdfld<HealthComponent>(x, "body"),
						(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<CharacterBody>(x, "get_teamComponent")
					}))
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)(KnockbackFin.StaticName + " #1 - IL Fail #2"));
					}
					((BaseUnityPlugin)this).Logger.LogDebug((object)("DamageIndex: " + damageIndex));
					int num6 = default(int);
					if (val18.TryGotoNext(new Func<Instruction, bool>[3]
					{
						(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, ref num6),
						(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
						(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<HealthComponent>(x, "get_fullCombinedHealth")
					}))
					{
						((BaseUnityPlugin)this).Logger.LogDebug((object)"1");
						val18.Emit(OpCodes.Ldarg_0);
						((BaseUnityPlugin)this).Logger.LogDebug((object)"2");
						val18.Emit(OpCodes.Ldarg_1);
						((BaseUnityPlugin)this).Logger.LogDebug((object)"3");
						val18.Emit(OpCodes.Ldloc, damageIndex);
						((BaseUnityPlugin)this).Logger.LogDebug((object)"4");
						val18.EmitDelegate<Func<HealthComponent, DamageInfo, float, float>>((Func<HealthComponent, DamageInfo, float, float>)delegate(HealthComponent healthComponent, DamageInfo damageInfo, float damage)
						{
							//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
							//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
							float num4 = damage;
							CharacterBody val19 = (Object.op_Implicit((Object)(object)damageInfo.attacker) ? damageInfo.attacker.GetComponent<CharacterBody>() : null);
							int num5 = ((Object.op_Implicit((Object)(object)val19) && Object.op_Implicit((Object)(object)val19.inventory)) ? val19.inventory.GetItemCount(Items.KnockBackHitEnemies) : 0);
							if (num5 > 0 && (healthComponent.body.isFlying || ((Object)(object)healthComponent.body.characterMotor != (Object)null && !healthComponent.body.characterMotor.isGrounded)))
							{
								num4 *= 1f + (KnockbackFin.Damage_Base.Value + KnockbackFin.Damage_Stack.Value * (float)(num5 - 1)) / 100f;
								EffectManager.SimpleImpactEffect(AssetReferences.mercExposeConsumeEffectPrefab, damageInfo.position, Vector3.up, true);
							}
							return num4;
						});
						((BaseUnityPlugin)this).Logger.LogDebug((object)"5");
						val18.Emit(OpCodes.Stloc, damageIndex);
						((BaseUnityPlugin)this).Logger.LogDebug((object)"6");
					}
					else
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)(KnockbackFin.StaticName + " #1 - IL Fail #3"));
					}
				};
			}
			if (BolsteringLantern.Rework.Value > 0)
			{
				CharacterBody.RecalculateStats += (Manipulator)delegate(ILContext il)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Expected O, but got Unknown
					//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
					ILCursor val16 = new ILCursor(il);
					if (val16.TryGotoNext(new Func<Instruction, bool>[3]
					{
						(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
						(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, typeof(Buffs), "LowerHealthHigherDamageBuff"),
						(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<CharacterBody>(x, "HasBuff")
					}))
					{
						ILLabel val17 = default(ILLabel);
						val16.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
						{
							(Instruction x) => ILPatternMatchingExt.MatchBrfalse(x, ref val17)
						});
						val16.Emit(OpCodes.Br, val16.Next);
					}
					else
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)(BolsteringLantern.StaticName + " #0 - IL Fail #1"));
					}
				};
			}
			if (BolsteringLantern.Rework.Value == 1)
			{
				object obj3 = <>c.<>9__5_8;
				if (obj3 == null)
				{
					hook_UpdateLowerHealthHigherDamage val3 = delegate(orig_UpdateLowerHealthHigherDamage orig, CharacterBody body)
					{
						if (NetworkServer.active)
						{
							int num3 = (Object.op_Implicit((Object)(object)body.inventory) ? body.inventory.GetItemCount(Items.LowerHealthHigherDamage) : 0);
							if (num3 > 0)
							{
								float normalizedHealth = body.healthComponent.GetNormalizedHealth();
								if (normalizedHealth <= (float)BolsteringLantern.LowHealth.Value / 100f && !body.HasBuff(Buffs.LowerHealthHigherDamageBuff))
								{
									body.AddBuff(Buffs.LowerHealthHigherDamageBuff);
									Util.PlaySound("Play_item_proc_lowerHealthHigherDamage_proc", ((Component)body).gameObject);
								}
								else if (normalizedHealth >= (float)BolsteringLantern.HighHealth.Value / 100f && body.HasBuff(Buffs.LowerHealthHigherDamageBuff))
								{
									body.RemoveBuff(Buffs.LowerHealthHigherDamageBuff);
								}
							}
							else if (num3 <= 0 && body.HasBuff(Buffs.LowerHealthHigherDamageBuff))
							{
								body.RemoveBuff(Buffs.LowerHealthHigherDamageBuff);
							}
						}
					};
					<>c.<>9__5_8 = val3;
					obj3 = (object)val3;
				}
				CharacterBody.UpdateLowerHealthHigherDamage += (hook_UpdateLowerHealthHigherDamage)obj3;
				GlobalEventManager.ProcessHitEnemy += (hook_ProcessHitEnemy)delegate(orig_ProcessHitEnemy orig, GlobalEventManager self, DamageInfo damageInfo, GameObject victim)
				{
					//IL_006e: 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_00dd: Unknown result type (might be due to invalid IL or missing references)
					//IL_00df: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke(self, damageInfo, victim);
					if (Object.op_Implicit((Object)(object)damageInfo.attacker) && damageInfo.procCoefficient > 0f)
					{
						CharacterBody component3 = damageInfo.attacker.GetComponent<CharacterBody>();
						if (Object.op_Implicit((Object)(object)component3) && component3.HasBuff(Buffs.LowerHealthHigherDamageBuff))
						{
							int itemCount2 = component3.inventory.GetItemCount(Items.LowerHealthHigherDamage);
							InflictDotInfo val14 = default(InflictDotInfo);
							val14.attackerObject = damageInfo.attacker;
							val14.victimObject = victim;
							val14.totalDamage = damageInfo.damage * (BolsteringLantern.Damage_Base.Value + BolsteringLantern.Damage_Stack.Value * (float)(itemCount2 - 1)) / 100f;
							val14.damageMultiplier = 1f;
							val14.duration = 0.1f;
							val14.dotIndex = (DotIndex)1;
							InflictDotInfo val15 = val14;
							StrengthenBurnUtils.CheckDotForUpgrade(component3.inventory, ref val15);
							DotController.InflictDot(ref val15);
						}
					}
					else
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)(KnockbackFin.StaticName + " #1 - IL Fail #1"));
					}
				};
			}
			if (BolsteringLantern.Rework.Value == 2)
			{
				new LanternCountBuff();
				object obj4 = <>c.<>9__5_10;
				if (obj4 == null)
				{
					hook_UpdateLowerHealthHigherDamage val4 = delegate
					{
					};
					<>c.<>9__5_10 = val4;
					obj4 = (object)val4;
				}
				CharacterBody.UpdateLowerHealthHigherDamage += (hook_UpdateLowerHealthHigherDamage)obj4;
				object obj5 = <>c.<>9__5_11;
				if (obj5 == null)
				{
					hook_FixedUpdate val5 = delegate(orig_FixedUpdate orig, CharacterBody body)
					{
						//IL_003f: Unknown result type (might be due to invalid IL or missing references)
						//IL_0050: Unknown result type (might be due to invalid IL or missing references)
						//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
						orig.Invoke(body);
						int num2 = ((Object.op_Implicit((Object)(object)body) && Object.op_Implicit((Object)(object)body.inventory)) ? body.inventory.GetItemCount(Items.LowerHealthHigherDamage) : 0);
						if (num2 > 0)
						{
							MinionGroup val12 = MinionGroup.FindGroup(body.masterObjectId);
							body.SetBuffCount(LanternCountBuff.LanternCounter.buffIndex, num2);
							if (val12 != null)
							{
								MinionOwnership[] members = val12.members;
								foreach (MinionOwnership val13 in members)
								{
									if (!((Object)(object)val13 == (Object)null))
									{
										CharacterMaster component2 = ((Component)val13).GetComponent<CharacterMaster>();
										if (Object.op_Implicit((Object)(object)component2) && Object.op_Implicit((Object)(object)component2.inventory) && Object.op_Implicit((Object)(object)component2.GetBody()))
										{
											component2.GetBody().SetBuffCount(LanternCountBuff.LanternCounter.buffIndex, num2);
										}
									}
								}
							}
						}
					};
					<>c.<>9__5_11 = val5;
					obj5 = (object)val5;
				}
				CharacterBody.FixedUpdate += (hook_FixedUpdate)obj5;
				object obj6 = <>c.<>9__5_12;
				if (obj6 == null)
				{
					hook_ProcessHitEnemy val6 = delegate(orig_ProcessHitEnemy orig, GlobalEventManager self, DamageInfo damageInfo, GameObject victim)
					{
						//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
						//IL_0143: Unknown result type (might be due to invalid IL or missing references)
						//IL_0148: Unknown result type (might be due to invalid IL or missing references)
						//IL_014a: Unknown result type (might be due to invalid IL or missing references)
						orig.Invoke(self, damageInfo, victim);
						if (Object.op_Implicit((Object)(object)damageInfo.attacker) && damageInfo.procCoefficient > 0f)
						{
							CharacterBody component = damageInfo.attacker.GetComponent<CharacterBody>();
							int buffCount = component.GetBuffCount(LanternCountBuff.LanternCounter);
							if (Object.op_Implicit((Object)(object)component) && buffCount > 0 && Util.CheckRoll(BolsteringLantern.Chance_Base.Value + BolsteringLantern.Chance_Stack.Value * (float)(buffCount - 1), 0f, (CharacterMaster)null))
							{
								Inventory val9 = ((component.master.minionOwnership.group != null && Object.op_Implicit((Object)(object)component.master.minionOwnership.group.resolvedOwnerMaster)) ? component.master.minionOwnership.group.resolvedOwnerMaster.inventory : component.inventory);
								InflictDotInfo val10 = default(InflictDotInfo);
								val10.attackerObject = damageInfo.attacker;
								val10.victimObject = victim;
								val10.totalDamage = damageInfo.damage * (BolsteringLantern.Damage_Base.Value + BolsteringLantern.Damage_Stack.Value * (float)(buffCount - 1)) / 100f;
								val10.damageMultiplier = 1f;
								val10.duration = 0.1f;
								val10.dotIndex = (DotIndex)1;
								InflictDotInfo val11 = val10;
								StrengthenBurnUtils.CheckDotForUpgrade(val9, ref val11);
								DotController.InflictDot(ref val11);
							}
						}
					};
					<>c.<>9__5_12 = val6;
					obj6 = (object)val6;
				}
				GlobalEventManager.ProcessHitEnemy += (hook_ProcessHitEnemy)obj6;
			}
			if (AntlerShield.Rework.Value != 1)
			{
				return;
			}
			CharacterBody.RecalculateStats += (Manipulator)delegate(ILContext il)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				ILCursor val8 = new ILCursor(il);
				if (val8.TryGotoNext(new Func<Instruction, bool>[3]
				{
					(Instruction x) => ILPatternMatchingExt.MatchCall<CharacterBody>(x, "set_armor"),
					(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
					(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, typeof(Buffs), "Cripple")
				}))
				{
					int index = val8.Index;
					val8.Index = index + 1;
					val8.Emit(OpCodes.Ldarg_0);
					val8.EmitDelegate<Action<CharacterBody>>((Action<CharacterBody>)delegate(CharacterBody body)
					{
						int num = (Object.op_Implicit((Object)(object)body.inventory) ? body.inventory.GetItemCount(Items.NegateAttack) : 0);
						if (num > 0)
						{
							body.armor += (AntlerShield.Armor_Percent_Base.Value + AntlerShield.Armor_Percent_Stack.Value * (float)(num - 1)) / 100f * body.moveSpeed;
							body.moveSpeed *= 1f + (AntlerShield.Movement_Base.Value + AntlerShield.Movement_Stack.Value * (float)(num - 1)) / 100f;
						}
					});
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)(AntlerShield.StaticName + " #1 - IL Fail #1"));
				}
			};
			HealthComponent.TakeDamageProcess += (Manipulator)delegate(ILContext il)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				ILCursor val7 = new ILCursor(il);
				if (val7.TryGotoNext(new Func<Instruction, bool>[2]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdfld(x, typeof(ItemCounts), "antlerShield"),
					(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 0)
				}))
				{
					val7.Index += 2;
					val7.EmitDelegate<Func<int, int>>((Func<int, int>)((int stack) => int.MaxValue));
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)(AntlerShield.StaticName + " #2 - IL Fail #1"));
				}
			};
		}

		private void SetUpUncommonItems()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			//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_00b3: Expected O, but got Unknown
			if (SaleStar.Rework.Value == 1)
			{
				PurchaseInteraction.OnInteractionBegin += (Manipulator)delegate(ILContext il)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Expected O, but got Unknown
					ILCursor val11 = new ILCursor(il);
					int num7 = default(int);
					if (val11.TryGotoNext(new Func<Instruction, bool>[3]
					{
						(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, typeof(Items), "LowerPricedChests"),
						(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<Inventory>(x, "GetItemCount"),
						(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, ref num7)
					}))
					{
						val11.Index += 3;
						val11.EmitDelegate<Func<int, int>>((Func<int, int>)((int stack) => int.MaxValue));
					}
					else
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)(SaleStar.StaticName + " #1 - IL Fail #1"));
					}
				};
				object obj = <>c.<>9__6_1;
				if (obj == null)
				{
					hook_OnInteractionBegin val = delegate(orig_OnInteractionBegin orig, PurchaseInteraction self, Interactor activator)
					{
						//IL_0114: Unknown result type (might be due to invalid IL or missing references)
						//IL_011e: Unknown result type (might be due to invalid IL or missing references)
						orig.Invoke(self, activator);
						CharacterBody component = ((Component)activator).GetComponent<CharacterBody>();
						int num5 = (Object.op_Implicit((Object)(object)component.inventory) ? component.inventory.GetItemCount(Items.LowerPricedChests) : 0);
						if (num5 > 0 && self.saleStarCompatible)
						{
							if (Object.op_Implicit((Object)(object)((Component)self).GetComponent<ChestBehavior>()))
							{
								ChestBehavior component2 = ((Component)self).GetComponent<ChestBehavior>();
								component2.dropCount++;
							}
							else if (Object.op_Implicit((Object)(object)((Component)self).GetComponent<RouletteChestController>()))
							{
								RouletteChestController component3 = ((Component)self).GetComponent<RouletteChestController>();
								component3.dropCount++;
							}
							float num6 = (SaleStar.IsHyperbolic.Value ? Util.ConvertAmplificationPercentageIntoReductionPercentage(SaleStar.Consume_Stack.Value * (float)(num5 - 1)) : (SaleStar.Consume_Stack.Value * (float)(num5 - 1)));
							if (Util.CheckRoll(SaleStar.Consume_Base.Value - num6, component.master))
							{
								component.inventory.RemoveItem(Items.LowerPricedChests, num5);
								component.inventory.GiveItem(Items.LowerPricedChestsConsumed, num5);
								CharacterMasterNotificationQueue.SendTransformNotification(component.master, Items.LowerPricedChests.itemIndex, Items.LowerPricedChestsConsumed.itemIndex, (TransformationType)6);
							}
							Util.PlaySound("Play_item_proc_lowerPricedChest", ((Component)self).gameObject);
						}
					};
					<>c.<>9__6_1 = val;
					obj = (object)val;
				}
				PurchaseInteraction.OnInteractionBegin += (hook_OnInteractionBegin)obj;
			}
			if (UnstableTransmitter.Rework.Value == 1)
			{
				object obj2 = <>c.<>9__6_2;
				if (obj2 == null)
				{
					hook_RpcTeleportCharacterToSafety val2 = delegate(orig_RpcTeleportCharacterToSafety orig, CharacterBody self)
					{
						//IL_004c: Unknown result type (might be due to invalid IL or missing references)
						//IL_0052: Expected O, but got Unknown
						//IL_0058: 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)
						//IL_0069: Unknown result type (might be due to invalid IL or missing references)
						//IL_006e: Unknown result type (might be due to invalid IL or missing references)
						//IL_0085: Unknown result type (might be due to invalid IL or missing references)
						//IL_0098: Unknown result type (might be due to invalid IL or missing references)
						//IL_009d: Unknown result type (might be due to invalid IL or missing references)
						//IL_0115: Unknown result type (might be due to invalid IL or missing references)
						//IL_0139: Unknown result type (might be due to invalid IL or missing references)
						//IL_0178: Unknown result type (might be due to invalid IL or missing references)
						//IL_017a: Unknown result type (might be due to invalid IL or missing references)
						if (self.hasEffectiveAuthority)
						{
							self.hasTeleported = true;
							int itemCount2 = self.inventory.GetItemCount(Items.TeleportOnLowHealth);
							EntityStateMachine.FindByCustomName(((Component)self).gameObject, "Body").SetNextState((EntityState)(object)new IntangibleSkillState());
							List<HurtBox> list = CollectionPool<HurtBox, List<HurtBox>>.RentCollection();
							SphereSearch val7 = new SphereSearch();
							val7.mask = ((LayerIndex)(ref LayerIndex.entityPrecise)).mask;
							val7.origin = self.transform.position;
							val7.radius = UnstableTransmitter.Range.Value;
							val7.queryTriggerInteraction = (QueryTriggerInteraction)0;
							val7.RefreshCandidates();
							val7.FilterCandidatesByHurtBoxTeam(TeamMask.GetEnemyTeams(self.teamComponent.teamIndex));
							val7.OrderCandidatesByDistance();
							val7.FilterCandidatesByDistinctHurtBoxEntities();
							val7.GetHurtBoxes(list);
							val7.ClearCandidates();
							for (int j = 0; j < list.Count; j++)
							{
								HurtBox val8 = list[j];
								CharacterBody body = val8.healthComponent.body;
								if (Object.op_Implicit((Object)(object)val8) && Object.op_Implicit((Object)(object)val8.healthComponent) && val8.healthComponent.alive)
								{
									InflictDotInfo val9 = default(InflictDotInfo);
									val9.attackerObject = ((Component)self).gameObject;
									val9.victimObject = ((Component)body).gameObject;
									val9.dotIndex = (DotIndex)0;
									val9.damageMultiplier = self.damage * ((UnstableTransmitter.Damage_Base.Value + UnstableTransmitter.Damage_Stack.Value * (float)(itemCount2 - 1)) / 150f);
									val9.duration = 3f;
									InflictDotInfo val10 = val9;
									DotController.InflictDot(ref val10);
								}
							}
						}
					};
					<>c.<>9__6_2 = val2;
					obj2 = (object)val2;
				}
				CharacterBody.RpcTeleportCharacterToSafety += (hook_RpcTeleportCharacterToSafety)obj2;
				HealthComponent.UpdateLastHitTime += (Manipulator)delegate(ILContext il)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Expected O, but got Unknown
					ILCursor val5 = new ILCursor(il);
					int num4 = default(int);
					ILLabel val6 = default(ILLabel);
					if (val5.TryGotoNext(new Func<Instruction, bool>[5]
					{
						(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, ref num4),
						(Instruction x) => ILPatternMatchingExt.MatchBle(x, ref val6),
						(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
						(Instruction x) => ILPatternMatchingExt.MatchLdfld<HealthComponent>(x, "body"),
						(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, typeof(Buffs), "TeleportOnLowHealth")
					}))
					{
						val5.EmitDelegate<Func<int, int>>((Func<int, int>)((int stack) => int.MaxValue));
					}
					else
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)(BolsteringLantern.StaticName + " #1 - IL Fail #1"));
					}
				};
				object obj3 = <>c.<>9__6_4;
				if (obj3 == null)
				{
					hook_UpdateLastHitTime val3 = delegate(orig_UpdateLastHitTime orig, HealthComponent self, float damageValue, Vector3 damagePosition, bool damageIsSilent, GameObject attacker)
					{
						//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
						if (NetworkServer.active && Object.op_Implicit((Object)(object)self.body) && damageValue > 0f)
						{
							float num2 = (self.health + self.shield) / self.combinedHealth;
							int num3 = (Object.op_Implicit((Object)(object)self.body.inventory) ? self.body.inventory.GetItemCount(Items.TeleportOnLowHealth) : 0);
							bool flag = Object.op_Implicit((Object)(object)self.body) && self.body.HasBuff(Buffs.TeleportOnLowHealth);
							if (num2 <= (float)UnstableTransmitter.LowHealth.Value / 100f && num3 > 0 && flag)
							{
								self.body.hasTeleported = true;
								self.body.RemoveBuff(Buffs.TeleportOnLowHealth);
								self.body.AddTimedBuff(Buffs.TeleportOnLowHealthCooldown, UnstableTransmitter.Refresh.Value);
								self.body.CallRpcTeleportCharacterToSafety();
							}
						}
						orig.Invoke(self, damageValue, damagePosition, damageIsSilent, attacker);
					};
					<>c.<>9__6_4 = val3;
					obj3 = (object)val3;
				}
				HealthComponent.UpdateLastHitTime += (hook_UpdateLastHitTime)obj3;
			}
			if (OldWarStealthKit.Rework.Value != 1)
			{
				return;
			}
			PhasingBodyBehavior.FixedUpdate += (Manipulator)delegate(ILContext il)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				ILCursor val4 = new ILCursor(il);
				if (val4.TryGotoNext(new Func<Instruction, bool>[3]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
					(Instruction x) => ILPatternMatchingExt.MatchCall(x, typeof(BaseItemBodyBehavior), "get_body"),
					(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, typeof(Buffs), "Cloak")
				}))
				{
					val4.Emit(OpCodes.Ldarg_0);
					val4.EmitDelegate<Action<PhasingBodyBehavior>>((Action<PhasingBodyBehavior>)delegate(PhasingBodyBehavior itemBase)
					{
						//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
						//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
						//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
						//IL_00c8: Expected O, but got Unknown
						int activeBuffsListCount = ((BaseItemBodyBehavior)itemBase).body.activeBuffsListCount;
						int itemCount = ((BaseItemBodyBehavior)itemBase).body.inventory.GetItemCount(Items.Phasing);
						int num = 1 + itemCount;
						for (int i = 0; i < activeBuffsListCount; i++)
						{
							BuffDef buffDef = BuffCatalog.GetBuffDef(((BaseItemBodyBehavior)itemBase).body.activeBuffsList[i]);
							if (buffDef.isDebuff && num > 0)
							{
								num--;
								i--;
								((BaseItemBodyBehavior)itemBase).body.RemoveBuff(buffDef);
							}
							else if (num <= 0)
							{
								break;
							}
						}
						if (num < 1 + itemCount)
						{
							EffectManager.SpawnEffect(LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/CleanseEffect"), new EffectData
							{
								origin = ((BaseItemBodyBehavior)itemBase).body.transform.position
							}, true);
						}
					});
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)(OldWarStealthKit.StaticName + " #1 - IL Fail #1"));
				}
			};
		}

		private void SetUpLegendaryItems()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: 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_00a1: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			//IL_00bb: 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_00c6: Expected O, but got Unknown
			if (WarBonds.Rework.Value == 1)
			{
				CharacterBody.Start += (Manipulator)delegate(ILContext il)
				{
					//IL_0008: Unknown result type (might be due to invalid IL or missing references)
					//IL_000e: Expected O, but got Unknown
					//IL_00be: 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)
					ILCursor val10 = new ILCursor(il);
					int itemIndex = -1;
					int num6 = default(int);
					ILLabel val11 = default(ILLabel);
					if (val10.TryGotoNext(new Func<Instruction, bool>[5]
					{
						(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, ref itemIndex),
						(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, ref num6),
						(Instruction x) => ILPatternMatchingExt.MatchBle(x, ref val11),
						(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
						(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, typeof(Items), "GoldOnStageStart")
					}))
					{
						val10.Emit(OpCodes.Ldloc, itemIndex);
						val10.EmitDelegate<Func<int, int>>((Func<int, int>)((int stack) => 0));
						val10.Emit(OpCodes.Stloc, itemIndex);
					}
					else
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)(WarBonds.StaticName + " #1 - IL Fail #1"));
					}
				};
				object obj = <>c.<>9__7_1;
				if (obj == null)
				{
					hook_Start val = delegate(orig_Start orig, CharacterBody self)
					{
						//IL_0056: Unknown result type (might be due to invalid IL or missing references)
						orig.Invoke(self);
						int num5 = ((Object.op_Implicit((Object)(object)self.master) && Object.op_Implicit((Object)(object)self.master.inventory) && NetworkServer.active) ? self.master.inventory.GetItemCount(Items.GoldOnStageStart) : 0);
						if (num5 > 0)
						{
							self.SetBuffCount(Buffs.FreeUnlocks.buffIndex, WarBonds.Purchase_Base.Value + WarBonds.Purchase_Stack.Value * (num5 - 1));
						}
					};
					<>c.<>9__7_1 = val;
					obj = (object)val;
				}
				CharacterBody.Start += (hook_Start)obj;
				object obj2 = <>c.<>9__7_2;
				if (obj2 == null)
				{
					Manipulator val2 = delegate(ILContext il)
					{
						//IL_0008: Unknown result type (might be due to invalid IL or missing references)
						//IL_000e: Expected O, but got Unknown
						//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
						//IL_00b