Decompiled source of EnemiesReturns v0.5.18

plugins/Risky_Sleeps-EnemiesReturns/EnemiesReturns.dll

Decompiled 2 weeks ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using AdvancedPrediction.Prediction;
using Assets.RoR2.Scripts.Platform;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using EliteReworks.Tweaks;
using EnemiesReturns.Achievements;
using EnemiesReturns.Behaviors;
using EnemiesReturns.Behaviors.JitterBonesStuff;
using EnemiesReturns.Behaviors.Judgement.MithrixWeaponDrop;
using EnemiesReturns.Behaviors.Judgement.Newt;
using EnemiesReturns.Behaviors.Judgement.WaveInteractable;
using EnemiesReturns.Components;
using EnemiesReturns.Components.BodyComponents;
using EnemiesReturns.Components.BodyComponents.CharacterMotor;
using EnemiesReturns.Components.BodyComponents.NetworkedEntityStateMachine;
using EnemiesReturns.Components.BodyComponents.Skills;
using EnemiesReturns.Components.GeneralComponents;
using EnemiesReturns.Components.MasterComponents;
using EnemiesReturns.Components.ModelComponents;
using EnemiesReturns.Components.ModelComponents.Hitboxes;
using EnemiesReturns.Components.ModelComponents.Hurtboxes;
using EnemiesReturns.Components.ModelComponents.Skins;
using EnemiesReturns.Configuration;
using EnemiesReturns.Configuration.Judgement;
using EnemiesReturns.Configuration.LynxTribe;
using EnemiesReturns.EditorHelpers;
using EnemiesReturns.Enemies.ArcherBug;
using EnemiesReturns.Enemies.Colossus;
using EnemiesReturns.Enemies.Ifrit;
using EnemiesReturns.Enemies.Ifrit.Pillar;
using EnemiesReturns.Enemies.Judgement;
using EnemiesReturns.Enemies.Judgement.Arraign;
using EnemiesReturns.Enemies.LynxTribe;
using EnemiesReturns.Enemies.LynxTribe.Archer;
using EnemiesReturns.Enemies.LynxTribe.Hunter;
using EnemiesReturns.Enemies.LynxTribe.Scout;
using EnemiesReturns.Enemies.LynxTribe.Shaman;
using EnemiesReturns.Enemies.LynxTribe.Storm;
using EnemiesReturns.Enemies.LynxTribe.Totem;
using EnemiesReturns.Enemies.MechanicalSpider;
using EnemiesReturns.Enemies.Spitter;
using EnemiesReturns.Equipment.MithrixHammer;
using EnemiesReturns.Items.ColossalKnurl;
using EnemiesReturns.Items.LynxFetish;
using EnemiesReturns.Items.SpawnPillarOnChampionKill;
using EnemiesReturns.Junk.ModdedEntityStates.Colossus.HeadLaser;
using EnemiesReturns.Junk.ModdedEntityStates.Ifrit;
using EnemiesReturns.Junk.ModdedEntityStates.LynxTribe.Hunter;
using EnemiesReturns.Junk.ModdedEntityStates.LynxTribe.Shaman;
using EnemiesReturns.Junk.ModdedEntityStates.LynxTribe.Shaman.Teleport;
using EnemiesReturns.Junk.ModdedEntityStates.LynxTribe.Totem;
using EnemiesReturns.Junk.ModdedEntityStates.Spitter;
using EnemiesReturns.ModCompats;
using EnemiesReturns.ModdedEntityStates.ArcherBugs;
using EnemiesReturns.ModdedEntityStates.Colossus;
using EnemiesReturns.ModdedEntityStates.Colossus.Death;
using EnemiesReturns.ModdedEntityStates.Colossus.HeadLaserBarrage;
using EnemiesReturns.ModdedEntityStates.Colossus.RockClap;
using EnemiesReturns.ModdedEntityStates.Colossus.Stomp;
using EnemiesReturns.ModdedEntityStates.Ifrit;
using EnemiesReturns.ModdedEntityStates.Ifrit.FlameCharge;
using EnemiesReturns.ModdedEntityStates.Ifrit.Hellzone;
using EnemiesReturns.ModdedEntityStates.Ifrit.Pillar;
using EnemiesReturns.ModdedEntityStates.Ifrit.Pillar.Enemy;
using EnemiesReturns.ModdedEntityStates.Ifrit.Pillar.Player;
using EnemiesReturns.ModdedEntityStates.Judgement.Arraign;
using EnemiesReturns.ModdedEntityStates.Judgement.Arraign.BaseSkyLeap;
using EnemiesReturns.ModdedEntityStates.Judgement.Arraign.Beam;
using EnemiesReturns.ModdedEntityStates.Judgement.Arraign.Phase1;
using EnemiesReturns.ModdedEntityStates.Judgement.Arraign.Phase1.SkyLeap;
using EnemiesReturns.ModdedEntityStates.Judgement.Arraign.Phase1.ThreeHitCombo;
using EnemiesReturns.ModdedEntityStates.Judgement.Arraign.Phase2;
using EnemiesReturns.ModdedEntityStates.Judgement.Arraign.Phase2.LeapingDash;
using EnemiesReturns.ModdedEntityStates.Judgement.Arraign.Phase2.ThreeHitCombo;
using EnemiesReturns.ModdedEntityStates.Judgement.Arraign.Slide;
using EnemiesReturns.ModdedEntityStates.Judgement.Mission;
using EnemiesReturns.ModdedEntityStates.Judgement.MithrixHammer;
using EnemiesReturns.ModdedEntityStates.Judgement.SkyLaser;
using EnemiesReturns.ModdedEntityStates.LynxTribe;
using EnemiesReturns.ModdedEntityStates.LynxTribe.Archer;
using EnemiesReturns.ModdedEntityStates.LynxTribe.Hunter;
using EnemiesReturns.ModdedEntityStates.LynxTribe.Hunter.Lunge;
using EnemiesReturns.ModdedEntityStates.LynxTribe.Scout;
using EnemiesReturns.ModdedEntityStates.LynxTribe.Shaman;
using EnemiesReturns.ModdedEntityStates.LynxTribe.Storm;
using EnemiesReturns.ModdedEntityStates.LynxTribe.Totem;
using EnemiesReturns.ModdedEntityStates.LynxTribe.Totem.Burrow;
using EnemiesReturns.ModdedEntityStates.MechanicalSpider;
using EnemiesReturns.ModdedEntityStates.MechanicalSpider.Dash;
using EnemiesReturns.ModdedEntityStates.MechanicalSpider.Death;
using EnemiesReturns.ModdedEntityStates.MechanicalSpider.DoubleShot;
using EnemiesReturns.ModdedEntityStates.Spitter;
using EnemiesReturns.PrefabSetupComponents.BodyComponents;
using EnemiesReturns.PrefabSetupComponents.MasterComponents;
using EnemiesReturns.PrefabSetupComponents.ModelComponents;
using EnemiesReturns.Projectiles;
using EnemiesReturns.Reflection;
using EnemiesReturns.zJunk.ModdedEntityStates.Judgement.Arraign;
using EntityStates;
using EntityStates.AI.Walker;
using EntityStates.BrotherMonster;
using EntityStates.GameOver;
using EntityStates.MeridianEvent;
using EntityStates.Missions.BrotherEncounter;
using Grumpy;
using HG;
using HG.Reflection;
using IL.RoR2;
using IL.RoR2.UI;
using JetBrains.Annotations;
using KinematicCharacterController;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using On.EntityStates.BrotherMonster;
using On.EntityStates.MeridianEvent;
using On.EntityStates.Missions.BrotherEncounter;
using On.RoR2;
using On.RoR2.SurvivorMannequins;
using On.RoR2.UI;
using R2API;
using R2API.Networking;
using Rewired.Utils;
using Rewired.Utils.Classes.Utility;
using Risky_Artifacts.Artifacts;
using RoR2;
using RoR2.Achievements;
using RoR2.AddressableAssets;
using RoR2.Audio;
using RoR2.CharacterAI;
using RoR2.CharacterSpeech;
using RoR2.ContentManagement;
using RoR2.EntityLogic;
using RoR2.ExpansionManagement;
using RoR2.Hologram;
using RoR2.Mecanim;
using RoR2.Navigation;
using RoR2.Networking;
using RoR2.Orbs;
using RoR2.Projectile;
using RoR2.Skills;
using RoR2.SurvivorMannequins;
using RoR2.UI;
using RoR2BepInExPack.GameAssetPaths;
using RoR2BepInExPack.Utilities;
using TMPro;
using ThreeEyedGames;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using UnityEngine.Rendering.PostProcessing;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.Serialization;
using UnityEngine.UI;

