using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using HG;
using IL.RoR2;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using On.RoR2;
using R2API;
using RoR2;
using RoR2.Audio;
using RoR2.Items;
using RoR2.Orbs;
using RoR2.Projectile;
using StormItemBuffs.Properties;
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 = "")]
[assembly: AssemblyCompany("StormItemBuffs")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("StormItemBuffs")]
[assembly: AssemblyTitle("StormItemBuffs")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: UnverifiableCode]
namespace StormItemBuffs
{
	public static class ArrayUtil
	{
		public static T[] Add<T>(this T[] array, params T[] items)
		{
			return (array ?? Enumerable.Empty<T>()).Concat(items).ToArray();
		}

		public static T[] Remove<T>(this T[] array, params T[] items)
		{
			return (array ?? Enumerable.Empty<T>()).Except(items).ToArray();
		}
	}
	public class WConfig
	{
		public static ConfigFile ConfigFileUNSORTED = new ConfigFile(Paths.ConfigPath + "\\Wolfo.Storm_Item_Buffs.cfg", true);

		public static ConfigEntry<bool> cfg_White_Antler;

		public static ConfigEntry<bool> cfg_White_Antler_FIX;

		public static ConfigEntry<bool> cfg_White_Chronic;

		public static ConfigEntry<bool> cfg_White_Chronic_SPEED;

		public static ConfigEntry<bool> cfg_White_Chronic_FIX;

		public static ConfigEntry<bool> cfg_White_BolsterLantern;

		public static ConfigEntry<bool> cfg_White_BolsterLantern_FIX;

		public static ConfigEntry<bool> cfg_White_WarpedEcho;

		public static ConfigEntry<bool> cfg_White_WarpedEcho_FIX;

		public static ConfigEntry<bool> cfg_White_KnockbackFin;

		public static ConfigEntry<bool> cfg_White_KnockbackFin_FIX;

		public static ConfigEntry<bool> cfg_Green_Beads;

		public static ConfigEntry<bool> cfg_Green_Beads_FIX;

		public static ConfigEntry<bool> cfg_Green_NoxThorn;

		public static ConfigEntry<bool> cfg_Green_NoxThorn_FIX;

		public static ConfigEntry<bool> cfg_Green_UnstableTrans;

		public static ConfigEntry<bool> cfg_Green_UnstableTrans_FIX;

		public static ConfigEntry<bool> cfg_Green_LumShot;

		public static ConfigEntry<bool> cfg_Green_LumShot_FIX;

		public static ConfigEntry<bool> cfg_Red_WarBonds;

		public static ConfigEntry<bool> cfg_Red_WarBonds_FIX;

		public static ConfigEntry<bool> cfg_Red_Meteor;

		public static ConfigEntry<bool> cfg_Red_Nectar;

		public static ConfigEntry<bool> cfg_Red_Nectar_FIX;

		public static ConfigEntry<bool> cfg_Red_Boomerang;

		public static ConfigEntry<bool> cfg_Red_Sonch_FIX;

		public static ConfigEntry<bool> cfg_Elite_Twisted;

		public static ConfigEntry<bool> cfg_Elite_Gilded;

		public static void InitConfig()
		{
			cfg_White_Antler = ConfigFileUNSORTED.Bind<bool>("White", "Antler Shield", true, "Changes as described on store page.");
			cfg_White_Antler_FIX = ConfigFileUNSORTED.Bind<bool>("White - Fixes", "Antler Shield", true, "Fixes as described on store page.");
			cfg_White_Chronic = ConfigFileUNSORTED.Bind<bool>("White", "Chronic Expansion", true, "Changes as described on store page.");
			cfg_White_Chronic_SPEED = ConfigFileUNSORTED.Bind<bool>("White", "Chronic Expansion - Speed", true, "Make it speed instead of damage.");
			cfg_White_Chronic_FIX = ConfigFileUNSORTED.Bind<bool>("White - Fixes", "Chronic Expansion", true, "Fixes as described on store page.");
			cfg_White_BolsterLantern = ConfigFileUNSORTED.Bind<bool>("White", "Bolstering Lantern", true, "Changes as described on store page.");
			cfg_White_BolsterLantern_FIX = ConfigFileUNSORTED.Bind<bool>("White - Fix", "Bolstering Lantern", true, "Fixes not working on enemy.");
			cfg_White_KnockbackFin = ConfigFileUNSORTED.Bind<bool>("White", "Knockback Fin", true, "Buffs as described on store page.");
			cfg_White_KnockbackFin_FIX = ConfigFileUNSORTED.Bind<bool>("White - Fixes", "Knockback Fin", true, "Fixes as described on store page.");
			cfg_White_WarpedEcho = ConfigFileUNSORTED.Bind<bool>("White", "Warped Echo", true, "Buffs as described on store page.");
			cfg_White_WarpedEcho_FIX = ConfigFileUNSORTED.Bind<bool>("White - Fixes", "Warped Echo", true, "Fixes as described on store page.");
			cfg_Green_Beads = ConfigFileUNSORTED.Bind<bool>("Green", "Prayer Beads", true, "Buffs as described on store page.");
			cfg_Green_Beads_FIX = ConfigFileUNSORTED.Bind<bool>("Green - Fixes", "Prayer Beads", true, "Fixes as described on store page.");
			cfg_Green_NoxThorn = ConfigFileUNSORTED.Bind<bool>("Green", "Noxious Thorn", true, "Buffs as described on store page.");
			cfg_Green_NoxThorn_FIX = ConfigFileUNSORTED.Bind<bool>("Green - Fixes", "Noxious Thorn", true, "Fixes as described on store page.");
			cfg_Green_UnstableTrans = ConfigFileUNSORTED.Bind<bool>("Green", "Unstable Transmitter", true, "Buffs as described on store page.");
			cfg_Green_UnstableTrans_FIX = ConfigFileUNSORTED.Bind<bool>("Green - Fixes", "Unstable Transmitter", true, "Fixes as described on store page.");
			cfg_Green_LumShot = ConfigFileUNSORTED.Bind<bool>("Green", "Luminous Shot", true, "Buffs as described on store page.");
			cfg_Green_LumShot_FIX = ConfigFileUNSORTED.Bind<bool>("Green - Fixes", "Luminous Shot", true, "Fixes as described on store page.");
			cfg_Red_WarBonds_FIX = ConfigFileUNSORTED.Bind<bool>("Red - Fixes", "War Bonds", true, "Fix giving 25 less gold than intended.");
			cfg_Red_WarBonds = ConfigFileUNSORTED.Bind<bool>("Red", "War Bonds", true, "Buffs as described on store page. Golden Gun.");
			cfg_Red_Meteor = ConfigFileUNSORTED.Bind<bool>("Red", "Runic Lens", true, "Uncapped as described on store page.");
			cfg_Red_Nectar = ConfigFileUNSORTED.Bind<bool>("Red", "Growth Nectar", true, "Buffs as described on store page.");
			cfg_Red_Nectar_FIX = ConfigFileUNSORTED.Bind<bool>("Red - Fixes", "Growth Nectar", true, "Fixes as described on store page.");
			cfg_Red_Sonch_FIX = ConfigFileUNSORTED.Bind<bool>("Red - Fixes", "Sonorous Whispers", true, "Fix it being 3% at one stack instead of 4% that they said it would be.");
			cfg_Red_Boomerang = ConfigFileUNSORTED.Bind<bool>("Red", "Electric Boomerang", true, "Changes as described on store page.");
			cfg_Elite_Twisted = ConfigFileUNSORTED.Bind<bool>("Elite", "Twisted Elite", true, "Nerfs as described on store page.");
			cfg_Elite_Gilded = ConfigFileUNSORTED.Bind<bool>("Elite", "Gilded Elite", true, "Nerfs as described on store page.");
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.Wolfo.StormItemBuffs", "StormItemBuffs", "1.2.0")]
	public class StormItemBuffs : BaseUnityPlugin
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

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

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

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

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

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

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

			public static Func<DamageInfo, DamageInfo, GameObject, DamageInfo> <>9__7_1;

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

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

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

			public static Func<float, DamageInfo, float> <>9__8_2;

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

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

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

			public static Func<float, HealthComponent, float> <>9__9_2;

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

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

			public static Func<float, HealthComponent, float> <>9__10_1;

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

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

			public static Func<DamageInfo, DamageInfo> <>9__11_1;

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

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

			public static Func<bool, bool> <>9__12_1;

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

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

			public static Func<bool, CharacterBody, bool> <>9__12_4;

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

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

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

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

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

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

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

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

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

			public static Func<EliteRules, bool> <>9__21_1;

			public static Action <>9__21_0;

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

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

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

			public static Func<float, DamageReport, float> <>9__23_0;

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

			public static Func<float, DamageInfo, float> <>9__25_0;

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

			public static Func<DifficultyIndex, DamageInfo, DifficultyIndex> <>9__25_2;

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

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

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

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

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

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

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

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

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

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

			public static Func<float, DamageInfo, float> <>9__29_1;

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

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

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

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

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

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

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

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

			public static Func<CharacterBody, CharacterBody> <>9__34_2;

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

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

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

			public static Func<LightningOrb, DamageInfo, CharacterBody, LightningOrb> <>9__34_6;

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

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

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

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

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

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

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

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

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

			public static Func<CharacterBody, DamageInfo, CharacterBody> <>9__38_5;

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

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

			public static Func<CharacterMotor, float, float> <>9__38_8;

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

			public static Func<float, float> <>9__39_0;

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

			public static StatHookEventHandler <>9__40_0;

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

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

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

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

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

			public static Func<float, HealthComponent, float> <>9__42_2;

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

			public static Func<float, float> <>9__42_4;

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

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

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

			public static Func<int, CharacterBody, int> <>9__44_1;

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

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

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

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

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

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

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

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

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

			public static StatHookEventHandler <>9__48_0;

			public static StatHookEventHandler <>9__49_0;

			public static StatHookEventHandler <>9__50_0;

			internal bool <FixSonchWhisperChance>b__5_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Items", "ResetChest");
			}

