using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using BetterSoulCost;
using BossDropRework;
using EntityStates;
using EntityStates.AI.Walker;
using EntityStates.Bandit2;
using EntityStates.BrotherMonster.Weapon;
using EntityStates.Captain.Weapon;
using EntityStates.CaptainSupplyDrop;
using EntityStates.GrandParent;
using EntityStates.LaserTurbine;
using EntityStates.Mage.Weapon;
using EntityStates.NullifierMonster;
using EntityStates.TeleporterHealNovaController;
using FabricatorStandalone;
using HG;
using HG.BlendableTypes;
using HG.Reflection;
using HarmonyLib;
using IL.RoR2;
using IL.RoR2.Items;
using IL.RoR2.Orbs;
using KinematicCharacterController;
using MissileRework;
using Mono.Cecil;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using MoreStats;
using On.EntityStates;
using On.EntityStates.LaserTurbine;
using On.EntityStates.TeleporterHealNovaController;
using On.RoR2;
using On.RoR2.Items;
using On.RoR2.Orbs;
using R2API;
using R2API.Utils;
using RainrotSharedUtils;
using RainrotSharedUtils.Components;
using RainrotSharedUtils.Difficulties;
using RainrotSharedUtils.Shelters;
using RainrotSharedUtils.Status;
using RoR2;
using RoR2.Achievements;
using RoR2.Artifacts;
using RoR2.Audio;
using RoR2.CharacterAI;
using RoR2.ContentManagement;
using RoR2.EntitlementManagement;
using RoR2.ExpansionManagement;
using RoR2.Hologram;
using RoR2.Items;
using RoR2.Navigation;
using RoR2.Orbs;
using RoR2.Projectile;
using RoR2.Skills;
using RoR2.UI;
using RoR2BepInExPack.GameAssetPaths;
using RoR2BepInExPack.GameAssetPaths.Version_1_39_0;
using RoR2BepInExPack.GameAssetPathsBetter;
using SwanSongExtended.Artifacts;
using SwanSongExtended.Characters;
using SwanSongExtended.Components;
using SwanSongExtended.Elites;
using SwanSongExtended.Equipment;
using SwanSongExtended.Equipment.Zapinator;
using SwanSongExtended.Interactables;
using SwanSongExtended.Items;
using SwanSongExtended.Modules;
using SwanSongExtended.Scavengers;
using SwanSongExtended.Skills;
using SwanSongExtended.States;
using SwanSongExtended.Storms;
using ThreeEyedGames;
using Unity;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: OptIn]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("SwanSongExtended")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("SwanSongExtended")]
[assembly: AssemblyTitle("SwanSongExtended")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: UnverifiableCode]
namespace RiskierRainContent.Interactables
{
	internal static class CombatEncounterHelper
	{
		public enum CustomDirectorType
		{
			GalleryDirector = 1,
			ConstructDirector
		}

		public static GameObject MethodOne(PurchaseInteraction purchaseInteraction, Interactor activator, int credits, CustomDirectorType directorType)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Expected O, but got Unknown
			Vector3 val = Vector3.zero;
			Quaternion rotation = Quaternion.identity;
			Transform transform = ((Component)purchaseInteraction).gameObject.transform;
			if (Object.op_Implicit((Object)(object)transform))
			{
				val = transform.position;
				rotation = transform.rotation;
			}
			GameObject val2 = LegacyResourcesAPI.Load<GameObject>("Prefabs/NetworkedObjects/Encounters/MonstersOnShrineUseEncounter");
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			GameObject val3 = Object.Instantiate<GameObject>(val2, val, Quaternion.identity);
			NetworkServer.Spawn(val3);
			CombatDirector component = val3.GetComponent<CombatDirector>();
			ParseDirectorType(((Component)component).gameObject, directorType);
			if (!Object.op_Implicit((Object)(object)component) || !Object.op_Implicit((Object)(object)Stage.instance))
			{
				return null;
			}
			float num = (float)credits * Stage.instance.entryDifficultyCoefficient;
			DirectorCard val4 = component.SelectMonsterCardForCombatShrine(num);
			if (val4 != null)
			{
				component.CombatShrineActivation(activator, num, val4);
				EffectData val5 = new EffectData
				{
					origin = val,
					rotation = rotation
				};
				if (directorType == CustomDirectorType.ConstructDirector)
				{
					GameObject val6 = LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/MonstersOnShrineUse");
					EffectManager.SpawnEffect(val6, val5, true);
				}
			}
			return val3;
		}