[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: OptIn]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("EnemiesReturns")]
[assembly: AssemblyTitle("EnemiesReturns")]
[assembly: AssemblyCompany("EnemiesReturns")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[Microsoft.CodeAnalysis.Embedded]
	[CompilerGenerated]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[Microsoft.CodeAnalysis.Embedded]
	[CompilerGenerated]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace EnemiesReturns
{
	public static class ConsoleCommands
	{
		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCSpawnTitans(ConCommandArgs args)
		{
			//IL_0016: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			CharacterBody cachedBody = LocalUserManager.readOnlyLocalUsersList[0].cachedBody;
			SpawnMonster(Addressables.LoadAssetAsync<CharacterSpawnCard>((object)"RoR2/Base/Titan/cscTitanBlackBeach.asset").WaitForCompletion(), cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(Addressables.LoadAssetAsync<CharacterSpawnCard>((object)"RoR2/Base/Titan/cscTitanDampCave.asset").WaitForCompletion(), cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(Addressables.LoadAssetAsync<CharacterSpawnCard>((object)"RoR2/Base/Titan/cscTitanGolemPlains.asset").WaitForCompletion(), cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(Addressables.LoadAssetAsync<CharacterSpawnCard>((object)"RoR2/Base/Titan/cscTitanGooLake.asset").WaitForCompletion(), cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(Addressables.LoadAssetAsync<CharacterSpawnCard>((object)"RoR2/Base/Titan/cscTitanGold.asset").WaitForCompletion(), cachedBody.modelLocator.modelBaseTransform.position);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCSpawnSpitters(ConCommandArgs args)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: 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)
			CharacterBody cachedBody = LocalUserManager.readOnlyLocalUsersList[0].cachedBody;
			SpawnMonster(SpitterBody.SpawnCards.cscSpitterDefault, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(SpitterBody.SpawnCards.cscSpitterLakes, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(SpitterBody.SpawnCards.cscSpitterDepths, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(SpitterBody.SpawnCards.cscSpitterSulfur, cachedBody.modelLocator.modelBaseTransform.position);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCSpawnColossi(ConCommandArgs args)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			CharacterBody cachedBody = LocalUserManager.readOnlyLocalUsersList[0].cachedBody;
			SpawnMonster(ColossusBody.SpawnCards.cscColossusDefault, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(ColossusBody.SpawnCards.cscColossusGrassy, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(ColossusBody.SpawnCards.cscColossusSnowy, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(ColossusBody.SpawnCards.cscColossusSandy, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(ColossusBody.SpawnCards.cscColossusSkyMeadow, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(ColossusBody.SpawnCards.cscColossusCastle, cachedBody.modelLocator.modelBaseTransform.position);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCPocketSpiders(ConCommandArgs args)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			CharacterBody cachedBody = LocalUserManager.readOnlyLocalUsersList[0].cachedBody;
			SpawnMonster(MechanicalSpiderEnemyBody.SpawnCards.cscMechanicalSpiderSnowy, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(MechanicalSpiderEnemyBody.SpawnCards.cscMechanicalSpiderDefault, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(MechanicalSpiderEnemyBody.SpawnCards.cscMechanicalSpiderGrassy, cachedBody.modelLocator.modelBaseTransform.position);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCSpawnLynx(ConCommandArgs args)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			CharacterBody cachedBody = LocalUserManager.readOnlyLocalUsersList[0].cachedBody;
			SpawnMonster(ArcherBody.SpawnCards.cscLynxArcherDefault, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(ArcherBodyAlly.SpawnCards.cscLynxArcherAlly, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(ScoutBody.SpawnCards.cscLynxScoutDefault, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(ScoutBodyAlly.SpawnCards.cscLynxScoutAlly, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(HunterBody.SpawnCards.cscLynxHunterDefault, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(HunterBodyAlly.SpawnCards.cscLynxHunterAlly, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(ShamanBody.SpawnCards.cscLynxShamanDefault, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(ShamanBodyAlly.SpawnCards.cscLynxShamanAlly, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(TotemBody.SpawnCards.cscLynxTotemDefault, cachedBody.modelLocator.modelBaseTransform.position);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCOutOfTimeTest(ConCommandArgs args)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			NetworkUser sender = args.sender;
			InvokeCMD(sender, "fixed_time", Random.Range(4200, 5100).ToString());
			InvokeCMD(sender, "run_set_stages_cleared", "11");
			InvokeCMD(sender, "team_set_level", "1", Random.Range(27, 31).ToString());
			InvokeCMD(sender, "random_items", Random.Range(78, 119).ToString(), "Tier1:100");
			InvokeCMD(sender, "random_items", Random.Range(43, 58).ToString(), "Tier2:100");
			InvokeCMD(sender, "random_items", Random.Range(8, 18).ToString(), "Tier3:100");
			InvokeCMD(sender, "random_items", Random.Range(3, 4).ToString(), "Boss:100");
			InvokeCMD(sender, "give_equip", "MithrixHammer");
			InvokeCMD(sender, "set_scene", "enemiesreturns_outoftime");
		}

		public static void InvokeCMD(NetworkUser user, string commandName, params string[] arguments)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = arguments.ToList();
			CmdSender val = default(CmdSender);
			((CmdSender)(ref val))..ctor(user);
			if (Object.op_Implicit((Object)(object)Console.instance))
			{
				Console.instance.RunCmd(val, commandName, list);
			}
			else
			{
				Log.Message("InvokeCMD called whilst no console instance exists");
			}
		}

		private static void SpawnMonster(CharacterSpawnCard card, Vector3 position)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			DirectorSpawnRequest val = new DirectorSpawnRequest((SpawnCard)(object)card, new DirectorPlacementRule
			{
				placementMode = (PlacementMode)3,
				position = position
			}, RoR2Application.rng);
			val.teamIndexOverride = (TeamIndex)2;
			val.ignoreTeamMemberLimit = true;
			DirectorCore.instance.TrySpawnObject(val);
		}
	}
	public static class Content
	{
		public static class Stages
		{
			public static SceneDef OutOfTime;

			public static SceneDef JudgementOutro;
		}

		public static class MusicTracks
		{
			public static MusicTrackDef Unknown;

			public static MusicTrackDef UnknownBoss;

			public static MusicTrackDef TheOrigin;
		}

		public static class GameEndings
		{
			public static GameEndingDef SurviveJudgement;
		}

		public static class ItemTiers
		{
			public static ItemTierDef HiddenInLogbook;
		}

		public static class Items
		{
			public static ItemDef ColossalCurl;

			public static ItemDef SpawnPillarOnChampionKill;

			public static ItemDef LynxFetish;

			public static ItemDef TradableRock;

			public static ItemDef LunarFlower;

			public static ItemDef HiddenAnointed;
		}

		public static class ItemRelationshipProviders
		{
			public static ItemRelationshipProvider ModdedContagiousItemProvider;
		}

		public static class Equipment
		{
			public static EquipmentDef MithrixHammer;

			public static EquipmentDef EliteAeonian;
		}

		public static class Buffs
		{
			public static BuffDef LynxArcherDamage;

			public static BuffDef LynxHunterArmor;

			public static BuffDef LynxScoutSpeed;

			public static BuffDef LynxShamanSpecialDamage;

			public static BuffDef ReduceHealing;

			public static BuffDef LynxStormImmunity;

			public static BuffDef AffixAeoninan;

			public static BuffDef ImmuneToAllDamageExceptHammer;

			public static BuffDef ImmuneToHammer;
		}

		public static class Elites
		{
			public static EliteDef Aeonian;
		}

		public static class DamageTypes
		{
			public static ModdedDamageType ApplyReducedHealing;

			public static ModdedDamageType EndGameBossWeapon;
		}
	}
	public class ContentProvider : IContentPackProvider
	{
		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct MonsterCategories
		{
			public const string Champions = "Champions";

			public const string Minibosses = "Minibosses";

			public const string BasicMonsters = "Basic Monsters";

			public const string Special = "Special";
		}

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

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

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

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

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

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

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

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

			public static Func<Texture2D, bool> <>9__32_7;

			public static Func<Texture2D, bool> <>9__32_8;

			public static Func<Texture2D, string> <>9__32_9;

			public static Func<Texture2D, Texture2D> <>9__32_10;

			public static Func<AnimationCurveDef, string> <>9__32_11;

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

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

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

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

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

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

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

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

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

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

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

			public static Func<Texture2D, bool> <>9__43_16;

			public static Func<Texture2D, string> <>9__43_17;

			public static Func<Texture2D, Texture2D> <>9__43_18;

			public static Func<AnimationCurveDef, bool> <>9__43_19;

			public static Func<AnimationCurveDef, bool> <>9__43_20;

			public static Func<AnimationCurveDef, bool> <>9__43_21;

			public static Func<AnimationCurveDef, bool> <>9__43_22;

			public static Func<AnimationCurveDef, bool> <>9__43_23;

			public static Func<AnimationCurveDef, bool> <>9__43_24;

			public static Func<AnimationCurveDef, bool> <>9__43_25;

			public static Func<AnimationCurveDef, bool> <>9__43_26;

			public static Func<AnimationCurveDef, bool> <>9__43_27;

			public static Func<EliteDef, bool> <>9__43_28;

			public static Func<SceneDef, bool> <>9__43_29;

			public static Func<SceneDef, bool> <>9__43_30;

			public static Func<SkillDef, bool> <>9__43_31;

			public static Func<SkillDef, bool> <>9__43_32;

			public static Func<SkillDef, bool> <>9__43_33;

			public static Func<SkillDef, bool> <>9__43_34;

			public static Func<SkillDef, bool> <>9__43_35;

			public static Func<SkillDef, bool> <>9__43_36;

			public static Func<SkillDef, bool> <>9__43_37;

			public static Func<SkillDef, bool> <>9__43_38;

			public static Func<SkillDef, bool> <>9__43_39;

			public static Func<SkillDef, bool> <>9__43_40;

			public static Func<SkillDef, bool> <>9__43_41;

			public static Func<SkillDef, bool> <>9__43_42;

			public static Action<SkillDef[]> <>9__43_6;

			public static Func<BuffDef, bool> <>9__43_43;

			public static Func<BuffDef, bool> <>9__43_44;

			public static Func<BuffDef, bool> <>9__43_45;

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

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

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

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

			public static Converter<GameObject, EffectDef> <>9__43_50;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			public static Func<ItemDef, bool> <>9__43_78;

			public static Func<ItemDef, bool> <>9__43_79;

			public static Func<ItemDef, bool> <>9__43_80;

			public static Func<GameEndingDef, bool> <>9__43_81;

			public static Func<ItemTierDef, bool> <>9__43_82;

			public static Func<EquipmentDef, bool> <>9__43_83;

			public static Func<EquipmentDef, bool> <>9__43_84;

			public static Func<CharacterSpawnCard, bool> <>9__43_85;

			public static Func<CharacterSpawnCard, bool> <>9__43_86;

			public static Action<CharacterSpawnCard[]> <>9__43_14;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			public static EffectCondition <>9__57_6;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			internal bool <CreateArcherBug>b__0_0(GameObject body)
			{
				return ((Object)body).name == "ArcherBugBody";
			}

			internal bool <CreateArcherBug>b__0_1(GameObject master)
			{
				return ((Object)master).name == "ArcherBugMaster";
			}

			internal bool <CreateColossus>b__1_0(GameObject body)
			{
				return ((Object)body).name == "ColossusBody";
			}

			internal bool <CreateColossus>b__1_1(GameObject master)
			{
				return ((Object)master).name == "ColossusMaster";
			}

			internal bool <CreateColossusItem>b__2_0(GameObject item)
			{
				return ((Object)item).name == "PickupColossalCurl";
			}

			internal bool <CreateColossusItem>b__2_1(GameObject item)
			{
				return ((Object)item).name == "ColossalKnurlFistProjectileGhost";
			}

			internal bool <CreateColossusItem>b__2_2(GameObject item)
			{
				return ((Object)item).name == "ColossalKnurlFistProjectile";
			}

			internal bool <LoadStaticContentAsync>b__32_7(Texture2D texture)
			{
				return ((Object)texture).name == "texLavaCrackRound";
			}

			internal bool <LoadStaticContentAsync>b__32_8(Texture2D texture)
			{
				return ((Object)texture).name.StartsWith("texRamp");
			}

			internal string <LoadStaticContentAsync>b__32_9(Texture2D texture)
			{
				return ((Object)texture).name;
			}

			internal Texture2D <LoadStaticContentAsync>b__32_10(Texture2D texture)
			{
				return texture;
			}

			internal string <LoadStaticContentAsync>b__32_11(AnimationCurveDef item)
			{
				return ((Object)item).name;
			}

			internal bool <LoadStaticContentAsync>b__32_6(Type type)
			{
				if (!type.IsAbstract && !type.IsInterface)
				{
					return type.GetCustomAttribute<RegisterEntityState>(inherit: false) != null;
				}
				return false;
			}

			internal bool <CreateIfrit>b__40_0(GameObject effect)
			{
				return ((Object)effect).name == "IfritSpawnPortal";
			}

			internal bool <CreateIfrit>b__40_1(GameObject projectile)
			{
				return ((Object)projectile).name == "IfritHellzonePillarProjectile";
			}

			internal bool <CreateIfrit>b__40_2(GameObject projectile)
			{
				return ((Object)projectile).name == "IfritHellzonePillarProjectileGhost";
			}

			internal bool <CreateIfrit>b__40_3(GameObject projectile)
			{
				return ((Object)projectile).name == "IfritHellzoneVolcanoEffect";
			}

			internal bool <CreateIfrit>b__40_4(GameObject body)
			{
				return ((Object)body).name == "IfritBody";
			}

			internal bool <CreateIfrit>b__40_5(GameObject mane)
			{
				return ((Object)mane).name == "IfritManeFireParticle";
			}

			internal bool <CreateIfrit>b__40_6(GameObject master)
			{
				return ((Object)master).name == "IfritMaster";
			}

			internal bool <CreateIfritItem>b__41_0(GameObject item)
			{
				return ((Object)item).name == "IfritItem";
			}

			internal bool <CreateIfritPillar>b__42_0(GameObject body)
			{
				return ((Object)body).name == "IfritPylonBody";
			}

			internal bool <CreateIfritPillar>b__42_1(GameObject master)
			{
				return ((Object)master).name == "IfritPylonMaster";
			}

			internal bool <CreateJudgementAsync>b__43_16(Texture2D texture)
			{
				return ((Object)texture).name.StartsWith("texRamp");
			}

			internal string <CreateJudgementAsync>b__43_17(Texture2D texture)
			{
				return ((Object)texture).name;
			}

			internal Texture2D <CreateJudgementAsync>b__43_18(Texture2D texture)
			{
				return texture;
			}

			internal bool <CreateJudgementAsync>b__43_19(AnimationCurveDef acd)
			{
				return ((Object)acd).name == "acdMoveSpeed";
			}

			internal bool <CreateJudgementAsync>b__43_20(AnimationCurveDef acd)
			{
				return ((Object)acd).name == "acdPreSlashMaterialAlpha";
			}

			internal bool <CreateJudgementAsync>b__43_21(AnimationCurveDef acd)
			{
				return ((Object)acd).name == "acdSlash1";
			}

			internal bool <CreateJudgementAsync>b__43_22(AnimationCurveDef acd)
			{
				return ((Object)acd).name == "acdSlash2";
			}

			internal bool <CreateJudgementAsync>b__43_23(AnimationCurveDef acd)
			{
				return ((Object)acd).name == "acdSlash3";
			}

			internal bool <CreateJudgementAsync>b__43_24(AnimationCurveDef acd)
			{
				return ((Object)acd).name == "acdSlash1P2";
			}

			internal bool <CreateJudgementAsync>b__43_25(AnimationCurveDef acd)
			{
				return ((Object)acd).name == "acdSlash2P2";
			}

			internal bool <CreateJudgementAsync>b__43_26(AnimationCurveDef acd)
			{
				return ((Object)acd).name == "acdSlash3P2";
			}

			internal bool <CreateJudgementAsync>b__43_27(AnimationCurveDef acd)
			{
				return ((Object)acd).name == "acdMithrixDash";
			}

			internal bool <CreateJudgementAsync>b__43_28(EliteDef elitedef)
			{
				return ((Object)elitedef).name == "EliteAeonian";
			}

			internal bool <CreateJudgementAsync>b__43_29(SceneDef sd)
			{
				return sd.cachedName == "enemiesreturns_outoftime";
			}

			internal bool <CreateJudgementAsync>b__43_30(SceneDef sd)
			{
				return sd.cachedName == "enemiesreturns_judgementoutro";
			}

			internal void <CreateJudgementAsync>b__43_6(SkillDef[] assets)
			{
				ArraignBody.P1Skills.ThreeHitCombo = assets.First((SkillDef asset) => ((Object)asset).name == "sdArraign3HitCombo");
				ArraignBody.P1Skills.ThreeHitCombo.baseRechargeInterval = ArraignP1.ThreeHitComboCooldown.Value;
				ArraignBody.P1Skills.LeftRightSwing = assets.First((SkillDef asset) => ((Object)asset).name == "sdArraignRightLeftSwing");
				ArraignBody.P1Skills.LeftRightSwing.baseRechargeInterval = ArraignP1.LeftRightSwingCooldown.Value;
				ArraignBody.P1Skills.SwordBeam = assets.First((SkillDef asset) => ((Object)asset).name == "sdArraignSwordBeam");
				ArraignBody.P1Skills.SwordBeam.baseRechargeInterval = ArraignP1.SwordBeamCooldown.Value;
				ArraignBody.P1Skills.SkyDrop = assets.First((SkillDef asset) => ((Object)asset).name == "sdArraignSkyDrop");
				ArraignBody.P1Skills.SkyDrop.baseRechargeInterval = ArraignP1.SkyDropCooldown.Value;
				ArraignBody.P1Skills.SwordThrow = assets.First((SkillDef asset) => ((Object)asset).name == "sdArraignSwordThrow");
				ArraignBody.P1Skills.SwordThrow.baseRechargeInterval = ArraignP1.SwordBeamCooldown.Value;
				ArraignBody.P1Skills.LightningStrikes = assets.First((SkillDef asset) => ((Object)asset).name == "sdArraignLightningStrikes");
				ArraignBody.P1Skills.LightningStrikes.baseRechargeInterval = ArraignP1.LightningStrikesCooldown.Value;
				ArraignBody.P2Skills.ThreeHitCombo = assets.First((SkillDef asset) => ((Object)asset).name == "sdArraign3HitComboP2");
				ArraignBody.P2Skills.ThreeHitCombo.baseRechargeInterval = ArraignP2.ThreeHitComboCooldown.Value;
				ArraignBody.P2Skills.LeftRightSwing = assets.First((SkillDef asset) => ((Object)asset).name == "sdArraignRightLeftSwingP2");
				ArraignBody.P2Skills.LeftRightSwing.baseRechargeInterval = ArraignP2.LeftRightSwingCooldown.Value;
				ArraignBody.P2Skills.DashLeap = assets.First((SkillDef asset) => ((Object)asset).name == "sdArraignDashAttackP2");
				ArraignBody.P2Skills.DashLeap.baseRechargeInterval = ArraignP2.DashLeapCooldown.Value;
				ArraignBody.P2Skills.SpearThrow = assets.First((SkillDef asset) => ((Object)asset).name == "sdArraignSpearThrow");
				ArraignBody.P2Skills.SpearThrow.baseRechargeInterval = ArraignP2.SpearThrowCooldown.Value;
				ArraignBody.HauntSkills.ClockAttack = assets.First((SkillDef asset) => ((Object)asset).name == "sdArraignaHauntClockAttack");
				ArraignBody.HauntSkills.ClockAttack.baseRechargeInterval = ArraignP2.ClockAttackCooldown.Value;
				ArraignBody.HauntSkills.SummonSkyLaser = assets.First((SkillDef asset) => ((Object)asset).name == "sdArraignHauntSkyLaser");
				ArraignBody.HauntSkills.SummonSkyLaser.baseRechargeInterval = ArraignP2.SkyLaserCooldown.Value;
			}

			internal bool <CreateJudgementAsync>b__43_31(SkillDef asset)
			{
				return ((Object)asset).name == "sdArraign3HitCombo";
			}

			internal bool <CreateJudgementAsync>b__43_32(SkillDef asset)
			{
				return ((Object)asset).name == "sdArraignRightLeftSwing";
			}

			internal bool <CreateJudgementAsync>b__43_33(SkillDef asset)
			{
				return ((Object)asset).name == "sdArraignSwordBeam";
			}

			internal bool <CreateJudgementAsync>b__43_34(SkillDef asset)
			{
				return ((Object)asset).name == "sdArraignSkyDrop";
			}

			internal bool <CreateJudgementAsync>b__43_35(SkillDef asset)
			{
				return ((Object)asset).name == "sdArraignSwordThrow";
			}

			internal bool <CreateJudgementAsync>b__43_36(SkillDef asset)
			{
				return ((Object)asset).name == "sdArraignLightningStrikes";
			}

			internal bool <CreateJudgementAsync>b__43_37(SkillDef asset)
			{
				return ((Object)asset).name == "sdArraign3HitComboP2";
			}

			internal bool <CreateJudgementAsync>b__43_38(SkillDef asset)
			{
				return ((Object)asset).name == "sdArraignRightLeftSwingP2";
			}

			internal bool <CreateJudgementAsync>b__43_39(SkillDef asset)
			{
				return ((Object)asset).name == "sdArraignDashAttackP2";
			}

			internal bool <CreateJudgementAsync>b__43_40(SkillDef asset)
			{
				return ((Object)asset).name == "sdArraignSpearThrow";
			}

			internal bool <CreateJudgementAsync>b__43_41(SkillDef asset)
			{
				return ((Object)asset).name == "sdArraignaHauntClockAttack";
			}

			internal bool <CreateJudgementAsync>b__43_42(SkillDef asset)
			{
				return ((Object)asset).name == "sdArraignHauntSkyLaser";
			}

			internal bool <CreateJudgementAsync>b__43_43(BuffDef buff)
			{
				return ((Object)buff).name == "bdAeonian";
			}

			internal bool <CreateJudgementAsync>b__43_44(BuffDef buff)
			{
				return ((Object)buff).name == "bdImmuneToHammer";
			}

			internal bool <CreateJudgementAsync>b__43_45(BuffDef buff)
			{
				return ((Object)buff).name == "bdImmuneToAllDamageExceptHammer";
			}

			internal bool <CreateJudgementAsync>b__43_46(GameObject asset)
			{
				CharacterBody val = default(CharacterBody);
				return asset.TryGetComponent<CharacterBody>(ref val);
			}

			internal bool <CreateJudgementAsync>b__43_47(GameObject asset)
			{
				CharacterMaster val = default(CharacterMaster);
				return asset.TryGetComponent<CharacterMaster>(ref val);
			}

			internal bool <CreateJudgementAsync>b__43_48(GameObject asset)
			{
				ProjectileController val = default(ProjectileController);
				return asset.TryGetComponent<ProjectileController>(ref val);
			}

			internal bool <CreateJudgementAsync>b__43_49(GameObject asset)
			{
				EffectComponent val = default(EffectComponent);
				return asset.TryGetComponent<EffectComponent>(ref val);
			}

			internal EffectDef <CreateJudgementAsync>b__43_50(GameObject item)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Expected O, but got Unknown
				return new EffectDef(item);
			}

			internal bool <CreateJudgementAsync>b__43_51(GameObject asset)
			{
				return ((Object)asset).name == "ArraignP1Body";
			}

			internal bool <CreateJudgementAsync>b__43_52(GameObject asset)
			{
				return ((Object)asset).name == "ArraignP2Body";
			}

			internal bool <CreateJudgementAsync>b__43_53(GameObject asset)
			{
				return ((Object)asset).name == "JudgementInteractable";
			}

			internal bool <CreateJudgementAsync>b__43_54(GameObject asset)
			{
				return ((Object)asset).name == "PileOfDirtInteractable";
			}

			internal bool <CreateJudgementAsync>b__43_55(GameObject asset)
			{
				return ((Object)asset).name == "BrokenTeleporterInteractable";
			}

			internal bool <CreateJudgementAsync>b__43_56(GameObject asset)
			{
				return ((Object)asset).name == "PortalJudgement";
			}

			internal bool <CreateJudgementAsync>b__43_57(GameObject asset)
			{
				return ((Object)asset).name == "MithrixHammerController";
			}

			internal bool <CreateJudgementAsync>b__43_58(GameObject asset)
			{
				return ((Object)asset).name == "ArraignP1SpeechController";
			}

			internal bool <CreateJudgementAsync>b__43_59(GameObject asset)
			{
				return ((Object)asset).name == "ArraignP2SpeechController";
			}

			internal bool <CreateJudgementAsync>b__43_60(GameObject asset)
			{
				return ((Object)asset).name == "MithrixHammerSwingEffect";
			}

			internal bool <CreateJudgementAsync>b__43_61(GameObject asset)
			{
				return ((Object)asset).name == "ArraignRemoveSwordEffect";
			}

			internal bool <CreateJudgementAsync>b__43_62(GameObject asset)
			{
				return ((Object)asset).name == "ArraignSlash3Wave";
			}

			internal bool <CreateJudgementAsync>b__43_63(GameObject asset)
			{
				return ((Object)asset).name == "ArraignPreLightningProjectile";
			}

			internal bool <CreateJudgementAsync>b__43_64(GameObject asset)
			{
				return ((Object)asset).name == "ArraignPreClockAttackProjectile";
			}

			internal bool <CreateJudgementAsync>b__43_65(GameObject asset)
			{
				return ((Object)asset).name == "ArraignSwordProjectile";
			}

			internal bool <CreateJudgementAsync>b__43_66(GameObject asset)
			{
				return ((Object)asset).name == "ArraignSpearProjectile";
			}

			internal bool <CreateJudgementAsync>b__43_67(GameObject asset)
			{
				return ((Object)asset).name == "ClockZoneEffect";
			}

			internal bool <CreateJudgementAsync>b__43_68(GameObject asset)
			{
				return ((Object)asset).name == "DropPositionEffect";
			}

			internal bool <CreateJudgementAsync>b__43_69(GameObject asset)
			{
				return ((Object)asset).name == "ArraignPreBeamGroundIndicator";
			}

			internal bool <CreateJudgementAsync>b__43_70(GameObject asset)
			{
				return ((Object)asset).name == "LanceStapEffect";
			}

			internal bool <CreateJudgementAsync>b__43_71(GameObject asset)
			{
				return ((Object)asset).name == "ArraignArmorBreakEffect";
			}

			internal bool <CreateJudgementAsync>b__43_72(GameObject asset)
			{
				return ((Object)asset).name == "SkyLaserBodySpawnEffect";
			}

			internal bool <CreateJudgementAsync>b__43_73(GameObject asset)
			{
				return ((Object)asset).name == "BeamPostProccess";
			}

			internal bool <CreateJudgementAsync>b__43_74(GameObject asset)
			{
				return ((Object)asset).name == "ArraignBeamPushbackEffect";
			}

			internal bool <CreateJudgementAsync>b__43_75(GameObject asset)
			{
				return ((Object)asset).name == "ArraignBeamPushbackEffectNoMuzzleParticles";
			}

			internal bool <CreateJudgementAsync>b__43_76(GameObject asset)
			{
				return ((Object)asset).name == "DisplayAeonian";
			}

			internal bool <CreateJudgementAsync>b__43_77(GameObject asset)
			{
				return ((Object)asset).name == "EnemiesReturnsCreditsAdditions";
			}

			internal bool <CreateJudgementAsync>b__43_78(ItemDef item)
			{
				return ((Object)item).name == "TradableRock";
			}

			internal bool <CreateJudgementAsync>b__43_79(ItemDef item)
			{
				return ((Object)item).name == "LunarFlower";
			}

			internal bool <CreateJudgementAsync>b__43_80(ItemDef item)
			{
				return ((Object)item).name == "HiddenAnointed";
			}

			internal bool <CreateJudgementAsync>b__43_81(GameEndingDef item)
			{
				return item.cachedName == "SurviveJudgement";
			}

			internal bool <CreateJudgementAsync>b__43_82(ItemTierDef item)
			{
				return ((Object)item).name == "HiddenInLogbook";
			}

			internal bool <CreateJudgementAsync>b__43_83(EquipmentDef equipment)
			{
				return ((Object)equipment).name == "MithrixHammer";
			}

			internal bool <CreateJudgementAsync>b__43_84(EquipmentDef equipment)
			{
				return ((Object)equipment).name == "EliteAeonianEquipment";
			}

			internal void <CreateJudgementAsync>b__43_14(CharacterSpawnCard[] assets)
			{
				SummonSkyLasers.cscSkyLaser = assets.First((CharacterSpawnCard asset) => ((Object)asset).name == "cscSkyLaser");
				Phase3.cscArraignHaunt = assets.First((CharacterSpawnCard asset) => ((Object)asset).name == "cscArraignHaunt");
			}

			internal bool <CreateJudgementAsync>b__43_85(CharacterSpawnCard asset)
			{
				return ((Object)asset).name == "cscSkyLaser";
			}

			internal bool <CreateJudgementAsync>b__43_86(CharacterSpawnCard asset)
			{
				return ((Object)asset).name == "cscArraignHaunt";
			}

			internal bool <CreateLynxTrap>b__49_0(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxTrapPrefab";
			}

			internal bool <CreateLynxShrine>b__50_0(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxTribeRetreatEffect";
			}

			internal bool <CreateLynxShrine>b__50_1(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxShrinePrefab";
			}

			internal bool <CreateLynxShrine>b__50_2(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxShrinePrefab2";
			}

			internal bool <CreateLynxShrine>b__50_3(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxShrinePrefab3";
			}

			internal bool <CreateLynxArcher>b__52_0(GameObject prefab)
			{
				return ((Object)prefab).name == "ArrowProjectile";
			}

			internal bool <CreateLynxArcher>b__52_1(GameObject prefab)
			{
				return ((Object)prefab).name == "ArrowProjectileGhost";
			}

			internal bool <CreateLynxArcher>b__52_2(GameObject prefab)
			{
				return ((Object)prefab).name == "ArrowProjectileGhost";
			}

			internal bool <CreateLynxArcher>b__52_3(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxArcherBody";
			}

			internal bool <CreateLynxArcher>b__52_4(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxArcherMaster";
			}

			internal bool <CreateLynxArcher>b__52_5(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxArcherAllyBody";
			}

			internal bool <CreateLynxArcher>b__52_6(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxArcherAllyMaster";
			}

			internal bool <CreateLynxHunter>b__53_0(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxHunterAttackEffect";
			}

			internal bool <CreateLynxHunter>b__53_1(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxHunterSpearTipEffect";
			}

			internal bool <CreateLynxHunter>b__53_2(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxHunterBody";
			}

			internal bool <CreateLynxHunter>b__53_3(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxHunterMaster";
			}

			internal bool <CreateLynxHunter>b__53_4(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxHunterAllyBody";
			}

			internal bool <CreateLynxHunter>b__53_5(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxHunterAllyMaster";
			}

			internal bool <CreateLynxScout>b__54_0(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxScoutClawEffectLeft";
			}

			internal bool <CreateLynxScout>b__54_1(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxScoutClawEffectRight";
			}

			internal bool <CreateLynxScout>b__54_2(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxScoutBody";
			}

			internal bool <CreateLynxScout>b__54_3(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxScoutMaster";
			}

			internal bool <CreateLynxScout>b__54_4(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxScoutAllyBody";
			}

			internal bool <CreateLynxScout>b__54_5(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxScoutAllyMaster";
			}

			internal bool <CreateLynxTotem>b__55_0(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxSpawnParticles";
			}

			internal bool <CreateLynxTotem>b__55_1(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxSpawnParticles";
			}

			internal bool <CreateLynxTotem>b__55_2(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxTotemFireWallProjectile";
			}

			internal bool <CreateLynxTotem>b__55_3(GameObject prefab)
			{
				return ((Object)prefab).name == "TotemShakeParticles";
			}

			internal bool <CreateLynxTotem>b__55_4(GameObject prefab)
			{
				return ((Object)prefab).name == "TotemSingleStoneParticle";
			}

			internal bool <CreateLynxTotem>b__55_5(GameObject prefab)
			{
				return ((Object)prefab).name == "TotemEyeGlowSummonTribe";
			}

			internal bool <CreateLynxTotem>b__55_6(GameObject prefab)
			{
				return ((Object)prefab).name == "TotemEyeGlowSummonStorm";
			}

			internal bool <CreateLynxTotem>b__55_7(GameObject prefab)
			{
				return ((Object)prefab).name == "TotemEyeGlowGroundpound";
			}

			internal bool <CreateLynxTotem>b__55_8(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxTotemGroundpoundProjectile";
			}

			internal bool <CreateLynxTotem>b__55_9(GameObject prefab)
			{
				return ((Object)prefab).name == "TotemSummonStormOrb";
			}

			internal bool <CreateLynxTotem>b__55_10(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxTotemBody";
			}

			internal bool <CreateLynxTotem>b__55_11(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxTotemMaster";
			}

			internal bool <CreateLynxTotemItem>b__56_0(GameObject item)
			{
				return ((Object)item).name == "PickupLynxFetish";
			}

			internal bool <CreateLynxShaman>b__57_0(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxSpawnParticles";
			}

			internal bool <CreateLynxShaman>b__57_1(GameObject prefab)
			{
				return ((Object)prefab).name == "ShamanSummonStormParticle";
			}

			internal bool <CreateLynxShaman>b__57_2(GameObject prefab)
			{
				return ((Object)prefab).name == "ShamanMask";
			}

			internal bool <CreateLynxShaman>b__57_3(GameObject prefab)
			{
				return ((Object)prefab).name == "ShamanTeleportEffectOut";
			}

			internal bool <CreateLynxShaman>b__57_4(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxShamanPushBackSummon";
			}

			internal bool <CreateLynxShaman>b__57_5(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxShamanPushBackExplosion";
			}

			internal bool <CreateLynxShaman>b__57_6(CharacterBody body)
			{
				return body.HasBuff(Content.Buffs.ReduceHealing);
			}

			internal bool <CreateLynxShaman>b__57_7(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxShamanProjectileImpactEffect";
			}

			internal bool <CreateLynxShaman>b__57_8(GameObject prefab)
			{
				return ((Object)prefab).name == "ShamanTrackingProjectile";
			}

			internal bool <CreateLynxShaman>b__57_9(GameObject body)
			{
				return ((Object)body).name == "LynxShamanBody";
			}

			internal bool <CreateLynxShaman>b__57_10(GameObject master)
			{
				return ((Object)master).name == "LynxShamanMaster";
			}

			internal bool <CreateLynxShaman>b__57_11(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxShamanAllyBody";
			}

			internal bool <CreateLynxShaman>b__57_12(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxShamanAllyMaster";
			}

			internal bool <CreateLynxStorm>b__58_0(GameObject body)
			{
				return ((Object)body).name == "StormBody";
			}

			internal bool <CreateLynxStorm>b__58_1(GameObject master)
			{
				return ((Object)master).name == "StormMaster";
			}

			internal bool <CreateMechanichalSpiderDrone>b__60_0(GameObject body)
			{
				return ((Object)body).name == "MechanicalSpiderDroneBody";
			}

			internal bool <CreateMechanichalSpiderDrone>b__60_1(GameObject master)
			{
				return ((Object)master).name == "MechanicalSpiderDroneMaster";
			}

			internal bool <CreateMechanichalSpiderDrone>b__60_2(GameObject interactable)
			{
				return ((Object)interactable).name == "MechanicalSpiderBroken";
			}

			internal bool <CreateMechanicalSpiderEnemy>b__61_0(GameObject body)
			{
				return ((Object)body).name == "MechanicalSpiderBody";
			}

			internal bool <CreateMechanicalSpiderEnemy>b__61_1(GameObject master)
			{
				return ((Object)master).name == "MechanicalSpiderMaster";
			}

			internal bool <CreateSpitter>b__62_0(GameObject body)
			{
				return ((Object)body).name == "SpitterBody";
			}

			internal bool <CreateSpitter>b__62_1(GameObject master)
			{
				return ((Object)master).name == "SpitterMaster";
			}
		}

		private readonly ContentPack _contentPack = new ContentPack();

		public const string AssetBundleName = "enemiesreturns";

		public const string AssetBundleStagesName = "enemiesreturnsstagesscenes";

		public const string AssetBundleStagesAssetsName = "enemiesreturnsstagesassets";

		public const string AssetBundleFolder = "AssetBundles";

		public const string SoundbankFolder = "Soundbanks";

		public const string SoundsSoundBankFileName = "EnemiesReturnsSounds";

		public const string MusicSoundBankFileName = "EnemiesReturnsMusic";

		public const string InitSoundBankFileName = "EnemiesReturnsInit";

		private readonly List<GameObject> bodyList = new List<GameObject>();

		private readonly List<GameObject> masterList = new List<GameObject>();

		private readonly List<Type> stateList = new List<Type>();

		private readonly List<SkillFamily> sfList = new List<SkillFamily>();

		private readonly List<SkillDef> sdList = new List<SkillDef>();

		private readonly List<EffectDef> effectsList = new List<EffectDef>();

		private readonly List<GameObject> projectilesList = new List<GameObject>();

		private readonly List<UnlockableDef> unlockablesList = new List<UnlockableDef>();

		private readonly List<ItemDef> itemList = new List<ItemDef>();

		private readonly List<NetworkSoundEventDef> nseList = new List<NetworkSoundEventDef>();

		private readonly List<GameObject> nopList = new List<GameObject>();

		private readonly List<BuffDef> bdList = new List<BuffDef>();

		public static readonly Dictionary<string, string> ShaderLookup = new Dictionary<string, string>
		{
			{ "stubbedror2/base/shaders/hgstandard", "RoR2/Base/Shaders/HGStandard.shader" },
			{ "stubbedror2/base/shaders/hgsnowtopped", "RoR2/Base/Shaders/HGSnowTopped.shader" },
			{ "stubbedror2/base/shaders/hgtriplanarterrainblend", "RoR2/Base/Shaders/HGTriplanarTerrainBlend.shader" },
			{ "stubbedror2/base/shaders/hgintersectioncloudremap", "RoR2/Base/Shaders/HGIntersectionCloudRemap.shader" },
			{ "stubbedror2/base/shaders/hgcloudremap", "RoR2/Base/Shaders/HGCloudRemap.shader" },
			{ "stubbedror2/base/shaders/hgopaquecloudremap", "RoR2/Base/Shaders/HGOpaqueCloudRemap.shader" },
			{ "stubbedror2/base/shaders/hgdistortion", "RoR2/Base/Shaders/HGDistortion.shader" },
			{ "stubbedcalm water/calmwater - dx11 - doublesided", "Calm Water/CalmWater - DX11 - DoubleSided.shader" },
			{ "stubbedcalm water/calmwater - dx11", "Calm Water/CalmWater - DX11.shader" },
			{ "stubbednature/speedtree", "RoR2/Base/Shaders/SpeedTreeCustom.shader" },
			{ "stubbeddecalicious/decaliciousdeferreddecal", "Decalicious/DecaliciousDeferredDecal.shader" },
			{ "stubbedror2/base/shaders/hgdamagenumber", "RoR2/Base/Shaders/HGDamageNumber.shader" },
			{ "stubbedror2/base/shaders/hguianimatealpha", "RoR2/Base/Shaders/HGUIAnimateAlpha.shader" }
		};

		public static Dictionary<string, Material> MaterialCache = new Dictionary<string, Material>();

		public static ItemDef VoidMegaCrabItem = Addressables.LoadAssetAsync<ItemDef>((object)"RoR2/DLC1/VoidMegaCrabItem.asset").WaitForCompletion();

		public string identifier => "com.Viliger.EnemiesReturns.ContentProvider";

		private void CreateArcherBug(GameObject[] assets, Dictionary<string, Sprite> iconLookup)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Expected O, but got Unknown
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Expected O, but got Unknown
			ArcherBugStuff archerBugStuff = new ArcherBugStuff();
			GameObject item = (FireCausticSpit.projectilePrefab = archerBugStuff.CreateCausticSpitProjectile());
			projectilesList.Add(item);
			UnlockableDef val = Utils.CreateUnlockableDef("Logs.ArcherBugBody.0", "ENEMIES_RETURNS_UNLOCKABLE_LOG_ARCHERBUG");
			unlockablesList.Add(val);
			GameObject val2 = archerBugStuff.CreateDeathEffect();
			effectsList.Add(new EffectDef(val2));
			EnemiesReturns.ModdedEntityStates.ArcherBugs.DeathState.deathEffectPrefab = val2;
			FireCausticSpit.chargeEffect = archerBugStuff.CreateCausticSpitChargeEffect();
			effectsList.Add(new EffectDef(FireCausticSpit.chargeEffect));
			ArcherBugBody archerBugBody = new ArcherBugBody();
			ArcherBugBody.Skills.CausticSpit = archerBugBody.CreateCausticSpitSkill();
			sdList.Add(ArcherBugBody.Skills.CausticSpit);
			ArcherBugBody.SkillFamilies.Primary = Utils.CreateSkillFamily("ArcherBugPrimaryFamily", ArcherBugBody.Skills.CausticSpit);
			sfList.Add(ArcherBugBody.SkillFamilies.Primary);
			ArcherBugBody.BodyPrefab = archerBugBody.AddBodyComponents(assets.First((GameObject body) => ((Object)body).name == "ArcherBugBody"), iconLookup["texArcherBugIcon"], val);
			bodyList.Add(ArcherBugBody.BodyPrefab);
			ArcherBugMaster.MasterPrefab = new ArcherBugMaster().AddMasterComponents(assets.First((GameObject master) => ((Object)master).name == "ArcherBugMaster"), ArcherBugBody.BodyPrefab);
			masterList.Add(ArcherBugMaster.MasterPrefab);
			ArcherBugBody.SpawnCards.cscArcherBugDefault = archerBugBody.CreateCard("cscArcherBugDefault", ArcherBugMaster.MasterPrefab, ArcherBugBody.SkinDefs.Default, ArcherBugBody.BodyPrefab);
			DirectorCard card = new DirectorCard
			{
				spawnCard = (SpawnCard)(object)ArcherBugBody.SpawnCards.cscArcherBugDefault,
				selectionWeight = ArcherBug.SelectionWeight.Value,
				preventOverhead = true,
				minimumStageCompletions = ArcherBug.MinimumStageCompletion.Value
			};
			DirectorCardHolder directorCard = new DirectorCardHolder
			{
				Card = card,
				MonsterCategory = (MonsterCategory)2
			};
			Utils.AddMonsterToStages(ArcherBug.DefaultStageList.Value, directorCard);
		}

		private void CreateColossus(GameObject[] assets, Dictionary<string, Sprite> iconLookup, Dictionary<string, AnimationCurveDef> acdLookup)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Expected O, but got Unknown
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0356: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Expected O, but got Unknown
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			//IL_0377: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Expected O, but got Unknown
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03de: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_040e: Expected O, but got Unknown
			//IL_040e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0413: Unknown result type (might be due to invalid IL or missing references)
			//IL_041b: Unknown result type (might be due to invalid IL or missing references)
			//IL_041d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Expected O, but got Unknown
			//IL_0455: Unknown result type (might be due to invalid IL or missing references)
			//IL_045a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0465: Unknown result type (might be due to invalid IL or missing references)
			//IL_0475: Unknown result type (might be due to invalid IL or missing references)
			//IL_0477: Unknown result type (might be due to invalid IL or missing references)
			//IL_047c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0483: Unknown result type (might be due to invalid IL or missing references)
			//IL_0495: Expected O, but got Unknown
			//IL_0495: Unknown result type (might be due to invalid IL or missing references)
			//IL_049a: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ab: Expected O, but got Unknown
			//IL_04b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0500: Unknown result type (might be due to invalid IL or missing references)
			//IL_050b: Unknown result type (might be due to invalid IL or missing references)
			//IL_051b: Unknown result type (might be due to invalid IL or missing references)
			//IL_051d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0522: Unknown result type (might be due to invalid IL or missing references)
			//IL_0529: Unknown result type (might be due to invalid IL or missing references)
			//IL_053b: Expected O, but got Unknown
			//IL_053b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0540: Unknown result type (might be due to invalid IL or missing references)
			//IL_0548: Unknown result type (might be due to invalid IL or missing references)
			//IL_054a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0551: Expected O, but got Unknown
			//IL_0582: Unknown result type (might be due to invalid IL or missing references)
			//IL_0587: Unknown result type (might be due to invalid IL or missing references)
			//IL_0592: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c2: Expected O, but got Unknown
			//IL_05c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d8: Expected O, but got Unknown
			//IL_05e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0628: Unknown result type (might be due to invalid IL or missing references)
			//IL_062d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0638: Unknown result type (might be due to invalid IL or missing references)
			//IL_0648: Unknown result type (might be due to invalid IL or missing references)
			//IL_064a: Unknown result type (might be due to invalid IL or missing references)
			//IL_064f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0656: Unknown result type (might be due to invalid IL or missing references)
			//IL_0668: Expected O, but got Unknown
			//IL_0668: Unknown result type (might be due to invalid IL or missing references)
			//IL_066d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0675: Unknown result type (might be due to invalid IL or missing references)
			//IL_0677: Unknown result type (might be due to invalid IL or missing references)
			//IL_067e: Expected O, but got Unknown
			//IL_068a: Unknown result type (might be due to invalid IL or missing references)
			//IL_068f: Unknown result type (might be due to invalid IL or missing references)
			ExplicitPickupDropTable droptable = CreateColossusItem(assets, iconLookup);
			if (Colossus.Enabled.Value)
			{
				ColossusStuff colossusStuff = new ColossusStuff();
				GameObject val = (StompBase.stompEffectPrefab = colossusStuff.CreateStompEffect());
				effectsList.Add(new EffectDef(val));
				GameObject item = (StompBase.projectilePrefab = colossusStuff.CreateStompProjectile());
				projectilesList.Add(item);
				GameObject val2 = colossusStuff.CreateDeathFallEffect();
				effectsList.Add(new EffectDef(val2));
				BaseDeath.fallEffect = val2;
				GameObject val3 = colossusStuff.CreateDeath2Effect();
				effectsList.Add(new EffectDef(val3));
				Death2.deathEffect = val3;
				RockClapEnd.clapEffect = colossusStuff.CreateClapEffect();
				GameObject item2 = (RockClapEnd.projectilePrefab = colossusStuff.CreateFlyingRockProjectile(FloatingRocksController.flyingRockPrefab = colossusStuff.CreateFlyingRocksGhost()));
				projectilesList.Add(item2);
				GameObject item3 = (HeadLaserBarrageAttack.projectilePrefab = colossusStuff.CreateLaserBarrageProjectile());
				projectilesList.Add(item3);
				GameObject val4 = (EnemiesReturns.ModdedEntityStates.Colossus.SpawnState.burrowPrefab = colossusStuff.CreateSpawnEffect());
				effectsList.Add(new EffectDef(val4));
				HeadLaserBarrageAttack.intencityGraph = acdLookup["LaserBarrageLightIntencity"].curve;
				UnlockableDef val5 = Utils.CreateUnlockableDef("Logs.ColossusBody.0", "ENEMIES_RETURNS_UNLOCKABLE_LOG_COLOSSUS");
				unlockablesList.Add(val5);
				HeadLaserAttack.beamPrefab = colossusStuff.CreateLaserEffect();
				ColossusBody colossusBody = new ColossusBody();
				ColossusBody.Skills.Stomp = colossusBody.CreateStompSkill();
				ColossusBody.Skills.StoneClap = colossusBody.CreateStoneClapSkill();
				ColossusBody.Skills.LaserBarrage = colossusBody.CreateLaserBarrageSkill();
				ColossusBody.Skills.HeadLaser = colossusBody.CreateHeadLaserSkill();
				sdList.Add(ColossusBody.Skills.Stomp);
				sdList.Add(ColossusBody.Skills.StoneClap);
				sdList.Add(ColossusBody.Skills.LaserBarrage);
				sdList.Add(ColossusBody.Skills.HeadLaser);
				ColossusBody.SkillFamilies.Primary = Utils.CreateSkillFamily("ColossusPrimaryFamily", ColossusBody.Skills.Stomp);
				ColossusBody.SkillFamilies.Secondary = Utils.CreateSkillFamily("ColossusSecondaryFamily", ColossusBody.Skills.StoneClap);
				ColossusBody.SkillFamilies.Utility = Utils.CreateSkillFamily("ColossusUtilityFamily", ColossusBody.Skills.LaserBarrage);
				ColossusBody.SkillFamilies.Special = Utils.CreateSkillFamily("ColossusSpecialFamily", ColossusBody.Skills.HeadLaser);
				sfList.Add(ColossusBody.SkillFamilies.Primary);
				sfList.Add(ColossusBody.SkillFamilies.Secondary);
				sfList.Add(ColossusBody.SkillFamilies.Utility);
				sfList.Add(ColossusBody.SkillFamilies.Special);
				ColossusBody.BodyPrefab = colossusBody.AddBodyComponents(assets.First((GameObject body) => ((Object)body).name == "ColossusBody"), iconLookup["texColossusIcon"], val5, droptable);
				bodyList.Add(ColossusBody.BodyPrefab);
				ColossusMaster.MasterPrefab = new ColossusMaster().AddMasterComponents(assets.First((GameObject master) => ((Object)master).name == "ColossusMaster"), ColossusBody.BodyPrefab);
				masterList.Add(ColossusMaster.MasterPrefab);
				ColossusBody.SpawnCards.cscColossusDefault = colossusBody.CreateCard("cscColossusDefault", ColossusMaster.MasterPrefab, ColossusBody.SkinDefs.Default, ColossusBody.BodyPrefab);
				DirectorCard card = new DirectorCard
				{
					spawnCard = (SpawnCard)(object)ColossusBody.SpawnCards.cscColossusDefault,
					selectionWeight = Colossus.SelectionWeight.Value,
					spawnDistance = (MonsterSpawnDistance)0,
					preventOverhead = true,
					minimumStageCompletions = Colossus.MinimumStageCompletion.Value
				};
				DirectorCardHolder directorCard = new DirectorCardHolder
				{
					Card = card,
					MonsterCategory = (MonsterCategory)4
				};
				Utils.AddMonsterToCardCategory(card, "Champions", (DirectorCardCategorySelection)(object)Addressables.LoadAssetAsync<FamilyDirectorCardCategorySelection>((object)"RoR2/Base/Common/dccsGolemFamily.asset").WaitForCompletion());
				Utils.AddMonsterToStages(Colossus.DefaultStageList.Value, directorCard);
				ColossusBody.SpawnCards.cscColossusSkyMeadow = colossusBody.CreateCard("cscColossusSkyMeadow", ColossusMaster.MasterPrefab, ColossusBody.SkinDefs.SkyMeadow, ColossusBody.BodyPrefab);
				DirectorCard card2 = new DirectorCard
				{
					spawnCard = (SpawnCard)(object)ColossusBody.SpawnCards.cscColossusSkyMeadow,
					selectionWeight = Colossus.SelectionWeight.Value,
					spawnDistance = (MonsterSpawnDistance)0,
					preventOverhead = true,
					minimumStageCompletions = Colossus.MinimumStageCompletion.Value
				};
				DirectorCardHolder directorCard2 = new DirectorCardHolder
				{
					Card = card2,
					MonsterCategory = (MonsterCategory)4
				};
				Utils.AddMonsterToStages(Colossus.SkyMeadowStageList.Value, directorCard2);
				ColossusBody.SpawnCards.cscColossusGrassy = colossusBody.CreateCard("cscColossusGrassy", ColossusMaster.MasterPrefab, ColossusBody.SkinDefs.Grassy, ColossusBody.BodyPrefab);
				DirectorCard card3 = new DirectorCard
				{
					spawnCard = (SpawnCard)(object)ColossusBody.SpawnCards.cscColossusGrassy,
					selectionWeight = Colossus.SelectionWeight.Value,
					spawnDistance = (MonsterSpawnDistance)0,
					preventOverhead = true,
					minimumStageCompletions = Colossus.MinimumStageCompletion.Value
				};
				DirectorCardHolder directorCard3 = new DirectorCardHolder
				{
					Card = card3,
					MonsterCategory = (MonsterCategory)4
				};
				Utils.AddMonsterToCardCategory(card3, "Champions", (DirectorCardCategorySelection)(object)Addressables.LoadAssetAsync<FamilyDirectorCardCategorySelection>((object)RoR2_Base_Common.dccsGolemFamilyNature_asset).WaitForCompletion());
				Utils.AddMonsterToStages(Colossus.GrassyStageList.Value, directorCard3);
				ColossusBody.SpawnCards.cscColossusCastle = colossusBody.CreateCard("cscColossusCastle", ColossusMaster.MasterPrefab, ColossusBody.SkinDefs.Castle, ColossusBody.BodyPrefab);
				DirectorCard card4 = new DirectorCard
				{
					spawnCard = (SpawnCard)(object)ColossusBody.SpawnCards.cscColossusCastle,
					selectionWeight = Colossus.SelectionWeight.Value,
					spawnDistance = (MonsterSpawnDistance)0,
					preventOverhead = true,
					minimumStageCompletions = Colossus.MinimumStageCompletion.Value
				};
				DirectorCardHolder directorCard4 = new DirectorCardHolder
				{
					Card = card4,
					MonsterCategory = (MonsterCategory)4
				};
				Utils.AddMonsterToStages(Colossus.CastleStageList.Value, directorCard4);
				ColossusBody.SpawnCards.cscColossusSandy = colossusBody.CreateCard("cscColossusSandy", ColossusMaster.MasterPrefab, ColossusBody.SkinDefs.Sandy, ColossusBody.BodyPrefab);
				DirectorCard card5 = new DirectorCard
				{
					spawnCard = (SpawnCard)(object)ColossusBody.SpawnCards.cscColossusSandy,
					selectionWeight = Colossus.SelectionWeight.Value,
					spawnDistance = (MonsterSpawnDistance)0,
					preventOverhead = true,
					minimumStageCompletions = Colossus.MinimumStageCompletion.Value
				};
				DirectorCardHolder directorCard5 = new DirectorCardHolder
				{
					Card = card5,
					MonsterCategory = (MonsterCategory)4
				};
				Utils.AddMonsterToCardCategory(card5, "Champions", (DirectorCardCategorySelection)(object)Addressables.LoadAssetAsync<FamilyDirectorCardCategorySelection>((object)"RoR2/Base/Common/dccsGolemFamilySandy.asset").WaitForCompletion());
				Utils.AddMonsterToStages(Colossus.SandyStageList.Value, directorCard5);
				ColossusBody.SpawnCards.cscColossusSnowy = colossusBody.CreateCard("cscColossusSnowy", ColossusMaster.MasterPrefab, ColossusBody.SkinDefs.Snowy, ColossusBody.BodyPrefab);
				DirectorCard card6 = new DirectorCard
				{
					spawnCard = (SpawnCard)(object)ColossusBody.SpawnCards.cscColossusSnowy,
					selectionWeight = Colossus.SelectionWeight.Value,
					spawnDistance = (MonsterSpawnDistance)0,
					preventOverhead = true,
					minimumStageCompletions = Colossus.MinimumStageCompletion.Value
				};
				DirectorCardHolder directorCard6 = new DirectorCardHolder
				{
					Card = card6,
					MonsterCategory = (MonsterCategory)4
				};
				Utils.AddMonsterToCardCategory(card6, "Champions", (DirectorCardCategorySelection)(object)Addressables.LoadAssetAsync<FamilyDirectorCardCategorySelection>((object)"RoR2/Base/Common/dccsGolemFamilySnowy.asset").WaitForCompletion());
				Utils.AddMonsterToStages(Colossus.SnowyStageList.Value, directorCard6);
				if (Colossus.AddToArtifactOfOrigin.Value && RiskyArtifafactsCompat.enabled)
				{
					RiskyArtifafactsCompat.AddMonsterToArtifactOfOrigin((SpawnCard)(object)ColossusBody.SpawnCards.cscColossusGrassy, 3);
				}
			}
		}

		private ExplicitPickupDropTable CreateColossusItem(GameObject[] assets, Dictionary<string, Sprite> iconLookup)
		{
			//IL_0011: 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)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: 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)
			ExplicitPickupDropTable val = null;
			if (Colossus.ItemEnabled.Value)
			{
				ColossalKnurlFactory.ColossalFist = ProcTypeAPI.ReserveProcType();
				ColossalKnurlFactory colossalKnurlFactory = new ColossalKnurlFactory();
				Content.Items.ColossalCurl = colossalKnurlFactory.CreateItem(assets.First((GameObject item) => ((Object)item).name == "PickupColossalCurl"), iconLookup["texColossalKnurlIcon"]);
				itemList.Add(Content.Items.ColossalCurl);
				val = ScriptableObject.CreateInstance<ExplicitPickupDropTable>();
				((Object)val).name = "epdtColossus";
				((PickupDropTable)val).canDropBeReplaced = true;
				val.pickupEntries = (PickupDefEntry[])(object)new PickupDefEntry[1]
				{
					new PickupDefEntry
					{
						pickupWeight = 1f,
						pickupDef = (Object)(object)Content.Items.ColossalCurl
					}
				};
				GameObject prefab = assets.First((GameObject item) => ((Object)item).name == "ColossalKnurlFistProjectileGhost");
				prefab = colossalKnurlFactory.CreateFistGhostPrefab(prefab);
				GameObject fistPrefab = assets.First((GameObject item) => ((Object)item).name == "ColossalKnurlFistProjectile");
				ColossalKnurlFactory.projectilePrefab = colossalKnurlFactory.CreateFistProjectile(fistPrefab, prefab);
				projectilesList.Add(ColossalKnurlFactory.projectilePrefab);
				ref Pair[] relationships = ref Content.ItemRelationshipProviders.ModdedContagiousItemProvider.relationships;
				Pair val2 = new Pair
				{
					itemDef1 = Content.Items.ColossalCurl,
					itemDef2 = VoidMegaCrabItem
				};
				ArrayUtils.ArrayAppend<Pair>(ref relationships, ref val2);
			}
			return val;
		}

		public IEnumerator FinalizeAsync(FinalizeAsyncArgs args)
		{
			args.ReportProgress(1f);
			yield break;
		}

		public IEnumerator GenerateContentPackAsync(GetContentPackAsyncArgs args)
		{
			ContentPack.Copy(_contentPack, args.output);
			args.ReportProgress(1f);
			yield break;
		}

		public IEnumerator LoadStaticContentAsync(LoadStaticContentAsyncArgs args)
		{
			Stopwatch totalStopwatch = new Stopwatch();
			((StopwatchBase)totalStopwatch).Start();
			_contentPack.identifier = identifier;
			Content.ItemRelationshipProviders.ModdedContagiousItemProvider = ScriptableObject.CreateInstance<ItemRelationshipProvider>();
			((Object)Content.ItemRelationshipProviders.ModdedContagiousItemProvider).name = "EnemiesReturnsContagiousItemProvider";
			Content.ItemRelationshipProviders.ModdedContagiousItemProvider.relationshipType = Addressables.LoadAssetAsync<ItemRelationshipType>((object)"RoR2/DLC1/Common/ContagiousItem.asset").WaitForCompletion();
			Content.ItemRelationshipProviders.ModdedContagiousItemProvider.relationships = Array.Empty<Pair>();
			Stopwatch val = new Stopwatch();
			((StopwatchBase)val).Start();
			string soundbanksFolderPath = Path.Combine(Path.GetDirectoryName(typeof(ContentProvider).Assembly.Location), "Soundbanks");
			LoadSoundBanks(soundbanksFolderPath);
			((StopwatchBase)val).Stop();
			Log.Info("Soundbanks loaded in " + ((StopwatchBase)val).elapsedSeconds);
			string assetBundleFolderPath = Path.Combine(Path.GetDirectoryName(typeof(ContentProvider).Assembly.Location), "AssetBundles");
			AssetBundle assetbundle = null;
			yield return LoadAssetBundle(Path.Combine(assetBundleFolderPath, "enemiesreturns"), args.progressReceiver, delegate(AssetBundle resultAssetBundle)
			{
				assetbundle = resultAssetBundle;
			});
			yield return LoadAllAssetsAsync<Material>(assetbundle, args.progressReceiver, (Action<Material[]>)delegate(Material[] assets)
			{
				SwapMaterials(assets);
			});
			Dictionary<string, Sprite> iconLookup = new Dictionary<string, Sprite>();
			Dictionary<string, Texture2D> rampLookups = new Dictionary<string, Texture2D>();
			Texture2D texLavaCrackRound = null;
			yield return LoadAllAssetsAsync<Texture2D>(assetbundle, args.progressReceiver, (Action<Texture2D[]>)delegate(Texture2D[] textures)
			{
				texLavaCrackRound = textures.First((Texture2D texture) => ((Object)texture).name == "texLavaCrackRound");
				rampLookups = textures.Where((Texture2D texture) => ((Object)texture).name.StartsWith("texRamp")).ToDictionary((Texture2D texture) => ((Object)texture).name, (Texture2D texture) => texture);
			});
			yield return LoadAllAssetsAsync<Sprite>(assetbundle, args.progressReceiver, (Action<Sprite[]>)delegate(Sprite[] assets)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Expected O, but got Unknown
				Stopwatch val3 = new Stopwatch();
				((StopwatchBase)val3).Start();
				foreach (Sprite val4 in assets)
				{
					iconLookup.Add(((Object)val4).name, val4);
				}
				((StopwatchBase)val3).Stop();
				Log.Info("Icons loaded in " + ((StopwatchBase)val3).elapsedSeconds);
			});
			Dictionary<string, AnimationCurveDef> acdLookup = new Dictionary<string, AnimationCurveDef>();
			yield return LoadAllAssetsAsync<AnimationCurveDef>(assetbundle, args.progressReceiver, (Action<AnimationCurveDef[]>)delegate(AnimationCurveDef[] assets)
			{
				acdLookup = assets.ToDictionary((AnimationCurveDef item) => ((Object)item).name);
			});
			yield return CreateJudgementAsync(args, iconLookup, rampLookups, acdLookup, assetBundleFolderPath);
			yield return LoadAllAssetsAsync<GameObject>(assetbundle, args.progressReceiver, (Action<GameObject[]>)delegate(GameObject[] assets)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Expected O, but got Unknown
				Stopwatch val2 = new Stopwatch();
				((StopwatchBase)val2).Start();
				CreateSpitter(assets, iconLookup);
				CreateColossus(assets, iconLookup, acdLookup);
				CreateIfrit(assets, iconLookup, texLavaCrackRound, acdLookup);
				CreateMechanicalSpider(assets, iconLookup, acdLookup);
				CreateLynxTribe(assets, iconLookup, acdLookup, rampLookups);
				CreateArcherBug(assets, iconLookup);
				((StopwatchBase)val2).Stop();
				Log.Info("Characters created in " + ((StopwatchBase)val2).elapsedSeconds);
			});
			Type[] array = (from type in Assembly.GetExecutingAssembly().GetTypes()
				where !type.IsAbstract && !type.IsInterface && type.GetCustomAttribute<RegisterEntityState>(inherit: false) != null
				select type).ToArray();
			_contentPack.entityStateTypes.Add(array);
			_contentPack.bodyPrefabs.Add(bodyList.ToArray());
			_contentPack.masterPrefabs.Add(masterList.ToArray());
			_contentPack.skillDefs.Add(sdList.ToArray());
			_contentPack.skillFamilies.Add(sfList.ToArray());
			_contentPack.entityStateTypes.Add(stateList.ToArray());
			_contentPack.effectDefs.Add(effectsList.ToArray());
			_contentPack.projectilePrefabs.Add(projectilesList.ToArray());
			_contentPack.unlockableDefs.Add(unlockablesList.ToArray());
			_contentPack.itemDefs.Add(itemList.ToArray());
			_contentPack.networkSoundEventDefs.Add(nseList.ToArray());
			_contentPack.networkedObjectPrefabs.Add(nopList.ToArray());
			_contentPack.itemRelationshipProviders.Add((ItemRelationshipProvider[])(object)new ItemRelationshipProvider[1] { Content.ItemRelationshipProviders.ModdedContagiousItemProvider });
			_contentPack.buffDefs.Add(bdList.ToArray());
			((StopwatchBase)totalStopwatch).Stop();
			Log.Info("Total loading time: " + ((StopwatchBase)totalStopwatch).elapsedSeconds);
		}

		private void SwapMaterials(Material[] assets)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_006a: 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)
			Stopwatch val = new Stopwatch();
			((StopwatchBase)val).Start();
			if (assets != null)
			{
				Material[] array = assets;
				foreach (Material val2 in array)
				{
					if (!ShaderLookup.TryGetValue(((Object)val2.shader).name.ToLower(), out var value))
					{
						Log.Info("Couldn't find replacement shader for " + ((Object)val2.shader).name.ToLower() + " in dictionary.");
						continue;
					}
					Shader val3 = Addressables.LoadAssetAsync<Shader>((object)value).WaitForCompletion();
					if (Object.op_Implicit((Object)(object)val3))
					{
						val2.shader = val3;
					}
					else
					{
						Log.Info("Couldn't find replacement shader for " + ((Object)val2.shader).name.ToLower());
					}
					MaterialCache.Add(((Object)val2).name, val2);
				}
			}
			((StopwatchBase)val).Stop();
			Log.Info("Materials swapped in " + ((StopwatchBase)val).elapsedSeconds);
		}

		private IEnumerator LoadAssetBundle(string assetBundleFullPath, IProgress<float> progress, Action<AssetBundle> onAssetBundleLoaded)
		{
			Stopwatch stopwatch = new Stopwatch();
			((StopwatchBase)stopwatch).Start();
			AssetBundleCreateRequest assetBundleCreateRequest = AssetBundle.LoadFromFileAsync(assetBundleFullPath);
			while (!((AsyncOperation)assetBundleCreateRequest).isDone)
			{
				progress.Report(((AsyncOperation)assetBundleCreateRequest).progress);
				yield return null;
			}
			onAssetBundleLoaded(assetBundleCreateRequest.assetBundle);
			((StopwatchBase)stopwatch).Stop();
			Log.Info("Asset bundle " + assetBundleFullPath + " loaded in " + ((StopwatchBase)stopwatch).elapsedSeconds);
		}

		private static IEnumerator LoadAllAssetsAsync<T>(AssetBundle assetBundle, IProgress<float> progress, Action<T[]> onAssetsLoaded) where T : Object
		{
			AssetBundleRequest sceneDefsRequest = assetBundle.LoadAllAssetsAsync<T>();
			while (!((AsyncOperation)sceneDefsRequest).isDone)
			{
				progress.Report(((AsyncOperation)sceneDefsRequest).progress);
				yield return null;
			}
			onAssetsLoaded(sceneDefsRequest.allAssets.Cast<T>().ToArray());
		}

		public static Material GetOrCreateMaterial(string materialName, Func<Material> materialCreateFunc)
		{
			if (!MaterialCache.TryGetValue(materialName, out var value))
			{
				value = materialCreateFunc();
				MaterialCache.Add(materialName, value);
			}
			return value;
		}

		public static Material GetOrCreateMaterial(string materialName, Func<Texture2D, Material> materialCreateFunc, Texture2D texture)
		{
			if (!MaterialCache.TryGetValue(materialName, out var value))
			{
				value = materialCreateFunc(texture);
				MaterialCache.Add(materialName, value);
			}
			return value;
		}

		public static Material GetOrCreateMaterial(string materialName, Func<Material, Material> materialCreateFunc, Material materialOrig)
		{
			if (!MaterialCache.TryGetValue(materialName, out var value))
			{
				value = materialCreateFunc(materialOrig);
				MaterialCache.Add(materialName, value);
			}
			return value;
		}

		private void LoadSoundBanks(string soundbanksFolderPath)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Invalid comparison between Unknown and I4
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Invalid comparison between Unknown and I4
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Invalid comparison between Unknown and I4
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			AKRESULT val = AkSoundEngine.AddBasePath(soundbanksFolderPath);
			if ((int)val == 1)
			{
				Log.Info("Added bank base path : " + soundbanksFolderPath);
			}
			else
			{
				Log.Error("Error adding base path : " + soundbanksFolderPath + " " + $"Error code : {val}");
			}
			uint num = default(uint);
			val = AkSoundEngine.LoadBank("EnemiesReturnsInit", ref num);
			if ((int)val == 1)
			{
				Log.Info("Added bank : EnemiesReturnsInit");
			}
			else
			{
				Log.Error("Error loading bank : EnemiesReturnsInit " + $"Error code : {val}");
			}
			val = AkSoundEngine.LoadBank("EnemiesReturnsMusic", ref num);
			if ((int)val == 1)
			{
				Log.Info("Added bank : EnemiesReturnsMusic");
			}
			else
			{
				Log.Error("Error loading bank : EnemiesReturnsMusic " + $"Error code : {val}");
			}
			val = AkSoundEngine.LoadBank("EnemiesReturnsSounds", ref num);
			if ((int)val == 1)
			{
				Log.Info("Added bank : EnemiesReturnsSounds");
			}
			else
			{
				Log.Error("Error loading bank : EnemiesReturnsSounds " + $"Error code : {val}");
			}
		}

		private void CreateIfrit(GameObject[] assets, Dictionary<string, Sprite> iconLookup, Texture2D texLavaCrackRound, Dictionary<string, AnimationCurveDef> acdLookup)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			//IL_0384: Unknown result type (might be due to invalid IL or missing references)
			//IL_0389: Unknown result type (might be due to invalid IL or missing references)
			//IL_0394: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c4: Expected O, but got Unknown
			//IL_03c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03da: Expected O, but got Unknown
			CreateIfritPillar(assets, iconLookup, acdLookup);
			ExplicitPickupDropTable droptable = CreateIfritItem(assets, iconLookup);
			if (Ifrit.Enabled.Value)
			{
				IfritStuff ifritStuff = new IfritStuff();
				EnemiesReturns.ModdedEntityStates.Ifrit.DeathState.deathEffect = ifritStuff.CreateDeathEffect();
				effectsList.Add(new EffectDef(EnemiesReturns.ModdedEntityStates.Ifrit.DeathState.deathEffect));
				SummonPylon.screamPrefab = ifritStuff.CreateBreathParticle();
				effectsList.Add(new EffectDef(SummonPylon.screamPrefab));
				NetworkSoundEventDef val = Utils.CreateNetworkSoundDef("ER_Ifrit_Hellzone_Rock_Play");
				nseList.Add(val);
				GameObject gameObject = assets.First((GameObject effect) => ((Object)effect).name == "IfritSpawnPortal");
				EnemiesReturns.ModdedEntityStates.Ifrit.SpawnState.spawnEffect = ifritStuff.CreateSpawnEffect(gameObject, acdLookup["acdPortalPP"]);
				effectsList.Add(new EffectDef(EnemiesReturns.ModdedEntityStates.Ifrit.SpawnState.spawnEffect));
				GameObject gameObject2 = assets.First((GameObject projectile) => ((Object)projectile).name == "IfritHellzonePillarProjectile");
				GameObject ghostPrefab = assets.First((GameObject projectile) => ((Object)projectile).name == "IfritHellzonePillarProjectileGhost");
				GameObject volcanoEffectPrefab = assets.First((GameObject projectile) => ((Object)projectile).name == "IfritHellzoneVolcanoEffect");
				GameObject val2 = ifritStuff.CreateHellzonePillarProjectile(gameObject2, ghostPrefab);
				GameObject val3 = ifritStuff.CreateHellfireDotZoneProjectile(val2, volcanoEffectPrefab, texLavaCrackRound, val);
				GameObject val4 = ifritStuff.CreateHellzoneProjectile();
				GameObject val5 = ifritStuff.CreateHellzonePredictionProjectile(val3, texLavaCrackRound);
				projectilesList.Add(val3);
				projectilesList.Add(val4);
				projectilesList.Add(val2);
				projectilesList.Add(val5);
				FlameCharge.flamethrowerEffectPrefab = ifritStuff.CreateFlameBreath();
				FireHellzoneFire.projectilePrefab = val4;
				FireHellzoneFire.dotZoneProjectile = val5;
				IfritBody ifritBody = new IfritBody();
				IfritBody.Skills.Hellzone = ifritBody.CreateHellzoneSkill();
				IfritBody.SkillFamilies.Secondary = Utils.CreateSkillFamily("IfritSecondaryFamily", IfritBody.Skills.Hellzone);
				IfritBody.Skills.SummonPylon = ifritBody.CreateSummonPylonSkill();
				IfritBody.SkillFamilies.Special = Utils.CreateSkillFamily("IfritSpecialFamily", IfritBody.Skills.SummonPylon);
				IfritBody.Skills.FlameCharge = ifritBody.CreateFlameChargeSkill();
				IfritBody.SkillFamilies.Utility = Utils.CreateSkillFamily("IfritUtilityFamily", IfritBody.Skills.FlameCharge);
				IfritBody.Skills.Smash = ifritBody.CreateSmashSkill();
				IfritBody.SkillFamilies.Primary = Utils.CreateSkillFamily("IfritPrimaryFamily", IfritBody.Skills.Smash);
				UnlockableDef val6 = Utils.CreateUnlockableDef("Logs.IfritBody.0", "ENEMIES_RETURNS_UNLOCKABLE_LOG_IFRIT");
				unlockablesList.Add(val6);
				IfritBody.BodyPrefab = ifritBody.AddBodyComponents(assets.First((GameObject body) => ((Object)body).name == "IfritBody"), iconLookup["texIconIfritBody"], val6, droptable);
				bodyList.Add(IfritBody.BodyPrefab);
				assets.First((GameObject mane) => ((Object)mane).name == "IfritManeFireParticle").GetComponent<Renderer>().material = GetOrCreateMaterial("matIfritManeFire", ifritBody.CreateManeFiresMaterial);
				IfritMaster.MasterPrefab = new IfritMaster().AddMasterComponents(assets.First((GameObject master) => ((Object)master).name == "IfritMaster"), IfritBody.BodyPrefab);
				masterList.Add(IfritMaster.MasterPrefab);
				IfritBody.SpawnCards.cscIfritDefault = ifritBody.CreateCard("cscIfritDefault", IfritMaster.MasterPrefab, IfritBody.SkinDefs.Default, IfritBody.BodyPrefab);
				DirectorCard card = new DirectorCard
				{
					spawnCard = (SpawnCard)(object)IfritBody.SpawnCards.cscIfritDefault,
					selectionWeight = Ifrit.SelectionWeight.Value,
					spawnDistance = (MonsterSpawnDistance)0,
					preventOverhead = true,
					minimumStageCompletions = Ifrit.MinimumStageCompletion.Value
				};
				DirectorCardHolder directorCard = new DirectorCardHolder
				{
					Card = card,
					MonsterCategory = (MonsterCategory)4
				};
				Utils.AddMonsterToStages(Ifrit.DefaultStageList.Value, directorCard);
				if (Ifrit.AddToArtifactOfOrigin.Value && RiskyArtifafactsCompat.enabled)
				{
					RiskyArtifafactsCompat.AddMonsterToArtifactOfOrigin((SpawnCard)(object)IfritBody.SpawnCards.cscIfritDefault, 2);
				}
			}
		}

		private ExplicitPickupDropTable CreateIfritItem(GameObject[] assets, Dictionary<string, Sprite> iconLookup)
		{
			//IL_0083: 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)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			ExplicitPickupDropTable val = null;
			if (Ifrit.ItemEnabled.Value)
			{
				Content.Items.SpawnPillarOnChampionKill = new SpawnPillarOnChampionKillFactory().CreateItem(assets.First((GameObject item) => ((Object)item).name == "IfritItem"), iconLookup["texIconIfritItem"]);
				itemList.Add(Content.Items.SpawnPillarOnChampionKill);
				val = ScriptableObject.CreateInstance<ExplicitPickupDropTable>();
				((Object)val).name = "epdtIfrit";
				((PickupDropTable)val).canDropBeReplaced = true;
				val.pickupEntries = (PickupDefEntry[])(object)new PickupDefEntry[1]
				{
					new PickupDefEntry
					{
						pickupWeight = 1f,
						pickupDef = (Object)(object)Content.Items.SpawnPillarOnChampionKill
					}
				};
				ref Pair[] relationships = ref Content.ItemRelationshipProviders.ModdedContagiousItemProvider.relationships;
				Pair val2 = new Pair
				{
					itemDef1 = Content.Items.SpawnPillarOnChampionKill,
					itemDef2 = VoidMegaCrabItem
				};
				ArrayUtils.ArrayAppend<Pair>(ref relationships, ref val2);
			}
			return val;
		}

		private void CreateIfritPillar(GameObject[] assets, Dictionary<string, Sprite> iconLookup, Dictionary<string, AnimationCurveDef> acdLookup)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			if (Ifrit.ItemEnabled.Value || Ifrit.Enabled.Value)
			{
				PillarStuff pillarStuff = new PillarStuff();
				EnemiesReturns.ModdedEntityStates.Ifrit.Pillar.SpawnState.burrowPrefab = pillarStuff.CreateSpawnEffect();
				effectsList.Add(new EffectDef(EnemiesReturns.ModdedEntityStates.Ifrit.Pillar.SpawnState.burrowPrefab));
				BaseDeathState.fallEffect = pillarStuff.CreateDeathFallEffect();
				effectsList.Add(new EffectDef(BaseDeathState.fallEffect));
				KilledDeathState.explosionPrefab = (BaseFireExplosion.explosionPrefab = pillarStuff.CreateExlosionEffectAlt());
				effectsList.Add(new EffectDef(BaseFireExplosion.explosionPrefab));
				GameObject val = assets.First((GameObject body) => ((Object)body).name == "IfritPylonBody");
				GameObject val2 = assets.First((GameObject master) => ((Object)master).name == "IfritPylonMaster");
				KilledDeathState.fireballYCurve = acdLookup["acdFireballFallCurve"].curve;
				PillarStuff.PillarExplosion = ProcTypeAPI.ReserveProcType();
				PillarMaster pillarMaster = new PillarMaster();
				if (Ifrit.Enabled.Value)
				{
					PillarEnemyBody pillarEnemyBody = new PillarEnemyBody();
					PillarEnemyBody.BodyPrefab = pillarEnemyBody.AddBodyComponents(PrefabAPI.InstantiateClone(val, "IfritPylonEnemyBody", false), iconLookup["texIconPillarEnemy"], acdLookup);
					bodyList.Add(PillarEnemyBody.BodyPrefab);
					PillarMaster.EnemyMasterPrefab = pillarMaster.AddMasterComponents(PrefabAPI.InstantiateClone(val2, "IfritPylonEnemyMaster", false), PillarEnemyBody.BodyPrefab);
					masterList.Add(PillarMaster.EnemyMasterPrefab);
					PillarEnemyBody.SpawnCard = pillarEnemyBody.CreateCard("cscIfritEnemyPillar", PillarMaster.EnemyMasterPrefab);
				}
				if (Ifrit.ItemEnabled.Value)
				{
					PillarAllyBody pillarAllyBody = new PillarAllyBody();
					PillarAllyBody.BodyPrefab = pillarAllyBody.AddBodyComponents(PrefabAPI.InstantiateClone(val, "IfritPylonPlayerBody", false), iconLookup["texIconPillarAlly"], acdLookup);
					bodyList.Add(PillarAllyBody.BodyPrefab);
					PillarMaster.AllyMasterPrefab = pillarMaster.AddMasterComponents(PrefabAPI.InstantiateClone(val2, "IfritPylonPlayerMaster", false), PillarAllyBody.BodyPrefab);
					masterList.Add(PillarMaster.AllyMasterPrefab);
					PillarAllyBody.SpawnCard = pillarAllyBody.CreateCard("cscIfritPlayerPillar", PillarMaster.AllyMasterPrefab);
				}
			}
		}

		public IEnumerator CreateJudgementAsync(LoadStaticContentAsyncArgs args, Dictionary<string, Sprite> iconLookup, Dictionary<string, Texture2D> rampLookups, Dictionary<string, AnimationCurveDef> acdLookup, string assetBundleFolderPath)
		{
			if (!Judgement.Enabled.Value)
			{
				yield break;
			}
			AssetBundle assetBundleStagesAssets = null;
			yield return LoadAssetBundle(Path.Combine(assetBundleFolderPath, "enemiesreturnsstagesassets"), args.progressReceiver, delegate(AssetBundle resultAssetBundle)
			{
				assetBundleStagesAssets = resultAssetBundle;
			});
			yield return LoadAllAssetsAsync<Sprite>(assetBundleStagesAssets, args.progressReceiver, (Action<Sprite[]>)delegate(Sprite[] assets)
			{
				foreach (Sprite val5 in assets)
				{
					if (((Object)val5).name == "texAnointedSkinIcon")
					{
						SetupJudgementPath.AnointedSkinIcon = val5;
					}
					iconLookup.Add(((Object)val5).name, val5);
				}
			});
			yield return LoadAllAssetsAsync<Texture2D>(assetBundleStagesAssets, args.progressReceiver, (Action<Texture2D[]>)delegate(Texture2D[] textures)
			{
				foreach (KeyValuePair<string, Texture2D> item3 in textures.Where((Texture2D texture) => ((Object)texture).name.StartsWith("texRamp")).ToDictionary((Texture2D texture) => ((Object)texture).name, (Texture2D texture) => texture))
				{
					rampLookups.Add(item3.Key, item3.Value);
				}
				SetupJudgementPath.aeonianEliteRamp = rampLookups["texRampAeonianElite"];
			});
			yield return LoadAllAssetsAsync<AnimationCurveDef>(assetBundleStagesAssets, args.progressRece