			internal bool <FixSonchWhisperChance>b__5_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.CharacterBody", "get_isElite");
			}

			internal bool <FixSonchWhisperChance>b__5_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 2f);
			}

			internal bool <LanternTeamFix>b__6_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.TeamComponent", "get_teamIndex");
			}

			internal bool <LumShot_TryProc>b__7_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdstr(x, "Prefabs/Effects/IncreasePrimaryDamageImpact");
			}

			internal bool <LumShot_TryProc>b__7_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.HealthComponent", "TakeDamage");
			}

			internal DamageInfo <LumShot_TryProc>b__7_1(DamageInfo val, DamageInfo og, GameObject victim)
			{
				og.attacker.GetComponent<CharacterBody>().IncreasePrimaryDamageReset();
				GlobalEventManager.instance.ProcessHitEnemy(val, victim);
				return val;
			}

			internal bool <LUCK_FIN>b__8_3(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Items", "KnockBackHitEnemies");
			}

			internal bool <LUCK_FIN>b__8_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 7.5f);
			}

			internal bool <LUCK_FIN>b__8_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 0f);
			}

			internal float <LUCK_FIN>b__8_2(float val, DamageInfo self)
			{
				if (Object.op_Implicit((Object)(object)self.attacker))
				{
					CharacterBody component = self.attacker.GetComponent<CharacterBody>();
					if (Object.op_Implicit((Object)(object)component) && Object.op_Implicit((Object)(object)component.master))
					{
						return component.master.luck;
					}
					return val;
				}
				return val;
			}

			internal bool <LUCK_ANTLER>b__9_3(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld(x, "RoR2.HealthComponent/ItemCounts", "antlerShield");
			}

			internal bool <LUCK_ANTLER>b__9_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 50f);
			}

			internal bool <LUCK_ANTLER>b__9_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 0f);
			}

			internal float <LUCK_ANTLER>b__9_2(float val, HealthComponent self)
			{
				if (!Object.op_Implicit((Object)(object)self.body) || !Object.op_Implicit((Object)(object)self.body.master))
				{
					return val;
				}
				return self.body.master.luck;
			}

			internal bool <LUCK_NOX>b__10_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.CharacterBody", "TriggerEnemyDebuffs");
			}

			internal bool <LUCK_NOX>b__10_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 0f);
			}

			internal float <LUCK_NOX>b__10_1(float val, HealthComponent self)
			{
				if (!Object.op_Implicit((Object)(object)self.body) || !Object.op_Implicit((Object)(object)self.body.master))
				{
					return val;
				}
				return self.body.master.luck;
			}

			internal bool <Chronic0Proc>b__11_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "LowerHealthHigherDamageBuff");
			}

			internal bool <Chronic0Proc>b__11_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld(x, "RoR2.DamageInfo", "procCoefficient");
			}

			internal DamageInfo <Chronic0Proc>b__11_1(DamageInfo damageInfo)
			{
				CharacterBody component = damageInfo.attacker.GetComponent<CharacterBody>();
				int itemCount = component.inventory.GetItemCount(Items.Seed);
				if (component.inventory.GetItemCount(Items.IncreaseDamageOnMultiKill) > 0)
				{
					component.AddIncreasedDamageMultiKillTime();
				}
				return damageInfo;
			}

			internal bool <GrowthNectarTimerThing>b__12_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "BoostAllStatsBuff");
			}

			internal bool <GrowthNectarTimerThing>b__12_5(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "BoostAllStatsBuff");
			}

			internal bool <GrowthNectarTimerThing>b__12_1(bool numberdy)
			{
				return false;
			}

			internal bool <GrowthNectarTimerThing>b__12_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "BoostAllStatsBuff");
			}

			internal bool <GrowthNectarTimerThing>b__12_3(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "BoostAllStatsBuff");
			}

			internal bool <GrowthNectarTimerThing>b__12_4(bool result, CharacterBody characterBody)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				if (!result)
				{
					EntitySoundManager.EmitSoundServer(NectarSound.index, characterBody.networkIdentity);
					EntitySoundManager.EmitSoundServer(NectarSound.index, characterBody.networkIdentity);
				}
				return false;
			}

			internal bool <ChronicFixNOBUFF>b__14_6(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "IncreaseDamageBuff");
			}

			internal bool <ChronicFixNOBUFF>b__14_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcI4(x, 5);
			}

			internal int <ChronicFixNOBUFF>b__14_1(int val)
			{
				return val + 1;
			}

			internal bool <ChronicFixNOBUFF>b__14_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcI4(x, 1);
			}

			internal bool <ChronicFixNOBUFF>b__14_3(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcI4(x, 1);
			}

			internal bool <ChronicFixNOBUFF>b__14_4(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld(x, "RoR2.CharacterBody", "baseDamage");
			}

			internal float <ChronicFixNOBUFF>b__14_5(float damage, CharacterBody body)
			{
				damage += body.levelDamage * (body.level - 1f);
				return damage;
			}

			internal bool <Chronic4Kill>b__17_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld(x, "RoR2.CharacterBody", "increasedDamageKillTimer");
			}

			internal bool <Chronic4Kill>b__17_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcI4(x, 5);
			}

			internal void <GildedTierFix>b__21_0()
			{
				Debug.LogWarning((object)"Gilded Elite tier 1.5x");
				if (CombatDirector.eliteTiers.Length >= 6)
				{
					CombatDirector.eliteTiers[1].isAvailable = (EliteRules rules) => CombatDirector.NotEliteOnlyArtifactActive() && (int)rules == 0;
					CombatDirector.eliteTiers[3].costMultiplier = 9f;
					CombatDirector.eliteTiers[3].eliteTypes = (EliteDef[])(object)new EliteDef[1] { Elites.Aurelionite };
				}
			}

			internal bool <GildedTierFix>b__21_1(EliteRules rules)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Invalid comparison between Unknown and I4
				return CombatDirector.NotEliteOnlyArtifactActive() && (int)rules == 0;
			}

			internal bool <NoxThornChance>b__22_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.CharacterBody", "TriggerEnemyDebuffs");
			}

			internal bool <NoxThornChance>b__22_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 25f);
			}

			internal bool <EchoNoFuckShieldHard>b__23_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld(x, "RoR2.DamageReport", "damageDealt");
			}

			internal float <EchoNoFuckShieldHard>b__23_0(float value, DamageReport damage)
			{
				if (damage.damageInfo.delayedDamageSecondHalf)
				{
					return -1f;
				}
				return value;
			}

			internal bool <EchoArmorAndE8>b__25_4(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.CharacterBody", "get_armor");
			}

			internal float <EchoArmorAndE8>b__25_0(float value, DamageInfo damage)
			{
				if (damage.delayedDamageSecondHalf)
				{
					return 0f;
				}
				return value;
			}

			internal bool <EchoArmorAndE8>b__25_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.Run", "get_selectedDifficulty");
			}

			internal DifficultyIndex <EchoArmorAndE8>b__25_2(DifficultyIndex value, DamageInfo damage)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				if (damage.delayedDamageSecondHalf)
				{
					return (DifficultyIndex)0;
				}
				return value;
			}

			internal bool <EchoArmorAndE8>b__25_5(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "DelayedDamageBuff");
			}

			internal bool <EchoArmorAndE8>b__25_3(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 0.5f);
			}

			internal bool <LumShotStatsIL>b__27_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.SkillLocator", "get_secondaryBonusStockSkill");
			}

			internal bool <LumShotStatsIL>b__27_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.GenericSkill", "set_cooldownScale");
			}

			internal float <LumShotStatsIL>b__27_1(float number, CharacterBody body)
			{
				if (Object.op_Implicit((Object)(object)body.inventory))
				{
					int itemCount = body.inventory.GetItemCount(Items.IncreasePrimaryDamage);
					if (itemCount > 0)
					{
						number *= 0.85f;
					}
				}
				return number;
			}

			internal bool <NoGoldPerLevel>b__28_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Items", "GoldOnStageStart");
			}

			internal bool <NoGoldPerLevel>b__28_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Items", "GoldOnStageStart");
			}

			internal bool <NoGoldPerLevel>b__28_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 1.5f);
			}

			internal bool <WarBondsDamage>b__29_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.CharacterBody", "get_canPerformBackstab");
			}

			internal bool <WarBondsDamage>b__29_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld(x, "RoR2.DamageInfo", "damage");
			}

			internal float <WarBondsDamage>b__29_1(float flot, DamageInfo damageInfo)
			{
				if (flot > 0f)
				{
					CharacterBody component = damageInfo.attacker.GetComponent<CharacterBody>();
					int buffCount = component.GetBuffCount(WarBondsBuff);
					if (buffCount > 0)
					{
						flot *= 1f + (float)buffCount * 0.03f;
					}
				}
				return flot;
			}

			internal bool <LowerLanternDamage>b__31_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "LowerHealthHigherDamageBuff");
			}

			internal bool <LowerLanternDamage>b__31_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 0.2f);
			}

			internal bool <LanterHealthVal>b__33_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR8(x, 0.5);
			}

			internal bool <LanterHealthVal>b__33_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR8(x, 0.5);
			}

			internal bool <LanterHealthVal>b__33_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR8(x, 0.5);
			}

			internal bool <NerfTwistedElites>b__34_7(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "EliteBeadCorruption");
			}

			internal bool <NerfTwistedElites>b__34_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 0.025f);
			}

			internal bool <NerfTwistedElites>b__34_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.CharacterBody", "get_teamComponent");
			}

			internal CharacterBody <NerfTwistedElites>b__34_2(CharacterBody body)
			{
				body.ClearTimedBuffs(Buffs.EliteBeadCorruption);
				return body;
			}

			internal bool <NerfTwistedElites>b__34_3(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld(x, "RoR2.Orbs.LightningOrb", "procCoefficient");
			}

			internal bool <NerfTwistedElites>b__34_4(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld(x, "RoR2.Orbs.LightningOrb", "range");
			}

			internal bool <NerfTwistedElites>b__34_5(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.Orbs.OrbManager", "AddOrb");
			}

			internal LightningOrb <NerfTwistedElites>b__34_6(LightningOrb orb, DamageInfo damageInfo, CharacterBody characterBody)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				orb.bouncedObjects = new List<HealthComponent>();
				orb.teamIndex = characterBody.teamComponent.teamIndex;
				HurtBox val = orb.PickNextTarget(damageInfo.position);
				if (Object.op_Implicit((Object)(object)val))
				{
					((Orb)orb).target = val;
				}
				else
				{
					((Orb)orb).target = null;
				}
				return orb;
			}

			internal bool <LumShotWorkBetter>b__36_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.CharacterBody", "get_luminousShotReady");
			}

			internal bool <LumShotWorkBetter>b__36_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.GenericSkill", "set_cooldownScale");
			}

			internal float <LumShotWorkBetter>b__36_1(float number, CharacterBody body)
			{
				if (Object.op_Implicit((Object)(object)body.inventory))
				{
					int itemCount = body.inventory.GetItemCount(Items.IncreasePrimaryDamage);
					if (itemCount > 0)
					{
						number *= 0.85f;
					}
				}
				return number;
			}

			internal bool <KnockMeUp>b__38_9(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Items", "KnockBackHitEnemies");
			}

			internal bool <KnockMeUp>b__38_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.CharacterBody", "get_isBoss");
			}

			internal bool <KnockMeUp>b__38_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld(x, "RoR2.CharacterBody", "isChampion");
			}

			internal bool <KnockMeUp>b__38_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 7.5f);
			}

			internal bool <KnockMeUp>b__38_3(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "KnockUpHitEnemies");
			}

			internal bool <KnockMeUp>b__38_4(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "KnockUpHitEnemies");
			}

			internal CharacterBody <KnockMeUp>b__38_5(CharacterBody characterBody, DamageInfo damageInfo)
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Expected O, but got Unknown
				float damage = Util.OnHitProcDamage(damageInfo.damage, 0f, KnockbackFinDamage);
				DamageInfo val = new DamageInfo
				{
					damage = damage,
					damageColorIndex = (DamageColorIndex)3,
					damageType = DamageTypeCombo.op_Implicit((DamageType)0),
					attacker = damageInfo.attacker,
					crit = damageInfo.crit,
					force = Vector3.zero,
					inflictor = null,
					position = damageInfo.position,
					procCoefficient = 0f
				};
				characterBody.healthComponent.TakeDamage(val);
				return characterBody;
			}

			internal bool <KnockMeUp>b__38_6(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 5f);
			}

			internal bool <KnockMeUp>b__38_7(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld(x, "RoR2.CharacterMotor", "mass");
			}

			internal float <KnockMeUp>b__38_8(CharacterMotor motor, float mass)
			{
				if (motor.body.isChampion && motor.body.isBoss)
				{
					return motor.mass * mass * 0.1f;
				}
				if (motor.body.isChampion)
				{
					return motor.mass * mass * 0.4f;
				}
				return motor.mass * mass;
			}

			internal bool <BetterUnstableTransmitter>b__39_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 3.5f);
			}

			internal float <BetterUnstableTransmitter>b__39_0(float mass)
			{
				return mass + 4f;
			}

			internal bool <BetterUnstableTransmitter>b__39_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 25f);
			}

			internal void <LumShotStats>b__40_0(CharacterBody body, StatHookEventArgs args)
			{
				if (!((Object)(object)body.inventory != (Object)null))
				{
					return;
				}
				int itemCount = body.inventory.GetItemCount(Items.IncreasePrimaryDamage);
				if (itemCount > 0)
				{
					float num = Mathf.Pow(0.85f, (float)itemCount);
					args.secondaryCooldownMultAdd += num;
					if (Object.op_Implicit((Object)(object)body.skillLocator.secondaryBonusStockSkill))
					{
						GenericSkill secondaryBonusStockSkill = body.skillLocator.secondaryBonusStockSkill;
						secondaryBonusStockSkill.cooldownScale *= num;
					}
				}
			}

			internal bool <NoMoreBuffMaxIncrease>b__41_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcI4(x, 4);
			}

			internal int <NoMoreBuffMaxIncrease>b__41_0(int number)
			{
				return 5;
			}

			internal bool <BetterAntlerReflect>b__42_6(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld(x, "RoR2.HealthComponent/ItemCounts", "antlerShield");
			}

			internal bool <BetterAntlerReflect>b__42_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 50f);
			}

			internal bool <BetterAntlerReflect>b__42_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 10f);
			}

			internal float <BetterAntlerReflect>b__42_2(float damage, HealthComponent healthComponent)
			{
				float num = (float)healthComponent.itemCounts.antlerShield * 4f + 4f;
				if (damage > healthComponent.body.damage * num)
				{
					damage = healthComponent.body.damage * num;
				}
				return damage;
			}

			internal bool <BetterAntlerReflect>b__42_3(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld(x, "RoR2.HealthComponent/ItemCounts", "antlerShield");
			}

			internal float <BetterAntlerReflect>b__42_4(float itemCount)
			{
				return 1f;
			}

			internal bool <BetterAntlerReflect>b__42_5(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 0.3f);
			}

			internal bool <MoreGrowthNectarCanditates>b__44_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "BoostAllStatsBuff");
			}

			internal bool <MoreGrowthNectarCanditates>b__44_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "BoostAllStatsBuff");
			}

			internal int <MoreGrowthNectarCanditates>b__44_1(int number, CharacterBody body)
			{
				if (Object.op_Implicit((Object)(object)body.inventory))
				{
					if (body.inventory.GetItemCount(Items.HealWhileSafe) > 0 && body.outOfDanger)
					{
						number++;
					}
					if (body.inventory.GetItemCount(Items.SprintArmor) > 0 && body.isSprinting)
					{
						number++;
					}
					if (Object.op_Implicit((Object)(object)((Component)body).GetComponent<IcicleBodyBehavior>()) && ((Component)body).GetComponent<IcicleBodyBehavior>().icicleAura.icicleLifetimes.Count > 0)
					{
						number++;
					}
				}
				return number;
			}

			internal bool <UncapMeteor>b__45_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Items", "MeteorAttackOnHighDamage");
			}

			internal bool <UncapMeteor>b__45_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 50f);
			}

			internal bool <UncapMeteor>b__45_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 75f);
			}

			internal bool <ChronicExpansionFixBuff>b__46_5(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "IncreaseDamageBuff");
			}

			internal bool <ChronicExpansionFixBuff>b__46_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcI4(x, 2);
			}

			internal bool <ChronicExpansionFixBuff>b__46_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 0.01f);
			}

			internal float <ChronicExpansionFixBuff>b__46_2(float damage, CharacterBody body)
			{
				float num = body.inventory.GetItemCount(Items.IncreaseDamageOnMultiKill);
				float num2 = body.GetBuffCount(Buffs.IncreaseDamageBuff);
				int num3 = (int)num + 2;
				return ((0.1f + num * 0.2f) / (float)num3 + (float)num3 * 0.01f - num2 * 0.01f) * num2;
			}

			internal bool <ChronicExpansionFixBuff>b__46_3(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld(x, "RoR2.CharacterBody", "baseDamage");
			}

			internal float <ChronicExpansionFixBuff>b__46_4(float damage, CharacterBody body)
			{
				damage += body.levelDamage * (body.level - 1f);
				return damage;
			}

			internal void <LanternSpeed>b__48_0(CharacterBody sender, StatHookEventArgs args)
			{
				if ((Object)(object)sender.inventory != (Object)null && sender.HasBuff(Buffs.LowerHealthHigherDamageBuff))
				{
					args.moveSpeedMultAdd += (float)sender.inventory.GetItemCount(Items.LowerHealthHigherDamage) * 0.2f;
				}
			}

			internal void <AntlerArmor>b__49_0(CharacterBody sender, StatHookEventArgs args)
			{
				if ((Object)(object)sender.inventory != (Object)null)
				{
					args.armorAdd += (float)sender.inventory.GetItemCount(Items.NegateAttack) * 6f;
				}
			}

			internal void <WarBondsStats>b__50_0(CharacterBody sender, StatHookEventArgs args)
			{
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)sender.inventory != (Object)null))
				{
					return;
				}
				int itemCount = sender.inventory.GetItemCount(Items.GoldOnStageStart);
				if (itemCount > 0 && Object.op_Implicit((Object)(object)Stage.instance))
				{
					int num = 400;
					int num2 = (int)(sender.master.money * 10 / Run.instance.GetDifficultyScaledCost(num, Stage.instance.entryDifficultyCoefficient));
					if (num2 > 10)
					{
						num2 = 10;
					}
					sender.SetBuffCount(WarBondsBuff.buffIndex, num2);
					args.moveSpeedMultAdd += 0.04f * (float)num2;
					args.attackSpeedMultAdd += 0.03f * (float)num2;
				}
				else
				{
					sender.SetBuffCount(WarBondsBuff.buffIndex, 0);
				}
			}
		}

		public static BuffDef WarBondsBuff = Addressables.LoadAssetAsync<BuffDef>((object)"RoR2/DLC2/Child/bdChildFrolicCooldown.asset").WaitForCompletion();

		public static NetworkSoundEventDef NectarSound = Addressables.LoadAssetAsync<NetworkSoundEventDef>((object)"RoR2/DLC2/nseBoostAllStats.asset").WaitForCompletion();

		public static float KnockbackFinDamage = 0.8f;

		public static float KnockbackFinCooldown = 0.5f;

		public void Awake()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Expected O, but got Unknown
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Expected O, but got Unknown
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Expected O, but got Unknown
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Expected O, but got Unknown
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Expected O, but got Unknown
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Expected O, but got Unknown
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Expected O, but got Unknown
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Expected O, but got Unknown
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Expected O, but got Unknown
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Expected O, but got Unknown
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Expected O, but got Unknown
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_039a: Expected O, but got Unknown
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Expected O, but got Unknown
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Expected O, but got Unknown
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0409: Expected O, but got Unknown
			//IL_03db: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e5: Expected O, but got Unknown
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bd: Expected O, but got Unknown
			//IL_0471: Unknown result type (might be due to invalid IL or missing references)
			//IL_047b: Expected O, but got Unknown
			//IL_0483: Unknown result type (might be due to invalid IL or missing references)
			//IL_048d: Expected O, but got Unknown
			//IL_0493: Unknown result type (might be due to invalid IL or missing references)
			//IL_0498: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0422: Unknown result type (might be due to invalid IL or missing references)
			//IL_042c: Expected O, but got Unknown
			//IL_0434: Unknown result type (might be due to invalid IL or missing references)
			//IL_043e: Expected O, but got Unknown
			//IL_054d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0557: Expected O, but got Unknown
			//IL_0513: Unknown result type (might be due to invalid IL or missing references)
			//IL_051d: Expected O, but got Unknown
			//IL_0598: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a2: Expected O, but got Unknown
			//IL_05d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05de: Expected O, but got Unknown
			//IL_0769: Unknown result type (might be due to invalid IL or missing references)
			//IL_076e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0782: Unknown result type (might be due to invalid IL or missing references)
			//IL_0787: Unknown result type (might be due to invalid IL or missing references)
			//IL_079b: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_07cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_07eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0604: Expected O, but got Unknown
			//IL_0618: Unknown result type (might be due to invalid IL or missing references)
			//IL_061f: Expected O, but got Unknown
			//IL_064c: Unknown result type (might be due to invalid IL or missing references)
			//IL_065b: Unknown result type (might be due to invalid IL or missing references)
			//IL_068c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0691: Unknown result type (might be due to invalid IL or missing references)
			//IL_0696: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_085f: Unknown result type (might be due to invalid IL or missing references)
			//IL_086b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0875: Expected O, but got Unknown
			//IL_0825: Unknown result type (might be due to invalid IL or missing references)
			//IL_082f: Expected O, but got Unknown
			//IL_0812: Unknown result type (might be due to invalid IL or missing references)
			//IL_081c: Expected O, but got Unknown
			//IL_088f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0899: Expected O, but got Unknown
			//IL_08c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d2: Expected O, but got Unknown
			//IL_08d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_08dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0971: Unknown result type (might be due to invalid IL or missing references)
			//IL_0972: Unknown result type (might be due to invalid IL or missing references)
			//IL_097c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0981: Unknown result type (might be due to invalid IL or missing references)
			//IL_098f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0990: Unknown result type (might be due to invalid IL or missing references)
			//IL_099a: Unknown result type (might be due to invalid IL or missing references)
			//IL_099f: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_09b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_09bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0917: Unknown result type (might be due to invalid IL or missing references)
			//IL_091c: Unknown result type (might be due to invalid IL or missing references)
			BurnEffectController.HandleDestroy += new hook_HandleDestroy(BurnEffectController_HandleDestroy);
			WConfig.InitConfig();
			if (WConfig.cfg_White_WarpedEcho_FIX.Value)
			{
				HealthComponent.TriggerOneShotProtection += new hook_TriggerOneShotProtection(EchoOSP);
				HealthComponent.TakeDamageProcess += new Manipulator(EchoArmorAndE8);
				if (WConfig.cfg_White_WarpedEcho.Value)
				{
					CharacterBody.SecondHalfOfDelayedDamage += new hook_SecondHalfOfDelayedDamage(EchoNoBypass);
					CharacterBody.OnTakeDamageServer += new Manipulator(EchoNoFuckShieldHard);
					Texture2D val = new Texture2D(128, 128, (TextureFormat)12, false);
					ImageConversion.LoadImage(val, Resources.texBuffDelayedDamageOnIcon, true);
					((Texture)val).filterMode = (FilterMode)1;
					Sprite iconSprite = Sprite.Create(val, new Rect(0f, 0f, 128f, 128f), new Vector2(0.5f, 0.5f));
					BuffDef val2 = Addressables.LoadAssetAsync<BuffDef>((object)"RoR2/DLC2/Items/DelayedDamage/bdDelayedDamageDebuff.asset").WaitForCompletion();
					val2.isHidden = false;
					val2.canStack = true;
					val2.iconSprite = iconSprite;
				}
			}
			if (WConfig.cfg_White_BolsterLantern_FIX.Value)
			{
				CharacterBody.UpdateLowerHealthHigherDamage += new Manipulator(LanternTeamFix);
				if (WConfig.cfg_White_BolsterLantern.Value)
				{
					if (WConfig.cfg_White_Chronic_SPEED.Value)
					{
						LanternSpeed();
						HealthComponent.TakeDamageProcess += new Manipulator(LowerLanternDamage);
						LanguageAPI.Add("ITEM_LOWERHEALTHHIGHERDAMAGE_PICKUP", "Bonus speed when hurt.", "en");
						LanguageAPI.Add("ITEM_LOWERHEALTHHIGHERDAMAGE_DESC", "When below <style=cIsHealth>90% health</style> increase movement speed by <style=cIsUtility>20%</style> <style=cStack>(+20% per stack)</style>.", "en");
					}
					else
					{
						LanguageAPI.Add("ITEM_LOWERHEALTHHIGHERDAMAGE_DESC", "When below <style=cIsHealth>90% health</style> receive a damage increase of <style=cIsDamage>20%</style> <style=cStack>(+20% damage bonus per item stack)</style>.", "en");
					}
					CharacterBody.UpdateLowerHealthHigherDamage += new Manipulator(LanterHealthVal);
				}
			}
			if (WConfig.cfg_White_Antler_FIX.Value)
			{
				if (WConfig.cfg_White_Antler.Value)
				{
					AntlerArmor();
					HealthComponent.TakeDamageProcess += new Manipulator(BetterAntlerReflect);
					LanguageAPI.Add("ITEM_NEGATEATTACK_PICKUP", "Reduces incoming damage a little and reflects it.", "en");
					LanguageAPI.Add("ITEM_NEGATEATTACK_DESC", "<style=cIsHealing>Increase armor</style> by <style=cIsHealing>6</style> <style=cStack>(+6 per stack)</style>. Getting hit reflects <style=cIsUtility>100%</style> damage, limited to <style=cIsUtility>800%</style> <style=cStack>(+800% per stack)</style> of your damage, back to the attacker.", "en");
				}
				else
				{
					HealthComponent.TakeDamageProcess += new Manipulator(LUCK_ANTLER);
				}
			}
			if (WConfig.cfg_White_Chronic_FIX.Value)
			{
				HealthComponent.TakeDamageProcess += new Manipulator(Chronic0Proc);
				if (WConfig.cfg_White_Chronic.Value)
				{
					CharacterBody.RecalculateStats += new Manipulator(ChronicExpansionFixBuff);
					CharacterBody.AddMultiKill += new hook_AddMultiKill(CapChronic);
					CharacterBody.AddMultiKill += new Manipulator(Chronic4Kill);
					CharacterBody.AddIncreasedDamageMultiKillTime += new hook_AddIncreasedDamageMultiKillTime(ChronicDuration);
					LanguageAPI.Add("ITEM_INCREASEDAMAGEONMULTIKILL_DESC", "Killing <style=cIsDamage>4</style> enemies grants a <style=cIsDamage>stacking damage buff</style>, increasing damage by <style=cIsDamage>10%</style> <style=cStack>(+2.5% per stack)</style> up to a maximimum of <style=cIsDamage>3</style> <style=cStack>(+1 per stack)</style> buffs or <style=cIsDamage>30%</style> <style=cStack>(+20% per stack)</style> damage. <style=cIsDamage>Resets</style> when outside of combat for 7s.", "en");
				}
				else
				{
					CharacterBody.RecalculateStats += new Manipulator(ChronicFixNOBUFF);
				}
			}
			if (WConfig.cfg_White_KnockbackFin_FIX.Value)
			{
				GlobalEventManager.ProcessHitEnemy += new Manipulator(LUCK_FIN);
				if (WConfig.cfg_White_KnockbackFin.Value)
				{
					GlobalEventManager.ProcessHitEnemy += new Manipulator(KnockMeUp);
					GlobalEventManager.ProcessHitEnemy += new hook_ProcessHitEnemy(KnockMeDown);
					Addressables.LoadAssetAsync<BuffDef>((object)"RoR2/DLC2/Items/KnockBackHitEnemies/bdKnockDownHitEnemies.asset").WaitForCompletion().isHidden = true;
					LanguageAPI.Add("ITEM_KNOCKBACKHITENEMIES_DESC", "<style=cIsUtility>10%</style> <style=cStack>(+10% per stack)</style> chance on hit to knock enemies into or out of the air dealing <style=cIsDamage>80%</style> TOTAL damage. <style=cStack>(Height increases per stack)</style>.", "en");
				}
			}
			if (WConfig.cfg_Green_NoxThorn_FIX.Value)
			{
				HealthComponent.TakeDamageProcess += new Manipulator(LUCK_NOX);
				if (WConfig.cfg_Green_NoxThorn.Value)
				{
					HealthComponent.TakeDamageProcess += new Manipulator(NoxThornChance);
					LanguageAPI.Add("ITEM_TRIGGERENEMYDEBUFFS_DESC", "<style=cIsDamage>37.5%</style> chance on getting hit to inflict <style=cIsDamage>2</style> <style=cStack>(+1 per stack)</style> stack of <style=cIsDamage>bleed</style> and <style=cIsDamage>2</style> <style=cStack>(+1 per stack)</style> of every other <style=cIsUtility>present stackable debuff</style> to every enemy in a <style=cIsDamage>30m</style> radius.", "en");
				}
				CharacterBody.TriggerEnemyDebuffs += new hook_TriggerEnemyDebuffs(NoxiousThornFix);
			}
			if (WConfig.cfg_Green_LumShot_FIX.Value)
			{
				CharacterBody.AddIncreasePrimaryDamageStack += new hook_AddIncreasePrimaryDamageStack(FixLumShotWrongDamageStat);
				if (WConfig.cfg_Green_LumShot.Value)
				{
					CharacterBody.AddIncreasePrimaryDamageStack += new Manipulator(NoMoreBuffMaxIncrease);
					GlobalEventManager.ProcessHitEnemy += new Manipulator(LumShot_TryProc);
					LanguageAPI.Add("ITEM_INCREASEPRIMARYDAMAGE_DESC", "Using the secondary skill <style=cIsDamage>charges</style> the next primary attack with <style=cIsDamage>+80%</style> <style=cStack>(+80% per stack)</style> damage <style=cIsDamage>per second of secondary cooldown</style> up to <style=cIsDamage>5</style> times.", "en");
				}
			}
			if (WConfig.cfg_Green_UnstableTrans_FIX.Value)
			{
				HealthComponent.UpdateLastHitTime += new hook_UpdateLastHitTime(TransmitterBeforeElixir);
				CharacterBody.RpcTeleportCharacterToSafety += new hook_RpcTeleportCharacterToSafety(TransmitterSFX);
				GameObject val3 = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC2/Items/TeleportOnLowHealth/PickupTeleportOnLowHealth.prefab").WaitForCompletion();
				((Component)val3.transform.GetChild(0)).transform.localPosition = new Vector3(0f, -0.1f, 0f);
				((Component)val3.transform.GetChild(1)).transform.localPosition = new Vector3(0f, -0.1f, 0f);
				if (WConfig.cfg_Green_Beads.Value)
				{
					CharacterBody.RpcTeleportCharacterToSafety += new Manipulator(BetterUnstableTransmitter);
					LanguageAPI.Add("ITEM_TELEPORTONLOWHEALTH_DESC", "Falling below <style=cIsHealth>25% health</style> causes you to explode, dealing <style=cIsDamage>3500%</style> <style=cStack>(+700% per stack)</style> damage and teleports you to safety. This effect recharges after <style=cIsUtility>2</style> minutes <style=cStack>(-20% per stack)</style>.", "en");
				}
			}
			if (WConfig.cfg_Green_Beads_FIX.Value)
			{
				CharacterBody.prayerBeadCalculateAppliedStats += new hook_prayerBeadCalculateAppliedStats(FixBreadBeadsInvasive);
				if (WConfig.cfg_Green_Beads.Value)
				{
					LanguageAPI.Add("ITEM_EXTRASTATSONLEVELUP_DESC", "Store an extra <style=cIsUtility>20%</style> <style=cStack>(+5% per stack)</style> of experience gained. Upon removal, increases <style=cIsHealing>max health</style>, <style=cIsHealing>regen</style>, and <style=cIsDamage>damage</style> by <style=cIsUtility>20%</style> <style=cStack>(+10% per stack)</style> of your <style=cIsUtility>leveling stats</style> based on stored experience.", "en");
				}
			}
			if (WConfig.cfg_Red_Meteor.Value)
			{
				GlobalEventManager.ProcessHitEnemy += new Manipulator(UncapMeteor);
				LanguageAPI.Add("ITEM_METEORATTACKONHIGHDAMAGE_DESC", "On hit, <style=cIsDamage>5%</style> base chance <style=cIsDamage>+1%</style><style=cStack> (+1% per stack)</style> per 100% damage done chance, to summon a meteor on the target, dealing <style=cIsDamage>2000%</style> base damage <style=cIsDamage>+50%</style><style=cStack> (+50% per stack)</style> TOTAL damage.", "en");
			}
			if (WConfig.cfg_Red_WarBonds_FIX.Value)
			{
				CharacterBody.Start += new hook_Start(FixWarBonds);
				if (WConfig.cfg_Red_WarBonds.Value)
				{
					CharacterBody.Start += new Manipulator(NoGoldPerLevel);
					WarBondsStats();
					Texture2D val4 = new Texture2D(128, 128, (TextureFormat)12, false);
					ImageConversion.LoadImage(val4, Resources.WarBondsBuff, true);
					((Texture)val4).filterMode = (FilterMode)1;
					Sprite iconSprite2 = Sprite.Create(val4, new Rect(0f, 0f, 128f, 128f), new Vector2(0.5f, 0.5f));
					WarBondsBuff.iconSprite = iconSprite2;
					WarBondsBuff.buffColor = Color32.op_Implicit(new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue));
					WarBondsBuff.isDebuff = false;
					WarBondsBuff.isCooldown = false;
					WarBondsBuff.isHidden = false;
					WarBondsBuff.canStack = true;
					WarBondsBuff.ignoreGrowthNectar = false;
					GameObject val5 = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC2/Items/GoldOnStageStart/PickupTreasuryDividends.prefab").WaitForCompletion();
					Material val6 = Addressables.LoadAssetAsync<Material>((object)"RoR2/DLC2/Items/GoldOnStageStart/matGoldOnStageStartMetal.mat").WaitForCompletion();
					((Renderer)((Component)val5.transform.GetChild(0)).GetComponent<MeshRenderer>()).materials = (Material[])(object)new Material[2] { val6, val6 };
					LanguageAPI.Add("ITEM_GOLDONSTAGESTART_PICKUP", "Increase attack and movement speed based on gold. Gain gold on stage start.", "en");
					LanguageAPI.Add("ITEM_GOLDONSTAGESTART_DESC", "Gain upwards of a <style=cIsDamage>30% attack speed</style> and <style=cIsUtility>40% movement speed</style> boost based on current gold, capping at <style=cIsUtility>400 gold</style>. Gain <style=cIsUtility>120 <style=cStack>(+80 per stack)</style> gold</style> at the start of every stage. <style=cIsUtility>Scale with Time</style>", "en");
				}
			}
			if (WConfig.cfg_Red_Nectar_FIX.Value)
			{
				Addressables.LoadAssetAsync<BuffDef>((object)"RoR2/Base/ElementalRings/bdElementalRingsReady.asset").WaitForCompletion().ignoreGrowthNectar = false;
				Addressables.LoadAssetAsync<BuffDef>((object)"RoR2/DLC1/ElementalRingVoid/bdElementalRingVoidReady.asset").WaitForCompletion().ignoreGrowthNectar = false;
				Addressables.LoadAssetAsync<BuffDef>((object)"RoR2/DLC1/BearVoid/bdBearVoidReady.asset").WaitForCompletion().ignoreGrowthNectar = false;
				Addressables.LoadAssetAsync<BuffDef>((object)"RoR2/DLC1/ImmuneToDebuff/bdImmuneToDebuffReady.asset").WaitForCompletion().ignoreGrowthNectar = false;
				Addressables.LoadAssetAsync<BuffDef>((object)"RoR2/Base/EliteHaunted/bdEliteHaunted.asset").WaitForCompletion().ignoreGrowthNectar = false;
				Addressables.LoadAssetAsync<BuffDef>((object)"RoR2/DLC2/bdBoostAllStatsBuff.asset").WaitForCompletion().startSfx = null;
				if (WConfig.cfg_Red_Nectar.Value)
				{
					CharacterBody.RecalculateStats += new Manipulator(MoreGrowthNectarCanditates);
				}
				CharacterBody.RecalculateStats += new Manipulator(GrowthNectarTimerThing);
			}
			if (WConfig.cfg_Red_Boomerang.Value)
			{
				GameObject val7 = LegacyResourcesAPI.Load<GameObject>("Prefabs/Projectiles/StunAndPierceBoomerang");
				val7.GetComponent<ProjectileDamage>().damageType.damageType = (DamageType)16777216;
				SetStateOnHurt.SetShockInternal += new hook_SetShockInternal(SetStateOnHurt_SetShockInternal);
			}
			if (WConfig.cfg_Red_Sonch_FIX.Value)
			{
				GlobalEventManager.OnCharacterDeath += new Manipulator(FixSonchWhisperChance);
				LanguageAPI.Add("ITEM_RESETCHESTS_DESC", "When a champion monster is killed it will always drop an item. All elites have a <style=cIsUtility>4%</style><style=cStack> (+1% per stack)</style> chance of dropping an item.", "en");
			}
			if (WConfig.cfg_Elite_Twisted.Value)
			{
				GlobalEventManager.ProcessHitEnemy += new Manipulator(NerfTwistedElites);
				EliteDef val8 = Addressables.LoadAssetAsync<EliteDef>((object)"RoR2/DLC2/Elites/EliteBead/edBead.asset").WaitForCompletion();
				val8.healthBoostCoefficient = 18f;
				val8.damageBoostCoefficient = 7f;
			}
			if (WConfig.cfg_Elite_Gilded.Value)
			{
				Addressables.LoadAssetAsync<EliteDef>((object)"RoR2/DLC2/Elites/EliteAurelionite/edAurelionite.asset").WaitForCompletion().healthBoostCoefficient = 4f;
			}
			((ResourceAvailability)(ref GameModeCatalog.availability)).CallWhenAvailable((Action)LateRunningMethod);
			Color colorShrineRewardJackpot = default(Color);
			((Color)(ref colorShrineRewardJackpot))..ctor(0.3f, 1f, 0.1f, 1f);
			LegacyResourcesAPI.Load<GameObject>("Prefabs/networkedobjects/shrines/ShrineChance").GetComponent<ShrineChanceBehavior>().colorShrineRewardJackpot = colorShrineRewardJackpot;
			Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/ShrineChance/ShrineChanceSandy Variant.prefab").WaitForCompletion().GetComponent<ShrineChanceBehavior>()
				.colorShrineRewardJackpot = colorShrineRewardJackpot;
			Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/ShrineChance/ShrineChanceSnowy Variant.prefab").WaitForCompletion().GetComponent<ShrineChanceBehavior>()
				.colorShrineRewardJackpot = colorShrineRewardJackpot;
			((Component)Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC2/Items/IncreasePrimaryDamage/IncreasePrimaryDamageImpact.prefab").WaitForCompletion().transform.GetChild(0)).GetComponent<Light>().color = new Color(1f, 1f, 0f, 1f);
		}

		private void FixSonchWhisperChance(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Items", "ResetChest")
			});
			val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.CharacterBody", "get_isElite")
			});
			if (val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 2f)
			}))
			{
				val.Next.OpCode = OpCodes.Ldc_R4;
				val.Next.Operand = 3;
			}
			else
			{
				Debug.LogWarning((object)"IL Failed: FixSonchWhisperChance");
			}
		}

		private void LanternTeamFix(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.TeamComponent", "get_teamIndex")
			}))
			{
				val.Index -= 2;
				val.RemoveRange(5);
			}
			else
			{
				Debug.LogWarning((object)"IL Failed: Lantern LanternTeamFix");
			}
		}

		private void LumShot_TryProc(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val2 = new ILCursor(il);
			val2.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdstr(x, "Prefabs/Effects/IncreasePrimaryDamageImpact")
			});
			if (val2.TryGotoPrev((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.HealthComponent", "TakeDamage")
			}))
			{
				val2.Emit(OpCodes.Ldarg_1);
				val2.Emit(OpCodes.Ldarg_2);
				val2.EmitDelegate<Func<DamageInfo, DamageInfo, GameObject, DamageInfo>>((Func<DamageInfo, DamageInfo, GameObject, DamageInfo>)delegate(DamageInfo val, DamageInfo og, GameObject victim)
				{
					og.attacker.GetComponent<CharacterBody>().IncreasePrimaryDamageReset();
					GlobalEventManager.instance.ProcessHitEnemy(val, victim);
					return val;
				});
			}
			else
			{
				Debug.LogWarning((object)"IL Failed: LumShot_TryProc");
			}
		}

		private void LUCK_FIN(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val2 = new ILCursor(il);
			if (val2.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Items", "KnockBackHitEnemies")
			}))
			{
				val2.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 7.5f)
				});
				val2.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 0f)
				});
				val2.Emit(OpCodes.Ldarg_1);
				val2.EmitDelegate<Func<float, DamageInfo, float>>((Func<float, DamageInfo, float>)delegate(float val, DamageInfo self)
				{
					if (Object.op_Implicit((Object)(object)self.attacker))
					{
						CharacterBody component = self.attacker.GetComponent<CharacterBody>();
						if (Object.op_Implicit((Object)(object)component) && Object.op_Implicit((Object)(object)component.master))
						{
							return component.master.luck;
						}
						return val;
					}
					return val;
				});
			}
			else
			{
				Debug.LogWarning((object)"IL Failed: Knockback Fin");
			}
		}

		private void LUCK_ANTLER(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val2 = new ILCursor(il);
			if (val2.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdfld(x, "RoR2.HealthComponent/ItemCounts", "antlerShield")
			}))
			{
				val2.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 50f)
				});
				val2.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 0f)
				});
				val2.Emit(OpCodes.Ldarg_0);
				val2.EmitDelegate<Func<float, HealthComponent, float>>((Func<float, HealthComponent, float>)((float val, HealthComponent self) => (!Object.op_Implicit((Object)(object)self.body) || !Object.op_Implicit((Object)(object)self.body.master)) ? val : self.body.master.luck));
			}
			else
			{
				Debug.LogWarning((object)"IL Failed: LUCK ANTLER Chance");
			}
		}

		private void LUCK_NOX(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val2 = new ILCursor(il);
			if (val2.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.CharacterBody", "TriggerEnemyDebuffs")
			}))
			{
				val2.TryGotoPrev((MoveType)2, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 0f)
				});
				val2.Emit(OpCodes.Ldarg_0);
				val2.EmitDelegate<Func<float, HealthComponent, float>>((Func<float, HealthComponent, float>)((float val, HealthComponent self) => (!Object.op_Implicit((Object)(object)self.body) || !Object.op_Implicit((Object)(object)self.body.master)) ? val : self.body.master.luck));
			}
			else
			{
				Debug.LogWarning((object)"IL Failed: LUCK Nox Chance");
			}
		}

		private void Chronic0Proc(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			ILCursor val = new ILCursor(il);
			val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "LowerHealthHigherDamageBuff")
			});
			if (val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdfld(x, "RoR2.DamageInfo", "procCoefficient")
			}))
			{
				val.EmitDelegate<Func<DamageInfo, DamageInfo>>((Func<DamageInfo, DamageInfo>)delegate(DamageInfo damageInfo)
				{
					CharacterBody component = damageInfo.attacker.GetComponent<CharacterBody>();
					int itemCount = component.inventory.GetItemCount(Items.Seed);
					if (component.inventory.GetItemCount(Items.IncreaseDamageOnMultiKill) > 0)
					{
						component.AddIncreasedDamageMultiKillTime();
					}
					return damageInfo;
				});
			}
			else
			{
				Debug.LogWarning((object)"IL Failed: Leeching Seed");
			}
		}

		private void GrowthNectarTimerThing(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "BoostAllStatsBuff")
			});
			if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "BoostAllStatsBuff")
			}))
			{
				int index = val.Index;
				val.Index = index + 1;
				val.EmitDelegate<Func<bool, bool>>((Func<bool, bool>)((bool numberdy) => false));
				val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "BoostAllStatsBuff")
				});
				val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "BoostAllStatsBuff")
				});
				index = val.Index;
				val.Index = index + 1;
				val.Emit(OpCodes.Ldarg_0);
				val.EmitDelegate<Func<bool, CharacterBody, bool>>((Func<bool, CharacterBody, bool>)delegate(bool result, CharacterBody characterBody)
				{
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0025: Unknown result type (might be due to invalid IL or missing references)
					if (!result)
					{
						EntitySoundManager.EmitSoundServer(NectarSound.index, characterBody.networkIdentity);
						EntitySoundManager.EmitSoundServer(NectarSound.index, characterBody.networkIdentity);
					}
					return false;
				});
			}
			else
			{
				Debug.LogWarning((object)"IL Failed: Growth Nectar");
			}
		}

		private void TransmitterSFX(orig_RpcTeleportCharacterToSafety orig, CharacterBody self)
		{
			orig.Invoke(self);
			Util.PlaySound("Play_imp_attack_blink", ((Component)self).gameObject);
			Util.PlaySound("Play_imp_attack_blink", ((Component)self).gameObject);
			Util.PlaySound("Play_imp_attack_blink", ((Component)self).gameObject);
		}

		private void ChronicFixNOBUFF(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val2 = new ILCursor(il);
			if (val2.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "IncreaseDamageBuff")
			}))
			{
				val2.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 5)
				});
				val2.EmitDelegate<Func<int, int>>((Func<int, int>)((int val) => val + 1));
				val2.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 1)
				});
				val2.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 1)
				});
				val2.Next.OpCode = OpCodes.Ldc_I4;
				val2.Next.Operand = 5;
				val2.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdfld(x, "RoR2.CharacterBody", "baseDamage")
				});
				val2.Emit(OpCodes.Ldarg_0);
				val2.EmitDelegate<Func<float, CharacterBody, float>>((Func<float, CharacterBody, float>)delegate(float damage, CharacterBody body)
				{
					damage += body.levelDamage * (body.level - 1f);
					return damage;
				});
			}
			else
			{
				Debug.LogWarning((object)"IL Failed: Chronic F");
			}
		}

		private void FixLumShotWrongDamageStat(orig_AddIncreasePrimaryDamageStack orig, CharacterBody self)
		{
			orig.Invoke(self);
			int buffCount = self.GetBuffCount(Buffs.IncreasePrimaryDamageBuff);
			int itemCount = self.inventory.GetItemCount(Items.IncreasePrimaryDamage);
			if (WConfig.cfg_Green_LumShot.Value)
			{
				if (Object.op_Implicit((Object)(object)self.skillLocator.secondaryBonusStockSkill))
				{
					float num = self.skillLocator.secondaryBonusStockSkill.baseRechargeInterval;
					if (num < 1f)
					{
						num = 1f;
					}
					self.luminousShotDamage = self.damage * (0.8f * num * (float)itemCount) * (float)buffCount;
				}
			}
			else
			{
				self.luminousShotDamage = self.damage * (1.25f + 0.25f * (float)itemCount) * (float)buffCount;
			}
		}

		private void ChronicDuration(orig_AddIncreasedDamageMultiKillTime orig, CharacterBody self)
		{
			orig.Invoke(self);
			self.increasedDamageKillTimer = 7f;
		}

		private void Chronic4Kill(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchStfld(x, "RoR2.CharacterBody", "increasedDamageKillTimer")
			}))
			{
				val.Prev.Operand = 7f;
				val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 5)
				});
				val.Next.OpCode = OpCodes.Ldc_I4_4;
			}
			else
			{
				Debug.LogWarning((object)"IL Failed: Chronic kills");
			}
		}

		public static void LateRunningMethod()
		{
			if (WConfig.cfg_White_KnockbackFin.Value)
			{
				Items.KnockBackHitEnemies.tags = Items.KnockBackHitEnemies.tags.Add((ItemTag)1);
			}
			if (WConfig.cfg_White_BolsterLantern.Value)
			{
				Items.LowerHealthHigherDamage.tags = Items.LowerHealthHigherDamage.tags.Remove((ItemTag)1);
			}
			if (WConfig.cfg_Green_Beads.Value)
			{
				Items.ExtraStatsOnLevelUp.tags = Items.ExtraStatsOnLevelUp.tags.Add((ItemTag)15, (ItemTag)2);
				Items.ExtraStatsOnLevelUp.tags = Items.ExtraStatsOnLevelUp.tags.Remove((ItemTag)3);
			}
			if (WConfig.cfg_White_Antler.Value)
			{
				Items.NegateAttack.tags = Items.NegateAttack.tags.Add((ItemTag)2);
			}
			Items.IncreaseDamageOnMultiKill.tags = Items.IncreaseDamageOnMultiKill.tags.Add((ItemTag)4);
			Items.DelayedDamage.tags = Items.DelayedDamage.tags.Add((ItemTag)4);
			Items.ExtraStatsOnLevelUp.tags = Items.ExtraStatsOnLevelUp.tags.Add((ItemTag)4);
			Items.ExtraShrineItem.tags = Items.ExtraShrineItem.tags.Add((ItemTag)4);
			Items.LowerPricedChests.tags = Items.LowerPricedChests.tags.Add((ItemTag)4);
			Items.GoldOnStageStart.tags = Items.GoldOnStageStart.tags.Add((ItemTag)4);
			Items.ResetChests.tags = Items.ResetChests.tags.Add((ItemTag)4);
			Items.BoostAllStats.tags = Items.BoostAllStats.tags.Add((ItemTag)4);
			DotController.GetDotDef((DotIndex)1).terminalTimedBuff = null;
			DotController.GetDotDef((DotIndex)1).terminalTimedBuffDuration = 0f;
			DotController.GetDotDef((DotIndex)7).terminalTimedBuff = null;
			DotController.GetDotDef((DotIndex)7).terminalTimedBuffDuration = 0f;
		}

		private static void BurnEffectController_HandleDestroy(orig_HandleDestroy orig, BurnEffectController self)
		{
			Object.Destroy((Object)(object)self);
		}

		private void SetStateOnHurt_SetShockInternal(orig_SetShockInternal orig, SetStateOnHurt self, float duration)
		{
			if (duration == 1f)
			{
				orig.Invoke(self, 5f);
			}
			else
			{
				orig.Invoke(self, duration);
			}
		}

		private void GildedTierFix()
		{
			RoR2Application.onLoad = (Action)Delegate.Combine(RoR2Application.onLoad, (Action)delegate
			{
				Debug.LogWarning((object)"Gilded Elite tier 1.5x");
				if (CombatDirector.eliteTiers.Length >= 6)
				{
					CombatDirector.eliteTiers[1].isAvailable = (EliteRules rules) => CombatDirector.NotEliteOnlyArtifactActive() && (int)rules == 0;
					CombatDirector.eliteTiers[3].costMultiplier = 9f;
					CombatDirector.eliteTiers[3].eliteTypes = (EliteDef[])(object)new EliteDef[1] { Elites.Aurelionite };
				}
			});
		}

		private void NoxThornChance(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.CharacterBody", "TriggerEnemyDebuffs")
			}))
			{
				val.TryGotoPrev((MoveType)0, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 25f)
				});
				val.Next.Operand = 37.5f;
			}
			else
			{
				Debug.LogWarning((object)"IL Failed: Nox Chance");
			}
		}

		private void EchoNoFuckShieldHard(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdfld(x, "RoR2.DamageReport", "damageDealt")
			}))
			{
				val.Emit(OpCodes.Ldarg_1);
				val.EmitDelegate<Func<float, DamageReport, float>>((Func<float, DamageReport, float>)((float value, DamageReport damage) => damage.damageInfo.delayedDamageSecondHalf ? (-1f) : value));
			}
			else
			{
				Debug.LogWarning((object)"IL Failed: Warped Echo SHIELD");
			}
		}

		private void EchoNoBypass(orig_SecondHalfOfDelayedDamage orig, CharacterBody self, DamageInfo halfDamage)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (((Enum)halfDamage.damageType.damageType).HasFlag((Enum)(object)(DamageType)1))
			{
				halfDamage.damageType.damageType = (DamageType)1;
			}
			else
			{
				halfDamage.damageType.damageType = (DamageType)0;
			}
			orig.Invoke(self, halfDamage);
		}

		private void EchoArmorAndE8(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.CharacterBody", "get_armor")
			}))
			{
				val.Emit(OpCodes.Ldarg_1);
				val.EmitDelegate<Func<float, DamageInfo, float>>((Func<float, DamageInfo, float>)((float value, DamageInfo damage) => damage.delayedDamageSecondHalf ? 0f : value));
				val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.Run", "get_selectedDifficulty")
				});
				val.Emit(OpCodes.Ldarg_1);
				val.EmitDelegate<Func<DifficultyIndex, DamageInfo, DifficultyIndex>>((Func<DifficultyIndex, DamageInfo, DifficultyIndex>)((DifficultyIndex value, DamageInfo damage) => damage.delayedDamageSecondHalf ? ((DifficultyIndex)0) : value));
				if (val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "DelayedDamageBuff")
				}))
				{
				}
				val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 0.5f)
				});
				val.Index += 2;
				val.RemoveRange(2);
			}
			else
			{
				Debug.LogWarning((object)"IL Failed: Warped Echo");
			}
		}

		private void EchoOSP(orig_TriggerOneShotProtection orig, HealthComponent self)
		{
			orig.Invoke(self);
			self.body.protectFromOneShot = true;
		}

		private void LumShotStatsIL(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.SkillLocator", "get_secondaryBonusStockSkill")
			}))
			{
				val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.GenericSkill", "set_cooldownScale")
				});
				val.Emit(OpCodes.Ldarg_0);
				val.EmitDelegate<Func<float, CharacterBody, float>>((Func<float, CharacterBody, float>)delegate(float number, CharacterBody body)
				{
					if (Object.op_Implicit((Object)(object)body.inventory))
					{
						int itemCount = body.inventory.GetItemCount(Items.IncreasePrimaryDamage);
						if (itemCount > 0)
						{
							number *= 0.85f;
						}
					}
					return number;
				});
			}
			else
			{
				Debug.LogWarning((object)"IL Failed: Lum Shot 2");
			}
		}

		private void NoGoldPerLevel(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			ILCursor val = new ILCursor(il);
			val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Items", "GoldOnStageStart")
			});
			if (val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Items", "GoldOnStageStart")
			}))
			{
				val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 1.5f)
				});
				val.Next.Operand = 0f;
			}
			else
			{
				Debug.LogWarning((object)"IL Failed: War Bonds Level");
			}
		}

		private void WarBondsDamage(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.CharacterBody", "get_canPerformBackstab")
			}))
			{
				val.TryGotoPrev((MoveType)2, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdfld(x, "RoR2.DamageInfo", "damage")
				});
				val.Emit(OpCodes.Ldarg_1);
				val.EmitDelegate<Func<float, DamageInfo, float>>((Func<float, DamageInfo, float>)delegate(float flot, DamageInfo damageInfo)
				{
					if (flot > 0f)
					{
						CharacterBody component = damageInfo.attacker.GetComponent<CharacterBody>();
						int buffCount = component.GetBuffCount(WarBondsBuff);
						if (buffCount > 0)
						{
							flot *= 1f + (float)buffCount * 0.03f;
						}
					}
					return flot;
				});
			}
			else
			{
				Debug.LogWarning((object)"IL Failed: Leeching Seed");
			}
		}

		private void TransmitterBeforeElixir(orig_UpdateLastHitTime orig, HealthComponent self, float damageValue, Vector3 damagePosition, bool damageIsSilent, GameObject attacker)
		{
			//IL_0106: 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 = 120f;
				if (self.isHealthLow && self.body.HasBuff(Buffs.TeleportOnLowHealth) && self.itemCounts.unstableTransmitter > 0)
				{
					self.body.RemoveBuff(Buffs.TeleportOnLowHealth);
					self.body.hasTeleported = true;
					float num2 = Mathf.Max(num - num * ((float)(self.itemCounts.unstableTransmitter - 1) * 0.2f), 15f);
					self.body.AddTimedBuff(Buffs.TeleportOnLowHealthCooldown, num2);
					if (WConfig.cfg_Green_UnstableTrans.Value)
					{
						self.body.AddTimedBuff(Buffs.Immune, 5f);
					}
					else
					{
						self.body.AddTimedBuff(Buffs.HiddenInvincibility, 2f);
					}
					self.body.CallRpcTeleportCharacterToSafety();
				}
			}
			orig.Invoke(self, damageValue, damagePosition, damageIsSilent, attacker);
		}

		private void LowerLanternDamage(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "LowerHealthHigherDamageBuff")
			}))
			{
				val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 0.2f)
				});
				val.Next.Operand = 0f;
			}
			else
			{
				Debug.LogWarning((object)"IL Failed: Less Lantern");
			}
		}

		private void CapChronic(orig_AddMultiKill orig, CharacterBody self, int kills)
		{
			orig.Invoke(self, kills);
			if (Object.op_Implicit((Object)(object)self.inventory))
			{
				int num = self.inventory.GetItemCount(Items.IncreaseDamageOnMultiKill) + 2;
				if (self.GetBuffCount(Buffs.IncreaseDamageBuff) >= num)
				{
					self.increasedDamageKillCountBuff = 0;
				}
			}
		}

		private void LanterHealthVal(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdcR8(x, 0.5)
			}))
			{
				val.Next.Operand = 0.9;
				int index = val.Index;
				val.Index = index + 1;
				val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdcR8(x, 0.5)
				});
				val.Next.Operand = 0.9;
				index = val.Index;
				val.Index = index + 1;
				val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdcR8(x, 0.5)
				});
				val.Next.Operand = 0.9;
			}
			else
			{
				Debug.LogWarning((object)"IL Failed: Lantern HP VAL");
			}
		}

		private void NerfTwistedElites(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "EliteBeadCorruption")
			}))
			{
				val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 0.025f)
				});
				val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.CharacterBody", "get_teamComponent")
				});
				val.EmitDelegate<Func<CharacterBody, CharacterBody>>((Func<CharacterBody, CharacterBody>)delegate(CharacterBody body)
				{
					body.ClearTimedBuffs(Buffs.EliteBeadCorruption);
					return body;
				});
				val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchStfld(x, "RoR2.Orbs.LightningOrb", "procCoefficient")
				});
				val.Prev.Operand = 0f;
				val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchStfld(x, "RoR2.Orbs.LightningOrb", "range")
				});
				val.Prev.Operand = 42f;
				val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.Orbs.OrbManager", "AddOrb")
				});
				val.Emit(OpCodes.Ldarg_1);
				val.Emit(OpCodes.Ldloc_2);
				val.EmitDelegate<Func<LightningOrb, DamageInfo, CharacterBody, LightningOrb>>((Func<LightningOrb, DamageInfo, CharacterBody, LightningOrb>)delegate(LightningOrb orb, DamageInfo damageInfo, CharacterBody characterBody)
				{
					//IL_0013: Unknown result type (might be due to invalid IL or missing references)
					//IL_0018: Unknown result type (might be due to invalid IL or missing references)
					//IL_001f: Unknown result type (might be due to invalid IL or missing references)
					orb.bouncedObjects = new List<HealthComponent>();
					orb.teamIndex = characterBody.teamComponent.teamIndex;
					HurtBox val2 = orb.PickNextTarget(damageInfo.position);
					if (Object.op_Implicit((Object)(object)val2))
					{
						((Orb)orb).target = val2;
					}
					else
					{
						((Orb)orb).target = null;
					}
					return orb;
				});
			}
			else
			{
				Debug.LogWarning((object)"IL Failed: Nerf Twisted Elite");
			}
		}

		private void FixBreadBeadsInvasive(orig_prayerBeadCalculateAppliedStats orig, CharacterBody self, float levelStat)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			if ((int)self.teamComponent.teamIndex == 1)
			{
				float num = 0f;
				num = ((!WConfig.cfg_Green_Beads.Value) ? ((float)self.GetBuffCount(Buffs.ExtraStatsOnLevelUpBuff) * levelStat * (0.15f + 0.05f * (float)self.extraStatsOnLevelUpCountModifier)) : ((float)self.GetBuffCount(Buffs.ExtraStatsOnLevelUpBuff) * levelStat * (0.1f + 0.1f * (float)self.extraStatsOnLevelUpCountModifier)));
				if (levelStat == self.levelMaxHealth)
				{
					float beadAppliedHealth = self.inventory.beadAppliedHealth;
					Inventory inventory = self.inventory;
					inventory.beadAppliedHealth += num;
				}
				else if (levelStat == self.levelMaxShield)
				{
					float beadAppliedShield = self.inventory.beadAppliedShield;
					Inventory inventory2 = self.inventory;
					inventory2.beadAppliedShield += num;
				}
				else if (levelStat == self.levelRegen)
				{
					float beadAppliedRegen = self.inventory.beadAppliedRegen;
					Inventory inventory3 = self.inventory;
					inventory3.beadAppliedRegen += num;
				}
				else if (levelStat == self.levelDamage)
				{
					float beadAppliedDamage = self.inventory.beadAppliedDamage;
					Inventory inventory4 = self.inventory;
					inventory4.beadAppliedDamage += num;
				}
			}
		}

		private void LumShotWorkBetter(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.CharacterBody", "get_luminousShotReady")
			}))
			{
				val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.GenericSkill", "set_cooldownScale")
				});
				val.Emit(OpCodes.Ldarg_0);
				val.EmitDelegate<Func<float, CharacterBody, float>>((Func<float, CharacterBody, float>)delegate(float number, CharacterBody body)
				{
					if (Object.op_Implicit((Object)(object)body.inventory))
					{
						int itemCount = body.inventory.GetItemCount(Items.IncreasePrimaryDamage);
						if (itemCount > 0)
						{
							number *= 0.85f;
						}
					}
					return number;
				});
			}
			else
			{
				Debug.LogWarning((object)"IL Failed: LUM SHOT PROC FIX");
			}
		}

		private void KnockMeDown(orig_ProcessHitEnemy orig, GlobalEventManager self, DamageInfo damageInfo, GameObject victim)
		{
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: 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_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Expected O, but got Unknown
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Expected I4, but got Unknown
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Expected O, but got Unknown
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_034b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0350: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self, damageInfo, victim);
			if (damageInfo.procCoefficient == 0f || damageInfo.rejected || !NetworkServer.active || !Object.op_Implicit((Object)(object)damageInfo.attacker) || !(damageInfo.procCoefficient > 0f))
			{
				return;
			}
			CharacterBody component = damageInfo.attacker.GetComponent<CharacterBody>();
			CharacterBody val = (Object.op_Implicit((Object)(object)victim) ? victim.GetComponent<CharacterBody>() : null);
			if (!Object.op_Implicit((Object)(object)component))
			{
				return;
			}
			CharacterMaster master = component.master;
			if (!Object.op_Implicit((Object)(object)master))
			{
				return;
			}
			Inventory inventory = master.inventory;
			int itemCount = inventory.GetItemCount(Items.KnockBackHitEnemies);
			if (itemCount <= 0 || val.HasBuff(Buffs.KnockUpHitEnemies))
			{
				return;
			}
			CharacterMotor component2 = victim.GetComponent<CharacterMotor>();
			RigidbodyMotor component3 = victim.GetComponent<RigidbodyMotor>();
			if (((Object.op_Implicit((Object)(object)component2) && !component2.isGrounded) || Object.op_Implicit((Object)(object)component3)) && Util.CheckRoll(Util.ConvertAmplificationPercentageIntoReductionPercentage(10f * (float)itemCount * damageInfo.procCoefficient), master))
			{
				val.AddTimedBuff(Buffs.KnockUpHitEnemies, KnockbackFinCooldown);
				float damage = Util.OnHitProcDamage(damageInfo.damage, 0f, KnockbackFinDamage);
				DamageInfo val2 = new DamageInfo
				{
					damage = damage,
					damageColorIndex = (DamageColorIndex)3,
					damageType = DamageTypeCombo.op_Implicit((DamageType)0),
					attacker = damageInfo.attacker,
					crit = damageInfo.crit,
					force = Vector3.zero,
					inflictor = null,
					position = damageInfo.position,
					procCoefficient = 0f
				};
				val.healthComponent.TakeDamage(val2);
				Ray aimRay = component.inputBank.GetAimRay();
				float scale = 1f;
				HullClassification hullClassification = val.hullClassification;
				HullClassification val3 = hullClassification;
				switch ((int)val3)
				{
				case 0:
					scale = 1f;
					break;
				case 1:
					scale = 5f;
					break;
				case 2:
					scale = 10f;
					break;
				}
				EffectManager.SpawnEffect(CommonAssets.knockbackFinEffect, new EffectData
				{
					origin = ((Component)val).gameObject.transform.position,
					scale = scale
				}, true);
				Vector3 val4 = default(Vector3);
				((Vector3)(ref val4))..ctor(0f, 1f, 0f);
				float num = 20f;
				if (Object.op_Implicit((Object)(object)component2))
				{
					num = component2.mass * 20f;
				}
				else if (Object.op_Implicit((Object)(object)component3))
				{
					num = component3.mass * 20f;
				}
				if (val.isBoss || val.isChampion)
				{
					num *= 0.3f;
				}
				float num2 = 0f - (num + num / 10f);
				float num3 = num + num / 20f * (float)(itemCount - 1);
				PhysForceInfo val5 = PhysForceInfo.Create();
				val5.force = num2 * val4;
				((PhysForceInfo)(ref val5)).ignoreGroundStick = false;
				((PhysForceInfo)(ref val5)).disableAirControlUntilCollision = false;
				((PhysForceInfo)(ref val5)).massIsOne = false;
				PhysForceInfo val6 = PhysForceInfo.Create();
				val6.force = num3 / 2f * ((Ray)(ref aimRay)).direction;
				((PhysForceInfo)(ref val6)).ignoreGroundStick = false;
				((PhysForceInfo)(ref val6)).disableAirControlUntilCollision = false;
				((PhysForceInfo)(ref val6)).massIsOne = false;
				if (Object.op_Implicit((Object)(object)component2))
				{
					component2.ApplyForceImpulse(ref val5);
					component2.ApplyForceImpulse(ref val6);
				}
				else if (Object.op_Implicit((Object)(object)component3))
				{
					component3.ApplyForceImpulse(ref val5);
					component3.ApplyForceImpulse(ref val6);
				}
				Util.PlaySound("Play_item_proc_knockBackHitEnemies", ((Component)component).gameObject);
			}
		}

		private void KnockMeUp(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Items", "KnockBackHitEnemies")
			}))
			{
				val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.CharacterBody", "get_isBoss")
				});
				int index = val.Index;
				val.Index = index - 1;
				val.RemoveRange(3);
				val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdfld(x, "RoR2.CharacterBody", "isChampion")
				});
				index = val.Index;
				val.Index = index - 1;
				val.RemoveRange(3);
				val.RemoveRange(4);
				val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 7.5f)
				});
				val.Next.Operand = 10f;
				val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "KnockUpHitEnemies")
				});
				val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "KnockUpHitEnemies")
				});
				val.Emit(OpCodes.Ldarg_1);
				val.EmitDelegate<Func<CharacterBody, DamageInfo, CharacterBody>>((Func<CharacterBody, DamageInfo, CharacterBody>)delegate(CharacterBody characterBody, DamageInfo damageInfo)
				{
					//IL_0017: Unknown result type (might be due to invalid IL or missing references)
					//IL_001c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0023: Unknown result type (might be due to invalid IL or missing references)
					//IL_0025: Unknown result type (might be due to invalid IL or missing references)
					//IL_002a: Unknown result type (might be due to invalid IL or missing references)
					//IL_002c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0031: Unknown result type (might be due to invalid IL or missing references)
					//IL_0036: Unknown result type (might be due to invalid IL or missing references)
					//IL_0042: Unknown result type (might be due to invalid IL or missing references)
					//IL_004e: Unknown result type (might be due to invalid IL or missing refer