		public static void ParseDirectorType(GameObject obj, CustomDirectorType value)
		{
			switch (value)
			{
			case CustomDirectorType.GalleryDirector:
				obj.AddComponent<GalleryDirector>();
				break;
			case CustomDirectorType.ConstructDirector:
				obj.AddComponent<ConstructDirector>();
				break;
			default:
				obj.AddComponent<GalleryDirector>();
				break;
			}
		}
	}
	internal class GalleryDirector : MonoBehaviour
	{
	}
	internal class ConstructDirector : MonoBehaviour
	{
	}
}
namespace SwanSongExtended
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	[R2APISubmoduleDependency(new string[] { "LanguageAPI", "PrefabAPI", "RecalculateStatsAPI", "DotAPI" })]
	[BepInPlugin("com.RiskOfBrainrot.SwanSongExtended", "SwanSongExtended", "0.1.0")]
	public class SwanSongPlugin : BaseUnityPlugin
	{
		public delegate void orig_idc(LaserTurbineController self);

		private class ResDiscContext
		{
			public LaserTurbineController laserTurbineController;

			public ResDiscContext(LaserTurbineController passive)
			{
				laserTurbineController = passive;
			}
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

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

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

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

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

			public static Action<PayCostContext> <>9__38_0;

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

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

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

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

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

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

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

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

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

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

			public static Func<int, EquipmentSlot, int> <>9__64_1;

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

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

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

			public static Func<int, Inventory, int> <>9__65_3;

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

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

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

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

			public static Action<EquipmentSlot> <>9__72_2;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			public static Func<float, int, float> <>9__85_11;

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

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

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

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

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

			public static Func<bool, DamageInfo, bool> <>9__99_2;

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

			public static hook_TrackBeadExperience <>9__111_1;

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

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

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

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

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

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

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

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

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

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

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

			public static Func<HealthComponent, LightningOrb, HealthComponent> <>9__129_3;

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

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

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

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

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

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

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

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

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

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

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

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

			public static Action<CraftableDef> <>9__205_0;

			internal bool <RemoveAegisOverheal>b__15_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<ItemCounts>(x, "barrierOnOverHeal");
			}

			internal bool <RemoveCrownReward>b__35_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "GoldOnHit");
			}

			internal bool <RemoveCrownReward>b__35_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<Inventory>(x, "GetItemCountEffective");
			}

			internal bool <RemoveCrownPenalty>b__36_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<ItemCounts>(x, "goldOnHit");
			}

			internal void <PatchMoneyCostForBrittleCrown>b__38_0(PayCostContext ctx)
			{
				CharacterBody activatorBody = ctx.activatorBody;
				if (Object.op_Implicit((Object)(object)activatorBody) && Object.op_Implicit((Object)(object)ctx.activatorMaster) && ctx.activatorMaster.money < ctx.cost)
				{
					ctx.cost = 0;
				}
			}

			internal bool <FreezeCard>b__44_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<Inventory>(x, "get_currentEquipmentIndex");
			}

			internal int <FreezeCard>b__44_1(Inventory inv)
			{
				return -1;
			}

			internal bool <FoconUpdate>b__54_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld<FocusConvergenceController>(x, "cap");
			}

			internal int <FoconUpdate>b__54_1(int cap)
			{
				return foconMaxStack;
			}

			internal bool <FoconApplyRadius>b__56_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld<FocusConvergenceController>(x, "convergenceRadiusDivisor");
			}

			internal bool <FoconApplyRadius>b__56_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld<FocusConvergenceController>(x, "convergenceRadiusDivisor");
			}

			internal bool <FoconApplyRadius>b__56_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchStindR4(x);
			}

			internal bool <FoconApplyRate>b__57_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld<FocusConvergenceController>(x, "convergenceChargeRateBonus");
			}

			internal float <FoconApplyRate>b__57_1(float chargeBonus)
			{
				return foconChargeBonus;
			}

			internal bool <AllowGestureUndercast>b__64_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<EquipmentSlot>(x, "get_stock");
			}

			internal int <AllowGestureUndercast>b__64_1(int stock, EquipmentSlot slot)
			{
				if (stock > 0)
				{
					return stock;
				}
				if (slot.inventory.GetItemCountEffective(Items.AutoCastEquipment) > 0)
				{
					return 1;
				}
				return 0;
			}

			internal bool <FixMaxStock>b__65_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "EquipmentMagazine");
			}

			internal bool <FixMaxStock>b__65_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<Inventory>(x, "GetItemCountEffective");
			}

			internal bool <FixMaxStock>b__65_2(Instruction x)
			{
				int num = default(int);
				return ILPatternMatchingExt.MatchStloc(x, ref num);
			}

			internal int <FixMaxStock>b__65_3(int stock, Inventory inv)
			{
				stock += GetGestureStockFromInventory(inv);
				return stock;
			}

			internal bool <RemoveGestureCdr>b__69_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "AutoCastEquipment");
			}

			internal bool <RemoveGestureCdr>b__69_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<Inventory>(x, "GetItemCountEffective");
			}

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

			internal bool <AddPreonAccumulatorBreak>b__72_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<EquipmentSlot>(x, "bfgChargeTimer");
			}

			internal void <AddPreonAccumulatorBreak>b__72_2(EquipmentSlot self)
			{
				TryGestureEquipmentBreak(self);
			}

			internal bool <RemoveGestureAutocast>b__74_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "AutoCastEquipment");
			}

			internal bool <RemoveGestureAutocast>b__74_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<Inventory>(x, "GetItemCountEffective");
			}

			internal bool <RevokeHappiestMaskRights>b__82_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "GhostOnKill");
			}

			internal bool <RevokeHappiestMaskRights>b__82_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<Inventory>(x, "GetItemCountEffective");
			}

			internal bool <ChangeMoveSpeed>b__84_0(Instruction x)
			{
				float num = default(float);
				return ILPatternMatchingExt.MatchLdcR4(x, ref num);
			}

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

			internal bool <ChangeMoveSpeed>b__84_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC1Content/Buffs", "KillMoveSpeed");
			}

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

			internal int <ChangeMoveSpeed>b__84_4(int buffCount)
			{
				if (buffCount > 0)
				{
					return 1;
				}
				return 0;
			}

			internal bool <ChangeDuration>b__85_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC1Content/Items", "MoveSpeedOnKill");
			}

			internal bool <ChangeDuration>b__85_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<Inventory>(x, "GetItemCountEffective");
			}

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

			internal bool <ChangeDuration>b__85_6(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC1Content/Buffs", "KillMoveSpeed");
			}

			internal bool <ChangeDuration>b__85_7(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<CharacterBody>(x, "ClearTimedBuffs");
			}

			internal bool <ChangeDuration>b__85_8(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<CharacterBody>(x, "AddTimedBuff");
			}

			internal float <ChangeDuration>b__85_11(float baseBuffDuration, int iterator)
			{
				return iterator + 1;
			}

			internal int <ChangeDuration>b__85_12(int vanillaBuffCount, int itemCount, CharacterBody attackerBody)
			{
				if (itemCount > 25)
				{
					return itemCount;
				}
				int buffCount = attackerBody.GetBuffCount(Buffs.KillMoveSpeed);
				return Mathf.Min(25, buffCount + itemCount);
			}

			internal bool <RevokeScopeRights>b__93_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC1Content/Items", "CritDamage");
			}

			internal bool <RevokeScopeRights>b__93_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<Inventory>(x, "GetItemCountEffective");
			}

			internal bool <FuckLeechingSeed>b__99_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcI4(x, 6);
			}

			internal bool <FuckLeechingSeed>b__99_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.ProcChainMask", "HasProc");
			}

			internal bool <FuckLeechingSeed>b__99_2(bool cantProc, DamageInfo damageInfo)
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Invalid comparison between Unknown and I4
				return cantProc || (!((DamageTypeCombo)(ref damageInfo.damageType)).IsDamageSourceSkillBased && (int)damageInfo.damageType.damageSource != 64);
			}

			internal bool <FuckPlanula>b__106_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld(x, "RoR2.HealthComponent/ItemCounts", "parentEgg");
			}

			internal void <PrayerBeadsRework>b__111_1(orig_TrackBeadExperience orig, CharacterMaster self, ulong idk)
			{
			}

			internal bool <ChangeBeadAppliedStats>b__115_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Items", "ExtraStatsOnLevelUp");
			}

			internal bool <ChangeBeadAppliedStats>b__115_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<Inventory>(x, "GetItemCountPermanent");
			}

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

			internal bool <ChangeBeadAppliedStats>b__115_5(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<CharacterBody>(x, "extraStatsOnLevelUpCount_CachedLastApplied");
			}

			internal void <ChangeBeadAppliedStats>b__115_7(int itemCount, CharacterBody self)
			{
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				int num = self.extraStatsOnLevelUpCount_CachedLastApplied - itemCount;
				self.extraStatsOnLevelUpCount_CachedLastApplied = itemCount;
				Inventory inventory = self.inventory;
				inventory.beadAppliedHealth += (float)num;
				Inventory inventory2 = self.inventory;
				inventory2.beadAppliedShield += (float)num;
				Inventory inventory3 = self.inventory;
				inventory3.beadAppliedRegen += (float)num;
				Inventory inventory4 = self.inventory;
				inventory4.beadAppliedDamage += (float)num;
				self.SetBuffCount(Buffs.ExtraStatsOnLevelUpBuff.buffIndex, (int)self.inventory.beadAppliedHealth);
			}

			internal bool <ChangeBeadAppliedStats>b__115_8(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "ExtraStatsOnLevelUpBuff");
			}

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

			internal int <ChangeBeadAppliedStats>b__115_10(int buffCount)
			{
				return 0;
			}

			internal bool <ChangeBeadAppliedStats>b__115_17(Instruction x)
			{
				float num = default(float);
				return ILPatternMatchingExt.MatchLdcR4(x, ref num);
			}

			internal bool <ChangeBeadAppliedStats>b__115_18(Instruction x)
			{
				ILLabel val = default(ILLabel);
				return ILPatternMatchingExt.MatchBleUn(x, ref val);
			}

			internal bool <RazorwireArrival>b__129_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<HurtBox>(x, "healthComponent");
			}

			internal HealthComponent <RazorwireArrival>b__129_3(HealthComponent hc, LightningOrb orb)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Invalid comparison between Unknown and I4
				if ((int)orb.lightningType == 6 && (Object)(object)hc != (Object)null)
				{
					for (int i = 0; (float)i < orb.procCoefficient; i++)
					{
						DotController.InflictDot(((Component)hc).gameObject, orb.attacker, hc.body.mainHurtBox, (DotIndex)0, razorwireBleedDuration, orb.damageValue, (uint?)null);
					}
					return null;
				}
				return hc;
			}

			internal bool <RazorwireBegin>b__130_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdflda<HealthComponent>(x, "itemCounts");
			}

			internal bool <RazorwireBegin>b__130_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<ItemCounts>(x, "thorns");
			}

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

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

			internal bool <RazorwireBegin>b__130_4(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdflda<HealthComponent>(x, "itemCounts");
			}

			internal bool <RazorwireBegin>b__130_5(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<ItemCounts>(x, "thorns");
			}

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

			internal bool <RazorwireBegin>b__130_8(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdflda<HealthComponent>(x, "itemCounts");
			}

			internal bool <RazorwireBegin>b__130_9(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<ItemCounts>(x, "thorns");
			}

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

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

			internal bool <RazorwireBegin>b__130_12(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<OrbManager>(x, "AddOrb");
			}

			internal void <RemoveCraftingRecipe>b__205_0(CraftableDef craftableDef)
			{
				craftableDef.recipes = (Recipe[])(object)new Recipe[0];
			}
		}

		public static int ignitionTankBurnChance = 15;

		public float ignitionBurnDamage = 2f;

		public float ignitionBurnDuration = 2f;

		private bool shouldIgnitionDamageAndDurationCompound = false;

		public static int stacheBurnChance = 25;

		public static int brandBurnChance = 30;

		public static float _aegisBarrierFlat = 40f;

		public static float _aegisBarrierPercent = 10f;

		public static BuffDef aegisDecayBuff;

		public static int brittleCrownStealCountBase = 2;

		public static int brittleCrownStealCountStack = 1;

		public static float crownCommonStealSoulCost = 0.25f;

		public static float crownUncommonStealSoulCost = 0.5f;

		public static float crownRareStealSoulCost = 0.8f;

		private string common = Tools.ConvertDecimal(crownCommonStealSoulCost);

		private string uncommon = Tools.ConvertDecimal(crownUncommonStealSoulCost);

		private string rare = Tools.ConvertDecimal(crownRareStealSoulCost);

		public static float cooldown = 90f;

		public static float secondsPerCost = 0.5f;

		public static float foconMinRadius = 8f;

		public static float foconRadiusMultiplier = 0.5f;

		public static float foconChargeBonus = 1f;

		public static int foconMaxStack = 5;

		public static float gestureEquipBreakChance = 40f;

		public static int gestureStockBase = 4;

		public static int gestureStockStack = 2;

		public static float gestureCdiBase = 1f;

		public static float gestureCdiStack = 0.5f;

		public static float hauntExecutionThreshold = 0.25f;

		private float ghostSpawnChanceOnExecute = 100f;

		private float ghostDurationPerStack = 6.66f;

		public int scopeBaseCrit = 5;

		public int scopeStackCrit = 0;

		public int scopeBaseStationaryCrit = 40;

		public int scopeStackStationaryCrit = 0;

		public static ItemDef seedItemDef;

		public static float seedRegenDurationBase = 0.25f;

		public static float seedRegenDurationStack = 0.25f;

		public static float sunDurationBase = 10f;

		public static float sunDurationStack = 5f;

		public static float beadsPermanentStatBonus = 0.07f;

		private static float razorwireArmorBase = 8f;

		private static float razorwireArmorStack = 8f;

		private static float razorwireRangeBase = 40f;

		private static float razorwireRangeStack = 0f;

		private static float razorwireTargetsBase = 5f;

		private static float razorwireTargetsStack = 2f;

		private static float razorwireBleedDuration = 5f;

		private static float razorwireDamage = 3.6f;

		private static float razorwireProcCoeff = 0.2f;

		private static float razorwireCooldown = 1f;

		public static GameObject laserTurbineControllerPrefab;

		private readonly Dictionary<EntityState, ResDiscContext> resDiscStateContext = new Dictionary<EntityState, ResDiscContext>();

		public const string guid = "com.RiskOfBrainrot.SwanSongExtended";

		public const string teamName = "RiskOfBrainrot";

		public const string modName = "SwanSongExtended";

		public const string version = "0.1.0";

		public const string expansionName = "Swan Song";

		public const string expansionName2 = "Secrets of the Scug";

		public const string expansionToken = "EXPANSION2R4R";

		public const string expansionToken2 = "EXPANSIONSOTS";

		public const string DEVELOPER_PREFIX = "FRUIT";

		public static SwanSongPlugin instance;

		public static ExpansionDef expansionDefSS2;

		public static ExpansionDef expansionDefSOTS;

		public const string iconsPath = "";

		private BuffDef brittleCrownBuff => CommonAssets.brittleCrownCursePurchase;

		private static float minSpin => LaserTurbineController.minSpin;

		private static float maxSpin => LaserTurbineController.maxSpin;

		private static float spinPerKill => LaserTurbineController.spinGeneratedOnKill;

		private static float spinDecayRate => LaserTurbineController.spinDecayPerSecondAfterRefresh;

		private GameObject meatballNapalmPool => CommonAssets.meatballNapalmPool;

		public static AssetBundle mainAssetBundle => CommonAssets.mainAssetBundle;

		public static AssetBundle retierAssetBundle => CommonAssets.retierAssetBundle;

		public static bool iabMissilesLoaded => ModLoaded("com.RiskOfBrainrot.IAmBecomeMissiles");

		public static bool isAELoaded => ModLoaded("com.Borbo.ArtificerExtended");

		public static bool is2R4RLoaded => ModLoaded("com.RiskOfBrainrot.RiskierRain");

		public static bool isHBULoaded => ModLoaded("com.Borbo.HuntressBuffULTIMATE");

		public static bool isScepterLoaded => ModLoaded("com.DestroyedClone.AncientScepter");

		public static bool autosprintLoaded => ModLoaded("com.johnedwa.RTAutoSprintEx");

		public static bool acridLungeLoaded => ModLoaded("Withor.AcridBiteLunge");

		public static bool ucrLoaded => ModLoaded("HIFU.UltimateCustomRun");

		public static bool fabricatorsLoaded => ModLoaded("com.RiskOfBrainrot.Fabricators");

		private void BurnReworks()
		{
			IgnitionTankRework();
		}

		private void IgnitionTankRework()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			StatHooks.GetMoreStatCoefficients += new MoreStatHookEventHandler(IgniTankBurnChance);
			StrengthenBurnUtils.CheckDotForUpgrade += new hook_CheckDotForUpgrade(OverrideIgnitionBurn);
			LanguageAPI.Add("ITEM_STRENGTHENBURN_PICKUP", "Your ignite effects deal triple damage.");
			LanguageAPI.Add("ITEM_STRENGTHENBURN_DESC", $"Gain <style=cIsDamage>{ignitionTankBurnChance}% ignite chance</style>. " + "All ignition effects deal <style=cIsDamage>+" + Tools.ConvertDecimal(ignitionBurnDamage) + "</style> <style=cStack>(+" + Tools.ConvertDecimal(ignitionBurnDamage) + " per stack)</style> more damage and last <style=cIsUtility>+" + Tools.ConvertDecimal(ignitionBurnDuration) + "</style> <style=cStack>(+" + Tools.ConvertDecimal(ignitionBurnDuration) + " per stack)</style> longer.");
		}

		private void IgniTankBurnChance(CharacterBody sender, MoreStatHookEventArgs args)
		{
			Inventory inventory = sender.inventory;
			if (Object.op_Implicit((Object)(object)inventory) && inventory.GetItemCountEffective(Items.StrengthenBurn) > 0)
			{
				args.burnChanceOnHit += (float)ignitionTankBurnChance;
			}
		}

		private void OverrideIgnitionBurn(orig_CheckDotForUpgrade orig, Inventory inventory, ref InflictDotInfo dotInfo)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if ((int)dotInfo.dotIndex != 1 && (int)dotInfo.dotIndex != 2)
			{
				return;
			}
			int itemCountEffective = inventory.GetItemCountEffective(Items.StrengthenBurn);
			if (itemCountEffective > 0)
			{
				dotInfo.preUpgradeDotIndex = dotInfo.dotIndex;
				dotInfo.dotIndex = (DotIndex)7;
				float num = 1f + ignitionBurnDamage * (float)itemCountEffective;
				float num2 = 1f + ignitionBurnDuration * (float)itemCountEffective;
				if (shouldIgnitionDamageAndDurationCompound)
				{
					dotInfo.totalDamage *= num * num2;
					dotInfo.damageMultiplier *= num;
				}
				else
				{
					dotInfo.totalDamage *= num;
					dotInfo.damageMultiplier *= num / num2;
				}
			}
		}

		public static int GetBurnCount(CharacterBody victimBody)
		{
			return victimBody.GetBuffCount(Buffs.OnFire) + victimBody.GetBuffCount(Buffs.StrongerBurn);
		}

		public void ReworkAegis()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			CreateBuff();
			Hooks();
			HealthComponent.Heal += new Manipulator(RemoveAegisOverheal);
			LanguageAPI.Add("ITEM_BARRIERONOVERHEAL_PICKUP", "Gain barrier on any interaction. While out of danger, barrier stops decaying.");
			LanguageAPI.Add("ITEM_BARRIERONOVERHEAL_DESC", "Using any interactable grants a <style=cIsHealing>temporary barrier</style> " + $"for <style=cIsHealing>{_aegisBarrierFlat} health</style> <style=cStack>(+{_aegisBarrierFlat} per stack)</style> " + "plus an additional " + $"<style=cIsHealing>{_aegisBarrierPercent}%</style> <style=cStack>(+{_aegisBarrierPercent}% per stack)</style> " + "of <style=cIsHealing>maximum health</style>. While outside of danger, <style=cIsUtility>barrier will not decay</style>.");
		}

		private void RemoveAegisOverheal(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdfld<ItemCounts>(x, "barrierOnOverHeal")
			});
			val.Emit(OpCodes.Pop);
			val.Emit(OpCodes.Ldc_I4_0);
		}

		private void CreateBuff()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			aegisDecayBuff = ScriptableObject.CreateInstance<BuffDef>();
			((Object)aegisDecayBuff).name = "AegisDecayFreeze";
			aegisDecayBuff.buffColor = new Color(0.95f, 0.85f, 0.08f);
			aegisDecayBuff.canStack = false;
			aegisDecayBuff.isDebuff = false;
			aegisDecayBuff.iconSprite = Addressables.LoadAssetAsync<Sprite>((object)"RoR2/Base/Common/texBuffGenericShield.tif").WaitForCompletion();
			ContentAddition.AddBuffDef(aegisDecayBuff);
		}

		public void Hooks()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			MultiShopCardUtils.OnMoneyPurchase += new hook_OnMoneyPurchase(OnMoneyPurchase);
			MultiShopCardUtils.OnNonMoneyPurchase += new hook_OnNonMoneyPurchase(OnNonMoneyPurchase);
			CharacterBody.OnInventoryChanged += new hook_OnInventoryChanged(AddItemBehavior);
			StatHooks.GetMoreStatCoefficients += new MoreStatHookEventHandler(AegisDecayFreeze);
		}

		private void AegisDecayFreeze(CharacterBody body, MoreStatHookEventArgs args)
		{
			if (body.HasBuff(aegisDecayBuff))
			{
				args.barrierFreezeCount++;
			}
		}

		private void OnNonMoneyPurchase(orig_OnNonMoneyPurchase orig, PayCostContext context)
		{
			AegisBarrierGrant(context);
			orig.Invoke(context);
		}

		private void OnMoneyPurchase(orig_OnMoneyPurchase orig, PayCostContext context)
		{
			AegisBarrierGrant(context);
			orig.Invoke(context);
		}

		private void AddItemBehavior(orig_OnInventoryChanged orig, CharacterBody self)
		{
			orig.Invoke(self);
			if (NetworkServer.active)
			{
				self.AddItemBehavior<AegisDecayBehavior>(self.inventory.GetItemCountEffective(Items.BarrierOnOverHeal));
			}
		}

		private void AegisBarrierGrant(PayCostContext context)
		{
			CharacterMaster activatorMaster = context.activatorMaster;
			CharacterBody val = ((activatorMaster != null) ? activatorMaster.GetBody() : null);
			if (Object.op_Implicit((Object)(object)val))
			{
				int itemCountEffective = val.inventory.GetItemCountEffective(Items.BarrierOnOverHeal);
				HealthComponent healthComponent = val.healthComponent;
				if (itemCountEffective > 0 && (Object)(object)healthComponent != (Object)null)
				{
					float num = Util.ConvertAmplificationPercentageIntoReductionNormalized(_aegisBarrierPercent * 0.01f) * healthComponent.fullCombinedHealth;
					float num2 = (float)itemCountEffective * _aegisBarrierFlat;
					healthComponent.AddBarrierAuthority(num + num2);
				}
			}
		}

		public void BrittleCrownChanges()
		{
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Expected O, but got Unknown
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Expected O, but got Unknown
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Expected O, but got Unknown
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Expected O, but got Unknown
			LanguageAPI.Add("ITEM_GOLDONHIT_NAME", "Sunken Crown");
			LanguageAPI.Add("ITEM_GOLDONHIT_PICKUP", "Steal from chests... " + Language.Styling.HealthColor("at the cost of health."));
			LanguageAPI.Add("ITEM_GOLDONHIT_DESC", "Allows interacting with chests without the ability to afford them, opening the chest " + Language.Styling.UtilityColor("without spending ANY money") + ". Stealing from chests costs " + Language.Styling.HealthColor("[ " + common + " / " + uncommon + " / " + rare + " ]") + " of your " + Language.Styling.HealthColor("maximum health") + ", depending on the size of the chest. " + $"Can steal up to {brittleCrownStealCountBase} {Language.Styling.StackText($"+{brittleCrownStealCountStack}")} times per stage.");
			HealthComponent.TakeDamageProcess += new Manipulator(RemoveCrownPenalty);
			GlobalEventManager.ProcessHitEnemy += new Manipulator(RemoveCrownReward);
			PurchaseInteraction.CanBeAffordedByInteractor += new hook_CanBeAffordedByInteractor(PurchaseInteraction_CanBeAffordedByInteractor);
			CharacterBody.OnInventoryChanged += new hook_OnInventoryChanged(AddBrittleCrownBehavior);
		}

		private void AddBrittleCrownBehavior(orig_OnInventoryChanged orig, CharacterBody self)
		{
			orig.Invoke(self);
			if (NetworkServer.active)
			{
				self.AddItemBehavior<BrittleCrownBehavior>(self.inventory.GetItemCountEffective(Items.GoldOnHit));
			}
		}

		private void RemoveCrownReward(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_005b: 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)
			ILCursor val = new ILCursor(il);
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[2]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "GoldOnHit"),
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<Inventory>(x, "GetItemCountEffective")
			});
			val.Emit(OpCodes.Pop);
			val.Emit(OpCodes.Ldc_I4, 0);
		}

		private void RemoveCrownPenalty(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdfld<ItemCounts>(x, "goldOnHit")
			});
			val.Emit(OpCodes.Pop);
			val.Emit(OpCodes.Ldc_I4, 0);
		}

		private void CTCInit(orig_Init orig)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			orig.Invoke();
			CostTypeDef costTypeDef = CostTypeCatalog.GetCostTypeDef((CostTypeIndex)1);
			MethodInfo method = ((Delegate)(object)costTypeDef.payCost).Method;
			ILHook val = new ILHook((MethodBase)method, new Manipulator(PatchMoneyCostForBrittleCrown));
		}

		private void PatchMoneyCostForBrittleCrown(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.Emit(OpCodes.Ldarg_1);
			val.EmitDelegate<Action<PayCostContext>>((Action<PayCostContext>)delegate(PayCostContext ctx)
			{
				CharacterBody activatorBody = ctx.activatorBody;
				if (Object.op_Implicit((Object)(object)activatorBody) && Object.op_Implicit((Object)(object)ctx.activatorMaster) && ctx.activatorMaster.money < ctx.cost)
				{
					ctx.cost = 0;
				}
			});
		}

		private bool PurchaseInteraction_CanBeAffordedByInteractor(orig_CanBeAffordedByInteractor orig, PurchaseInteraction self, Interactor activator)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			bool flag = orig.Invoke(self, activator);
			if (flag)
			{
				return flag;
			}
			CharacterBody val = null;
			if ((int)self.costType == 1 && self.saleStarCompatible && ((Component)activator).gameObject.TryGetComponent<CharacterBody>(ref val) && val.HasBuff(brittleCrownBuff) && val.master.money < self.cost)
			{
				int num = 1;
				int difficultyScaledCost = Run.instance.GetDifficultyScaledCost(45, Stage.instance.entryDifficultyCoefficient);
				int difficultyScaledCost2 = Run.instance.GetDifficultyScaledCost(245, Stage.instance.entryDifficultyCoefficient);
				if (self.cost >= num && self.cost < difficultyScaledCost)
				{
					CounterfeitCalculations(val, crownCommonStealSoulCost);
				}
				else if (self.cost >= difficultyScaledCost && self.cost < difficultyScaledCost2)
				{
					CounterfeitCalculations(val, crownUncommonStealSoulCost);
				}
				else
				{
					CounterfeitCalculations(val, crownRareStealSoulCost);
				}
				flag = true;
			}
			return flag;
		}

		public void CounterfeitCalculations(CharacterBody activator, float soulCost)
		{
			SoulCostPlugin.AddSoulCostToBody(activator, soulCost);
			Util.PlaySound("sfx_lunarmoney_start", ((Component)activator).gameObject);
			if (NetworkServer.active)
			{
				activator.AddBuff(Buffs.FreeUnlocks);
				activator.RemoveBuff(brittleCrownBuff);
			}
		}

		public void ExecutiveCardChanges()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			EquipmentDef val = Addressables.LoadAssetAsync<EquipmentDef>((object)"RoR2/DLC1/MultiShopCard/MultiShopCard.asset").WaitForCompletion();
			val.cooldown = cooldown;
			LanguageAPI.Add("EQUIPMENT_MULTISHOPCARD_PICKUP", "Hack a targeted interactable. Hacked Multishops remain open.");
			LanguageAPI.Add("EQUIPMENT_MULTISHOPCARD_DESC", "Target an interactable to <style=cIsUtility>hack</style> it, unlocking its contents for <style=cIsUtility>free</style>. If the target is a <style=cIsUtility>multishop</style> terminal, the other terminals will <style=cIsUtility>remain open</style>.");
			MultiShopCardUtils.OnPurchase += new Manipulator(FreezeCard);
			EquipmentSlot.UpdateTargets += new hook_UpdateTargets(CardTargetInteractables);
			EquipmentSlot.PerformEquipmentAction += new hook_PerformEquipmentAction(PerformEquipmentAction);
		}

		private void FreezeCard(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.GotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<Inventory>(x, "get_currentEquipmentIndex")
			});
			val.Remove();
			val.EmitDelegate<Func<Inventory, int>>((Func<Inventory, int>)((Inventory inv) => -1));
		}

		private bool PerformEquipmentAction(orig_PerformEquipmentAction orig, EquipmentSlot self, EquipmentDef equipmentDef)
		{
			if ((Object)(object)equipmentDef == (Object)(object)Equipment.MultiShopCard)
			{
				return ActivateEquipment(self);
			}
			return orig.Invoke(self, equipmentDef);
			static bool ActivateEquipment(EquipmentSlot slot)
			{
				bool result = false;
				GameObject rootObject = slot.currentTarget.rootObject;
				if ((Object)(object)rootObject != (Object)null)
				{
					PurchaseInteraction component = rootObject.GetComponent<PurchaseInteraction>();
					if ((Object)(object)component != (Object)null && HackingMainState.PurchaseInteractionIsValidTarget(component))
					{
						component.Networkcost = 0;
						ShopTerminalBehavior val = default(ShopTerminalBehavior);
						if (rootObject.TryGetComponent<ShopTerminalBehavior>(ref val) && Object.op_Implicit((Object)(object)val.serverMultiShopController))
						{
							val.serverMultiShopController.SetCloseOnTerminalPurchase(component, false);
						}
						DroneVendorTerminalBehavior val2 = default(DroneVendorTerminalBehavior);
						if (rootObject.TryGetComponent<DroneVendorTerminalBehavior>(ref val2) && Object.op_Implicit((Object)(object)val2.serverMultiShopController))
						{
							val2.serverMultiShopController.SetCloseOnTerminalPurchase(component, false);
						}
						Interactor val3 = default(Interactor);
						if ((Object)(object)slot.characterBody != (Object)null && ((Component)slot.characterBody).TryGetComponent<Interactor>(ref val3))
						{
							val3.AttemptInteraction(rootObject);
						}
						slot.InvalidateCurrentTarget();
						result = true;
					}
				}
				return result;
			}
		}

		private void CardTargetInteractables(orig_UpdateTargets orig, EquipmentSlot self, EquipmentIndex targetingEquipmentIndex, bool userShouldAnticipateTarget)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: 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_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			if (targetingEquipmentIndex != Equipment.MultiShopCard.equipmentIndex || !userShouldAnticipateTarget)
			{
				orig.Invoke(self, targetingEquipmentIndex, userShouldAnticipateTarget);
				return;
			}
			float num = 150f;
			float num2 = 10f;
			float num3 = Mathf.Cos(Mathf.Clamp(num2, 0f, 180f) * MathF.PI / 180f);
			float num4 = default(float);
			Ray val = CameraRigController.ModifyAimRayIfApplicable(self.GetAimRay(), ((Component)self.characterBody).gameObject, ref num4);
			Collider[] array = Physics.OverlapSphere(((Ray)(ref val)).origin, num + num4, -1, (QueryTriggerInteraction)2);
			bool flag = false;
			GameObject rootObject = self.currentTarget.rootObject;
			Vector3 val3;
			if ((Object)(object)rootObject != (Object)null)
			{
				PurchaseInteraction val2 = ((rootObject != null) ? rootObject.GetComponent<PurchaseInteraction>() : null);
				if ((Object)(object)val2 != (Object)null)
				{
					flag = HackingMainState.PurchaseInteractionIsValidTarget(val2) && val2.available;
				}
				Vector3 origin = ((Ray)(ref val)).origin;
				Vector3 position = rootObject.transform.position;
				if (flag)
				{
					val3 = position - origin;
					if (!(((Vector3)(ref val3)).sqrMagnitude > num * num))
					{
						Vector3 direction = ((Ray)(ref val)).direction;
						val3 = position - origin;
						if (!(Vector3.Dot(direction, ((Vector3)(ref val3)).normalized) < num3))
						{
							goto IL_0146;
						}
					}
				}
				self.InvalidateCurrentTarget();
			}
			goto IL_0146;
			IL_0146:
			bool flag2 = false;
			PurchaseInteraction val4 = null;
			Collider[] array2 = array;
			foreach (Collider val5 in array2)
			{
				Vector3 direction2 = ((Ray)(ref val)).direction;
				val3 = ((Component)val5).transform.position - ((Ray)(ref val)).origin;
				float num5 = Vector3.Dot(direction2, ((Vector3)(ref val3)).normalized);
				if (num5 < num3)
				{
					continue;
				}
				Vector3 origin2 = ((Ray)(ref val)).origin;
				Vector3 position2 = ((Component)val5).transform.position;
				if (!HasLos(origin2, position2))
				{
					continue;
				}
				EntityLocator component = ((Component)val5).GetComponent<EntityLocator>();
				if (!Object.op_Implicit((Object)(object)component))
				{
					continue;
				}
				PurchaseInteraction component2 = component.entity.GetComponent<PurchaseInteraction>();
				if (Object.op_Implicit((Object)(object)component2))
				{
					flag2 = HackingMainState.PurchaseInteractionIsValidTarget(component2);
					if (flag2)
					{
						flag2 = true;
						val4 = component2;
						break;
					}
					if ((Object)(object)val4 == (Object)null && component2.available)
					{
						val4 = component2;
					}
				}
			}
			if ((Object)(object)val4 != (Object)null)
			{
				if (flag2 && userShouldAnticipateTarget)
				{
					self.targetIndicator.visualizerPrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/RecyclerIndicator");
				}
				else
				{
					self.targetIndicator.visualizerPrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/RecyclerBadIndicator");
				}
				self.currentTarget = new UserTargetInfo
				{
					transformToIndicateAt = ((Component)val4).gameObject.transform,
					pickupController = null,
					hurtBox = null,
					rootObject = ((Component)val4).gameObject
				};
				self.targetIndicator.active = true;
				self.targetIndicator.targetTransform = self.currentTarget.transformToIndicateAt;
			}
			else
			{
				self.InvalidateCurrentTarget();
				self.targetIndicator.active = false;
			}
		}

		public bool HasLos(Vector3 origin, Vector3 targetPosition)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: 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)
			Vector3 val = targetPosition - origin;
			RaycastHit val2 = default(RaycastHit);
			return !Physics.Raycast(origin, val, ref val2, ((Vector3)(ref val)).magnitude - 1f, LayerMask.op_Implicit(((LayerIndex)(ref LayerIndex.world)).mask), (QueryTriggerInteraction)1);
		}

		private void FreezeCardf(orig_OnPurchase orig, PayCostContext context, int moneyCost)
		{
		}

		public void FocusedConvergenceChanges()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			FocusConvergenceController.ApplyRadius += new hook_ApplyRadius(FoconNewRadius);
			FocusConvergenceController.ApplyRate += new Manipulator(FoconApplyRate);
			FocusConvergenceController.DoUpdate += new Manipulator(FoconUpdate);
			LanguageAPI.Add("ITEM_FOCUSEDCONVERGENCE_PICKUP", $"Increase the speed Holdout Zones charge... <color=#FF7F7F>BUT reduce the size of the zone</color>. Max of {foconMaxStack}.");
			LanguageAPI.Add("ITEM_FOCUSEDCONVERGENCE_DESC", "Holdout Zones charge <style=cIsUtility>" + Tools.ConvertDecimal(foconChargeBonus) + " <style=cStack>(+" + Tools.ConvertDecimal(foconChargeBonus) + " per stack)</style> faster</style>, but are <style=cIsHealth>" + Tools.ConvertDecimal(1f - foconRadiusMultiplier) + " smaller</style> <style=cStack>(-" + Tools.ConvertDecimal(1f - foconRadiusMultiplier) + " per stack)</style>. " + $"Max of {foconMaxStack}.");
		}

		private void FoconUpdate(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.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld<FocusConvergenceController>(x, "cap")
			});
			val.EmitDelegate<Func<int, int>>((Func<int, int>)((int cap) => foconMaxStack));
		}

		private void FoconNewRadius(orig_ApplyRadius orig, MonoBehaviour self, ref float radius)
		{
			FocusConvergenceController val = (FocusConvergenceController)(object)((self is FocusConvergenceController) ? self : null);
			if (val.currentFocusConvergenceCount > 0)
			{
				radius -= foconMinRadius;
				radius *= Mathf.Pow(foconRadiusMultiplier, (float)val.currentFocusConvergenceCount);
				radius += foconMinRadius;
			}
		}

		private void FoconApplyRadius(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.GotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld<FocusConvergenceController>(x, "convergenceRadiusDivisor")
			});
			val.Emit(OpCodes.Ldc_R4, foconMinRadius);
			val.Emit(OpCodes.Sub);
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld<FocusConvergenceController>(x, "convergenceRadiusDivisor")
			});
			val.Remove();
			val.Emit(OpCodes.Ldc_R4, 2);
			val.GotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchStindR4(x)
			});
			val.Emit(OpCodes.Ldc_R4, foconMinRadius);
			val.Emit(OpCodes.Add);
		}

		private void FoconApplyRate(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.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld<FocusConvergenceController>(x, "convergenceChargeRateBonus")
			});
			val.EmitDelegate<Func<float, float>>((Func<float, float>)((float chargeBonus) => foconChargeBonus));
		}

		public void GestureChanges()
		{
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Expected O, but got Unknown
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Expected O, but got Unknown
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Expected O, but got Unknown
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Expected O, but got Unknown
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Expected O, but got Unknown
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Expected O, but got Unknown
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Expected O, but got Unknown
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Expected O, but got Unknown
			LanguageAPI.Add("ITEM_AUTOCASTEQUIPMENT_PICKUP", "Greatly increase equipment stock... " + Language.Styling.HealthColor("BUT greatly increase equipment cooldown.") + " Equipments can be activated during their cooldown, " + Language.Styling.HealthColor("with a chance to break."));
			LanguageAPI.Add("ITEM_AUTOCASTEQUIPMENT_DESC", "Hold " + Language.Styling.UtilityColor($"{gestureStockBase} additional equipment charges") + " " + Language.Styling.StackText($"+{gestureStockStack}") + "... " + Language.Styling.HealthColor("BUT increase equipment cooldown by +" + Tools.ConvertDecimal(gestureCdiBase)) + " " + Language.Styling.StackText("+" + Tools.ConvertDecimal(gestureCdiStack)) + ". Using your equipment without charges " + Language.Styling.UtilityColor("under-casts") + " it, allowing it to be used " + Language.Styling.HealthColor($"with a {gestureEquipBreakChance}% chance to break") + ". " + Language.Styling.UtilityColor("Unaffected by luck."));
			EquipmentSlot.MyFixedUpdate += new Manipulator(RemoveGestureAutocast);
			Inventory.CalculateEquipmentCooldownScale += new Manipulator(RemoveGestureCdr);
			EquipmentSlot.ExecuteIfReady += new Manipulator(AllowGestureUndercast);
			EquipmentSlot.OnEquipmentExecuted += new hook_OnEquipmentExecuted(AddGestureUndercast);
			Inventory.CalculateEquipmentCooldownScale += new hook_CalculateEquipmentCooldownScale(AddGestureCdi);
			Inventory.GetEquipmentSlotMaxCharges += new hook_GetEquipmentSlotMaxCharges(AddGestureStock);
			EquipmentSlot.MyFixedUpdate += new hook_MyFixedUpdate(AddGestureBreak);
			Inventory.UpdateEquipment += new Manipulator(FixMaxStock);
		}

		private void AllowGestureUndercast(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<EquipmentSlot>(x, "get_stock")
			});
			val.Emit(OpCodes.Ldarg_0);
			val.EmitDelegate<Func<int, EquipmentSlot, int>>((Func<int, EquipmentSlot, int>)delegate(int stock, EquipmentSlot slot)
			{
				if (stock > 0)
				{
					return stock;
				}
				return (slot.inventory.GetItemCountEffective(Items.AutoCastEquipment) > 0) ? 1 : 0;
			});
		}

		private void FixMaxStock(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[2]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "EquipmentMagazine"),
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<Inventory>(x, "GetItemCountEffective")
			});
			int num = default(int);
			val.GotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchStloc(x, ref num)
			});
			val.Emit(OpCodes.Ldarg_0);
			val.EmitDelegate<Func<int, Inventory, int>>((Func<int, Inventory, int>)delegate(int stock, Inventory inv)
			{
				stock += GetGestureStockFromInventory(inv);
				return stock;
			});
		}

		private int AddGestureStock(orig_GetEquipmentSlotMaxCharges orig, Inventory self)
		{
			int num = orig.Invoke(self);
			return num + GetGestureStockFromInventory(self);
		}

		public static int GetGestureStockFromInventory(Inventory inv)
		{
			int itemCountEffective = inv.GetItemCountEffective(Items.AutoCastEquipment);
			if (itemCountEffective > 0)
			{
				return 4 + 2 * (itemCountEffective - 1);
			}
			return 0;
		}

		private float AddGestureCdi(orig_CalculateEquipmentCooldownScale orig, Inventory self)
		{
			float num = orig.Invoke(self);
			int itemCountEffective = self.GetItemCountEffective(Items.AutoCastEquipment);
			if (itemCountEffective > 0)
			{
				num *= 1f + gestureCdiBase + gestureCdiStack * (float)(itemCountEffective - 1);
			}
			return num;
		}

		private void RemoveGestureCdr(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_005b: 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)
			ILCursor val = new ILCursor(il);
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[2]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "AutoCastEquipment"),
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<Inventory>(x, "GetItemCountEffective")
			});
			val.Emit(OpCodes.Pop);
			val.Emit(OpCodes.Ldc_I4, 0);
		}

		private void AddGestureUndercast(orig_OnEquipmentExecuted orig, EquipmentSlot self)
		{
			bool flag = false;
			if (NetworkServer.active && self.stock <= 0 && self.inventory.GetItemCountEffective(Items.AutoCastEquipment) > 0)
			{
				self.inventory.RestockEquipmentCharges(self.activeEquipmentSlot, 1);
				flag = true;
			}
			orig.Invoke(self);
			if (NetworkServer.active && flag)
			{
				self.characterBody.AddBuff(CommonAssets.gestureQueueEquipBreak);
				if (self.subcooldownTimer <= 0f)
				{
					TryGestureEquipmentBreak(self);
				}
			}
		}

		private void AddGestureBreak(orig_MyFixedUpdate orig, EquipmentSlot self, float deltaTime)
		{
			orig.Invoke(self, deltaTime);
			if (NetworkServer.active && self.subcooldownTimer <= 0f)
			{
				TryGestureEquipmentBreak(self);
			}
		}

		private void AddPreonAccumulatorBreak(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[2]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 0f),
				(Instruction x) => ILPatternMatchingExt.MatchStfld<EquipmentSlot>(x, "bfgChargeTimer")
			});
			val.Emit(OpCodes.Ldarg_0);
			val.EmitDelegate<Action<EquipmentSlot>>((Action<EquipmentSlot>)delegate(EquipmentSlot self)
			{
				TryGestureEquipmentBreak(self);
			});
		}

		public static void TryGestureEquipmentBreak(EquipmentSlot self)
		{
			if (NetworkServer.active && self.characterBody.HasBuff(CommonAssets.gestureQueueEquipBreak))
			{
				if (Util.CheckRoll(gestureEquipBreakChance, 0f, (CharacterMaster)null))
				{
					self.inventory.SetEquipmentIndex((EquipmentIndex)(-1));
				}
				self.characterBody.RemoveBuff(CommonAssets.gestureQueueEquipBreak);
			}
		}

		private void RemoveGestureAutocast(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_005b: 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)
			ILCursor val = new ILCursor(il);
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[2]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "AutoCastEquipment"),
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<Inventory>(x, "GetItemCountEffective")
			});
			val.Emit(OpCodes.Pop);
			val.Emit(OpCodes.Ldc_I4, 0);
		}

		public void HappiestMaskRework()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			StatHooks.GetMoreStatCoefficients += new MoreStatHookEventHandler(MaskExecution);
			GlobalEventManager.onServerCharacterExecuted += HappiestMaskGhostSpawn;
			GlobalEventManager.OnCharacterDeath += new Manipulator(RevokeHappiestMaskRights);
			CharacterBody.OnInventoryChanged += new hook_OnInventoryChanged(AddMaskBehavior);
			LanguageAPI.Add("ITEM_GHOSTONKILL_PICKUP", "Haunt nearby enemies, marking them for execution. Executing enemies summons a ghost.");
			LanguageAPI.Add("ITEM_GHOSTONKILL_DESC", $"Once every <style=cIsDamage>{HappiestMaskBehavior.baseHauntInterval}</style> seconds, " + "<style=cIsDamage>Haunt</style> a nearby non-boss enemy, marking them for Execution below <style=cIsHealth>" + Tools.ConvertDecimal(hauntExecutionThreshold) + "</style> health. Execution <style=cIsDamage>spawns a ghost</style> of the killed enemy with <style=cIsDamage>1500%</style> damage, " + $"lasting for <style=cIsDamage>{ghostDurationPerStack}s</style> <style=cStack>(+{ghostDurationPerStack}s per stack)</style> " + Language.Styling.UtilityColor("(double for Haunted enemies)") + ".");
			LanguageAPI.Add("ITEM_GHOSTONKILL_LORE", "<style=cMono>\r\n//--AUTO-TRANSCRIPTION FROM RALLYPOINT DELTA --//</style>\r\n\r\n“Sir, the ghosts are back.”\r\n\r\nThe man sighed. After a routine expedition, one of the crew members – a simple soldier - had recovered an artifact thought to have been aboard the Contact Light – a simple mask, adorned with a painfully happy grin. \r\n\r\n“I’ll take care of it.” The man trudged down the hall towards the barracks. The Lemurians he had killed earlier that day walked down the hall by him, barely earning a second glance from the man. This had become so commonplace that most of the crew members in this block had grown accustomed to having a ghostly room-mate.\r\n\r\nBut enough was enough. Stepping through the ghost of an Imp, the man slammed the door open. The lights were off, and in the corner sat the soldier.\r\n\r\n“Alright, we’ve had enough fun playing with the dead. Fork it over.”\r\n\r\nNo response. The man grunted and hoisted the soldier to his feet, giving him a few rough shakes. “Hey, can you hear me!? I said hand over the mask! I’m tired of waking up next to Beetles, so give it a rest already--”\r\n\r\nThe soldier’s limp body moved. Slowly, the soldier raised his finger – pointing directly at the man.\r\n\r\n“What are you...?” With a sense of dread, the man turned and saw the Lemurians he had killed earlier step into the room. Their mouths began to glow with an otherworldly light.\r\n\r\nThe man cursed under his breath as he loaded his shotgun. “This planet, I tell you...”");
		}

		private void MaskExecution(CharacterBody sender, MoreStatHookEventArgs args)
		{
			bool flag = sender.HasBuff(CommonAssets.hauntDebuff);
			args.ModifyBaseExecutionThreshold(hauntExecutionThreshold, flag);
		}

		private void AddMaskBehavior(orig_OnInventoryChanged orig, CharacterBody self)
		{
			orig.Invoke(self);
			int itemCountEffective = self.inventory.GetItemCountEffective(Items.GhostOnKill);
			self.AddItemBehavior<HappiestMaskBehavior>(itemCountEffective);
		}

		private void HappiestMaskGhostSpawn(DamageReport damageReport, float executionHealthLost)
		{
			CharacterBody victimBody = damageReport.victimBody;
			CharacterBody attackerBody = damageReport.attackerBody;
			if (!Object.op_Implicit((Object)(object)victimBody) || !Object.op_Implicit((Object)(object)attackerBody))
			{
				return;
			}
			Inventory inventory = attackerBody.inventory;
			if (!Object.op_Implicit((Object)(object)inventory))
			{
				return;
			}
			int num = inventory.GetItemCountEffective(Items.GhostOnKill);
			if (num > 0 && Object.op_Implicit((Object)(object)victimBody) && Util.CheckRoll(ghostSpawnChanceOnExecute, attackerBody.master))
			{
				if (victimBody.HasBuff(CommonAssets.hauntDebuff))
				{
					num *= 2;
				}
				Util.TryToCreateGhost(victimBody, attackerBody, Mathf.CeilToInt((float)num * ghostDurationPerStack));
			}
		}

		private void RevokeHappiestMaskRights(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[2]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "GhostOnKill"),
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<Inventory>(x, "GetItemCountEffective")
			});
			val.Emit(OpCodes.Ldc_I4, 0);
			val.Emit(OpCodes.Mul);
		}

		public void HuntersHarpoonRework()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			CharacterBody.RecalculateStats += new Manipulator(ChangeMoveSpeed);
			GlobalEventManager.OnCharacterDeath += new Manipulator(ChangeDuration);
			LanguageAPI.Add("ITEM_MOVESPEEDONKILL_DESC", "Killing an enemy increases <style=cIsUtility>movement speed</style> by <style=cIsUtility>125%</style> for <style=cIsUtility>1</style> <style=cStack>(+1 per stack)</style> seconds. Consecutive kills increase buff duration to up to 25 seconds.");
		}

		public static void ChangeMoveSpeed(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);
			float num = default(float);
			if (!val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[4]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, ref num),
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC1Content/Buffs", "KillMoveSpeed"),
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<CharacterBody>(x, "GetBuffCount")
			}))
			{
				Log.DebugBreakpoint("ChangeMoveSpeed");
				return;
			}
			val.Next.Operand = 1.25f;
			val.Index += 4;
			val.EmitDelegate<Func<int, int>>((Func<int, int>)((int buffCount) => (buffCount > 0) ? 1 : 0));
		}

		private void ChangeDuration(ILContext il)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			int attackerBodyLoc = 16;
			int itemCountLoc = 54;
			int buffCountLoc = 86;
			int iteratorLoc = 91;
			ILLabel val2 = val.DefineLabel();
			ILLabel val3 = val.DefineLabel();
			if (!val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[3]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC1Content/Items", "MoveSpeedOnKill"),
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<Inventory>(x, "GetItemCountEffective"),
				(Instruction x) => ILPatternMatchingExt.MatchStloc(x, ref itemCountLoc)
			}))
			{
				Log.DebugBreakpoint("ChangeDuration", 1);
				return;
			}
			if (!val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[2]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 5),
				(Instruction x) => ILPatternMatchingExt.MatchStloc(x, ref buffCountLoc)
			}))
			{
				Log.DebugBreakpoint("ChangeDuration", 2);
				return;
			}
			int index = val.Index;
			val.Index = index + 1;
			val2 = val.MarkLabel();
			if (!val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[3]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, ref attackerBodyLoc),
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC1Content/Buffs", "KillMoveSpeed"),
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<CharacterBody>(x, "ClearTimedBuffs")
			}))
			{
				Log.DebugBreakpoint("ChangeDuration", 3);
				return;
			}
			if (!val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<CharacterBody>(x, "AddTimedBuff")
			}))
			{
				Log.DebugBreakpoint("ChangeDuration", 4);
				return;
			}
			val3 = val.MarkLabel();
			if (!val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[2]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, ref iteratorLoc),
				(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, buffCountLoc)
			}))
			{
				Log.DebugBreakpoint("ChangeDuration", 5);
				return;
			}
			val.GotoLabel(val3, (MoveType)1, false);
			val.Emit(OpCodes.Ldloc, iteratorLoc);
			val.EmitDelegate<Func<float, int, float>>((Func<float, int, float>)((float baseBuffDuration, int iterator) => iterator + 1));
			val.GotoLabel(val2, (MoveType)1, false);
			val.Emit(OpCodes.Ldloc, itemCountLoc);
			val.Emit(OpCodes.Ldloc, attackerBodyLoc);
			val.EmitDelegate<Func<int, int, CharacterBody, int>>((Func<int, int, CharacterBody, int>)delegate(int vanillaBuffCount, int itemCount, CharacterBody attackerBody)
			{
				if (itemCount > 25)
				{
					return itemCount;
				}
				int buffCount = attackerBody.GetBuffCount(Buffs.KillMoveSpeed);
				return Mathf.Min(25, buffCount + itemCount);
			});
		}

		public void ReworkLaserScope()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			ItemDef val = Addressables.LoadAssetAsync<ItemDef>((object)"RoR2/DLC1/CritDamage/CritDamage.asset").WaitForCompletion();
			RetierItemAsync(RoR2_DLC1_CritDamage.CritDamage_asset, (ItemTier)1, FixIcon);
			RecalculateStatsAPI.GetStatCoefficients += new StatHookEventHandler(ScopeCritChance);
			CharacterBody.OnInventoryChanged += new hook_OnInventoryChanged(AddScopeItemBehavior);
			LanguageAPI.Add("ITEM_CRITDAMAGE_NAME", "Combat Telescope");
			LanguageAPI.Add("ITEM_CRITDAMAGE_PICKUP", "Increases 'Critical Strike' chance and damage while stationary.");
			LanguageAPI.Add("ITEM_CRITDAMAGE_DESC", "<style=cIsDamage>Critical Strikes</style> deal an additional <style=cIsDamage>100% damage</style> <style=cStack>(+100% per stack)</style>. " + $"Gain <style=cIsDamage>{scopeBaseCrit}% critical chance</style>, " + $"or <style=cIsDamage>{scopeBaseStationaryCrit}%</style> after standing still " + $"for <style=cIsUtility>{CombatTelescopeBehavior.combatTelescopeWaitTime}</style> seconds.");
			static void FixIcon(ItemDef itemDef)
			{
				Sprite val2 = retierAssetBundle.LoadAsset<Sprite>("Assets/Icons/Laser_Scope.png");
				if (Object.op_Implicit((Object)(object)val2))
				{
					itemDef.pickupIconSprite = val2;
				}
			}
		}

		private void AddScopeItemBehavior(orig_OnInventoryChanged orig, CharacterBody self)
		{
			orig.Invoke(self);
			self.AddItemBehavior<CombatTelescopeBehavior>(self.inventory.GetItemCountEffective(Items.CritDamage));
		}

		private void ScopeCritChance(CharacterBody sender, StatHookEventArgs args)
		{
			if (!Object.op_Implicit((Object)(object)sender.inventory))
			{
				return;
			}
			int itemCountEffective = sender.inventory.GetItemCountEffective(Items.CritDamage);
			if (itemCountEffective > 0)
			{
				int num = scopeBaseCrit;
				int buffCount = sender.GetBuffCount(CommonAssets.combatTelescopeCritChance);
				if (buffCount > 0)
				{
					num = scopeBaseStationaryCrit;
				}
				args.critAdd += (float)num;
			}
		}

		private void RevokeScopeRights(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[2]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC1Content/Items", "CritDamage"),
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<Inventory>(x, "GetItemCountEffective")
			});
			val.Emit(OpCodes.Ldc_I4, 0);
			val.Emit(OpCodes.Mul);
		}

		public void ReworkLeechingSeed()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			RetierItemAsync(RoR2_Base_Seed.Seed_asset, (ItemTier)0, FixIcon);
			GlobalEventManager.ProcessHitEnemy += new Manipulator(FuckLeechingSeed);
			static void FixIcon(ItemDef itemDef)
			{
				Sprite val = retierAssetBundle.LoadAsset<Sprite>("Assets/Icons/Leeching_Seed.png");
				if (Object.op_Implicit((Object)(object)val))
				{
					itemDef.pickupIconSprite = val;
				}
			}
		}

		private void NewSeedBehavior(CharacterBody body, DamageInfo damageInfo, CharacterBody victimBody)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (((ProcChainMask)(ref damageInfo.procChainMask)).HasProc((ProcType)6))
			{
				return;
			}
			Inventory inventory = body.inventory;
			if ((Object)(object)inventory != (Object)null)
			{
				int itemCountEffective = inventory.GetItemCountEffective(seedItemDef);
				if (itemCountEffective > 0)
				{
					ProcChainMask procChainMask = damageInfo.procChainMask;
					((ProcChainMask)(ref procChainMask)).AddProc((ProcType)6);
					body.AddTimedBuff(Buffs.MeatRegenBoost, (seedRegenDurationBase + seedRegenDurationStack * (float)(itemCountEffective - 1)) * damageInfo.procCoefficient);
				}
			}
		}

		private void FuckLeechingSeed(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0065: 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>[2]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 6),
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.ProcChainMask", "HasProc")
			}))
			{
				val.Emit(OpCodes.Ldarg_1);
				val.EmitDelegate<Func<bool, DamageInfo, bool>>((Func<bool, DamageInfo, bool>)((bool cantProc, DamageInfo damageInfo) => cantProc || (!((DamageTypeCombo)(ref damageInfo.damageType)).IsDamageSourceSkillBased && (int)damageInfo.damageType.damageSource != 64)));
			}
		}

		public void ReworkFreshMeat()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			ChangeBuffStacking("MeatRegenBoost", canStack: true);
			RecalculateStatsAPI.GetStatCoefficients += new StatHookEventHandler(LetMeatActuallyStack);
			GlobalEventManager.OnCharacterDeath += new hook_OnCharacterDeath(MeatRegen);
			LanguageAPI.Add("ITEM_FLATHEALTH_PICKUP", "Regenerate health after killing an enemy.");
			LanguageAPI.Add("ITEM_FLATHEALTH_DESC", "Increases <style=cIsHealing>base health regeneration</style> by <style=cIsHealing>+2 hp/s</style> for <style=cIsUtility>3s</style> <style=cStack>(+3s per stack)</style> after killing an enemy.");
		}

		private void MeatRegen(orig_OnCharacterDeath orig, GlobalEventManager self, DamageReport damageReport)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			CharacterBody attackerBody = damageReport.attackerBody;
			if ((Object)(object)attackerBody != (Object)null && (Object)(object)attackerBody.inventory != (Object)null)
			{
				Inventory inventory = attackerBody.inventory;
				int itemCountEffective = inventory.GetItemCountEffective(Items.FlatHealth);
				if (itemCountEffective > 0)
				{
					attackerBody.AddTimedBuffAuthority(Buffs.MeatRegenBoost.buffIndex, (float)(3 * itemCountEffective));
				}
			}
			orig.Invoke(self, damageReport);
		}

		private void LetMeatActuallyStack(CharacterBody sender, StatHookEventArgs args)
		{
			int buffCount = sender.GetBuffCount(Buffs.MeatRegenBoost);
			if (buffCount > 1)
			{
				args.baseRegenAdd += 2f * (1f + 0.2f * (sender.level - 1f)) * (float)(buffCount - 1);
			}
			Inventory inventory = sender.inventory;
			if ((Object)(object)inventory != (Object)null)
			{
				args.baseHealthAdd -= (float)(inventory.GetItemCountEffective(Items.FlatHealth) * 25);
			}
		}

		private void PlanulaChanges()
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			LanguageAPI.Add("ITEM_PARENTEGG_PICKUP", "The unmatched power of the sun!");
			LanguageAPI.Add("ITEM_PARENTEGG_DESC", "After beginning the teleporter event, " + Language.Styling.DamageColor("summon a sun overhead") + " that lasts for " + Language.Styling.DamageColor(sunDurationBase.ToString()) + " seconds " + Language.Styling.StackText($"+{sunDurationStack}") + ". " + Language.Styling.HealthColor("All enemies and allies burn near the sun") + ".");
			HealthComponent.TakeDamageProcess += new Manipulator(FuckPlanula);
			IdleToChargingState.OnEnter += new hook_OnEnter(OnTeleporterEventPreStart);
			ChargingState.OnEnter += new hook_OnEnter(OnTeleporterEventStart);
			ChargingState.FixedUpdate += new hook_FixedUpdate(OnTeleporterEventUpdate);
		}

		private void FuckPlanula(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdfld(x, "RoR2.HealthComponent/ItemCounts", "parentEgg")
			});
			val.Emit(OpCodes.Pop);
			val.Emit(OpCodes.Ldc_I4_0);
		}

		private void OnTeleporterEventPreStart(orig_OnEnter orig, IdleToChargingState self)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			if (!NetworkServer.active)
			{
				return;
			}
			int itemCountForTeam = Util.GetItemCountForTeam((TeamIndex)1, Items.ParentEgg.itemIndex, false, false);
			if (itemCountForTeam <= 0)
			{
				return;
			}
			TeleporterInteraction teleporterInteraction = ((BaseTeleporterState)self).teleporterInteraction;
			GameObject chargeActivatorServer = teleporterInteraction.chargeActivatorServer;
			PlanulaSunController planulaSunController = ((Component)teleporterInteraction).gameObject.AddComponent<PlanulaSunController>();
			Debug.Log((object)((Object)(object)planulaSunController != (Object)null));
			if ((Object)(object)planulaSunController != (Object)null)
			{
				planulaSunController.holdoutZoneController = teleporterInteraction.holdoutZoneController;
				Transform val = ((EntityState)self).transform.Find("FireworkOrigin");
				if ((Object)(object)val == (Object)null)
				{
					val = ((Component)teleporterInteraction).transform;
				}
				planulaSunController.activator = chargeActivatorServer;
				planulaSunController.CreateBeamEffect(val);
				planulaSunController.SetSunDuration(itemCountForTeam);
			}
		}

		private void OnTeleporterEventStart(orig_OnEnter orig, ChargingState self)
		{
			orig.Invoke(self);
			if (NetworkServer.active)
			{
				PlanulaSunController component = ((EntityState)self).gameObject.GetComponent<PlanulaSunController>();
				if ((Object)(object)component != (Object)null)
				{
					component.EndBeamEffect();
					component.CreateSun();
				}
			}
		}

		private void OnTeleporterEventUpdate(orig_FixedUpdate orig, ChargingState self)
		{
			orig.Invoke(self);
			if (NetworkServer.active)
			{
			}
		}

		public void PrayerBeadsRework()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			RetierItemAsync(RoR2_DLC2_Items_ExtraStatsOnLevelUp.ExtraStatsOnLevelUp_asset, (ItemTier)1, ChangeTags);
			CharacterMaster.OnBodyStart += new hook_OnBodyStart(InitializeBeadBuff);
			object obj = <>c.<>9__111_1;
			if (obj == null)
			{
				hook_TrackBeadExperience val = delegate
				{
				};
				<>c.<>9__111_1 = val;
				obj = (object)val;
			}
			CharacterMaster.TrackBeadExperience += (hook_TrackBeadExperience)obj;
			CharacterBody.RecalculateStats += new Manipulator(ChangeBeadAppliedStats);
			ExperienceManager.AwardExperience += new hook_AwardExperience(BeadExperience);
			StatHooks.GetMoreStatCoefficients += new MoreStatHookEventHandler(BeadScrapCount);
			LanguageAPI.Add("ITEM_EXTRASTATSONLEVELUP_PICKUP", "Prioritized when used with <style=cIsHealing>Uncommon</style> 3D Printers. Permanently increase ALL stats after removal.");
			LanguageAPI.Add("ITEM_EXTRASTATSONLEVELUP_DESC", "Prioritized when used with <style=cIsHealing>Uncommon</style> 3D Printers. After removal, permanently grants a " + Language.Styling.ConvertDecimal(beadsPermanentStatBonus) + " increase to <style=cIsUtility>experience gain</style>, <style=cIsHealing>health</style>, <style=cIsHealing>shield</style>, <style=cIsHealing>regeneration</style>, and <style=cIsDamage>damage</style>.");
			static void ChangeTags(ItemDef itemDef)
			{
				ItemTag[] array = new ItemTag[6];
				RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
				itemDef.tags = (ItemTag[])(object)array;
			}
		}

		private void BeadScrapCount(CharacterBody sender, MoreStatHookEventArgs args)
		{
			if (Object.op_Implicit((Object)(object)sender.inventory))
			{
				args.scrapGreenCountAdd += sender.inventory.GetItemCountEffective(Items.ExtraStatsOnLevelUp);
			}
		}

		private void BeadExperience(orig_AwardExperience orig, ExperienceManager self, Vector3 origin, CharacterBody body, ulong amount)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)body.master != (Object)null && (Object)(object)body.inventory != (Object)null)
			{
				float num = 1f + body.inventory.beadAppliedHealth * beadsPermanentStatBonus;
				amount += (ulong)((float)amount * num);
			}
			orig.Invoke(self, origin, body, amount);
		}

		private void InitializeBeadBuff(orig_OnBodyStart orig, CharacterMaster self, CharacterBody body)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self, body);
			Inventory inventory = body.inventory;
			if (!((Object)(object)inventory == (Object)null) && !(inventory.beadAppliedHealth <= 0f))
			{
				body.SetBuffCount(Buffs.ExtraStatsOnLevelUpBuff.buffIndex, (int)inventory.beadAppliedHealth);
			}
		}

		private void ChangeBeadAppliedStats(ILContext il)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			ILCursor c = new ILCursor(il);
			int itemCountLoc = 69;
			ILLabel label = null;
			if (!c.TryGotoNext((MoveType)2, new Func<Instruction, bool>[3]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Items", "ExtraStatsOnLevelUp"),
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<Inventory>(x, "GetItemCountPermanent"),
				(Instruction x) => ILPatternMatchingExt.MatchStloc(x, ref itemCountLoc)
			}))
			{
				Log.DebugBreakpoint("ChangeBeadAppliedStats", 1);
				return;
			}
			if (!c.TryGotoNext((MoveType)2, new Func<Instruction, bool>[4]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, itemCountLoc),
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
				(Instruction x) => ILPatternMatchingExt.MatchLdfld<CharacterBody>(x, "extraStatsOnLevelUpCount_CachedLastApplied"),
				(Instruction x) => ILPatternMatchingExt.MatchBge(x, ref label)
			}))
			{
				Log.DebugBreakpoint("ChangeBeadAppliedStats", 2);
				return;
			}
			c.Emit(OpCodes.Ldloc, itemCountLoc);
			c.Emit(OpCodes.Ldarg_0);
			c.EmitDelegate<Action<int, CharacterBody>>((Action<int, CharacterBody>)delegate(int itemCount, CharacterBody self)
			{
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				int num6 = self.extraStatsOnLevelUpCount_CachedLastApplied - itemCount;
				self.extraStatsOnLevelUpCount_CachedLastApplied = itemCount;
				Inventory inventory = self.inventory;
				inventory.beadAppliedHealth += (float)num6;
				Inventory inventory2 = self.inventory;
				inventory2.beadAppliedShield += (float)num6;
				Inventory inventory3 = self.inventory;
				inventory3.beadAppliedRegen += (float)num6;
				Inventory inventory4 = self.inventory;
				inventory4.beadAppliedDamage += (float)num6;
				self.SetBuffCount(Buffs.ExtraStatsOnLevelUpBuff.buffIndex, (int)self.inventory.beadAppliedHealth);
			});
			if (!c.TryGotoNext((MoveType)2, new Func<Instruction, bool>[2]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "ExtraStatsOnLevelUpBuff"),
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<CharacterBody>(x, "GetBuffCount")
			}))
			{
				Log.DebugBreakpoint("ChangeBeadAppliedStats", 3);
				return;
			}
			c.EmitDelegate<Func<int, int>>((Func<int, int>)((int buffCount) => 0));
			c.GotoLabel(label, (MoveType)1, false);
			ChangeBeadStat("beadAppliedHealth", ChangeBeadHealthBonus);
			ChangeBeadStat("beadAppliedShield", ChangeBeadShieldBonus);
			ChangeBeadStat("beadAppliedRegen", ChangeBeadRegenBonus);
			ChangeBeadStat("beadAppliedDamage", ChangeBeadDamageBonus);
			static float ChangeBeadDamageBonus(float beadBonusStacks, CharacterBody self, float level)
			{
				float num = self.baseDamage + self.levelDamage * level;
				return num * beadsPermanentStatBonus * beadBonusStacks;
			}
			static float ChangeBeadHealthBonus(float beadBonusStacks, CharacterBody self, float level)
			{
				float num5 = self.baseMaxHealth + self.levelMaxHealth * level;
				return num5 * beadsPermanentStatBonus * beadBonusStacks;
			}
			static float ChangeBeadRegenBonus(float beadBonusStacks, CharacterBody self, float level)
			{
				float num2 = Mathf.Abs(self.baseRegen + self.levelRegen * level);
				return num2 * beadsPermanentStatBonus * beadBonusStacks;
			}
			static float ChangeBeadShieldBonus(float beadBonusStacks, CharacterBody self, float level)
			{
				float num3 = self.baseMaxHealth + self.levelMaxHealth * level;
				return num3 * beadsPermanentStatBonus * beadBonusStacks;
			}
			void ChangeBeadStat(string beadStatName, Func<float, CharacterBody, float, float> callback)
			{
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				float num4 = default(float);
				ILLabel val = default(ILLabel);
				if (!c.TryGotoNext((MoveType)2, new Func<Instruction, bool>[3]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdfld<Inventory>(x, beadStatName),
					(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, ref num4),
					(Instruction x) => ILPatternMatchingExt.MatchBleUn(x, ref val)
				}) || !c.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdfld<Inventory>(x, beadStatName)
				}))
				{
					Log.DebugBreakpoint("ChangeBeadStat:" + beadStatName, 3);
				}
				else
				{
					c.Emit(OpCodes.Ldarg_0);
					c.EmitDelegate<Func<float, CharacterBody, float>>((Func<float, CharacterBody, float>)delegate(float beadBonus, CharacterBody self)
					{
						float arg = self.level - 1f;
						return callback(beadBonus, self, arg);
					});
				}
			}
		}

		public void RazorwireRework()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			RecalculateStatsAPI.GetStatCoefficients += new StatHookEventHandler(RazorwireArmor);
			CharacterBody.OnInventoryChanged += new hook_OnInventoryChanged(AddRazorBehavior);
			HealthComponent.TakeDamageProcess += new Manipulator(RazorwireBegin);
			LightningOrb.OnArrival += new Manipulator(RazorwireArrival);
			LanguageAPI.Add("ITEM_THORNS_PICKUP", "Retaliate in a burst of bleeding razors on taking damage. Recharges over time.");
			LanguageAPI.Add("ITEM_THORNS_DESC", $"Increase <style=cIsHealing>armor</style> by <style=cIsHealing>{razorwireArmorBase}</style> <style=cStack>(+{razorwireArmorStack} per stack)</stack>" + "Getting hit causes you to explode in a burst of razors, " + $"<style=cIsDamage>bleeding</style> up to <style=cIsDamage>{razorwireTargetsBase}</style> " + $"<style=cStack>(+{razorwireTargetsStack} per stack)</style> nearby enemies " + "for <style=cIsDamage>" + Tools.ConvertDecimal(razorwireBleedDuration * 0.8f) + "</style> base damage per <style=cIsDamage>razor charge</style> expelled. " + $"You can hold up to {RazorwireBehavior.baseRazors} <style=cStack>(+{RazorwireBehavior.stackRazors} per stack)</style> " + $"razor charges, all reloading over <style=cIsUtility>{RazorwireBehavior.rechargeTime}</style> seconds.");
		}

		private void RazorwireArmor(CharacterBody sender, StatHookEventArgs args)
		{
			if (Object.op_Implicit((Object)(object)sender.inventory))
			{
				int itemCountEffective = sender.inventory.GetItemCountEffective(Items.Thorns);
				if (itemCountEffective > 0)
				{
					args.armorAdd += razorwireArmorBase + razorwireArmorStack * (float)(itemCountEffective - 1);
				}
			}
		}

		private void AddRazorBehavior(orig_OnInventoryChanged orig, CharacterBody self)
		{
			orig.Invoke(self);
			int itemCountEffective = self.inventory.GetItemCountEffective(Items.Thorns);
			self.AddItemBehavior<RazorwireBehavior>(itemCountEffective);
		}

		private void RazorwireArrival(ILContext il)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			int healthComponentLoc = 0;
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[2]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdfld<HurtBox>(x, "healthComponent"),
				(Instruction x) => ILPatternMatchingExt.MatchStloc(x, ref healthComponentLoc)
			});
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, healthComponentLoc)
			});
			val.Emit(OpCodes.Ldarg_0);
			val.EmitDelegate<Func<HealthComponent, LightningOrb, HealthComponent>>((Func<HealthComponent, LightningOrb, HealthComponent>)delegate(HealthComponent hc, LightningOrb orb)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Invalid comparison between Unknown and I4
				if ((int)orb.lightningType == 6 && (Object)(object)hc != (Object)null)
				{
					for (int i = 0; (float)i < orb.procCoefficient; i++)
					{
						DotController.InflictDot(((Component)hc).gameObject, orb.attacker, hc.body.mainHurtBox, (DotIndex)0, razorwireBleedDuration, orb.damageValue, (uint?)null);
					}
					return null;
				}
				return hc;
			});
		}

		private void RazorwireBegin(ILContext il)
		{
			//IL_0008: Unknown result type (might