using System;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using On.RoR2;
using RoR2;
using UnityEngine;

[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.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("ModularEclipse")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ModularEclipse")]
[assembly: AssemblyTitle("ModularEclipse")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace ModularEclipse;

[BepInPlugin("com.HouseOfFruits.ModularEclipse", "ModularEclipse", "1.0.0")]
public class ModularEclipsePlugin : BaseUnityPlugin
{
	public const string guid = "com.HouseOfFruits.ModularEclipse";

	public const string teamName = "HouseOfFruits";

	public const string modName = "ModularEclipse";

	public const string version = "1.0.0";

	public static PluginInfo PInfo { get; private set; }

	internal static ConfigFile ArtifactWhitelistConfig { get; set; }

	public static void SetArtifactDefaultWhitelist(ArtifactDef artifactDef, bool defaultValue)
	{
		string cachedName = artifactDef.cachedName;
		if (cachedName == "")
		{
			Debug.LogError((object)("Artifact " + artifactDef.nameToken + " has no cached name! The Eclipse rule choice selection will not work for it."));
		}
		else
		{
			ArtifactWhitelistConfig.Bind<bool>("Eclipse: Whitelisted Artifacts", cachedName, defaultValue, "If true, this artifact will be *allowed* for use in the Eclipse gamemode. Recommended only difficulty artifacts should be enabled.");
		}
	}

	private void Awake()
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Expected O, but got Unknown
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Expected O, but got Unknown
		ArtifactWhitelistConfig = new ConfigFile(Paths.ConfigPath + "\\ModularEclipse.cfg", true);
		EclipseRun.OverrideRuleChoices += new hook_OverrideRuleChoices(EclipseRuleChoices);
	}

	private void EclipseRuleChoices(orig_OverrideRuleChoices orig, EclipseRun self, RuleChoiceMask mustInclude, RuleChoiceMask mustExclude, ulong runSeed)
	{
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		int num = 0;
		ReadOnlyCollection<NetworkUser> readOnlyInstancesList = NetworkUser.readOnlyInstancesList;
		for (int i = 0; i < readOnlyInstancesList.Count; i++)
		{
			NetworkUser val = readOnlyInstancesList[i];
			SurvivorDef survivorPreference = val.GetSurvivorPreference();
			if (Object.op_Implicit((Object)(object)survivorPreference))
			{
				int num2 = EclipseRun.GetNetworkUserSurvivorCompletedEclipseLevel(val, survivorPreference) + 1;
				num = ((num > 0) ? Math.Min(num, num2) : num2);
			}
		}
		num = Math.Min(num, EclipseRun.maxEclipseLevel);
		DifficultyIndex eclipseDifficultyIndex = EclipseRun.GetEclipseDifficultyIndex(num);
		RuleDef val2 = RuleCatalog.FindRuleDef("Difficulty");
		foreach (RuleChoiceDef choice in val2.choices)
		{
			if (choice.excludeByDefault && choice.difficultyIndex <= eclipseDifficultyIndex)
			{
				if (choice.difficultyIndex == eclipseDifficultyIndex)
				{
					val2.defaultChoiceIndex = choice.localIndex;
				}
				((SerializableBitArray)mustInclude)[choice.globalIndex] = true;
				((SerializableBitArray)mustExclude)[choice.globalIndex] = false;
			}
			else
			{
				((SerializableBitArray)mustInclude)[choice.globalIndex] = false;
				((SerializableBitArray)mustExclude)[choice.globalIndex] = true;
			}
		}
		((Run)self).ForceChoice(mustInclude, mustExclude, "Items." + ((Object)Items.LunarTrinket).name + ".Off");
		for (int j = 0; j < ArtifactCatalog.artifactCount; j++)
		{
			ArtifactDef artifactDef = ArtifactCatalog.GetArtifactDef((ArtifactIndex)j);
			string cachedName = artifactDef.cachedName;
			if (cachedName == "")
			{
				Debug.LogError((object)("Artifact " + artifactDef.nameToken + " has no cached name! The Eclipse rule choice selection will not work for it."));
				continue;
			}
			Debug.LogWarning((object)cachedName);
			if (!ArtifactWhitelistConfig.Bind<bool>("Eclipse: Whitelisted Artifacts", cachedName, false, "If true, this artifact will be *allowed* for use in the Eclipse gamemode. Recommended only difficulty artifacts should be enabled.").Value)
			{
				RuleDef val3 = RuleCatalog.FindRuleDef("Artifacts." + cachedName);
				((Run)self).ForceChoice(mustInclude, mustExclude, val3.FindChoice("Off"));
			}
		}
	}
}

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.GoldGat;
using EntityStates.ImpBossMonster;
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;
using On.EntityStates.CaptainSupplyDrop;
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;
using RainrotSharedUtils.Components;
using RainrotSharedUtils.Shelters;
using RiskierRain.Components;
using RiskierRain.CoreModules;
using RoR2;
using RoR2.CharacterAI;
using RoR2.ContentManagement;
using RoR2.Items;
using RoR2.Orbs;
using RoR2.Projectile;
using RoR2.Skills;
using RoR2.UI;
using RoR2BepInExPack.GameAssetPaths;
using SwanSongExtended;
using ThreeEyedGames;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Events;
using UnityEngine.Networking;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("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.2.10")]
	[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__26_0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			public static Func<uint> <>9__129_2;

			public static Func<uint, uint> <>9__134_0;

			public static Func<uint, uint> <>9__135_0;

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

			public static Action<CharacterBody> <>9__202_1;

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

			public static hook_OnEnter <>9__215_0;

			public static hook_OnEnter <>9__215_1;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			internal uint <FixGoldRewards>b__134_0(uint money)
			{
				float compensatedDifficultyFraction = GetCompensatedDifficultyFraction();
				return (uint)Mathf.CeilToInt((float)money * compensatedDifficultyFraction * goldRewardMultiplierGlobal);
			}

			internal uint <FixExpRewards>b__135_0(uint exp)
			{
				float compensatedDifficultyFraction = GetCompensatedDifficultyFraction();
				return (uint)Mathf.CeilToInt((float)exp * compensatedDifficultyFraction * expRewardMultiplierGlobal);
			}

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

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

			internal bool <ChangeEliteTierStats>b__210_0(EliteRules rules)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Invalid comparison between Unknown and I4
				//IL_0053: 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_0040: Invalid comparison between Unknown and I4
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Invalid comparison between Unknown and I4
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Invalid comparison between Unknown and I4
				return (Run.instance.stageClearCount >= Tier2EliteMinimumStageDrizzle && (int)rules == 0 && (int)Run.instance.selectedDifficulty <= 0) || (Run.instance.stageClearCount >= Tier2EliteMinimumStageRainstorm && (int)rules == 0 && (int)Run.instance.selectedDifficulty == 1) || (Run.instance.stageClearCount >= Tier2EliteMinimumStageMonsoon && (int)rules == 0 && (int)Run.instance.selectedDifficulty == 2) || (Run.instance.stageClearCount >= Tier2EliteMinimumStageEclipse && (int)rules == 0 && (int)Run.instance.selectedDifficulty > 2);
			}

			internal void <FixJellyNuke>b__215_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__215_1(orig_OnEnter orig, ChargeState self)
			{
				orig.Invoke(self);
				self.duration = 3f;
			}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			internal int <InfusionBuff>b__320_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__330_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC1Content/Items", "ChainLightningVoid");
			}

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

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

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

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

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

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

			internal int <FixLostSeersDamageImmunity>b__340_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__345_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "EquipmentMagazine");
			}

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

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

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

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

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

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

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

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

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

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

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

			internal Vector3 <BuffDevilOrb>b__392_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__393_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<InflictDotInfo>(x, "totalDamage");
			}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			internal float <CooldownBuff>b__405_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__405_8(Instruction x)
			{
				return ILPatternMatchingExt.MatchConvR4(x);
			}

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

			internal float <CooldownBuff>b__405_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__406_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "IceRing");
			}

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

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

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

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

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

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

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

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

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

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

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

			internal bool <SceneDirector_Start>b__410_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__410_1(GameObject obj)
			{
				return ((Object)obj).name == "NewtStatue, Guarantee" || ((Object)obj).name == "NewtStatue, Guaranteed" || ((Object)obj).name == "NewtStatue (Permanent)";
			}

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

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

			internal void <DeathMarkFix_Stacking>b__428_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__429_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Buffs", "DeathMark");
			}

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

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

			internal float <DeathMarkFix_Damage>b__429_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__454_0(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "BleedOnHitAndExplode");
			}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public static float drizzleDifficultyBoost = 0f;

		public static float rainstormDifficultyBoost = 3f;

		public static float monsoonDifficultyBoost = 6f;

		public static float eclipseDifficultyBoost = 9f;

		public static float baseScalingMultiplier = 1.1f;

		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 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 bool useAmbientLevel = false;

		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 = 0.75f;

		public static float fastDirectorCreditMultiplier = 0.75f;

		public static float slowDirectorEliteBias = 1f;

		public static float slowDirectorCreditMultiplier = 1.5f;

		public static float teleLesserEliteBias = 1f;

		public static float teleLesserCreditMultiplier = 1f;

		public static float teleBossEliteBias = 1f;

		public static float teleBossCreditMultiplier = 1f;

		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 = 1f;

		private static float goldRewardMultiplierGlobal = 0.6f;

		private static float expRewardMultiplierGlobal = 0.6f;

		private static float compensationForStartingLevel = 0.5f;

		public float interactableCreditsMultiplier = 1.5f;

		public float monsterCreditsMultiplier = 1.5f;

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

		public static int Tier2EliteMinimumStageDrizzle = 10;

		public static int Tier2EliteMinimumStageRainstorm = 5;

		public static int Tier2EliteMinimumStageMonsoon = 3;

		public static int Tier2EliteMinimumStageEclipse = 3;

		private static string Tier2EliteName = "Tier 2";

		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 = 800f;

		private float gupBaseArmor = 25f;

		private float gupBaseDamage = 12f;

		private float gupBaseSpeed = 14f;

		private float gupBaseRegen = 0f;

		private GameObject geepPrefab;

		private float geepBaseHealth = 400f;

		private float geepBaseArmor = 25f;

		private float geepBaseDamage = 8f;

		private float geepBaseSpeed = 10f;

		private float geepBaseRegen = 0f;

		private GameObject gipPrefab;

		private float gipBaseHealth = 200f;

		private float gipBaseArmor = 25f;

		private float gipBaseDamage = 5f;

		private float gipBaseSpeed = 6f;

		private float gipBaseRegen = 0f;

		private int nulliferBombCount = 10;

		private GameObject barnaclePrefab;

		private float fuckRegen = 0f;

		private GameObject lesserWispPrefab;

		private float wispBaseDamage = 1.5f;

		private GameObject xiMaster = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/MajorAndMinorConstruct/MegaConstructMaster.prefab").WaitForCompletion();

		private AISkillDriver[] xiAI;

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

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

		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 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 float shockForceExitFraction = 0.1f;

		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 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.2.10";

		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;

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

		private void DifficultyDependentTeleParticles()
		{
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			drizzleDesc = drizzleDesc + "\n>Teleporter Visuals: <style=cIsHealing>+" + Tools.ConvertDecimal(easyTeleParticleRadius / normalTeleParticleRadius - 1f) + "</style> ";
			rainstormDesc = rainstormDesc + "\n>Teleporter Visuals: +" + Tools.ConvertDecimal(normalTeleParticleRadius / normalTeleParticleRadius - 1f) + " ";
			monsoonDesc = monsoonDesc + "\n>Teleporter Visuals: <style=cIsHealth>" + Tools.ConvertDecimal(1f - hardTeleParticleRadius / normalTeleParticleRadius) + "</style> ";
			BaseTeleporterState.OnEnter += new hook_OnEnter(TeleporterParticleScale);
		}

		private void TeleporterParticleScale(orig_OnEnter orig, BaseTeleporterState self)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected I4, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Invalid comparison between Unknown and I4
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			float num = 1f;
			DifficultyIndex selectedDifficulty = Run.instance.selectedDifficulty;
			DifficultyIndex val = selectedDifficulty;
			switch (val - -1)
			{
			default:
				if ((int)val != 11)
				{
					num = eclipseTeleParticleRadius;
				}
				break;
			case 3:
				num = hardTeleParticleRadius;
				break;
			case 2:
				num = normalTeleParticleRadius;
				break;
			case 1:
				num = easyTeleParticleRadius;
				break;
			case 0:
				break;
			}
			TeleporterInteraction component = ((EntityState)self).GetComponent<TeleporterInteraction>();
			if (Object.op_Implicit((Object)(object)component) && Object.op_Implicit((Object)(object)component.modelChildLocator))
			{
				Transform val2 = ((Component)component).transform.Find("TeleporterBaseMesh/BuiltInEffects/PassiveParticle, Sphere");
				if (Object.op_Implicit((Object)(object)val2))
				{
					val2.localScale = Vector3.one * defaultTeleParticleRadius * num;
				}
			}
		}

		internal static float GetAmbientLevelBoost()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected I4, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Invalid comparison between Unknown and I4
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			float result = 0f;
			if (!useAmbientLevel)
			{
				return result;
			}
			DifficultyIndex selectedDifficulty = Run.instance.selectedDifficulty;
			DifficultyIndex val = selectedDifficulty;
			DifficultyIndex val2 = val;
			switch (val2 - -1)
			{
			default:
				if ((int)val2 != 11)
				{
					result = ((selectedDifficulty < eclipseLevelVeryHard) ? monsoonDifficultyBoost : eclipseDifficultyBoost);
				}
				break;
			case 3:
				result = monsoonDifficultyBoost;
				break;
			case 2:
				result = rainstormDifficultyBoost;
				break;
			case 1:
				result = drizzleDifficultyBoost;
				break;
			case 0:
				break;
			}
			return result;
		}

		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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			useAmbientLevel = true;
			Run.ambientLevelCap = ambientLevelCap;
			Run.RecalculateDifficultyCoefficentInternal += new hook_RecalculateDifficultyCoefficentInternal(DifficultyCoefficientChanges);
			DirectorMoneyWave.Update += new Manipulator(DirectorCreditGainChanges);
		}

		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_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			DifficultyDef difficultyDef = DifficultyCatalog.GetDifficultyDef(self.selectedDifficulty);
			float num = difficultyDef.scalingValue;
			if (self.selectedDifficulty >= eclipseLevelVeryHard)
			{
				num += 1f;
			}
			float num2 = self.GetRunStopwatch() * (1f / 60f);
			float num3 = 0.0506f * baseScalingMultiplier;
			float num4 = GetTimeDifficultyFactor(num2, num);
			float num5 = GetStageDifficultyFactor(self.stageClearCount);
			float num6 = 1f + playerBaseDifficultyFactor * (float)(self.participatingPlayerCount - 1);
			float num7 = Mathf.Pow((float)self.participatingPlayerCount, playerScalingDifficultyFactor);
			float num8 = num3 * num * num7;
			float num9 = (num6 + num8 * num2) * num4 * num5;
			self.difficultyCoefficient = num9;
			self.compensatedDifficultyCoefficient = num9;
			self.oneOverCompensatedDifficultyCoefficientSquared = 1f / (self.compensatedDifficultyCoefficient * self.compensatedDifficultyCoefficient);
			self.ambientLevel = Mathf.Min(1f + GetAmbientLevelBoost() + 3f * (num9 - num6), (float)Run.ambientLevelCap);
			int ambientLevelFloor = self.ambientLevelFloor;
			self.ambientLevelFloor = Mathf.FloorToInt(self.ambientLevel);
			if (ambientLevelFloor != self.ambientLevelFloor && ambientLevelFloor != 0 && self.ambientLevelFloor > ambientLevelFloor)
			{
				self.OnAmbientLevelUp();
			}
			float GetStageDifficultyFactor(int stageClearCount)
			{
				float num10 = Mathf.Pow(difficultyIncreasePerStage, (float)stageClearCount);
				int num11 = Mathf.FloorToInt((float)self.stageClearCount / 5f);
				if (self.stageClearCount % 5 <= 1 && Object.op_Implicit((Object)(object)Stage.instance) && SceneCatalog.GetSceneDefForCurrentScene().isFinalStage)
				{
					num11--;
				}
				float num12 = Mathf.Pow(difficultyIncreasePerLoop, (float)num11);
				return num10 * num12;
			}
			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;
				if (sender.baseNameToken != "JELLYFISH_BODY_NAME")
				{
					args.attackSpeedMultAdd += Mathf.Clamp01(num / 200f) * 4f;
				}
				if (sender.isChampion)
				{
					args.armorAdd += 3f * num;
				}
				else
				{
					args.moveSpeedMultAdd += Mathf.Clamp01(num / 200f) * 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, 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_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Invalid comparison between Unknown and I4
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			DifficultyIndex selectedDifficulty = Run.instance.selectedDifficulty;
			if ((int)sender.teamComponent.teamIndex != 1)
			{
				if (selectedDifficulty < eclipseLevelBossShield)
				{
					return;
				}
				if (sender.isBoss)
				{
					args.baseShieldAdd += sender.maxHealth * eclipseBossShieldFraction;
				}
				if (selectedDifficulty < eclipseLevelEnemyCdr || selectedDifficulty < eclipseLevelEnemyMspd)
				{
					return;
				}
				args.moveSpeedMultAdd += eclipseEnemyMspd;
			}
			if ((int)sender.teamComponent.teamIndex == 1 && selectedDifficulty >= eclipseLevelPlayerDegen)
			{
				args.baseRegenAdd -= (sender.baseRegen + sender.levelRegen * sender.level) * (eclipsePlayerDegen * sender.level);
			}
		}

		private void VoidFieldsStageType()
		{
			//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_0016: Unknown result type (might be due to invalid IL or missing references)
			SceneDef val = Addressables.LoadAssetAsync<SceneDef>((object)"RoR2/Base/arena/arena.asset").WaitForCompletion();
			val.sceneType = (SceneType)2;
		}

		private void VoidFieldsTimeCost()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			WardOnAndReady.OnExit += new hook_OnExit(AddVoidFieldsTimeCost);
		}

		private void AddVoidFieldsTimeCost(orig_OnExit orig, WardOnAndReady self)
		{
			orig.Invoke(self);
			Run.instance.SetRunStopwatch(Run.instance.GetRunStopwatch() + voidFieldsTimeCost);
		}

		private void ChangeDirectorStats()
		{
			//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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Common/Director.prefab").WaitForCompletion();
			CombatDirector[] components = val.GetComponents<CombatDirector>();
			if (components.Length != 0)
			{
				CombatDirector val2 = components[0];
				if ((Object)(object)val2 != (Object)null)
				{
					val2.eliteBias = fastDirectorEliteBias;
					val2.eliteBias = fastDirectorCreditMultiplier;
				}
				CombatDirector val3 = components[1];
				if ((Object)(object)val3 != (Object)null)
				{
					val3.eliteBias = slowDirectorEliteBias;
					val3.eliteBias = slowDirectorCreditMultiplier;
				}
			}
			GameObject val4 = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Common/Director.prefab").WaitForCompletion();
			GameObject val5 = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Common/Director.prefab").WaitForCompletion();
			AdjustTeleporterDirectors(val4.GetComponents<CombatDirector>());
			AdjustTeleporterDirectors(val5.GetComponents<CombatDirector>());
			static void AdjustTeleporterDirectors(CombatDirector[] directors)
			{
				if (directors != null && directors.Length != 0)
				{
					foreach (CombatDirector val6 in directors)
					{
						if (val6.customName == "Boss")
						{
							val6.eliteBias = teleBossEliteBias;
							val6.creditMultiplier = teleBossCreditMultiplier;
						}
						if (val6.customName == "Monsters")
						{
							val6.eliteBias = teleLesserEliteBias;
							val6.creditMultiplier = teleLesserCreditMultiplier;
						}
					}
				}
			}
		}

		public void AddPityCharge()
		{
			//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
			ChargingState.FixedUpdate += new hook_FixedUpdate(WeakenBossPostTpCharge);
			ChargingState.OnExit += new hook_OnExit(PityChargeOnExit);
		}

		private void PityChargeOnExit(orig_OnExit orig, ChargingState self)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			orig.Invoke(self);
			if (pityChargeOn)
			{
				pityChargeOn = false;
				pityChargeShrinkDelta = 0f;
				pityChargeRecolorDelta = 0f;
				((BaseTeleporterState)self).teleporterInteraction.holdoutZoneController.calcColor -= new CalcColorDelegate(PityChargeCalcColor);
				((BaseTeleporterState)self).teleporterInteraction.holdoutZoneController.calcRadius -= new CalcRadiusDelegate(PityChargeCalcRadius);
			}
		}

		private void PityChargeCalcRadius(ref float radius)
		{
			radius = Mathf.Max(radius * (1f - pityChargeShrinkDelta), 10f);
		}

		private void PityChargeCalcColor(ref Color color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			color = FocusConvergenceController.convergenceMaterialColor;
		}

		private void WeakenBossPostTpCharge(orig_FixedUpdate orig, ChargingState baseState)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Expected O, but got Unknown
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(baseState);
			if (((BaseTeleporterState)baseState).teleporterInteraction.holdoutZoneController.charge >= 1f)
			{
				if (((BaseTeleporterState)baseState).teleporterInteraction.monstersCleared || !((BaseTeleporterState)baseState).teleporterInteraction.holdoutZoneController.isAnyoneCharging)
				{
					return;
				}
				if (!pityChargeOn)
				{
					pityChargeOn = true;
					((BaseTeleporterState)baseState).teleporterInteraction.holdoutZoneController.calcColor += new CalcColorDelegate(PityChargeCalcColor);
					((BaseTeleporterState)baseState).teleporterInteraction.holdoutZoneController.calcRadius += new CalcRadiusDelegate(PityChargeCalcRadius);
					Chat.AddMessage("<style=cIsUtility>The overcharged teleporter begins its Convergence...</style>");
				}
				if (pityChargeRecolorDelta < 1f)
				{
					pityChargeRecolorDelta += Time.fixedDeltaTime;
				}
				pityChargeShrinkDelta += Time.fixedDeltaTime * 0.01f;
				if (!NetworkServer.active)
				{
					return;
				}
				BossGroup bossGroup = ((BaseTeleporterState)baseState).teleporterInteraction.bossGroup;
				BossMemory[] bossMemories = bossGroup.bossMemories;
				foreach (BossMemory val in bossMemories)
				{
					CharacterBody val2 = val.cachedBody;
					if ((Object)(object)val2 == (Object)null && (Object)(object)val.cachedMaster != (Object)null)
					{
						val2 = val.cachedMaster.GetBody();
					}
					if ((Object)(object)val2 != (Object)null)
					{
						val2.AddTimedBuff(Buffs.Cripple, 9999f);
						val2.AddTimedBuff(Buffs.HealingDisabled, 9999f);
						HealthComponent healthComponent = val2.healthComponent;
						if (Object.op_Implicit((Object)(object)healthComponent) && healthComponent.health > 1f)
						{
							DamageInfo val3 = new DamageInfo();
							val3.damage = (val2.maxHealth + val2.maxShield) * 0.01f * Time.fixedDeltaTime;
							val3.damageType = new DamageTypeCombo(DamageTypeCombo.op_Implicit((DamageType)2048), (DamageTypeExtended)0, (DamageSource)0);
							val3.damageType |= DamageTypeCombo.op_Implicit((DamageType)2);
							val3.damageType |= DamageTypeCombo.op_Implicit((DamageType)64);
							val3.procCoefficient = 1f;
							val3.position = val2.corePosition;
							healthComponent.TakeDamage(val3);
						}
					}
				}
			}
			else
			{
				pityChargeOn = false;
			}
		}

		private void FixMoneyScaling()
		{
			ChestRebalance();
			ChestCostScaling();
			EnemyRewards();
		}

		private void ChestCostScaling()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			Run.GetDifficultyScaledCost_int_float += new hook_GetDifficultyScaledCost_int_float(ChangeScaledCost);
			awuBody = awu.GetComponent<CharacterBody>();
			if (!Object.op_Implicit((Object)(object)awuBody))
			{
				return;
			}
			awuBody.baseArmor = awuArmor;
			if (awuAdaptiveArmorCount <= 0)
			{
				CharacterBody obj = awuBody;
				obj.armor += awuAdditionalArmor;
				return;
			}
			GivePickupsOnStart val = ((Component)awuBody).gameObject.AddComponent<GivePickupsOnStart>();
			if (Object.op_Implicit((Object)(object)val))
			{
				ItemInfo val2 = default(ItemInfo);
				val2.count = awuAdaptiveArmorCount;
				val2.itemString = Addressables.LoadAssetAsync<ItemDef>((object)"RoR2/Base/AdaptiveArmor/AdaptiveArmor.asset").WaitForCompletion().nameToken;
				val.itemInfos = (ItemInfo[])(object)new ItemInfo[1] { val2 };
			}
		}

		private void GoldShrineRework()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)goldShrine == (Object)null)
			{
				Debug.Log((object)"goldshrine null!! uh oh!!!!");
				return;
			}
			PurchaseInteraction component = goldShrine.GetComponent<PurchaseInteraction>();
			if ((Object)(object)component == (Object)null)
			{
				Debug.Log((object)"goldshrine purchase thing null bwuh");
				return;
			}
			component.costType = (CostTypeIndex)3;
			component.cost = goldShrineCost;
		}

		private void BloodShrineRewardRework()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			ShrineBloodBehavior.AddShrineStack += new Manipulator(ShrineBloodReward);
		}

		private void ShrineBloodReward(ILContext il)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			int rewardLoc = 1;
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdfld<ShrineBloodBehavior>(x, "goldToPaidHpRatio")
			});
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchStloc(x, ref rewardLoc)
			});
			val.EmitDelegate<Func<uint>>((Func<uint>)(() => (uint)Run.instance.GetDifficultyScaledCost(25, Stage.instance.entryDifficultyCoefficient)));
			val.Emit(OpCodes.Stloc, rewardLoc);
		}

		private void ShrineBloodBehavior_Start(orig_Start orig, ShrineBloodBehavior self)
		{
			orig.Invoke(self);
			if (NetworkServer.active)
			{
				((MonoBehaviour)this).StartCoroutine(WaitForPlayerBody(self));
			}
		}

		private IEnumerator WaitForPlayerBody(ShrineBloodBehavior instance)
		{
			yield return (object)new WaitForSeconds(2f);
			if (instance.goldToPaidHpRatio == 0f)
			{
				yield break;
			}
			foreach (PlayerCharacterMasterController playerCharacterMasterController in PlayerCharacterMasterController.instances)
			{
				CharacterBody body = playerCharacterMasterController.master.GetBody();
				if (Object.op_Implicit((Object)(object)body))
				{
					float maxHealth = body.healthComponent.fullCombinedHealth;
					if (maxHealth > (float)teamMaxHealth)
					{
						teamMaxHealth = (int)maxHealth;
					}
				}
			}
			float moneyTotal = Run.instance.GetDifficultyScaledCost(totalBloodGoldValue, Stage.instance.entryDifficultyCoefficient);
			float maxMulti = moneyTotal / (float)teamMaxHealth;
			if (maxMulti > 0f)
			{
				instance.goldToPaidHpRatio = maxMulti / 2.18f;
			}
		}

		private void EnemyRewards()
		{
			//IL_001d: Unknown r