using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using EntityStates;
using EntityStates.BeetleQueenMonster;
using EntityStates.ClayBruiser.Weapon;
using EntityStates.GoldGat;
using EntityStates.Gup;
using EntityStates.ImpBossMonster;
using EntityStates.LunarWisp;
using EntityStates.Missions.Arena.NullWard;
using EntityStates.NullifierMonster;
using EntityStates.QuestVolatileBattery;
using EntityStates.ShrineHalcyonite;
using EntityStates.VagrantMonster;
using EntityStates.VagrantNovaItem;
using HG;
using IL.RoR2;
using IL.RoR2.Items;
using IL.RoR2.Orbs;
using IL.RoR2.Projectile;
using IL.RoR2.Skills;
using Mono.Cecil;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using MoreStats;
using On.EntityStates.CaptainSupplyDrop;
using On.EntityStates.ClayBruiser.Weapon;
using On.EntityStates.Gup;
using On.EntityStates.LunarWisp;
using On.EntityStates.Missions.Arena.NullWard;
using On.EntityStates.NullifierMonster;
using On.EntityStates.QuestVolatileBattery;
using On.EntityStates.ShrineHalcyonite;
using On.EntityStates.VagrantMonster;
using On.EntityStates.VagrantNovaItem;
using On.RoR2;
using On.RoR2.Items;
using On.RoR2.Orbs;
using On.RoR2.UI;
using R2API;
using R2API.Utils;
using RainrotSharedUtils.Difficulties;
using RainrotSharedUtils.Shelters;
using RiskierRain.Components;
using RiskierRain.CoreModules;
using RoR2;
using RoR2.ContentManagement;
using RoR2.Items;
using RoR2.Orbs;
using RoR2.Projectile;
using RoR2.Skills;
using RoR2.UI;
using RoR2BepInExPack.GameAssetPaths.Version_1_39_0;
using RoR2BepInExPack.GameAssetPathsBetter;
using SwanSongExtended;
using SwanSongExtended.Modules;
using SwanSongExtended.Storms;
using ThreeEyedGames;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.ResourceManagement.AsyncOperations;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("RiskierRain")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("RiskierRain")]
[assembly: AssemblyTitle("RiskierRain")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: UnverifiableCode]
namespace RiskierRain
{
	[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.*/)]
	[BepInPlugin("com.RiskOfBrainrot.RiskierRain", "RiskierRain", "1.3.9")]
	[R2APISubmoduleDependency(new string[] { "LanguageAPI", "PrefabAPI", "DirectorAPI", "ItemAPI", "RecalculateStatsAPI", "EliteAPI" })]
	internal class RiskierRainPlugin : BaseUnityPlugin
	{
		public delegate bool orig_getHasOneShotProtection(CharacterBody self);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			public static Func<uint> <>9__138_2;

			public static Action<GameObject> <>9__188_0;

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

			public static Action<CharacterBody> <>9__208_1;

			public static hook_OnEnter <>9__219_0;

			public static hook_OnEnter <>9__219_1;

			public static hook_OnEnter <>9__254_0;

			public static hook_OnEnter <>9__278_1;

			public static hook_OnEnter <>9__278_2;

			public static hook_OnEnter <>9__278_3;

			public static hook_OnEnter <>9__279_1;

			public static hook_OnEnter <>9__279_2;

			public static hook_OnEnter <>9__279_3;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			public static Func<int, HealthComponent, int> <>9__361_2;

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

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

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

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

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

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

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

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

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

			public static Func<ChestBehavior, int, ChestBehavior> <>9__377_2;

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

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

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

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

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

			public static Func<ChestBehavior, int, int> <>9__378_8;

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

			public static Func<RouletteChestController, int, int> <>9__378_10;

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

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

			public static Func<float, SprintWispBodyBehavior, float> <>9__414_1;

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

			public static Func<Vector3, DevilOrb, Vector3> <>9__416_1;

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

			public static Func<float, DamageReport, int, float> <>9__417_1;

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

			public static Func<float, DamageReport, int, float> <>9__417_3;

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

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

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

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

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

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

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

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

			public static Func<float, DamageReport, int, float> <>9__418_8;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			public static Func<GameObject, bool> <>9__434_0;

			public static Func<GameObject, bool> <>9__434_1;

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

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

			public static Action<CharacterBody, BuffDef, float, float> <>9__452_3;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			public static Func<DamageTypeCombo, DamageTypeCombo> <>9__515_1;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			public static Func<float, JumpDamageStrikeBodyBehavior, float> <>9__523_2;

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

			public static Func<float> <>9__524_1;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			public static Func<Type, bool> <>9__593_0;

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

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

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

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

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

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

			internal bool <AmbientLevelChanges>b__26_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchMul(x);
			}

			internal bool <AmbientLevelChanges>b__26_3(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<Mathf>(x, "Floor");
			}

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

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

			internal bool <AmbientLevelChanges>b__26_6(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<Run>(x, "stageClearCount");
			}

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

			internal bool <AmbientLevelChanges>b__26_9(Instruction x)
			{
				return ILPatternMatchingExt.MatchMul(x);
			}

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

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

			internal bool <AmbientLevelChanges>b__26_12(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<Run>(x, "stageClearCount");
			}

			internal bool <AmbientLevelChanges>b__26_13(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld<Run>(x, "ambientLevelCap");
			}

			internal float <AmbientLevelChanges>b__26_14(float levelIn)
			{
				float ambientLevelBoost = GetAmbientLevelBoost();
				return levelIn + ambientLevelBoost;
			}

			internal bool <RemoveEclipseStats>b__57_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<Run>(x, "get_selectedDifficulty");
			}

			internal bool <RemoveEclipseStats>b__57_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<Run>(x, "get_selectedDifficulty");
			}

			internal bool <RemoveEclipseEffect>b__58_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<Run>(x, "get_selectedDifficulty");
			}

			internal bool <EclipseHoldoutScale>b__60_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<Run>(x, "get_selectedDifficulty");
			}

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

			internal bool <EclipseHoldoutScale>b__60_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<HealthComponent>(x, "get_fullHealth");
			}

			internal bool <ShrineBloodReward>b__138_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<ShrineBloodBehavior>(x, "goldToPaidHpRatio");
			}

			internal uint <ShrineBloodReward>b__138_2()
			{
				return (uint)Run.instance.GetDifficultyScaledCost(25, Stage.instance.entryDifficultyCoefficient);
			}

			internal void <DoubleChestHook>b__188_0(GameObject casinoChest)
			{
				PurchaseInteraction val = default(PurchaseInteraction);
				if (casinoChest.TryGetComponent<PurchaseInteraction>(ref val))
				{
					val.saleStarCompatible = false;
				}
				RouletteChestController val2 = default(RouletteChestController);
				if (casinoChest.TryGetComponent<RouletteChestController>(ref val2))
				{
					val2.dropCount = 2;
				}
			}

			internal bool <SoulShrineLuckBuff>b__208_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Buffs", "ExtraLifeBuff");
			}

			internal void <SoulShrineLuckBuff>b__208_1(CharacterBody body)
			{
				body.AddBuff(Assets.soulShrineLuckBuff);
			}

			internal void <FixJellyNuke>b__219_0(orig_OnEnter orig, ChargeMegaNova self)
			{
				orig.Invoke(self);
				self.duration = ChargeMegaNova.baseDuration;
				if (((EntityState)self).characterBody.attackSpeed > 1.5f)
				{
					self.duration = 2f;
				}
			}

			internal void <FixJellyNuke>b__219_1(orig_OnEnter orig, ChargeState self)
			{
				orig.Invoke(self);
				self.duration = 3f;
			}

			internal void <GupChanges>b__254_0(orig_OnEnter orig, BaseSplitDeath self)
			{
				self.moneyMultiplier = 0f;
				orig.Invoke(self);
			}

			internal void <NerfTemplar>b__278_1(orig_OnEnter orig, MinigunFire self)
			{
				MinigunFire.baseFireInterval = templarFireInterval * templarBaseAttackSpeed;
				orig.Invoke(self);
			}

			internal void <NerfTemplar>b__278_2(orig_OnEnter orig, MinigunSpinUp self)
			{
				MinigunSpinUp.baseDuration = templarSpinUpDuration * templarBaseAttackSpeed;
				orig.Invoke(self);
			}

			internal void <NerfTemplar>b__278_3(orig_OnEnter orig, MinigunSpinDown self)
			{
				MinigunSpinDown.baseDuration = templarSpinDownDuration * templarBaseAttackSpeed;
				orig.Invoke(self);
			}

			internal void <NerfChimeraWisp>b__279_1(orig_OnEnter orig, FireLunarGuns self)
			{
				FireLunarGuns.baseFireInterval = 0.1f * chimeraWispBaseAttackSpeed;
				FireLunarGuns.baseDuration = 4f * chimeraWispBaseAttackSpeed;
				orig.Invoke(self);
			}

			internal void <NerfChimeraWisp>b__279_2(orig_OnEnter orig, ChargeLunarGuns self)
			{
				ChargeLunarGuns.baseDuration = chimeraWispChargeDuration * chimeraWispBaseAttackSpeed;
				ChargeLunarGuns.spinUpDuration = chimeraWispChargeDuration * chimeraWispBaseAttackSpeed;
				orig.Invoke(self);
			}

			internal void <NerfChimeraWisp>b__279_3(orig_OnEnter orig, SeekingBomb self)
			{
				SeekingBomb.spinUpDuration = 2f * chimeraWispBaseAttackSpeed;
				SeekingBomb.baseDuration = 3f * chimeraWispBaseAttackSpeed;
				orig.Invoke(self);
			}

			internal bool <GummyInheritItems>b__309_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchNewobj<DirectorSpawnRequest>(x);
			}

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

			internal bool <CapacitorNerf>b__319_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchMul(x);
			}

			internal bool <CapacitorNerf>b__319_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<GenericDamageOrb>(x, "damageValue");
			}

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

			internal bool <CapacitorBuff>b__320_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<BlastAttack>(x, "falloffModel");
			}

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

			internal bool <CapacitorBuff>b__320_3(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<BlastAttack>(x, "radius");
			}

			internal bool <GlassesNerf>b__323_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "CritGlasses");
			}

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

			internal bool <GlassesNerf>b__323_4(Instruction x)
			{
				return ILPatternMatchingExt.MatchConvR4(x);
			}

			internal bool <RemovePauldronAttackSpeed>b__328_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld(x, "RoR2.CharacterBody", "baseAttackSpeed");
			}

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

			internal bool <RemovePauldronAttackSpeed>b__328_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld(x, "RoR2.CharacterBody", "levelAttackSpeed");
			}

			internal bool <RemovePauldronAttackSpeed>b__328_5(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Buffs", "WarCryBuff");
			}

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

			internal bool <RemovePauldronAttackSpeed>b__328_8(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 1f);
			}

			internal bool <MeteorFix>b__331_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<BlastAttack>(x, "falloffModel");
			}

			internal bool <InfusionBuff>b__339_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "Infusion");
			}

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

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

			internal bool <InfusionBuff>b__339_5(Instruction x)
			{
				return ILPatternMatchingExt.MatchMul(x);
			}

			internal int <InfusionBuff>b__339_7(int currentInfusionCap, int infusionCount, CharacterBody body)
			{
				float num = 100 * infusionCount;
				if ((Object)(object)body != (Object)null)
				{
					float num2 = 1f + 0.3f * (body.level - 1f);
					num = newInfusionBaseHealth * num2 * (float)infusionCount;
				}
				return (int)num;
			}

			internal bool <PolyluteDamage>b__349_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC1Content/Items", "ChainLightningVoid");
			}

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

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

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

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

			internal bool <ModifyFireShuriken>b__355_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<CharacterBody>(x, "get_damage");
			}

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

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

			internal bool <FixLostSeersDamageImmunity>b__361_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC1Content/Items", "CritGlassesVoid");
			}

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

			internal int <FixLostSeersDamageImmunity>b__361_2(int lensCount, HealthComponent hc)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				CharacterBody body = hc.body;
				if (((Enum)body.bodyFlags).HasFlag((Enum)(object)(BodyFlags)2048))
				{
					return 0;
				}
				return lensCount;
			}

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

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

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

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

			internal bool <StickyBombRework>b__375_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "StickyBomb");
			}

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

			internal bool <StickyBombRework>b__375_3(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.Util", "OnHitProcDamage");
			}

			internal float <StickyBombRework>b__375_4(float damageCoefficient, int itemCount)
			{
				return stickyDamageCoeffBase + stickyDamageCoeffStack * (float)(itemCount - 1);
			}

			internal bool <SaleStarItemDrop>b__377_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<ChestBehavior>(x, "Roll");
			}

			internal ChestBehavior <SaleStarItemDrop>b__377_2(ChestBehavior chest, int droppedIndex)
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				if (droppedIndex + 1 >= chest.maxDropCount && chest.maxDropCount > chest.dropCount)
				{
					chest.maxDropCount = chest.dropCount;
					chest.dropTable = Addressables.LoadAssetAsync<PickupDropTable>((object)RoR2_Base_ShrineChance.dtShrineChance_asset).WaitForCompletion();
				}
				return chest;
			}

			internal bool <SaleStarOnInteraction>b__378_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<PurchaseInteraction>(x, "saleStarCompatible");
			}

			internal bool <SaleStarOnInteraction>b__378_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.Inventory/ItemTransformation/TryTransformResult", "get_totalTransformed");
			}

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

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

			internal bool <SaleStarOnInteraction>b__378_7(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<ChestBehavior>(x, "dropCount");
			}

			internal int <SaleStarOnInteraction>b__378_8(ChestBehavior chest, int totalTransformed)
			{
				chest.maxDropCount = chest.dropCount;
				return chest.dropCount + totalTransformed;
			}

			internal bool <SaleStarOnInteraction>b__378_9(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<RouletteChestController>(x, "dropCount");
			}

			internal int <SaleStarOnInteraction>b__378_10(RouletteChestController chest, int totalTransformed)
			{
				return chest.dropCount + totalTransformed;
			}

			internal bool <NkuhanasBuff>b__413_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<DevilOrb>(x, "damageValue");
			}

			internal bool <NerfDiscipleDamage>b__414_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<DevilOrb>(x, "damageValue");
			}

			internal float <NerfDiscipleDamage>b__414_1(float damageIn, SprintWispBodyBehavior behavior)
			{
				return damageIn / (float)((BaseItemBodyBehavior)behavior).stack;
			}

			internal bool <BuffDevilOrb>b__416_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<DamageInfo>(x, "force");
			}

			internal Vector3 <BuffDevilOrb>b__416_1(Vector3 forceIn, DevilOrb orb)
			{
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Invalid comparison between Unknown and I4
				//IL_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_0117: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0121: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Unknown result type (might be due to invalid IL or missing references)
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: Unknown result type (might be due to invalid IL or missing references)
				//IL_0137: Unknown result type (might be due to invalid IL or missing references)
				//IL_0138: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_013c: Unknown result type (might be due to invalid IL or missing references)
				HealthComponent healthComponent = ((Orb)orb).target.healthComponent;
				float num = 1f;
				if ((Object)(object)healthComponent.body.characterMotor != (Object)null)
				{
					num = healthComponent.body.characterMotor.mass;
				}
				else if ((Object)(object)healthComponent.body.rigidbody != (Object)null)
				{
					num = healthComponent.body.rigidbody.mass;
				}
				EffectType effectType = orb.effectType;
				EffectType val = effectType;
				if ((int)val != 0)
				{
					if ((int)val == 1)
					{
						if (useDiscipleKnockbackSlow)
						{
							num *= 15f;
							healthComponent.body.AddTimedBuffAuthority(Buffs.Slow50.buffIndex, 3f);
						}
						else
						{
							num *= 0f;
						}
					}
				}
				else if (useNkuhanaKnockbackSlow)
				{
					num *= 25f;
					healthComponent.body.AddTimedBuffAuthority(Buffs.Slow50.buffIndex, 3f);
				}
				else
				{
					num *= 0f;
				}
				Vector3 val2 = ((Component)((Orb)orb).target).transform.position - orb.attacker.transform.position;
				return ((Vector3)(ref val2)).normalized * (100f + num);
			}

			internal bool <GasChanges>b__417_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<InflictDotInfo>(x, "totalDamage");
			}

			internal float <GasChanges>b__417_1(float currentDamage, DamageReport damageReport, int itemCount)
			{
				return (gasBaseBurnDamage + gasStackBurnDamage * (float)(itemCount - 1)) * damageReport.attackerBody.damage;
			}

			internal bool <GasChanges>b__417_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<BlastAttack>(x, "baseDamage");
			}

			internal float <GasChanges>b__417_3(float currentDamage, DamageReport damageReport, int itemCount)
			{
				return (gasBaseDamage + gasStackDamage * (float)itemCount) * damageReport.attackerBody.damage;
			}

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

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

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

			internal bool <GasChangesOld>b__418_3(Instruction x)
			{
				return ILPatternMatchingExt.MatchConvR4(x);
			}

			internal bool <GasChangesOld>b__418_4(Instruction x)
			{
				return ILPatternMatchingExt.MatchMul(x);
			}

			internal bool <GasChangesOld>b__418_5(Instruction x)
			{
				return ILPatternMatchingExt.MatchAdd(x);
			}

			internal float <GasChangesOld>b__418_6(float currentDuration, int itemCount)
			{
				return gasBaseBurnDamage + gasStackBurnDamage * (float)(itemCount - 1);
			}

			internal bool <GasChangesOld>b__418_7(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<BlastAttack>(x, "baseDamage");
			}

			internal float <GasChangesOld>b__418_8(float currentDamage, DamageReport damageReport, int itemCount)
			{
				return (gasBaseDamage + gasStackDamage * (float)itemCount) * damageReport.attackerBody.damage;
			}

			internal bool <WillOWispChanges>b__419_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "ExplodeOnDeath");
			}

			internal bool <WillOWispChanges>b__419_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.Util", "OnKillProcDamage");
			}

			internal float <WillOWispChanges>b__419_3(float currentDamage, int itemCount)
			{
				return willowispBaseDamage * (1f + willowispScaleFraction * (float)(itemCount - 1));
			}

			internal bool <WillOWispChanges>b__419_4(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<DelayBlast>(x, "radius");
			}

			internal float <WillOWispChanges>b__419_5(float currentRadius, int itemCount)
			{
				return willowispBaseRange + willowispStackRange * (float)itemCount;
			}

			internal bool <VoidsentFlameChanges>b__420_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC1Content/Items", "ExplodeOnDeathVoid");
			}

			internal int <VoidsentFlameChanges>b__420_2(int itemCountIn)
			{
				if (itemCountIn > 0 && Util.CheckRoll(voidsentBaseChance + voidsentStackChance * (float)(itemCountIn - 1), 0f, (CharacterMaster)null))
				{
					return itemCountIn;
				}
				return 0;
			}

			internal bool <VoidsentFlameChanges>b__420_3(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.Util", "OnKillProcDamage");
			}

			internal float <VoidsentFlameChanges>b__420_4(float currentDamage, int itemCount)
			{
				return voidsentBaseDamage * (1f + voidsentScaleFraction * (float)(itemCount - 1));
			}

			internal bool <VoidsentFlameChanges>b__420_5(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<DelayBlast>(x, "radius");
			}

			internal float <VoidsentFlameChanges>b__420_6(float currentRadius, int itemCount)
			{
				return voidsentBaseRange + voidsentStackRange * (float)itemCount;
			}

			internal bool <CooldownBuff>b__429_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "IceRing");
			}

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

			internal bool <CooldownBuff>b__429_5(Instruction x)
			{
				return ILPatternMatchingExt.MatchConvR4(x);
			}

			internal float <CooldownBuff>b__429_6(float cooldown, CharacterBody self)
			{
				float num = 1f;
				if (Object.op_Implicit((Object)(object)self.skillLocator.special))
				{
					float cooldownScale = self.skillLocator.special.cooldownScale;
					num *= cooldownScale;
					if (!(self.skillLocator.special.flatCooldownReduction < 9f))
					{
					}
				}
				return cooldown * num;
			}

			internal bool <CooldownBuff>b__429_8(Instruction x)
			{
				return ILPatternMatchingExt.MatchConvR4(x);
			}

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

			internal float <CooldownBuff>b__429_10(float seconds, CharacterBody self)
			{
				float num = 0f;
				if (Object.op_Implicit((Object)(object)self.skillLocator.special))
				{
				}
				return Mathf.Max(seconds - num, 1f);
			}

			internal bool <RunaldNerf>b__430_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "IceRing");
			}

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

			internal bool <RunaldNerf>b__430_4(Instruction x)
			{
				return ILPatternMatchingExt.MatchConvR4(x);
			}

			internal bool <RunaldNerf>b__430_5(Instruction x)
			{
				return ILPatternMatchingExt.MatchMul(x);
			}

			internal bool <RunaldNerf>b__430_8(Instruction x)
			{
				MethodReference val = default(MethodReference);
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, ref val);
			}

			internal float <RunaldNerf>b__430_9(float damage, CharacterBody attackerBody)
			{
				float num = attackerBody.baseDamage * runaldBaseDamage;
				return damage + num;
			}

			internal bool <KjaroNerf>b__431_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "FireRing");
			}

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

			internal bool <KjaroNerf>b__431_4(Instruction x)
			{
				return ILPatternMatchingExt.MatchConvR4(x);
			}

			internal bool <KjaroNerf>b__431_5(Instruction x)
			{
				return ILPatternMatchingExt.MatchMul(x);
			}

			internal bool <KjaroNerf>b__431_8(Instruction x)
			{
				MethodReference val = default(MethodReference);
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, ref val);
			}

			internal float <KjaroNerf>b__431_9(float damage, CharacterBody attackerBody)
			{
				float num = attackerBody.baseDamage * kjaroBaseDamage;
				return damage + num;
			}

			internal bool <SceneDirector_Start>b__434_0(GameObject obj)
			{
				return ((Object)obj).name == "NewtStatue" || ((Object)obj).name == "NewtStatue (1)" || ((Object)obj).name == "NewtStatue (2)" || ((Object)obj).name == "NewtStatue (3)" || ((Object)obj).name == "NewtStatue (4)";
			}

			internal bool <SceneDirector_Start>b__434_1(GameObject obj)
			{
				return ((Object)obj).name == "NewtStatue, Guarantee" || ((Object)obj).name == "NewtStatue, Guaranteed" || ((Object)obj).name == "NewtStatue (Permanent)";
			}

			internal bool <DeathMarkFix_Stacking>b__452_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Buffs", "DeathMark");
			}

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

			internal void <DeathMarkFix_Stacking>b__452_3(CharacterBody body, BuffDef buffDef, float duration, float itemCount)
			{
				int buffCount = body.GetBuffCount(Buffs.DeathMark);
				int num = 0;
				if (buffCount < (int)itemCount)
				{
					num = (int)itemCount - buffCount;
				}
				for (float num2 = 0f; num2 < (float)num; num2 += 1f)
				{
					body.AddTimedBuff(buffDef, duration);
				}
			}

			internal bool <DeathMarkFix_Damage>b__453_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Buffs", "DeathMark");
			}

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

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

			internal float <DeathMarkFix_Damage>b__453_3(float damage, HealthComponent hc)
			{
				CharacterBody body = hc.body;
				float num = 1f;
				int buffCount = body.GetBuffCount(Buffs.DeathMark);
				num += deathMarkBonusDamage * (float)buffCount;
				Debug.Log((object)(damage + " " + num));
				return num;
			}

			internal bool <RevokeShatterspleenBleedRights>b__478_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "BleedOnHitAndExplode");
			}

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

			internal bool <RevokeShatterspleenDeathRights>b__479_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "BleedOnHitAndExplode");
			}

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

			internal bool <VoidBearChanges>b__490_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC1Content/Items", "BearVoid");
			}

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

			internal float <VoidBearChanges>b__490_3(float inDuration)
			{
				float num = 15f;
				float num2 = 5f;
				return num2 + inDuration * ((num - num2) / num);
			}

			internal bool <TeddyChanges>b__492_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld(x, "RoR2.HealthComponent/ItemCounts", "bear");
			}

			internal bool <TeddyChanges>b__492_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.Util", "ConvertAmplificationPercentageIntoReductionPercentage");
			}

			internal bool <HoofNerf>b__496_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "Hoof");
			}

			internal bool <HoofNerf>b__496_3(Instruction x)
			{
				return ILPatternMatchingExt.MatchConvR4(x);
			}

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

			internal float <HoofNerf>b__496_5(float itemCount, float speedBonus)
			{
				float result = 0f;
				if (itemCount > 0f)
				{
					result = hoofSpeedBonusBase + hoofSpeedBonusStack * (itemCount - 1f);
				}
				return result;
			}

			internal bool <DrinkNerf>b__500_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "SprintBonus");
			}

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

			internal bool <DrinkNerf>b__500_4(Instruction x)
			{
				return ILPatternMatchingExt.MatchConvR4(x);
			}

			internal float <DrinkNerf>b__500_5(float speedBonus, float itemCount)
			{
				float result = 0f;
				if (itemCount > 0f)
				{
					result = drinkSpeedBonusBase + drinkSpeedBonusStack * (itemCount - 1f);
				}
				return result;
			}

			internal bool <FaradaySparks>b__513_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC3Content/Buffs", "JumpDamageStrikeCharge");
			}

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

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

			internal bool <ChangeFaradayDischargeDamageType>b__515_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<BlastAttack>(x, "damageType");
			}

			internal DamageTypeCombo <ChangeFaradayDischargeDamageType>b__515_1(DamageTypeCombo doesntMatter)
			{
				//IL_0003: 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_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				return new DamageTypeCombo(DamageTypeCombo.op_Implicit((DamageType)32), (DamageTypeExtended)0, (DamageSource)8);
			}

			internal bool <IncreaseFaradayDischargeDamage>b__516_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<CharacterBody>(x, "get_damage");
			}

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

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

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

			internal bool <IncreaseFaradayDischargeDamage>b__516_4(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<BaseItemBodyBehavior>(x, "stack");
			}

			internal bool <ReduceFaradayMaxDischarge>b__517_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC3Content/Buffs", "JumpDamageStrikeCharge");
			}

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

			internal bool <ReduceFaradayMaxDischarge>b__517_3(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC3Content/Buffs", "JumpDamageStrikeCharge");
			}

			internal bool <ReduceFaradayMaxDischarge>b__517_4(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<BuffDef>(x, "get_buffIndex");
			}

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

			internal bool <ReduceFaradayMaxDischarge>b__517_6(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<CharacterBody>(x, "SetBuffCount");
			}

			internal int <ReduceFaradayMaxDischarge>b__517_7(int doesntMatter, int buffCount)
			{
				int num = buffCount - faradayMaxDischarge;
				if (num < 0)
				{
					return 0;
				}
				if (num == faradayRequiredCharge && faradayPreventDoubleDischarge)
				{
					return faradayRequiredCharge - 1;
				}
				return num;
			}

			internal bool <IncreaseFaradayChargeRequirement_DischargeEffects>b__518_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC3Content/Buffs", "JumpDamageStrikeCharge");
			}

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

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

			internal bool <IncreaseFaradayChargeRequirement_DischargeEffects>b__518_5(Instruction x)
			{
				ILLabel val = default(ILLabel);
				return ILPatternMatchingExt.MatchBge(x, ref val);
			}

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

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

			internal bool <IncreaseFaradayChargeRequirement_UpdateCharge>b__521_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchClt(x);
			}

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

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

			internal bool <IncreaseFaradayChargeRequirement_GetRadius>b__522_2(Instruction x)
			{
				ILLabel val = default(ILLabel);
				return ILPatternMatchingExt.MatchBge(x, ref val);
			}

			internal bool <BuffFaradayChargeRate>b__523_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<JumpDamageStrikeBodyBehavior>(x, "isCharging");
			}

			internal bool <BuffFaradayChargeRate>b__523_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<JumpDamageStrikeBodyBehavior>(x, "distanceTraveled");
			}

			internal float <BuffFaradayChargeRate>b__523_2(float addedDistance, JumpDamageStrikeBodyBehavior behavior)
			{
				float num = Mathf.Pow((1f + faradayChargeIncreaseStack * (float)(((BaseItemBodyBehavior)behavior).stack - 1)) * faradayChargeIncreaseBase, 0.2f);
				return addedDistance * num;
			}

			internal bool <FixFaradayDeltaTime>b__524_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<Time>(x, "get_deltaTime");
			}

			internal float <FixFaradayDeltaTime>b__524_1()
			{
				return Time.fixedDeltaTime;
			}

			internal bool <MonsterToothHealChange>b__536_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "Tooth");
			}

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

			internal bool <MonsterToothHealChange>b__536_3(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<HealthPickup>(x, "flatHealing");
			}

			internal float <MonsterToothHealChange>b__536_4(float currentHealAmt, int itemCount)
			{
				return monsterToothFlatHeal * (float)itemCount;
			}

			internal bool <MonsterToothHealChange>b__536_5(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<HealthPickup>(x, "fractionalHealing");
			}

			internal float <MonsterToothHealChange>b__536_6(float currentHealAmt)
			{
				return monsterToothPercentHeal;
			}

			internal bool <MedkitHealChange>b__537_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "Medkit");
			}

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

			internal bool <MedkitHealChange>b__537_3(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 20f);
			}

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

			internal float <MedkitHealChange>b__537_5(float currentHealAmt, int itemCount)
			{
				return medkitFlatHeal * (float)itemCount;
			}

			internal bool <MedkitHealChange>b__537_6(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<CharacterBody>(x, "get_maxHealth");
			}

			internal bool <MedkitHealChange>b__537_7(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcR4(x, 0.05f);
			}

			internal float <MedkitHealChange>b__537_8(float currentHealAmt)
			{
				return medkitPercentHeal;
			}

			internal bool <ScytheNerf>b__538_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "HealOnCrit");
			}

			internal bool <ScytheNerf>b__538_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<HealthComponent>(x, "Heal");
			}

			internal float <ScytheNerf>b__538_3(float currentHealAmt, int itemCount)
			{
				return scytheBaseHeal + scytheStackHeal * (float)itemCount;
			}

			internal bool <ReduceBungusInterval>b__540_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<HealingWard>(x, "interval");
			}

			internal float <ReduceBungusInterval>b__540_1(float interval)
			{
				return fungusHealInterval;
			}

			internal bool <ReduceBungusWaitTime>b__541_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<CharacterBody>(x, "notMovingStopwatch");
			}

			internal bool <InitializeEverything>b__577_4(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<SkillDef>(x, "attackSpeedBuffsRestockSpeed");
			}

			internal bool <InitializeCoreModules>b__593_0(Type type)
			{
				return !type.IsAbstract && type.IsSubclassOf(typeof(CoreModule));
			}
		}

		public static float drizzleDifficultyBoost = 0f;

		public static float rainstormDifficultyBoost = 0f;

		public static float monsoonDifficultyBoost = 3f;

		public static float eclipseDifficultyBoost = 6f;

		public static float baseScalingMultiplier = 0.9f;

		public static float difficultyIncreasePerMinutePerDifficulty = 0.01f;

		public static float difficultyIncreasePerMinuteBase = 1f;

		public static float difficultyIncreasePerStage = 0.9f;

		public static float difficultyIncreasePerLoop = 1.3f;

		public static float playerBaseDifficultyFactor = 0.2f;

		public static float playerScalingDifficultyFactor = 0.2f;

		public static float playerSpawnRateFactor = 0.5f;

		public static float difficultySpawnRateFactor = 0.4f;

		public static int ambientLevelCapDrizzle = 99;

		public static int ambientLevelCap = 999;

		public static float easyTeleParticleRadius = 1f;

		public static float normalTeleParticleRadius = 0.8f;

		public static float hardTeleParticleRadius = 0.4f;

		public static float eclipseTeleParticleRadius = 0.4f;

		public static float defaultTeleParticleRadius = 0.9f;

		public static DifficultyIndex eclipseLevelBossShield = (DifficultyIndex)3;

		public static float eclipseBossShieldFraction = 0.1f;

		public static string eclipseOneDesc = "\n<mspace=0.5em>(1)</mspace> Boss Shields: <style=cIsHealth>+" + Tools.ConvertDecimal(eclipseBossShieldFraction) + "</style>";

		public static DifficultyIndex eclipseLevelHoldoutLoss = (DifficultyIndex)4;

		public static float eclipseHoldoutLossRate = 0.03f;

		public static string eclipseTwoDesc = "\n<mspace=0.5em>(2)</mspace> Holdout Zone Discharge: <style=cIsHealth>-" + Tools.ConvertDecimal(eclipseHoldoutLossRate) + " per second</style>";

		public static DifficultyIndex eclipseLevelEnemyCdr = (DifficultyIndex)5;

		public static float eclipseEnemyCdr = 0.5f;

		public static string eclipseThreeDesc = "\n<mspace=0.5em>(3)</mspace> Enemy Cooldowns: <style=cIsHealth>-" + Tools.ConvertDecimal(eclipseEnemyCdr) + "</style>";

		public static DifficultyIndex eclipseLevelSmallHoldout = (DifficultyIndex)6;

		public static float eclipseHoldoutScale = 0.7f;

		public static string eclipseFourDesc = "\n<mspace=0.5em>(4)</mspace> Holdout Zone Radius: <style=cIsHealth>-" + Tools.ConvertDecimal(1f - eclipseHoldoutScale) + "</style>";

		public static DifficultyIndex eclipseLevelEnemyMspd = (DifficultyIndex)7;

		public static float eclipseEnemyMspd = 0.25f;

		public static string eclipseFiveDesc = "\n<mspace=0.5em>(5)</mspace> Enemy Speed: <style=cIsHealth>+" + Tools.ConvertDecimal(eclipseEnemyMspd) + "</style>";

		public static DifficultyIndex eclipseLevelSpiteArtifact = (DifficultyIndex)8;

		public static string eclipseSixDesc = "\n<mspace=0.5em>(6)</mspace> On Kill: <style=cIsHealth>Enemies drop exploding bombs</style>";

		public static DifficultyIndex eclipseLevelVeryHard = (DifficultyIndex)9;

		public static string eclipseSevenDesc = "\n<mspace=0.5em>(7)</mspace> Difficulty: <style=cIsHealth>Very Hard</style>";

		public static DifficultyIndex eclipseLevelPlayerDegen = (DifficultyIndex)10;

		public static float eclipsePlayerDegen = 0.2f;

		public static string eclipseEightDesc = "\n<mspace=0.5em>(8)</mspace> Health Degeneration: <style=cIsHealth>-" + Tools.ConvertDecimal(eclipsePlayerDegen) + " per level</style>";

		public static float voidFieldsTimeCost = 120f;

		public static float fastDirectorEliteBias = 1.2f;

		public static float fastDirectorCreditMultiplier = 0.75f;

		public static float slowDirectorEliteBias = 1.2f;

		public static float slowDirectorCreditMultiplier = 1f;

		public static float teleLesserEliteBias = 1f;

		public static float teleLesserCreditMultiplier = 0.8f;

		public static float teleBossEliteBias = 1f;

		public static float teleBossCreditMultiplier = 1f;

		public static float teleBossCreditMultiplierStage1 = 0.5f;

		private static bool pityChargeOn = false;

		private static float pityChargeShrinkDelta = 0f;

		private static float pityChargeRecolorDelta = 0f;

		private GameObject awu = LegacyResourcesAPI.Load<GameObject>("prefabs/characterbodies/SuperRoboBallBossBody");

		private CharacterBody awuBody;

		private float awuArmor = 40f;

		private float awuAdditionalArmor = 0f;

		private int awuAdaptiveArmorCount = 1;

		private static float costExponent = 1.15f;

		private static float goldRewardMultiplierGlobal = 0.3f;

		private static float expRewardMultiplierGlobal = 0.4f;

		private static float compensationForStartingLevel = 1f;

		public float interactableCreditsAdd = 125f;

		public float monsterCreditsMultiplier = 1f;

		private PurchaseInteraction smallChest = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Chest1/Chest1.prefab").WaitForCompletion().GetComponent<PurchaseInteraction>();

		private PurchaseInteraction smallCategoryChestDamage = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/CategoryChest/CategoryChestDamage.prefab").WaitForCompletion().GetComponent<PurchaseInteraction>();

		private PurchaseInteraction smallCategoryChestHealing = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/CategoryChest/CategoryChestHealing.prefab").WaitForCompletion().GetComponent<PurchaseInteraction>();

		private PurchaseInteraction smallCategoryChestUtility = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/CategoryChest/CategoryChestUtility.prefab").WaitForCompletion().GetComponent<PurchaseInteraction>();

		private PurchaseInteraction bigChest = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Chest2/Chest2.prefab").WaitForCompletion().GetComponent<PurchaseInteraction>();

		private PurchaseInteraction bigCategoryChestDamage = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/CategoryChest2/CategoryChest2Damage Variant.prefab").WaitForCompletion().GetComponent<PurchaseInteraction>();

		private PurchaseInteraction bigCategoryChestHealing = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/CategoryChest2/CategoryChest2Healing Variant.prefab").WaitForCompletion().GetComponent<PurchaseInteraction>();

		private PurchaseInteraction bigCategoryChestUtility = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/CategoryChest2/CategoryChest2Utility Variant.prefab").WaitForCompletion().GetComponent<PurchaseInteraction>();

		private PurchaseInteraction casinoChest = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/CasinoChest/CasinoChest.prefab").WaitForCompletion().GetComponent<PurchaseInteraction>();

		private PurchaseInteraction chanceShrine = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/ShrineChance/ShrineChance.prefab").WaitForCompletion().GetComponent<PurchaseInteraction>();

		private PurchaseInteraction chanceShrineSnowy = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/ShrineChance/ShrineChanceSnowy Variant.prefab").WaitForCompletion().GetComponent<PurchaseInteraction>();

		private PurchaseInteraction chanceShrineSandy = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/ShrineChance/ShrineChanceSandy Variant.prefab").WaitForCompletion().GetComponent<PurchaseInteraction>();

		private MultiShopController smallShop = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/TripleShop/TripleShop.prefab").WaitForCompletion().GetComponent<MultiShopController>();

		private MultiShopController bigShop = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/TripleShopLarge/TripleShopLarge.prefab").WaitForCompletion().GetComponent<MultiShopController>();

		private MultiShopController equipmentShop = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/TripleShopEquipment/TripleShopEquipment.prefab").WaitForCompletion().GetComponent<MultiShopController>();

		private string discountChestPrefix = "Bargain";

		private int smallChestTypeCost = 20;

		private int smallShopTypeCost = 35;

		private int smallCategoryChestTypeCost = 25;

		private int bigChestTypeCost = 45;

		private int bigShopTypeCost = 70;

		private int bigCategoryChestTypeCost = 50;

		private int goldChestTypeCost = 200;

		private int bigDroneTypeCost = 160;

		private int casinoChestTypeCost = 30;

		private int chanceShrineTypeCost = 15;

		private GameObject goldShrine = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/ShrineGoldshoresAccess/ShrineGoldshoresAccess.prefab").WaitForCompletion();

		private int goldShrineCost = 5;

		private static int teamMaxHealth;

		private static int totalBloodGoldValue = 60;

		private const float totalHealthFraction = 2.18f;

		private static float chestsPerHealthBar = 2f;

		public int equipBarrelWeightS1 = 20;

		public int equipBarrelLimitS1 = 5;

		public int equipBarrelWeight = 6;

		public int equipBarrelLimit = 2;

		public int equipShopWeightS3 = 20;

		public int equipShopLimitS3 = 4;

		public int equipShopWeight = 4;

		public int equipShopLimit = 2;

		public int scrapperWeight = 1000;

		public int scrapperLimit = 3;

		public int doubleChestWeight = 15;

		public static GameObject whitePrinter = LegacyResourcesAPI.Load<GameObject>("prefabs/networkedobjects/chest/Duplicator");

		public static GameObject greenPrinter = LegacyResourcesAPI.Load<GameObject>("prefabs/networkedobjects/chest/DuplicatorLarge");

		public static GameObject redPrinter = LegacyResourcesAPI.Load<GameObject>("prefabs/networkedobjects/chest/DuplicatorMilitary");

		public static GameObject scrapper = LegacyResourcesAPI.Load<GameObject>("prefabs/networkedobjects/chest/Scrapper");

		public int printerGreenWeight = 20;

		public int printerGreenLimit = 4;

		public int printerRedWeight = 4;

		public int printerRedLimit = 1;

		public int printerRedWeightS5 = 1000;

		public int printerRedLimitS5 = 2;

		public int lunarPodWeightS1 = 20;

		public int lunarPodLimitS1 = 6;

		public int lunarPodWeight = 6;

		public int lunarPodLimit = 2;

		private BasicPickupDropTable doubleChestDropTable = Addressables.LoadAssetAsync<BasicPickupDropTable>((object)"RoR2/Base/CasinoChest/dtCasinoChest.asset").WaitForCompletion();

		private InteractableSpawnCard doubleChestSpawnCard = Addressables.LoadAssetAsync<InteractableSpawnCard>((object)"RoR2/Base/CasinoChest/iscCasinoChest.asset").WaitForCompletion();

		public DirectorCard doubleChestDirectorCard;

		public static int halcyoniteShrineLowGoldCost = 35;

		public static int halcyoniteShrineMidGoldCost = 75;

		public static int halcyoniteShrineMaxGoldCost = 125;

		public static float halcyoniteShrineRadius = 30f;

		public static int soulShrineLuckIncrease = 1;

		private GameObject soulShrine = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC2/ShrineColossusAccess.prefab").WaitForCompletion();

		public static int Tier2EliteMinimumStageDefault = 6;

		public static int Tier2EliteMinimumStageDrizzle = 11;

		public static int Tier2EliteMinimumStageRainstorm = 6;

		public static int Tier2EliteMinimumStageMonsoon = 4;

		public static int Tier2EliteMinimumStageEclipse = 4;

		private static string Tier2EliteName = "Rare";

		private float genesisLoopBlastDamageCoefficient = 30f;

		private float vagrantBaseHealth = 1600f;

		private GameObject vagrantPrefab;

		private GameObject pestPrefab;

		private GameObject pestSpit;

		private float pestBaseHealth = 50f;

		private float pestBaseDamage = 6f;

		private float pestBaseSpeed = 4f;

		private float pestSpitVelocity = 70f;

		private GameObject queenSpitPrefab;

		private GameObject queenAcidPrefab;

		private float spitDamageCoefficient = 0.4f;

		private float acidSize = 2f;

		private float acidDamageCoefficient = 2.5f;

		private float acidDamageFrequency = 4f;

		private CharacterSpawnCard gupSpawnCard;

		private int gupCreditCost = 200;

		private GameObject gupPrefab;

		private float gupBaseHealth = 1000f;

		private float gupBaseArmor = 0f;

		private float gupBaseDamage = 12f;

		private float gupBaseSpeed = 14f;

		private float gupBaseRegen = 0f;

		private GameObject geepPrefab;

		private float geepBaseHealth = 500f;

		private float geepBaseArmor = 0f;

		private float geepBaseDamage = 8f;

		private float geepBaseSpeed = 10f;

		private float geepBaseRegen = 0f;

		private GameObject gipPrefab;

		private float gipBaseHealth = 250f;

		private float gipBaseArmor = 0f;

		private float gipBaseDamage = 5f;

		private float gipBaseSpeed = 6f;

		private float gipBaseRegen = 0f;

		private int nulliferBombCount = 10;

		private GameObject barnaclePrefab;

		private float fuckBarnacleRegen = 0f;

		private GameObject lesserWispPrefab;

		private float wispBaseDamage = 1.5f;

		private GameObject templarPrefab = LegacyResourcesAPI.Load<GameObject>("prefabs/characterbodies/ClayBruiserBody");

		public static float templarBaseDamage = 9f;

		public static float templarBaseAttackSpeed = 1f;

		public static float templarFireInterval = 0.05f;

		public static float templarSpinUpDuration = 1.5f;

		public static float templarSpinDownDuration = 2f;

		private GameObject chimeraWispPrefab = LegacyResourcesAPI.Load<GameObject>("prefabs/characterbodies/LunarWispBody");

		public static float chimeraWispBaseDamage = 5f;

		public static float chimeraWispBaseAttackSpeed = 1f;

		public static float chimeraWispFireInterval = 0.1f;

		public static float chimeraWispFireDuration = 4f;

		public static float chimeraWispChargeDuration = 3.33f;

		public static int solusScorcherCreditCost = 18;

		public static float solusScorcherBaseHealth = 111f;

		public static float solusScorcherBaseMovespeed = 9f;

		public static int solusProspectorCreditCost = 11;

		public static float solusProspectorBaseHealth = 110f;

		public static float solusProspectorBaseMovespeed = 11.5f;

		public static EquipmentDef[] scavBlacklistedEquips = (EquipmentDef[])(object)new EquipmentDef[3]
		{
			Equipment.PassiveHealing,
			Equipment.Fruit,
			Equipment.LifestealOnHit
		};

		public float crunderFunnyMoneyProcChance = 10f;

		public Func<ItemIndex, bool> gooboItemCopyFilter = Inventory.defaultItemCopyFilterDelegate.Invoke;

		private float gummyLifetime = 30f;

		private int gummyDamage = 0;

		private float gummyDamageMultiplier = 0.7f;

		private int gummyHealth = 20;

		private float gummyHealthMultiplier = 1f;

		public int blastShowerBuffCount = 3;

		public static float capacitorDamageCoefficient = 10f;

		public static float capacitorBlastRadius = 13f;

		public static float capacitorCooldown = 20f;

		private float glassesNewCritChance = 10f;

		private float pauldronDamageMultiplier = 1f;

		private float pauldronAspdMultiplier = 0.5f;

		private FalloffModel falloffModel = (FalloffModel)0;

		private float justiceMinDamageCoeff = 8f;

		public static float newInfusionBaseHealth = 40f;

		public float wungusRegenBase = 1.5f;

		public float wungusRegenStack = 1.5f;

		public float luteDamageCoefficient = 0.4f;

		private GameObject shurikenProjectilePrefab;

		public float shurikenBaseDamage = 0.8f;

		public float shurikenStackDamage = 0f;

		public float shurikenProcCoefficient = 2f;

		public float daisyRadiusMultiplier = 1.15f;

		public const float fuelCellCooldownMultiplier = 0.67f;

		public static string fuelCellEquipCdr = Tools.ConvertDecimal(0.32999998f);

		public static int fuelCellStock = 2;

		public const float chaosCooldownMultiplier = 0.67f;

		public static string chaosEquipCdr = Tools.ConvertDecimal(0.32999998f);

		public static float stickyDamageCoeffBase = 3.2f;

		public static float stickyDamageCoeffStack = 0.4f;

		private GameObject daggerPrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/Projectiles/DaggerProjectile");

		private GameObject willowispPrefab = LegacyResourcesAPI.Load<GameObject>("prefabs/networkedobjects/WilloWispDelay");

		private GameObject voidsentPrefab = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/ExplodeOnDeathVoid/ExplodeOnDeathVoidExplosion.prefab").WaitForCompletion();

		private GameObject spleenPrefab = LegacyResourcesAPI.Load<GameObject>("prefabs/networkedobjects/BleedOnHitAndExplodeDelay");

		private GameObject fireworkProjectilePrefab = LegacyResourcesAPI.Load<GameObject>("prefabs/projectiles/FireworkProjectile");

		private GameObject resdiscProjectilePrefab = LegacyResourcesAPI.Load<GameObject>("prefabs/projectiles/LaserTurbineBomb");

		private GameObject meatballProjectilePrefab = LegacyResourcesAPI.Load<GameObject>("Prefabs/Projectiles/FireMeatBall");

		private static float willowispProcCoeff = 0.75f;

		private static float willowispBaseDamage = 3.6f;

		private static float willowispScaleFraction = 0.75f;

		private static float willowispBaseRange = 16f;

		private static float willowispStackRange = 0f;

		private static float voidsentProcCoeff = 1f;

		private static float voidsentBaseDamage = 5.6f;

		private static float voidsentScaleFraction = 0.75f;

		private static float voidsentBaseRange = 24f;

		private static float voidsentStackRange = 0f;

		private static float voidsentBaseChance = 33f;

		private static float voidsentStackChance = 0f;

		private static float gasBaseDamage = 0.5f;

		private static float gasStackDamage = 0f;

		private static float gasBaseBurnDamage = 1f;

		private static float gasStackBurnDamage = 1f;

		private float discipleDevilorbProc = 0.4f;

		private float opinionDevilorbProc = 0.75f;

		public static bool useNkuhanaKnockbackSlow = false;

		public static bool useDiscipleKnockbackSlow = false;

		private float nkuhanaNewDamageMultiplier = 3.5f;

		private static float runaldBaseDamage = 6f;

		private static float runaldTotalDamage = 1f;

		private static float kjaroBaseDamage = 6f;

		private static float kjaroTotalDamage = 1f;

		private static string runaldTotal = Tools.ConvertDecimal(runaldTotalDamage);

		private static string kjaroTotal = Tools.ConvertDecimal(kjaroTotalDamage);

		public static float newtAltarChance = 0.3f;

		public static float deathMarkBonusDamage = 0.3f;

		private float elephantBuffDuration = 10f;

		private int elephantArmor = 200;

		public static float tarSlowAspdReduction = 0.3f;

		public static float kitSlowAspdReduction = 0.3f;

		public static float chronoSlowAspdReduction = 0.5f;

		public static float chillSlowAspdReduction = 0.6f;

		private float critHudDamageMul = 1f;

		private GameObject healPack = LegacyResourcesAPI.Load<GameObject>("prefabs/networkedobjects/HealPack");

		private float toothDuration = 15f;

		private GameObject ammoPack = LegacyResourcesAPI.Load<GameObject>("prefabs/networkedobjects/AmmoPack");

		private GameObject moneyPack = LegacyResourcesAPI.Load<GameObject>("prefabs/networkedobjects/BonusMoneyPack");

		public static int minSpikes = 3;

		public static int maxSpikes = 4;

		public static int baseSpikesPerBuff = 2;

		public static int stackSpikesPerBuff = 1;

		public static float minDamageCoefficient = 5f;

		public static float releaseSpeed = 2f;

		public static float spikeDamageCoefficient = 0.3f;

		public static float spikeProcCoefficient = 1f;

		public static int shatterspleenBleedChance = 20;

		public static GameObject impBleedSpikePrefab;

		public static int rapFreeArmor = 2;

		public static int knurlFreeArmor = 15;

		public static int bucklerFreeArmor = 10;

		public static float voidBearNewMaxCooldown = 15f;

		public static float voidBearNewMinCooldown = 5f;

		public static float teddyNewMaxValue = 0.5f;

		public static float hoofSpeedBonusBase = 0.1f;

		public static float hoofSpeedBonusStack = 0.1f;

		public static float drinkSpeedBonusBase = 0.2f;

		public static float drinkSpeedBonusStack = 0.15f;

		public static float faradayMaxMoveSpeed = 1f;

		public static float faradayMaxJumpStrength = 1.5f;

		public static float faradayChargeIncreaseBase = 1.5f;

		public static float faradayChargeIncreaseStack = 0.5f;

		public static float faradayDamageBase = 8f;

		public static float faradayDamageStack = 5f;

		public static int faradayRequiredCharge = 34;

		public static int faradayMaxDischarge = 66;

		public static bool faradayPreventDoubleDischarge = true;

		public static float scytheBaseHeal = 0f;

		public static float scytheStackHeal = 5f;

		public static float monsterToothFlatHeal = 10f;

		public static float monsterToothPercentHeal = 0f;

		public static float medkitFlatHeal = 40f;

		public static float medkitPercentHeal = 0f;

		public static float notMovingRequirement = 0.1f;

		public static float fungusHealInterval = 0.125f;

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

		public const string teamName = "RiskOfBrainrot";

		public const string modName = "RiskierRain";

		public const string version = "1.3.9";

		public static bool isAELoaded = Tools.isLoaded("com.Borbo.ArtificerExtended");

		public static bool isHBULoaded = Tools.isLoaded("com.Borbo.HuntressBuffULTIMATE");

		public static bool isScepterLoaded = Tools.isLoaded("com.DestroyedClone.AncientScepter");

		public static bool autosprintLoaded = Tools.isLoaded("com.johnedwa.RTAutoSprintEx");

		public static bool acridLungeLoaded = Tools.isLoaded("Withor.AcridBiteLunge");

		public static bool ucrLoaded = Tools.isLoaded("HIFU.UltimateCustomRun");

		public static string drizzleDesc = "Simplifies difficulty for players new to the game. Weeping and gnashing is replaced by laughter and tickles.<style=cStack>\n\n>Player Health Regeneration: <style=cIsHealing>+50%</style> \n>Difficulty Scaling: <style=cIsHealing>-50%</style> \n>Player Damage Reduction: <style=cIsHealing>+38%</style>";

		public static string rainstormDesc = "This is the way the game is meant to be played! Test your abilities and skills against formidable foes.<style=cStack>\n\n>Player Health Regeneration: +0% \n>Difficulty Scaling: +0% ";

		public static string monsoonDesc = "For hardcore players. Every bend introduces pain and horrors of the planet. You will die.<style=cStack>\n\n>Player Health Regeneration: <style=cIsHealth>-40%</style> \n>Difficulty Scaling: <style=cIsHealth>+50%</style>";

		private GameObject meatballNapalmPool;

		private static float faradayChargeIncreaseStackInverse => faradayChargeIncreaseStack / (1f + faradayChargeIncreaseStack);

		public static PluginInfo PInfo { get; private set; }

		public static string dropPrefabsPath => Assets.dropPrefabsPath;

		public static string iconsPath => Assets.iconsPath;

		public static string eliteMaterialsPath => Assets.eliteMaterialsPath;

		internal static ConfigFile CustomConfigFile { get; set; }

		public static ConfigEntry<bool> EnableConfig { get; set; }

		internal static float GetAmbientLevelBoost()
		{
			return DifficultyUtilsModule.GetAmbientLevelBoost();
		}

		private void FreezeTimeScalingOnFinalLevels()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			Run.ShouldUpdateRunStopwatch += new hook_ShouldUpdateRunStopwatch(ModifyShouldUpdateRunStopwatch);
		}

		private bool ModifyShouldUpdateRunStopwatch(orig_ShouldUpdateRunStopwatch orig, Run self)
		{
			bool flag = orig.Invoke(self);
			if (!flag)
			{
				return flag;
			}
			return !SceneCatalog.mostRecentSceneDef.isFinalStage;
		}

		private void ChangeDifficultyCoefficientCalculation()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			Run.ambientLevelCap = ambientLevelCap;
			Run.RecalculateDifficultyCoefficentInternal += new hook_RecalculateDifficultyCoefficentInternal(DifficultyCoefficientChanges);
			DirectorMoneyWave.Update += new Manipulator(DirectorCreditGainChanges);
			drizzleDesc = drizzleDesc + "\n>Starting Difficulty: <style=cIsHealing>Easy</style>" + $"\n>Max Enemy Level: <style=cIsHealing>{ambientLevelCapDrizzle - ambientLevelCap}</style> " + $"\n>{Tier2EliteName} Elites: <style=cIsHealing>Stage {Tier2EliteMinimumStageDrizzle}</style>" + "\n>Teleporter Visuals: <style=cIsHealing>+" + Tools.ConvertDecimal(easyTeleParticleRadius / normalTeleParticleRadius - 1f) + "</style> ";
			rainstormDesc = rainstormDesc + "\n>Starting Difficulty: Medium" + $"\n>{Tier2EliteName} Elites: Stage {Tier2EliteMinimumStageRainstorm}" + "\n>Teleporter Visuals: +" + Tools.ConvertDecimal(normalTeleParticleRadius / normalTeleParticleRadius - 1f) + " ";
			monsoonDesc = monsoonDesc + "\n>Starting Difficulty: <style=cIsHealth>Hard</style>" + $"\n>{Tier2EliteName} Elites: <style=cIsHealth>Stage {Tier2EliteMinimumStageMonsoon}</style>" + "\n>Teleporter Visuals: <style=cIsHealth>" + Tools.ConvertDecimal(1f - hardTeleParticleRadius / normalTeleParticleRadius) + "</style> ";
			RoR2Application.onLoad = (Action)Delegate.Combine(RoR2Application.onLoad, new Action(AddDifficultyStats));
		}

		private void AddDifficultyStats()
		{
			//IL_000a: 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_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected I4, but got Unknown
			//IL_0057: 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_0090: 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_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: 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)
			for (int i = 0; i < 11; i++)
			{
				DifficultyIndex val = (DifficultyIndex)i;
				DifficultyDef difficultyDef = DifficultyCatalog.GetDifficultyDef(val);
				StartingDifficulty val2 = (StartingDifficulty)0;
				float num = 0f;
				float num2 = difficultyDef.scalingValue - 1f;
				int num3 = ambientLevelCap;
				int num4 = 5;
				float num5 = 1f;
				DifficultyIndex val3 = val;
				DifficultyIndex val4 = val3;
				switch ((int)val4)
				{
				case 0:
					val2 = (StartingDifficulty)0;
					num = drizzleDifficultyBoost;
					num4 = Tier2EliteMinimumStageDrizzle;
					num5 = easyTeleParticleRadius;
					num3 = ambientLevelCapDrizzle;
					break;
				case 1:
					val2 = (StartingDifficulty)3;
					num = rainstormDifficultyBoost;
					num4 = Tier2EliteMinimumStageRainstorm;
					num5 = normalTeleParticleRadius;
					break;
				case 2:
					val2 = (StartingDifficulty)6;
					num = monsoonDifficultyBoost;
					num4 = Tier2EliteMinimumStageMonsoon;
					num5 = hardTeleParticleRadius;
					break;
				default:
					val2 = (StartingDifficulty)6;
					num = monsoonDifficultyBoost;
					num4 = Tier2EliteMinimumStageMonsoon;
					num5 = hardTeleParticleRadius;
					if (val >= eclipseLevelVeryHard)
					{
						num = eclipseDifficultyBoost;
						num2 += 1f;
						val2 = (StartingDifficulty)9;
					}
					break;
				}
				MoreDifficultyStats moreDifficultyStats = DifficultyUtilsModule.GetMoreDifficultyStats(val);
				moreDifficultyStats.startingDifficultyDisplay = (float)val2;
				moreDifficultyStats.startingLevelBoost = num;
				moreDifficultyStats.startingDifficultyCoefficientBoost = num2;
				moreDifficultyStats.ambientLevelCap = num3;
				moreDifficultyStats.tier2EliteStage = num4;
				moreDifficultyStats.teleporterParticleRangeMultiplier = num5;
				DifficultyUtilsModule.difficultyCustomStats[val] = moreDifficultyStats;
			}
		}

		private void DirectorCreditGainChanges(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			float num5 = default(float);
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, ref num5)
			});
			int index = val.Index;
			val.Index = index - 1;
			val.Remove();
			val.Emit(OpCodes.Ldc_R4, 1f - playerSpawnRateFactor);
			float num4 = default(float);
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, ref num4)
			});
			index = val.Index;
			val.Index = index - 1;
			val.Remove();
			val.Emit(OpCodes.Ldc_R4, playerSpawnRateFactor);
			float num3 = default(float);
			int num2 = default(int);
			float num = default(float);
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[3]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, ref num3),
				(Instruction x) => ILPatternMatchingExt.MatchStloc(x, ref num2),
				(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, ref num)
			});
			index = val.Index;
			val.Index = index - 1;
			val.Remove();
			val.Emit(OpCodes.Ldc_R4, difficultySpawnRateFactor);
		}

		private void AmbientLevelChanges(ILContext il)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			int timeLoc = 2;
			int num = 2;
			float num5 = default(float);
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[4]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, ref timeLoc),
				(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, ref num5),
				(Instruction x) => ILPatternMatchingExt.MatchMul(x),
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<Mathf>(x, "Floor")
			});
			int index = val.Index;
			val.Index = index - 1;
			val.Emit(OpCodes.Ldc_R4, baseScalingMultiplier);
			val.Emit(OpCodes.Mul);
			float num4 = default(float);
			val.GotoNext((MoveType)0, new Func<Instruction, bool>[3]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, ref num4),
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
				(Instruction x) => ILPatternMatchingExt.MatchLdfld<Run>(x, "stageClearCount")
			});
			val.Remove();
			val.Emit(OpCodes.Ldc_R4, difficultyIncreasePerStage);
			float num3 = default(float);
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[3]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, ref timeLoc),
				(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, ref num3),
				(Instruction x) => ILPatternMatchingExt.MatchMul(x)
			});
			val.Emit(OpCodes.Ldc_R4, baseScalingMultiplier);
			val.Emit(OpCodes.Mul);
			float num2 = default(float);
			val.GotoNext((MoveType)0, new Func<Instruction, bool>[3]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, ref num2),
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
				(Instruction x) => ILPatternMatchingExt.MatchLdfld<Run>(x, "stageClearCount")
			});
			val.Remove();
			val.Emit(OpCodes.Ldc_R4, difficultyIncreasePerStage);
			val.GotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld<Run>(x, "ambientLevelCap")
			});
			val.EmitDelegate<Func<float, float>>((Func<float, float>)delegate(float levelIn)
			{
				float ambientLevelBoost = GetAmbientLevelBoost();
				return levelIn + ambientLevelBoost;
			});
		}

		private void DifficultyCoefficientChanges(orig_RecalculateDifficultyCoefficentInternal orig, Run self)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			float timeInMinutes = self.GetRunStopwatch() * (1f / 60f);
			int stageClearCount = self.stageClearCount;
			float playerBaseFactor;
			float difficultyCoefficient = GetDifficultyCoefficient(self, timeInMinutes, stageClearCount, out playerBaseFactor);
			float coefficientBoostForDifficulty = GetCoefficientBoostForDifficulty(self.selectedDifficulty);
			self.difficultyCoefficient = difficultyCoefficient;
			self.compensatedDifficultyCoefficient = difficultyCoefficient + coefficientBoostForDifficulty;
			self.oneOverCompensatedDifficultyCoefficientSquared = 1f / (self.compensatedDifficultyCoefficient * self.compensatedDifficultyCoefficient);
			self.ambientLevel = Mathf.Min(1f + GetAmbientLevelBoost() + 3f * (difficultyCoefficient - playerBaseFactor), (float)Run.ambientLevelCap);
			int ambientLevelFloor = self.ambientLevelFloor;
			self.ambientLevelFloor = Mathf.FloorToInt(self.ambientLevel);
			if (ambientLevelFloor != self.ambientLevelFloor && ambientLevelFloor != 0 && self.ambientLevelFloor > ambientLevelFloor)
			{
				self.OnAmbientLevelUp();
			}
		}

		public static float GetCoefficientBoostForDifficulty(DifficultyIndex difficulty)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			DifficultyDef difficultyDef = DifficultyCatalog.GetDifficultyDef(difficulty);
			float result = 0f;
			if (DifficultyUtilsModule.ValidateCachedDifficultyStats())
			{
				result = DifficultyUtilsModule.cachedDifficultyStats.startingDifficultyCoefficientBoost;
			}
			return result;
		}

		public static float GetScalingValueForDifficulty(DifficultyIndex difficulty)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			DifficultyDef difficultyDef = DifficultyCatalog.GetDifficultyDef(difficulty);
			return difficultyDef.scalingValue;
		}

		public static float GetDifficultyCoefficient(Run run, float timeInMinutes, int stageClearCount, out float playerBaseFactor)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			float scalingValueForDifficulty = GetScalingValueForDifficulty(run.selectedDifficulty);
			float num = 0.0506f * baseScalingMultiplier;
			float num2 = GetTimeDifficultyFactor(timeInMinutes, scalingValueForDifficulty);
			float num3 = GetStageDifficultyFactor(stageClearCount);
			playerBaseFactor = 1f + playerBaseDifficultyFactor * (float)(run.participatingPlayerCount - 1);
			float num4 = Mathf.Pow((float)run.participatingPlayerCount, playerScalingDifficultyFactor);
			float num5 = num * scalingValueForDifficulty * num4;
			return (playerBaseFactor + num5 * timeInMinutes) * num2 * num3;
			static float GetStageDifficultyFactor(int stageClearCount)
			{
				float num6 = Mathf.Pow(difficultyIncreasePerStage, (float)stageClearCount);
				int num7 = Mathf.FloorToInt((float)stageClearCount / 5f);
				if (stageClearCount % 5 <= 1 && Object.op_Implicit((Object)(object)Stage.instance) && SceneCatalog.GetSceneDefForCurrentScene().isFinalStage)
				{
					num7--;
				}
				float num8 = Mathf.Pow(difficultyIncreasePerLoop, (float)num7);
				return num6 * num8;
			}
			static float GetTimeDifficultyFactor(float timeInMinutes, float scalingValue)
			{
				return Mathf.Pow(difficultyIncreasePerMinuteBase + difficultyIncreasePerMinutePerDifficulty * scalingValue, timeInMinutes);
			}
		}

		private void MonsoonStatBoost()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			monsoonDesc += "\n>Enemies gain <style=cIsHealth>unique scaling</style></style>";
			RecalculateStatsAPI.GetStatCoefficients += new StatHookEventHandler(MonsoonPlusStatBuffs2);
		}

		private void MonsoonPlusStatBuffs2(CharacterBody sender, StatHookEventArgs args)
		{
			//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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Invalid comparison between Unknown and I4
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			DifficultyIndex selectedDifficulty = Run.instance.selectedDifficulty;
			float ambientLevelBoost = GetAmbientLevelBoost();
			if ((int)sender.teamComponent.teamIndex != 1 && (int)selectedDifficulty >= 2)
			{
				float num = sender.level - ambientLevelBoost;
				float num2 = Mathf.Clamp01(num / 200f);
				float num3 = ((sender.baseNameToken == "CLAYBRUISER_BODY_NAME" || sender.baseNameToken == "LUNARWISP_BODY_NAME" || sender.baseNameToken == "JELLYFISH_BODY_NAME") ? 2f : 4f);
				args.attackSpeedMultAdd += num2 * num3;
				if (sender.isChampion)
				{
					args.armorAdd += 3f * num;
				}
				else
				{
					args.moveSpeedMultAdd += num2 * 2f;
				}
			}
		}

		private void EclipseChanges()
		{
			//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
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			CharacterMaster.OnBodyStart += new Manipulator(RemoveEclipseEffect);
			GlobalEventManager.OnCharacterHitGroundServer += new Manipulator(RemoveEclipseEffect);
			HealthComponent.Heal += new Manipulator(RemoveEclipseEffect);
			DeathRewards.OnKilledServer += new Manipulator(RemoveEclipseEffect);
			HealthComponent.TakeDamageProcess += new Manipulator(RemoveEclipseEffect);
			CharacterBody.RecalculateStats += new Manipulator(RemoveEclipseStats);
			RecalculateStatsAPI.GetStatCoefficients += new StatHookEventHandler(EclipseStatBuffs);
			CharacterBody.RecalculateStats += new hook_RecalculateStats(EclipseCdr);
			RunArtifactManager.SetArtifactEnabled += new hook_SetArtifactEnabled(EclipseSpiteArtifact);
			HoldoutZoneController.DoUpdate += new Manipulator(EclipseHoldoutScale);
			HoldoutZoneController.Start += new hook_Start(EclipseHoldoutDischarge);
			string text = "\"You only celebrate in the light... because I allow it.\" \n\n";
			string text2 = "Starts at baseline Monsoon difficulty.<style=cSub>\n";
			string text3 = "</style>";
			LanguageAPI.Add("ECLIPSE_1_DESCRIPTION", text2 + eclipseOneDesc + text3);
			LanguageAPI.Add("ECLIPSE_2_DESCRIPTION", text2 + eclipseOneDesc + eclipseTwoDesc + text3);
			LanguageAPI.Add("ECLIPSE_3_DESCRIPTION", text2 + eclipseOneDesc + eclipseTwoDesc + eclipseThreeDesc + text3);
			LanguageAPI.Add("ECLIPSE_4_DESCRIPTION", text2 + eclipseOneDesc + eclipseTwoDesc + eclipseThreeDesc + eclipseFourDesc + text3);
			LanguageAPI.Add("ECLIPSE_5_DESCRIPTION", text2 + eclipseOneDesc + eclipseTwoDesc + eclipseThreeDesc + eclipseFourDesc + eclipseFiveDesc + text3);
			LanguageAPI.Add("ECLIPSE_6_DESCRIPTION", text2 + eclipseOneDesc + eclipseTwoDesc + eclipseThreeDesc + eclipseFourDesc + eclipseFiveDesc + eclipseSixDesc + text3);
			LanguageAPI.Add("ECLIPSE_7_DESCRIPTION", text2 + eclipseOneDesc + eclipseTwoDesc + eclipseThreeDesc + eclipseFourDesc + eclipseFiveDesc + eclipseSixDesc + eclipseSevenDesc + text3);
			LanguageAPI.Add("ECLIPSE_8_DESCRIPTION", text + text2 + eclipseOneDesc + eclipseTwoDesc + eclipseThreeDesc + eclipseFourDesc + eclipseFiveDesc + eclipseSixDesc + eclipseSevenDesc + eclipseEightDesc + text3);
		}

		private void EclipseCdr(orig_RecalculateStats orig, CharacterBody self)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			DifficultyIndex selectedDifficulty = Run.instance.selectedDifficulty;
			if ((int)self.teamComponent.teamIndex != 1 && selectedDifficulty >= eclipseLevelEnemyCdr)
			{
				float cooldownScale = 1f - eclipseEnemyCdr;
				SkillLocator skillLocator = self.skillLocator;
				if ((Object)(object)skillLocator != (Object)null)
				{
					StatHooks.ApplyCooldownScale(skillLocator.primary, cooldownScale);
					StatHooks.ApplyCooldownScale(skillLocator.secondary, cooldownScale);
					StatHooks.ApplyCooldownScale(skillLocator.utility, cooldownScale);
					StatHooks.ApplyCooldownScale(skillLocator.special, cooldownScale);
				}
			}
		}

		private void RemoveEclipseStats(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)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: 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<Run>(x, "get_selectedDifficulty")
			});
			val.Emit(OpCodes.Pop);
			val.Emit(OpCodes.Ldc_I4, -1);
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<Run>(x, "get_selectedDifficulty")
			});
			val.Emit(OpCodes.Pop);
			val.Emit(OpCodes.Ldc_I4, -1);
		}

		private void RemoveEclipseEffect(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.MatchCallOrCallvirt<Run>(x, "get_selectedDifficulty")
			});
			val.Emit(OpCodes.Pop);
			val.Emit(OpCodes.Ldc_I4, -1);
		}

		private void EclipseHoldoutDischarge(orig_Start orig, HoldoutZoneController self)
		{
			//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)
			if (Run.instance.selectedDifficulty >= eclipseLevelHoldoutLoss)
			{
				self.dischargeRate = Mathf.Max(self.dischargeRate, eclipseHoldoutLossRate);
			}
			orig.Invoke(self);
		}

		private void EclipseHoldoutScale(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected I4, but got Unknown
			ILCursor val = new ILCursor(il);
			int num = 3;
			int num2 = default(int);
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[2]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<Run>(x, "get_selectedDifficulty"),
				(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, ref num2)
			});
			int index = val.Index;
			val.Index = index - 1;
			val.Remove();
			val.Emit(OpCodes.Ldc_I4, (int)eclipseLevelSmallHoldout);
		}

		private void EclipseSpiteArtifact(orig_SetArtifactEnabled orig, RunArtifactManager self, ArtifactDef artifactDef, bool newEnabled)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Run.instance == (Object)null)
			{
				orig.Invoke(self, artifactDef, newEnabled);
				return;
			}
			if (Run.instance.selectedDifficulty >= eclipseLevelSpiteArtifact && (Object)(object)artifactDef == (Object)(object)Artifacts.bombArtifactDef)
			{
				newEnabled = true;
			}
			orig.Invoke(self, artifactDef, newEnabled);
		}

		private void EclipseStatBuffs(CharacterBody sender, Stat