Decompiled source of ZetAspects v2.8.6

plugins/ZetAspects/ZetAspects.dll

Decompiled 2 weeks ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using IL.RoR2;
using IL.RoR2.Stats;
using Mono.Cecil;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour.HookGen;
using On.RoR2;
using On.RoR2.Items;
using On.RoR2.UI;
using On.RoR2.UI.LogBook;
using On.RoR2.UI.MainMenu;
using RoR2;
using RoR2.ContentManagement;
using RoR2.ExpansionManagement;
using RoR2.Orbs;
using RoR2.Projectile;
using RoR2.Stats;
using RoR2.UI;
using RoR2.UI.MainMenu;
using SimpleJSON;
using TMPro;
using TPDespair.ZetAspects.Compat;
using TPDespair.ZetAspects.Items;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Networking;
using UnityEngine.Rendering.PostProcessing;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("ZetAspects")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ZetAspects")]
[assembly: AssemblyTitle("ZetAspects")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace TPDespair.ZetAspects
{
	public static class Catalog
	{
		public static class RiskOfRain
		{
			private static bool equipDefPopulated;

			private static bool buffDefPopulated;

			private static bool iconsReplaced;

			public static bool populated;

			internal static void PreInit()
			{
				PopulateEquipment();
				ApplyEquipmentIcons();
			}

			internal static void Init()
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				mithrixBodyIndex = BodyCatalog.FindBodyIndex("BrotherBody");
				voidlingBodyIndex = BodyCatalog.FindBodyIndex("VoidRaidCrabBody");
				urchinTurretBodyIndex = BodyCatalog.FindBodyIndex("UrchinTurretBody");
				healOrbBodyIndex = BodyCatalog.FindBodyIndex("AffixEarthHealerBody");
				artifactShellBodyIndex = BodyCatalog.FindBodyIndex("ArtifactShellBody");
				goldenTitanBodyIndex = BodyCatalog.FindBodyIndex("TitanGoldBody");
				PopulateEquipment();
				PopulateBuffs();
				SetupText();
				ItemEntries(DropHooks.CanObtainItem());
				CopyExpansionReq();
				CopyModelPrefabs();
				ApplyEquipmentIcons();
				if (DropHooks.CanObtainEquipment())
				{
					EquipmentEntries(shown: true);
				}
				EquipmentColor();
				BuffDef affixHauntedRecipient = Buffs.AffixHauntedRecipient;
				affixHauntedRecipient.buffColor = Color.white;
				affixHauntedRecipient.iconSprite = Sprites.HauntCloak;
				FillEqualities();
				populated = true;
			}

			private static void PopulateEquipment()
			{
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				if (!equipDefPopulated)
				{
					Equip.AffixWhite = Equipment.AffixWhite;
					Equip.AffixBlue = Equipment.AffixBlue;
					Equip.AffixRed = Equipment.AffixRed;
					Equip.AffixHaunted = Equipment.AffixHaunted;
					Equip.AffixPoison = Equipment.AffixPoison;
					Equip.AffixLunar = Equipment.AffixLunar;
					Equip.AffixEarth = EquipmentCatalog.GetEquipmentDef(EquipmentCatalog.FindEquipmentIndex("EliteEarthEquipment"));
					Equip.AffixVoid = EquipmentCatalog.GetEquipmentDef(EquipmentCatalog.FindEquipmentIndex("EliteVoidEquipment"));
					equipDefPopulated = true;
				}
			}

			private static void PopulateBuffs()
			{
				if (!buffDefPopulated)
				{
					Buff.AffixWhite = Buffs.AffixWhite;
					Buff.AffixBlue = Buffs.AffixBlue;
					Buff.AffixRed = Buffs.AffixRed;
					Buff.AffixHaunted = Buffs.AffixHaunted;
					Buff.AffixPoison = Buffs.AffixPoison;
					Buff.AffixLunar = Buffs.AffixLunar;
					Buff.AffixEarth = Buffs.EliteEarth;
					Buff.AffixVoid = Buffs.EliteVoid;
					buffDefPopulated = true;
				}
			}

			private static void SetupText()
			{
				ZetAspectWhite.SetupTokens();
				ZetAspectBlue.SetupTokens();
				ZetAspectRed.SetupTokens();
				ZetAspectHaunted.SetupTokens();
				ZetAspectPoison.SetupTokens();
				ZetAspectLunar.SetupTokens();
				ZetAspectEarth.SetupTokens();
				ZetAspectVoid.SetupTokens();
			}

			internal static void ItemEntries(bool shown)
			{
				SetItemState(Item.ZetAspectWhite, shown);
				SetItemState(Item.ZetAspectBlue, shown);
				SetItemState(Item.ZetAspectRed, shown);
				SetItemState(Item.ZetAspectHaunted, shown);
				SetItemState(Item.ZetAspectPoison, shown);
				SetItemState(Item.ZetAspectLunar, shown);
				SetItemState(Item.ZetAspectEarth, shown);
				SetItemState(Item.ZetAspectVoid, shown);
			}

			private static void CopyExpansionReq()
			{
				CopyExpansion(Item.ZetAspectWhite, Equip.AffixWhite);
				CopyExpansion(Item.ZetAspectBlue, Equip.AffixBlue);
				CopyExpansion(Item.ZetAspectRed, Equip.AffixRed);
				CopyExpansion(Item.ZetAspectHaunted, Equip.AffixHaunted);
				CopyExpansion(Item.ZetAspectPoison, Equip.AffixPoison);
				CopyExpansion(Item.ZetAspectLunar, Equip.AffixLunar);
				CopyExpansion(Item.ZetAspectEarth, Equip.AffixEarth);
				CopyExpansion(Item.ZetAspectVoid, Equip.AffixVoid);
			}

			private static void CopyModelPrefabs()
			{
				CopyEquipmentPrefab(Item.ZetAspectEarth, Equip.AffixEarth);
				CopyItemPrefab(Item.ZetAspectVoid, Equip.AffixVoid);
			}

			private static void ApplyEquipmentIcons()
			{
				if (!iconsReplaced)
				{
					ReplaceEquipmentIcon(Equip.AffixWhite, Sprites.AffixWhite, Sprites.OutlineOrange);
					ReplaceEquipmentIcon(Equip.AffixBlue, Sprites.AffixBlue, Sprites.OutlineOrange);
					ReplaceEquipmentIcon(Equip.AffixRed, Sprites.AffixRed, Sprites.OutlineOrange);
					ReplaceEquipmentIcon(Equip.AffixHaunted, Sprites.AffixHaunted, Sprites.OutlineOrange);
					ReplaceEquipmentIcon(Equip.AffixPoison, Sprites.AffixPoison, Sprites.OutlineOrange);
					ReplaceEquipmentIcon(Equip.AffixLunar, Sprites.AffixLunar, Sprites.OutlineBlue);
					ReplaceEquipmentIcon(Equip.AffixEarth, Sprites.AffixEarth, Sprites.OutlineOrange);
					ReplaceEquipmentIcon(Equip.AffixVoid, Sprites.AffixVoid, Sprites.OutlineOrange);
					iconsReplaced = true;
				}
			}

			internal static void EquipmentEntries(bool shown)
			{
				SetEquipmentState(Equip.AffixWhite, shown);
				SetEquipmentState(Equip.AffixBlue, shown);
				SetEquipmentState(Equip.AffixRed, shown);
				SetEquipmentState(Equip.AffixHaunted, shown);
				SetEquipmentState(Equip.AffixPoison, shown);
				SetEquipmentState(Equip.AffixLunar, shown);
				SetEquipmentState(Equip.AffixEarth, shown);
				SetEquipmentState(Equip.AffixVoid, shown);
			}

			internal static void EquipmentColor()
			{
				ColorEquipmentDroplet(Equip.AffixWhite);
				ColorEquipmentDroplet(Equip.AffixBlue);
				ColorEquipmentDroplet(Equip.AffixRed);
				ColorEquipmentDroplet(Equip.AffixHaunted);
				ColorEquipmentDroplet(Equip.AffixPoison);
				ColorEquipmentDroplet(Equip.AffixLunar);
				ColorEquipmentDroplet(Equip.AffixEarth);
				ColorEquipmentDroplet(Equip.AffixVoid);
			}

			internal static void FillEqualities()
			{
				CreateEquality(Equip.AffixWhite, Buff.AffixWhite, Item.ZetAspectWhite);
				CreateEquality(Equip.AffixBlue, Buff.AffixBlue, Item.ZetAspectBlue);
				CreateEquality(Equip.AffixRed, Buff.AffixRed, Item.ZetAspectRed);
				CreateEquality(Equip.AffixHaunted, Buff.AffixHaunted, Item.ZetAspectHaunted);
				CreateEquality(Equip.AffixPoison, Buff.AffixPoison, Item.ZetAspectPoison);
				CreateEquality(Equip.AffixLunar, Buff.AffixLunar, Item.ZetAspectLunar);
				CreateEquality(Equip.AffixEarth, Buff.AffixEarth, Item.ZetAspectEarth);
				CreateEquality(Equip.AffixVoid, Buff.AffixVoid, Item.ZetAspectVoid);
			}
		}

		public static class SpikeStrip
		{
			private static bool equipDefPopulated = false;

			private static bool buffDefPopulated = false;

			private static bool iconsReplaced = false;

			public static bool populated = false;

			private static int state = -1;

			public static bool Enabled
			{
				get
				{
					if (state == -1)
					{
						if (PluginLoaded("com.groovesalad.GrooveSaladSpikestripContent"))
						{
							state = 1;
						}
						else
						{
							state = 0;
						}
					}
					return state == 1;
				}
			}

			internal static void PreInit()
			{
				if (Enabled)
				{
					PopulateEquipment();
					DisableInactiveItems();
					ApplyEquipmentIcons();
				}
			}

			internal static void Init()
			{
				if (Enabled)
				{
					PopulateEquipment();
					PopulateBuffs();
					DisableInactiveItems();
					SetupText();
					ItemEntries(DropHooks.CanObtainItem());
					CopyExpansionReq();
					CopyModelPrefabs();
					ApplyEquipmentIcons();
					if (DropHooks.CanObtainEquipment())
					{
						EquipmentEntries(shown: true);
					}
					EquipmentColor();
					FillEqualities();
					populated = true;
				}
			}

			private static void PopulateEquipment()
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Invalid comparison between Unknown and I4
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Invalid comparison between Unknown and I4
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Invalid comparison between Unknown and I4
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0084: 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_0087: Invalid comparison between Unknown and I4
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				if (!equipDefPopulated)
				{
					EquipmentIndex val = EquipmentCatalog.FindEquipmentIndex("EQUIPMENT_AFFIXPLATED");
					if ((int)val != -1)
					{
						Equip.AffixPlated = EquipmentCatalog.GetEquipmentDef(val);
					}
					val = EquipmentCatalog.FindEquipmentIndex("EQUIPMENT_AFFIXWARPED");
					if ((int)val != -1)
					{
						Equip.AffixWarped = EquipmentCatalog.GetEquipmentDef(val);
					}
					val = EquipmentCatalog.FindEquipmentIndex("EQUIPMENT_AFFIXVEILED");
					if ((int)val != -1)
					{
						Equip.AffixVeiled = EquipmentCatalog.GetEquipmentDef(val);
					}
					val = EquipmentCatalog.FindEquipmentIndex("EQUIPMENT_AFFIXARAGONITE");
					if ((int)val != -1)
					{
						Equip.AffixAragonite = EquipmentCatalog.GetEquipmentDef(val);
					}
					equipDefPopulated = true;
				}
			}

			private static void PopulateBuffs()
			{
				if (!buffDefPopulated)
				{
					if (Object.op_Implicit((Object)(object)Equip.AffixPlated))
					{
						Buff.AffixPlated = Equip.AffixPlated.passiveBuffDef;
					}
					if (Object.op_Implicit((Object)(object)Equip.AffixWarped))
					{
						Buff.AffixWarped = Equip.AffixWarped.passiveBuffDef;
					}
					if (Object.op_Implicit((Object)(object)Equip.AffixVeiled))
					{
						Buff.AffixVeiled = Equip.AffixVeiled.passiveBuffDef;
					}
					if (Object.op_Implicit((Object)(object)Equip.AffixAragonite))
					{
						Buff.AffixAragonite = Equip.AffixAragonite.passiveBuffDef;
					}
					buffDefPopulated = true;
				}
			}

			private static void DisableInactiveItems()
			{
				int populatedState = GetPopulatedState(equipDefPopulated, buffDefPopulated);
				DisableInactiveItem(Item.ZetAspectPlated, ref Equip.AffixPlated, ref Buff.AffixPlated, populatedState);
				DisableInactiveItem(Item.ZetAspectWarped, ref Equip.AffixWarped, ref Buff.AffixWarped, populatedState);
				DisableInactiveItem(Item.ZetAspectVeiled, ref Equip.AffixVeiled, ref Buff.AffixVeiled, populatedState);
				DisableInactiveItem(Item.ZetAspectAragonite, ref Equip.AffixAragonite, ref Buff.AffixAragonite, populatedState);
			}

			private static void SetupText()
			{
				ZetAspectPlated.SetupTokens();
				ZetAspectWarped.SetupTokens();
				ZetAspectVeiled.SetupTokens();
				ZetAspectAragonite.SetupTokens();
			}

			internal static void ItemEntries(bool shown)
			{
				SetItemState(Item.ZetAspectPlated, shown);
				SetItemState(Item.ZetAspectWarped, shown);
				SetItemState(Item.ZetAspectVeiled, shown);
				SetItemState(Item.ZetAspectAragonite, shown);
			}

			private static void CopyExpansionReq()
			{
				CopyExpansion(Item.ZetAspectPlated, Equip.AffixPlated);
				CopyExpansion(Item.ZetAspectWarped, Equip.AffixWarped);
				CopyExpansion(Item.ZetAspectVeiled, Equip.AffixVeiled);
				CopyExpansion(Item.ZetAspectAragonite, Equip.AffixAragonite);
			}

			private static void CopyModelPrefabs()
			{
				CopyEquipmentPrefab(Item.ZetAspectPlated, Equip.AffixPlated);
				CopyEquipmentPrefab(Item.ZetAspectWarped, Equip.AffixWarped);
				CopyEquipmentPrefab(Item.ZetAspectVeiled, Equip.AffixVeiled);
				CopyEquipmentPrefab(Item.ZetAspectAragonite, Equip.AffixAragonite);
			}

			private static void ApplyEquipmentIcons()
			{
				if (!iconsReplaced)
				{
					ReplaceEquipmentIcon(Equip.AffixPlated, Sprites.AffixPlated, Sprites.OutlineOrange);
					ReplaceEquipmentIcon(Equip.AffixWarped, Sprites.AffixWarped, Sprites.OutlineOrange);
					ReplaceEquipmentIcon(Equip.AffixVeiled, Sprites.AffixVeiled, Sprites.OutlineOrange);
					ReplaceEquipmentIcon(Equip.AffixAragonite, Sprites.AffixAragonite, Sprites.OutlineOrange);
					iconsReplaced = true;
				}
			}

			internal static void EquipmentEntries(bool shown)
			{
				SetEquipmentState(Equip.AffixPlated, shown);
				SetEquipmentState(Equip.AffixWarped, shown);
				SetEquipmentState(Equip.AffixVeiled, shown);
				SetEquipmentState(Equip.AffixAragonite, shown);
			}

			internal static void EquipmentColor()
			{
				ColorEquipmentDroplet(Equip.AffixPlated);
				ColorEquipmentDroplet(Equip.AffixWarped);
				ColorEquipmentDroplet(Equip.AffixVeiled);
				ColorEquipmentDroplet(Equip.AffixAragonite);
			}

			internal static void FillEqualities()
			{
				CreateEquality(Equip.AffixPlated, Buff.AffixPlated, Item.ZetAspectPlated);
				CreateEquality(Equip.AffixWarped, Buff.AffixWarped, Item.ZetAspectWarped);
				CreateEquality(Equip.AffixVeiled, Buff.AffixVeiled, Item.ZetAspectVeiled);
				CreateEquality(Equip.AffixAragonite, Buff.AffixAragonite, Item.ZetAspectAragonite);
			}
		}

		public static class GoldenCoastPlus
		{
			private static bool equipDefPopulated = false;

			private static bool buffDefPopulated = false;

			private static bool iconsReplaced = false;

			public static bool populated = false;

			private static int state = -1;

			public static bool Enabled
			{
				get
				{
					if (state == -1)
					{
						if (PluginLoaded("com.Skell.GoldenCoastPlus") || PluginLoaded("com.Phreel.GoldenCoastPlusRevived"))
						{
							state = 1;
						}
						else
						{
							state = 0;
						}
					}
					return state == 1;
				}
			}

			internal static void PreInit()
			{
				if (Enabled)
				{
					PopulateEquipment();
					DisableInactiveItems();
					ApplyEquipmentIcons();
				}
			}

			internal static void Init()
			{
				if (Enabled)
				{
					PopulateEquipment();
					PopulateBuffs();
					DisableInactiveItems();
					SetupText();
					ItemEntries(DropHooks.CanObtainItem());
					CopyExpansionReq();
					CopyModelPrefabs();
					ApplyEquipmentIcons();
					if (DropHooks.CanObtainEquipment())
					{
						EquipmentEntries(shown: true);
					}
					EquipmentColor();
					FillEqualities();
					populated = true;
				}
			}

			private static void PopulateEquipment()
			{
				//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_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Invalid comparison between Unknown and I4
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				if (!equipDefPopulated)
				{
					EquipmentIndex val = EquipmentCatalog.FindEquipmentIndex("EliteGoldEquipment");
					if ((int)val != -1)
					{
						Equip.AffixGold = EquipmentCatalog.GetEquipmentDef(val);
					}
					equipDefPopulated = true;
				}
			}

			private static void PopulateBuffs()
			{
				if (!buffDefPopulated)
				{
					if (Object.op_Implicit((Object)(object)Equip.AffixGold))
					{
						Buff.AffixGold = Equip.AffixGold.passiveBuffDef;
					}
					buffDefPopulated = true;
				}
			}

			private static void DisableInactiveItems()
			{
				int populatedState = GetPopulatedState(equipDefPopulated, buffDefPopulated);
				DisableInactiveItem(Item.ZetAspectGold, ref Equip.AffixGold, ref Buff.AffixGold, populatedState);
			}

			private static void SetupText()
			{
				ZetAspectGold.SetupTokens();
			}

			internal static void ItemEntries(bool shown)
			{
				SetItemState(Item.ZetAspectGold, shown);
			}

			private static void CopyExpansionReq()
			{
				CopyExpansion(Item.ZetAspectGold, Equip.AffixGold);
			}

			private static void CopyModelPrefabs()
			{
				CopyEquipmentPrefab(Item.ZetAspectGold, Equip.AffixGold);
			}

			private static void ApplyEquipmentIcons()
			{
				if (!iconsReplaced)
				{
					ReplaceEquipmentIcon(Equip.AffixGold, Sprites.AffixGold, Sprites.OutlineOrange);
					iconsReplaced = true;
				}
			}

			internal static void EquipmentEntries(bool shown)
			{
				SetEquipmentState(Equip.AffixGold, shown);
			}

			internal static void EquipmentColor()
			{
				ColorEquipmentDroplet(Equip.AffixGold);
			}

			internal static void FillEqualities()
			{
				CreateEquality(Equip.AffixGold, Buff.AffixGold, Item.ZetAspectGold);
			}
		}

		public static class Aetherium
		{
			private static bool equipDefPopulated = false;

			private static bool buffDefPopulated = false;

			private static bool iconsReplaced = false;

			public static bool populated = false;

			private static int state = -1;

			public static bool Enabled
			{
				get
				{
					if (state == -1)
					{
						if (PluginLoaded("com.KomradeSpectre.Aetherium"))
						{
							state = 1;
						}
						else
						{
							state = 0;
						}
					}
					return state == 1;
				}
			}

			internal static void PreInit()
			{
				if (Enabled)
				{
					PopulateEquipment();
					DisableInactiveItems();
					ApplyEquipmentIcons();
				}
			}

			internal static void Init()
			{
				if (Enabled)
				{
					PopulateEquipment();
					PopulateBuffs();
					DisableInactiveItems();
					SetupText();
					ItemEntries(DropHooks.CanObtainItem());
					CopyExpansionReq();
					CopyModelPrefabs();
					ApplyEquipmentIcons();
					if (DropHooks.CanObtainEquipment())
					{
						EquipmentEntries(shown: true);
					}
					EquipmentColor();
					FillEqualities();
					populated = true;
				}
			}

			private static void PopulateEquipment()
			{
				//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_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Invalid comparison between Unknown and I4
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				if (!equipDefPopulated)
				{
					EquipmentIndex val = EquipmentCatalog.FindEquipmentIndex("AETHERIUM_ELITE_EQUIPMENT_AFFIX_SANGUINE");
					if ((int)val != -1)
					{
						Equip.AffixSanguine = EquipmentCatalog.GetEquipmentDef(val);
					}
					equipDefPopulated = true;
				}
			}

			private static void PopulateBuffs()
			{
				//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_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Invalid comparison between Unknown and I4
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				if (!buffDefPopulated)
				{
					BuffIndex val = BuffCatalog.FindBuffIndex("AFFIX_SANGUINE");
					if ((int)val != -1)
					{
						Buff.AffixSanguine = BuffCatalog.GetBuffDef(val);
					}
					buffDefPopulated = true;
				}
			}

			private static void DisableInactiveItems()
			{
				int populatedState = GetPopulatedState(equipDefPopulated, buffDefPopulated);
				DisableInactiveItem(Item.ZetAspectSanguine, ref Equip.AffixSanguine, ref Buff.AffixSanguine, populatedState);
			}

			private static void SetupText()
			{
				ZetAspectSanguine.SetupTokens();
			}

			internal static void ItemEntries(bool shown)
			{
				SetItemState(Item.ZetAspectSanguine, shown);
			}

			private static void CopyExpansionReq()
			{
				CopyExpansion(Item.ZetAspectSanguine, Equip.AffixSanguine);
			}

			private static void CopyModelPrefabs()
			{
				CopyEquipmentPrefab(Item.ZetAspectSanguine, Equip.AffixSanguine);
			}

			private static void ApplyEquipmentIcons()
			{
				if (!iconsReplaced)
				{
					ReplaceEquipmentIcon(Equip.AffixSanguine, Sprites.AffixSanguine, Sprites.OutlineOrange);
					iconsReplaced = true;
				}
			}

			internal static void EquipmentEntries(bool shown)
			{
				SetEquipmentState(Equip.AffixSanguine, shown);
			}

			internal static void EquipmentColor()
			{
				ColorEquipmentDroplet(Equip.AffixSanguine);
			}

			internal static void FillEqualities()
			{
				CreateEquality(Equip.AffixSanguine, Buff.AffixSanguine, Item.ZetAspectSanguine);
			}
		}

		public static class Bubbet
		{
			private static bool equipDefPopulated = false;

			private static bool buffDefPopulated = false;

			private static bool iconsReplaced = false;

			public static bool populated = false;

			private static int state = -1;

			public static bool Enabled
			{
				get
				{
					if (state == -1)
					{
						if (PluginLoaded("bubbet.bubbetsitems"))
						{
							state = 1;
						}
						else
						{
							state = 0;
						}
					}
					return state == 1;
				}
			}

			internal static void PreInit()
			{
				if (Enabled)
				{
					PopulateEquipment();
					DisableInactiveItems();
					ApplyEquipmentIcons();
				}
			}

			internal static void Init()
			{
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				if (Enabled)
				{
					PopulateEquipment();
					PopulateBuffs();
					DisableInactiveItems();
					SetupText();
					ItemEntries(DropHooks.CanObtainItem());
					CopyExpansionReq();
					CopyModelPrefabs();
					ApplyEquipmentIcons();
					if (DropHooks.CanObtainEquipment())
					{
						EquipmentEntries(shown: true);
					}
					EquipmentColor();
					BuffDef affixSepia = Buff.AffixSepia;
					if (Object.op_Implicit((Object)(object)affixSepia))
					{
						affixSepia.buffColor = Color.white;
						affixSepia.iconSprite = Sprites.SepiaElite;
					}
					FillEqualities();
					populated = true;
				}
			}

			private static void PopulateEquipment()
			{
				//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_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Invalid comparison between Unknown and I4
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				if (!equipDefPopulated)
				{
					EquipmentIndex val = EquipmentCatalog.FindEquipmentIndex("EquipmentDefSepiaElite");
					if ((int)val != -1)
					{
						Equip.AffixSepia = EquipmentCatalog.GetEquipmentDef(val);
					}
					equipDefPopulated = true;
				}
			}

			private static void PopulateBuffs()
			{
				//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_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Invalid comparison between Unknown and I4
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				if (!buffDefPopulated)
				{
					BuffIndex val = BuffCatalog.FindBuffIndex("BuffDefSepia");
					if ((int)val != -1)
					{
						Buff.AffixSepia = BuffCatalog.GetBuffDef(val);
					}
					buffDefPopulated = true;
				}
			}

			private static void DisableInactiveItems()
			{
				int populatedState = GetPopulatedState(equipDefPopulated, buffDefPopulated);
				DisableInactiveItem(Item.ZetAspectSepia, ref Equip.AffixSepia, ref Buff.AffixSepia, populatedState);
			}

			private static void SetupText()
			{
				ZetAspectSepia.SetupTokens();
			}

			internal static void ItemEntries(bool shown)
			{
				SetItemState(Item.ZetAspectSepia, shown);
			}

			private static void CopyExpansionReq()
			{
				CopyExpansion(Item.ZetAspectSepia, Equip.AffixSepia);
			}

			private static void CopyModelPrefabs()
			{
				CopyItemPrefab(Item.ZetAspectSepia, Equip.AffixSepia);
			}

			private static void ApplyEquipmentIcons()
			{
				if (!iconsReplaced)
				{
					ReplaceEquipmentIcon(Equip.AffixSepia, Sprites.AffixSepia, Sprites.OutlineOrange);
					iconsReplaced = true;
				}
			}

			internal static void EquipmentEntries(bool shown)
			{
				SetEquipmentState(Equip.AffixSepia, shown);
			}

			internal static void EquipmentColor()
			{
				ColorEquipmentDroplet(Equip.AffixSepia);
			}

			internal static void FillEqualities()
			{
				CreateEquality(Equip.AffixSepia, Buff.AffixSepia, Item.ZetAspectSepia);
			}
		}

		public static class WarWisp
		{
			private static bool equipDefPopulated = false;

			private static bool buffDefPopulated = false;

			private static bool iconsReplaced = false;

			public static bool populated = false;

			private static int state = -1;

			public static bool Enabled
			{
				get
				{
					if (state == -1)
					{
						if (PluginLoaded("com.PopcornFactory.WispMod"))
						{
							state = 1;
						}
						else
						{
							state = 0;
						}
					}
					return state == 1;
				}
			}

			internal static void PreInit()
			{
				if (Enabled)
				{
					PopulateEquipment();
					DisableInactiveItems();
					ApplyEquipmentIcons();
				}
			}

			internal static void Init()
			{
				if (Enabled)
				{
					PopulateEquipment();
					PopulateBuffs();
					DisableInactiveItems();
					SetupText();
					ItemEntries(DropHooks.CanObtainItem());
					CopyExpansionReq();
					CopyModelPrefabs();
					ApplyEquipmentIcons();
					if (DropHooks.CanObtainEquipment())
					{
						EquipmentEntries(shown: true);
					}
					EquipmentColor();
					FillEqualities();
					populated = true;
				}
			}

			private static void PopulateEquipment()
			{
				//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_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Invalid comparison between Unknown and I4
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				if (!equipDefPopulated)
				{
					EquipmentIndex val = EquipmentCatalog.FindEquipmentIndex("WARFRAMEWISP_ELITE_EQUIPMENT_AFFIX_NULLIFIER");
					if ((int)val != -1)
					{
						Equip.AffixNullifier = EquipmentCatalog.GetEquipmentDef(val);
					}
					equipDefPopulated = true;
				}
			}

			private static void PopulateBuffs()
			{
				//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_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Invalid comparison between Unknown and I4
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				if (!buffDefPopulated)
				{
					BuffIndex val = BuffCatalog.FindBuffIndex("AFFIX_NULLIFIER");
					if ((int)val != -1)
					{
						Buff.AffixNullifier = BuffCatalog.GetBuffDef(val);
					}
					buffDefPopulated = true;
				}
			}

			private static void DisableInactiveItems()
			{
				int populatedState = GetPopulatedState(equipDefPopulated, buffDefPopulated);
				DisableInactiveItem(Item.ZetAspectNullifier, ref Equip.AffixNullifier, ref Buff.AffixNullifier, populatedState);
			}

			private static void SetupText()
			{
				ZetAspectNullifier.SetupTokens();
			}

			internal static void ItemEntries(bool shown)
			{
				SetItemState(Item.ZetAspectNullifier, shown);
			}

			private static void CopyExpansionReq()
			{
				CopyExpansion(Item.ZetAspectNullifier, Equip.AffixNullifier);
			}

			private static void CopyModelPrefabs()
			{
				CopyEquipmentPrefab(Item.ZetAspectNullifier, Equip.AffixNullifier);
			}

			private static void ApplyEquipmentIcons()
			{
				if (!iconsReplaced)
				{
					ReplaceEquipmentIcon(Equip.AffixNullifier, Sprites.AffixNullifier, Sprites.NullOutlineOrange);
					iconsReplaced = true;
				}
			}

			internal static void EquipmentEntries(bool shown)
			{
				SetEquipmentState(Equip.AffixNullifier, shown);
			}

			internal static void EquipmentColor()
			{
				ColorEquipmentDroplet(Equip.AffixNullifier);
			}

			internal static void FillEqualities()
			{
				CreateEquality(Equip.AffixNullifier, Buff.AffixNullifier, Item.ZetAspectNullifier);
			}
		}

		public static class Blighted
		{
			private static bool equipDefPopulated = false;

			private static bool buffDefPopulated = false;

			private static bool iconsReplaced = false;

			public static bool populated = false;

			private static int state = -1;

			public static bool Enabled
			{
				get
				{
					if (state == -1)
					{
						if (PluginLoaded("com.Moffein.BlightedElites"))
						{
							state = 1;
						}
						else
						{
							state = 0;
						}
					}
					return state == 1;
				}
			}

			internal static void PreInit()
			{
				if (Enabled)
				{
					PopulateEquipment();
					DisableInactiveItems();
					ApplyEquipmentIcons();
				}
				else
				{
					PopulateEquipment();
					DisableInactiveItems();
				}
			}

			internal static void Init()
			{
				if (Enabled)
				{
					PopulateEquipment();
					PopulateBuffs();
					DisableInactiveItems();
					SetupText();
					ItemEntries(DropHooks.CanObtainItem());
					CopyExpansionReq();
					CopyModelPrefabs();
					ApplyEquipmentIcons();
					if (DropHooks.CanObtainEquipment())
					{
						EquipmentEntries(shown: true);
					}
					EquipmentColor();
					FillEqualities();
					populated = true;
				}
				else
				{
					PopulateEquipment();
					DisableInactiveItems();
				}
			}

			private static void PopulateEquipment()
			{
				//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_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Invalid comparison between Unknown and I4
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				if (!equipDefPopulated)
				{
					EquipmentIndex val = EquipmentCatalog.FindEquipmentIndex("AffixBlightedMoffein");
					if ((int)val != -1)
					{
						Equip.AffixBlighted = EquipmentCatalog.GetEquipmentDef(val);
					}
					equipDefPopulated = true;
				}
			}

			private static void PopulateBuffs()
			{
				if (!buffDefPopulated)
				{
					if (Object.op_Implicit((Object)(object)Equip.AffixBlighted))
					{
						Buff.AffixBlighted = Equip.AffixBlighted.passiveBuffDef;
					}
					buffDefPopulated = true;
				}
			}

			private static void DisableInactiveItems()
			{
				int populatedState = GetPopulatedState(equipDefPopulated, buffDefPopulated);
				DisableInactiveItem(Item.ZetAspectBlighted, ref Equip.AffixBlighted, ref Buff.AffixBlighted, populatedState);
			}

			private static void SetupText()
			{
				ZetAspectBlighted.SetupTokens();
			}

			internal static void ItemEntries(bool shown)
			{
				SetItemState(Item.ZetAspectBlighted, shown);
			}

			private static void CopyExpansionReq()
			{
				CopyExpansion(Item.ZetAspectBlighted, Equip.AffixBlighted);
			}

			private static void CopyModelPrefabs()
			{
				CopyEquipmentPrefab(Item.ZetAspectBlighted, Equip.AffixBlighted);
			}

			private static void ApplyEquipmentIcons()
			{
				if (!iconsReplaced)
				{
					ReplaceEquipmentIcon(Equip.AffixBlighted, Sprites.AffixBlighted, Sprites.OutlineOrange);
					iconsReplaced = true;
				}
			}

			internal static void EquipmentEntries(bool shown)
			{
				SetEquipmentState(Equip.AffixBlighted, shown);
			}

			internal static void EquipmentColor()
			{
				ColorEquipmentDroplet(Equip.AffixBlighted);
			}

			internal static void FillEqualities()
			{
				CreateEquality(Equip.AffixBlighted, Buff.AffixBlighted, Item.ZetAspectBlighted);
			}
		}

		public static class GOTCE
		{
			private static bool equipDefPopulated = false;

			private static bool buffDefPopulated = false;

			private static bool iconsReplaced = false;

			public static bool populated = false;

			private static int state = -1;

			public static bool Enabled
			{
				get
				{
					if (state == -1)
					{
						if (PluginLoaded("com.TheBestAssociatedLargelyLudicrousSillyheadGroup.GOTCE"))
						{
							state = 1;
						}
						else
						{
							state = 0;
						}
					}
					return state == 1;
				}
			}

			internal static void PreInit()
			{
				if (Enabled)
				{
					PopulateEquipment();
					DisableInactiveItems();
					ApplyEquipmentIcons();
				}
			}

			internal static void Init()
			{
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				if (Enabled)
				{
					PopulateEquipment();
					PopulateBuffs();
					DisableInactiveItems();
					SetupText();
					ItemEntries(DropHooks.CanObtainItem());
					CopyExpansionReq();
					CopyModelPrefabs();
					ApplyEquipmentIcons();
					if (DropHooks.CanObtainEquipment())
					{
						EquipmentEntries(shown: true);
					}
					EquipmentColor();
					BuffDef backupDebuff = Buff.BackupDebuff;
					if (Object.op_Implicit((Object)(object)backupDebuff))
					{
						backupDebuff.buffColor = Color.white;
						backupDebuff.iconSprite = Sprites.BackupDebuff;
					}
					FillEqualities();
					populated = true;
				}
			}

			private static void PopulateEquipment()
			{
				//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_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Invalid comparison between Unknown and I4
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				if (!equipDefPopulated)
				{
					EquipmentIndex val = EquipmentCatalog.FindEquipmentIndex("ELITE_EQUIPMENT_BACKUP");
					if ((int)val != -1)
					{
						Equip.AffixBackup = EquipmentCatalog.GetEquipmentDef(val);
					}
					equipDefPopulated = true;
				}
			}

			private static void PopulateBuffs()
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Invalid comparison between Unknown and I4
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				if (!buffDefPopulated)
				{
					if (Object.op_Implicit((Object)(object)Equip.AffixBackup))
					{
						Buff.AffixBackup = Equip.AffixBackup.passiveBuffDef;
					}
					BuffIndex val = BuffCatalog.FindBuffIndex("Backuped");
					if ((int)val != -1)
					{
						Buff.BackupDebuff = BuffCatalog.GetBuffDef(val);
					}
					buffDefPopulated = true;
				}
			}

			private static void DisableInactiveItems()
			{
				int populatedState = GetPopulatedState(equipDefPopulated, buffDefPopulated);
				DisableInactiveItem(Item.ZetAspectBackup, ref Equip.AffixBackup, ref Buff.AffixBackup, populatedState);
			}

			private static void SetupText()
			{
				ZetAspectBackup.SetupTokens();
			}

			internal static void ItemEntries(bool shown)
			{
				SetItemState(Item.ZetAspectBackup, shown);
			}

			private static void CopyExpansionReq()
			{
				CopyExpansion(Item.ZetAspectBackup, Equip.AffixBackup);
			}

			private static void CopyModelPrefabs()
			{
				CopyEquipmentPrefab(Item.ZetAspectBackup, Equip.AffixBackup);
			}

			private static void ApplyEquipmentIcons()
			{
				if (!iconsReplaced)
				{
					ReplaceEquipmentIcon(Equip.AffixBackup, Sprites.AffixBackup, Sprites.CrackedOutlineOrange);
					iconsReplaced = true;
				}
			}

			internal static void EquipmentEntries(bool shown)
			{
				SetEquipmentState(Equip.AffixBackup, shown);
			}

			internal static void EquipmentColor()
			{
				ColorEquipmentDroplet(Equip.AffixBackup);
			}

			internal static void FillEqualities()
			{
				CreateEquality(Equip.AffixBackup, Buff.AffixBackup, Item.ZetAspectBackup);
			}
		}

		public static class Thalasso
		{
			private static bool equipDefPopulated = false;

			private static bool buffDefPopulated = false;

			private static bool iconsReplaced = false;

			public static bool populated = false;

			private static int state = -1;

			public static bool Enabled
			{
				get
				{
					if (state == -1)
					{
						if (PluginLoaded("com.jt_hehe.Thalassophobia"))
						{
							state = 1;
						}
						else
						{
							state = 0;
						}
					}
					return state == 1;
				}
			}

			internal static void PreInit()
			{
				if (Enabled)
				{
					PopulateEquipment();
					DisableInactiveItems();
					ApplyEquipmentIcons();
				}
			}

			internal static void Init()
			{
				if (Enabled)
				{
					PopulateEquipment();
					PopulateBuffs();
					DisableInactiveItems();
					SetupText();
					ItemEntries(DropHooks.CanObtainItem());
					CopyExpansionReq();
					CopyModelPrefabs();
					ApplyEquipmentIcons();
					if (DropHooks.CanObtainEquipment())
					{
						EquipmentEntries(shown: true);
					}
					EquipmentColor();
					FillEqualities();
					populated = true;
				}
			}

			private static void PopulateEquipment()
			{
				//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_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Invalid comparison between Unknown and I4
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				if (!equipDefPopulated)
				{
					EquipmentIndex val = EquipmentCatalog.FindEquipmentIndex("THALASSOPHOBIA_ELITE_EQUIPMENT_AFFIX_PURE");
					if ((int)val != -1)
					{
						Equip.AffixPurity = EquipmentCatalog.GetEquipmentDef(val);
					}
					equipDefPopulated = true;
				}
			}

			private static void PopulateBuffs()
			{
				if (!buffDefPopulated)
				{
					if (Object.op_Implicit((Object)(object)Equip.AffixPurity))
					{
						Buff.AffixPurity = Equip.AffixPurity.passiveBuffDef;
					}
					buffDefPopulated = true;
				}
			}

			private static void DisableInactiveItems()
			{
				int populatedState = GetPopulatedState(equipDefPopulated, buffDefPopulated);
				DisableInactiveItem(Item.ZetAspectPurity, ref Equip.AffixPurity, ref Buff.AffixPurity, populatedState);
			}

			private static void SetupText()
			{
				ZetAspectPurity.SetupTokens();
			}

			internal static void ItemEntries(bool shown)
			{
				SetItemState(Item.ZetAspectPurity, shown);
			}

			private static void CopyExpansionReq()
			{
				CopyExpansion(Item.ZetAspectPurity, Equip.AffixPurity);
			}

			private static void CopyModelPrefabs()
			{
				CopyItemPrefab(Item.ZetAspectPurity, Equip.AffixPurity);
			}

			private static void ApplyEquipmentIcons()
			{
				if (!iconsReplaced)
				{
					ReplaceEquipmentIcon(Equip.AffixPurity, Sprites.AffixPurity, Sprites.OutlineOrange);
					iconsReplaced = true;
				}
			}

			internal static void EquipmentEntries(bool shown)
			{
				SetEquipmentState(Equip.AffixPurity, shown);
			}

			internal static void EquipmentColor()
			{
				ColorEquipmentDroplet(Equip.AffixPurity);
			}

			internal static void FillEqualities()
			{
				CreateEquality(Equip.AffixPurity, Buff.AffixPurity, Item.ZetAspectPurity);
			}
		}

		public static class RisingTides
		{
			private static bool equipDefPopulated = false;

			private static bool buffDefPopulated = false;

			private static bool iconsReplaced = false;

			public static bool populated = false;

			private static int state = -1;

			public static bool Enabled
			{
				get
				{
					if (state == -1)
					{
						if (PluginLoaded("com.themysticsword.risingtides"))
						{
							state = 1;
						}
						else
						{
							state = 0;
						}
					}
					return state == 1;
				}
			}

			internal static void PreInit()
			{
				if (Enabled)
				{
					PopulateEquipment();
					DisableInactiveItems();
					ApplyEquipmentIcons();
				}
			}

			internal static void Init()
			{
				if (Enabled)
				{
					PopulateEquipment();
					PopulateBuffs();
					DisableInactiveItems();
					SetupText();
					ItemEntries(DropHooks.CanObtainItem());
					CopyExpansionReq();
					CopyModelPrefabs();
					ApplyEquipmentIcons();
					if (DropHooks.CanObtainEquipment())
					{
						EquipmentEntries(shown: true);
					}
					EquipmentColor();
					FillEqualities();
					populated = true;
				}
			}

			private static void PopulateEquipment()
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Invalid comparison between Unknown and I4
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Invalid comparison between Unknown and I4
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Invalid comparison between Unknown and I4
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Invalid comparison between Unknown and I4
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Invalid comparison between Unknown and I4
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Invalid comparison between Unknown and I4
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				if (!equipDefPopulated)
				{
					EquipmentIndex val = EquipmentCatalog.FindEquipmentIndex("RisingTides_AffixBarrier");
					if ((int)val != -1)
					{
						Equip.AffixBarrier = EquipmentCatalog.GetEquipmentDef(val);
					}
					val = EquipmentCatalog.FindEquipmentIndex("RisingTides_AffixBlackHole");
					if ((int)val != -1)
					{
						Equip.AffixBlackHole = EquipmentCatalog.GetEquipmentDef(val);
					}
					val = EquipmentCatalog.FindEquipmentIndex("RisingTides_AffixMoney");
					if ((int)val != -1)
					{
						Equip.AffixMoney = EquipmentCatalog.GetEquipmentDef(val);
					}
					val = EquipmentCatalog.FindEquipmentIndex("RisingTides_AffixNight");
					if ((int)val != -1)
					{
						Equip.AffixNight = EquipmentCatalog.GetEquipmentDef(val);
					}
					val = EquipmentCatalog.FindEquipmentIndex("RisingTides_AffixWater");
					if ((int)val != -1)
					{
						Equip.AffixWater = EquipmentCatalog.GetEquipmentDef(val);
					}
					val = EquipmentCatalog.FindEquipmentIndex("RisingTides_AffixImpPlane");
					if ((int)val != -1)
					{
						Equip.AffixRealgar = EquipmentCatalog.GetEquipmentDef(val);
					}
					equipDefPopulated = true;
				}
			}

			private static void PopulateBuffs()
			{
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Invalid comparison between Unknown and I4
				//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0101: Invalid comparison between Unknown and I4
				//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_010c: Unknown result type (might be due to invalid IL or missing references)
				if (!buffDefPopulated)
				{
					if (Object.op_Implicit((Object)(object)Equip.AffixBarrier))
					{
						Buff.AffixBarrier = Equip.AffixBarrier.passiveBuffDef;
					}
					if (Object.op_Implicit((Object)(object)Equip.AffixBlackHole))
					{
						Buff.AffixBlackHole = Equip.AffixBlackHole.passiveBuffDef;
					}
					if (Object.op_Implicit((Object)(object)Equip.AffixMoney))
					{
						Buff.AffixMoney = Equip.AffixMoney.passiveBuffDef;
					}
					if (Object.op_Implicit((Object)(object)Equip.AffixNight))
					{
						Buff.AffixNight = Equip.AffixNight.passiveBuffDef;
					}
					if (Object.op_Implicit((Object)(object)Equip.AffixWater))
					{
						Buff.AffixWater = Equip.AffixWater.passiveBuffDef;
					}
					if (Object.op_Implicit((Object)(object)Equip.AffixRealgar))
					{
						Buff.AffixRealgar = Equip.AffixRealgar.passiveBuffDef;
					}
					BuffIndex val = BuffCatalog.FindBuffIndex("RisingTides_NightSpeedBoost");
					if ((int)val != -1)
					{
						Buff.NightSpeed = BuffCatalog.GetBuffDef(val);
					}
					val = BuffCatalog.FindBuffIndex("RisingTides_NightReducedVision");
					if ((int)val != -1)
					{
						Buff.NightBlind = BuffCatalog.GetBuffDef(val);
					}
					buffDefPopulated = true;
				}
			}

			private static void DisableInactiveItems()
			{
				int populatedState = GetPopulatedState(equipDefPopulated, buffDefPopulated);
				DisableInactiveItem(Item.ZetAspectBarrier, ref Equip.AffixBarrier, ref Buff.AffixBarrier, populatedState);
				DisableInactiveItem(Item.ZetAspectBlackHole, ref Equip.AffixBlackHole, ref Buff.AffixBlackHole, populatedState);
				DisableInactiveItem(Item.ZetAspectMoney, ref Equip.AffixMoney, ref Buff.AffixMoney, populatedState);
				DisableInactiveItem(Item.ZetAspectNight, ref Equip.AffixNight, ref Buff.AffixNight, populatedState);
				DisableInactiveItem(Item.ZetAspectWater, ref Equip.AffixWater, ref Buff.AffixWater, populatedState);
				DisableInactiveItem(Item.ZetAspectRealgar, ref Equip.AffixRealgar, ref Buff.AffixRealgar, populatedState);
			}

			private static void SetupText()
			{
				ZetAspectBarrier.SetupTokens();
				ZetAspectBlackHole.SetupTokens();
				ZetAspectMoney.SetupTokens();
				ZetAspectNight.SetupTokens();
				ZetAspectWater.SetupTokens();
				ZetAspectRealgar.SetupTokens();
			}

			internal static void ItemEntries(bool shown)
			{
				SetItemState(Item.ZetAspectBarrier, shown);
				SetItemState(Item.ZetAspectBlackHole, shown);
				SetItemState(Item.ZetAspectMoney, shown);
				SetItemState(Item.ZetAspectNight, shown);
				SetItemState(Item.ZetAspectWater, shown);
				SetItemState(Item.ZetAspectRealgar, shown);
			}

			private static void CopyExpansionReq()
			{
				CopyExpansion(Item.ZetAspectBarrier, Equip.AffixBarrier);
				CopyExpansion(Item.ZetAspectBlackHole, Equip.AffixBlackHole);
				CopyExpansion(Item.ZetAspectMoney, Equip.AffixMoney);
				CopyExpansion(Item.ZetAspectNight, Equip.AffixNight);
				CopyExpansion(Item.ZetAspectWater, Equip.AffixWater);
				CopyExpansion(Item.ZetAspectRealgar, Equip.AffixRealgar);
			}

			private static void CopyModelPrefabs()
			{
				CopyEquipmentPrefab(Item.ZetAspectBarrier, Equip.AffixBarrier);
				CopyEquipmentPrefab(Item.ZetAspectBlackHole, Equip.AffixBlackHole);
				CopyEquipmentPrefab(Item.ZetAspectMoney, Equip.AffixMoney);
				CopyEquipmentPrefab(Item.ZetAspectNight, Equip.AffixNight);
				CopyEquipmentPrefab(Item.ZetAspectWater, Equip.AffixWater);
				CopyEquipmentPrefab(Item.ZetAspectRealgar, Equip.AffixRealgar);
			}

			private static void ApplyEquipmentIcons()
			{
				if (!iconsReplaced)
				{
					ReplaceEquipmentIcon(Equip.AffixBarrier, Sprites.AffixBarrier, Sprites.OutlineOrange);
					ReplaceEquipmentIcon(Equip.AffixBlackHole, Sprites.AffixBlackHole, Sprites.OutlineOrange);
					ReplaceEquipmentIcon(Equip.AffixMoney, Sprites.AffixMoney, Sprites.OutlineOrange);
					ReplaceEquipmentIcon(Equip.AffixNight, Sprites.AffixNight, Sprites.OutlineOrange);
					ReplaceEquipmentIcon(Equip.AffixWater, Sprites.AffixWater, Sprites.OutlineOrange);
					ReplaceEquipmentIcon(Equip.AffixRealgar, Sprites.AffixRealgar, Sprites.OutlineOrange);
					iconsReplaced = true;
				}
			}

			internal static void EquipmentEntries(bool shown)
			{
				SetEquipmentState(Equip.AffixBarrier, shown);
				SetEquipmentState(Equip.AffixBlackHole, shown);
				SetEquipmentState(Equip.AffixMoney, shown);
				SetEquipmentState(Equip.AffixNight, shown);
				SetEquipmentState(Equip.AffixWater, shown);
				SetEquipmentState(Equip.AffixRealgar, shown);
			}

			internal static void EquipmentColor()
			{
				ColorEquipmentDroplet(Equip.AffixBarrier);
				ColorEquipmentDroplet(Equip.AffixBlackHole);
				ColorEquipmentDroplet(Equip.AffixMoney);
				ColorEquipmentDroplet(Equip.AffixNight);
				ColorEquipmentDroplet(Equip.AffixWater);
				ColorEquipmentDroplet(Equip.AffixRealgar);
			}

			internal static void FillEqualities()
			{
				CreateEquality(Equip.AffixBarrier, Buff.AffixBarrier, Item.ZetAspectBarrier);
				CreateEquality(Equip.AffixBlackHole, Buff.AffixBlackHole, Item.ZetAspectBlackHole);
				CreateEquality(Equip.AffixMoney, Buff.AffixMoney, Item.ZetAspectMoney);
				CreateEquality(Equip.AffixNight, Buff.AffixNight, Item.ZetAspectNight);
				CreateEquality(Equip.AffixWater, Buff.AffixWater, Item.ZetAspectWater);
				CreateEquality(Equip.AffixRealgar, Buff.AffixRealgar, Item.ZetAspectRealgar);
			}
		}

		public static class NemRisingTides
		{
			private static bool equipDefPopulated = false;

			private static bool buffDefPopulated = false;

			private static bool iconsReplaced = false;

			public static bool populated = false;

			private static int state = -1;

			public static bool Enabled
			{
				get
				{
					if (state == -1)
					{
						if (PluginLoaded("prodzpod.NemesisRisingTides"))
						{
							state = 1;
						}
						else
						{
							state = 0;
						}
					}
					return state == 1;
				}
			}

			internal static void PreInit()
			{
				if (Enabled)
				{
					PopulateEquipment();
					DisableInactiveItems();
					ApplyEquipmentIcons();
				}
				else
				{
					PopulateEquipment();
					DisableInactiveItems();
				}
			}

			internal static void Init()
			{
				if (Enabled)
				{
					PopulateEquipment();
					PopulateBuffs();
					DisableInactiveItems();
					SetupText();
					ItemEntries(DropHooks.CanObtainItem());
					CopyExpansionReq();
					CopyModelPrefabs();
					ApplyEquipmentIcons();
					if (DropHooks.CanObtainEquipment())
					{
						EquipmentEntries(shown: true);
					}
					EquipmentColor();
					FillEqualities();
					populated = true;
				}
				else
				{
					PopulateEquipment();
					DisableInactiveItems();
				}
			}

			private static void PopulateEquipment()
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Invalid comparison between Unknown and I4
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Invalid comparison between Unknown and I4
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				if (!equipDefPopulated)
				{
					TPDespair.ZetAspects.Compat.NemRisingTides.PrepareEquipmentCheck();
					EquipmentIndex val = EquipmentCatalog.FindEquipmentIndex("NemesisRisingTides_AffixBuffered");
					if ((int)val != -1 && TPDespair.ZetAspects.Compat.NemRisingTides.GetBufferedEnabled())
					{
						Equip.AffixBuffered = EquipmentCatalog.GetEquipmentDef(val);
					}
					val = EquipmentCatalog.FindEquipmentIndex("NemesisRisingTides_AffixOppressive");
					if ((int)val != -1 && TPDespair.ZetAspects.Compat.NemRisingTides.GetOppressiveEnabled())
					{
						Equip.AffixOppressive = EquipmentCatalog.GetEquipmentDef(val);
					}
					equipDefPopulated = true;
				}
			}

			private static void PopulateBuffs()
			{
				if (!buffDefPopulated)
				{
					if (Object.op_Implicit((Object)(object)Equip.AffixBuffered))
					{
						Buff.AffixBuffered = Equip.AffixBuffered.passiveBuffDef;
					}
					if (Object.op_Implicit((Object)(object)Equip.AffixOppressive))
					{
						Buff.AffixOppressive = Equip.AffixOppressive.passiveBuffDef;
					}
					buffDefPopulated = true;
				}
			}

			private static void DisableInactiveItems()
			{
				int populatedState = GetPopulatedState(equipDefPopulated, buffDefPopulated);
				DisableInactiveItem(Item.ZetAspectBuffered, ref Equip.AffixBuffered, ref Buff.AffixBuffered, populatedState);
				DisableInactiveItem(Item.ZetAspectOppressive, ref Equip.AffixOppressive, ref Buff.AffixOppressive, populatedState);
			}

			private static void SetupText()
			{
				ZetAspectBuffered.SetupTokens();
				ZetAspectOppressive.SetupTokens();
			}

			internal static void ItemEntries(bool shown)
			{
				SetItemState(Item.ZetAspectBuffered, shown);
				SetItemState(Item.ZetAspectOppressive, shown);
			}

			private static void CopyExpansionReq()
			{
				CopyExpansion(Item.ZetAspectBuffered, Equip.AffixBuffered);
				CopyExpansion(Item.ZetAspectOppressive, Equip.AffixOppressive);
			}

			private static void CopyModelPrefabs()
			{
				CopyEquipmentPrefab(Item.ZetAspectBuffered, Equip.AffixBuffered);
				CopyEquipmentPrefab(Item.ZetAspectOppressive, Equip.AffixOppressive);
			}

			private static void ApplyEquipmentIcons()
			{
				if (!iconsReplaced)
				{
					ReplaceEquipmentIcon(Equip.AffixBuffered, Sprites.AffixBuffered, Sprites.OutlineOrange);
					ReplaceEquipmentIcon(Equip.AffixOppressive, Sprites.AffixOppressive, Sprites.OutlineOrange);
					iconsReplaced = true;
				}
			}

			internal static void EquipmentEntries(bool shown)
			{
				SetEquipmentState(Equip.AffixBuffered, shown);
				SetEquipmentState(Equip.AffixOppressive, shown);
			}

			internal static void EquipmentColor()
			{
				ColorEquipmentDroplet(Equip.AffixBuffered);
				ColorEquipmentDroplet(Equip.AffixOppressive);
			}

			internal static void FillEqualities()
			{
				CreateEquality(Equip.AffixBuffered, Buff.AffixBuffered, Item.ZetAspectBuffered);
				CreateEquality(Equip.AffixOppressive, Buff.AffixOppressive, Item.ZetAspectOppressive);
			}
		}

		public static class MoreElites
		{
			private static bool equipDefPopulated = false;

			private static bool buffDefPopulated = false;

			private static bool iconsReplaced = false;

			public static bool populated = false;

			private static int state = -1;

			public static bool Enabled
			{
				get
				{
					if (state == -1)
					{
						if (PluginLoaded("com.Nuxlar.MoreElites"))
						{
							state = 1;
						}
						else
						{
							state = 0;
						}
					}
					return state == 1;
				}
			}

			internal static void PreInit()
			{
				if (Enabled)
				{
					PopulateEquipment();
					DisableInactiveItems();
					ApplyEquipmentIcons();
				}
			}

			internal static void Init()
			{
				if (Enabled)
				{
					PopulateEquipment();
					PopulateBuffs();
					DisableInactiveItems();
					SetupText();
					ItemEntries(DropHooks.CanObtainItem());
					CopyExpansionReq();
					CopyModelPrefabs();
					ApplyEquipmentIcons();
					if (DropHooks.CanObtainEquipment())
					{
						EquipmentEntries(shown: true);
					}
					EquipmentColor();
					FillEqualities();
					populated = true;
				}
			}

			private static void PopulateEquipment()
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Invalid comparison between Unknown and I4
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Invalid comparison between Unknown and I4
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Invalid comparison between Unknown and I4
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0084: 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_0087: Invalid comparison between Unknown and I4
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				if (!equipDefPopulated)
				{
					EquipmentIndex val = EquipmentCatalog.FindEquipmentIndex("AffixEmpowering");
					if ((int)val != -1)
					{
						Equip.AffixEmpowering = EquipmentCatalog.GetEquipmentDef(val);
					}
					val = EquipmentCatalog.FindEquipmentIndex("AffixFrenziedNuxlar");
					if ((int)val != -1)
					{
						Equip.AffixFrenzied = EquipmentCatalog.GetEquipmentDef(val);
					}
					val = EquipmentCatalog.FindEquipmentIndex("AffixVolatile");
					if ((int)val != -1)
					{
						Equip.AffixVolatile = EquipmentCatalog.GetEquipmentDef(val);
					}
					val = EquipmentCatalog.FindEquipmentIndex("AffixEcho");
					if ((int)val != -1)
					{
						Equip.AffixEcho = EquipmentCatalog.GetEquipmentDef(val);
					}
					equipDefPopulated = true;
				}
			}

			private static void PopulateBuffs()
			{
				if (!buffDefPopulated)
				{
					if (Object.op_Implicit((Object)(object)Equip.AffixEmpowering))
					{
						Buff.AffixEmpowering = Equip.AffixEmpowering.passiveBuffDef;
					}
					if (Object.op_Implicit((Object)(object)Equip.AffixFrenzied))
					{
						Buff.AffixFrenzied = Equip.AffixFrenzied.passiveBuffDef;
					}
					if (Object.op_Implicit((Object)(object)Equip.AffixVolatile))
					{
						Buff.AffixVolatile = Equip.AffixVolatile.passiveBuffDef;
					}
					if (Object.op_Implicit((Object)(object)Equip.AffixEcho))
					{
						Buff.AffixEcho = Equip.AffixEcho.passiveBuffDef;
					}
					buffDefPopulated = true;
				}
			}

			private static void DisableInactiveItems()
			{
				int populatedState = GetPopulatedState(equipDefPopulated, buffDefPopulated);
				DisableInactiveItem(Item.ZetAspectEmpowering, ref Equip.AffixEmpowering, ref Buff.AffixEmpowering, populatedState);
				DisableInactiveItem(Item.ZetAspectFrenzied, ref Equip.AffixFrenzied, ref Buff.AffixFrenzied, populatedState);
				DisableInactiveItem(Item.ZetAspectVolatile, ref Equip.AffixVolatile, ref Buff.AffixVolatile, populatedState);
				DisableInactiveItem(Item.ZetAspectEcho, ref Equip.AffixEcho, ref Buff.AffixEcho, populatedState);
			}

			private static void SetupText()
			{
				ZetAspectEmpowering.SetupTokens();
				ZetAspectFrenzied.SetupTokens();
				ZetAspectVolatile.SetupTokens();
				ZetAspectEcho.SetupTokens();
			}

			internal static void ItemEntries(bool shown)
			{
				SetItemState(Item.ZetAspectEmpowering, shown);
				SetItemState(Item.ZetAspectFrenzied, shown);
				SetItemState(Item.ZetAspectVolatile, shown);
				SetItemState(Item.ZetAspectEcho, shown);
			}

			private static void CopyExpansionReq()
			{
				CopyExpansion(Item.ZetAspectEmpowering, Equip.AffixEmpowering);
				CopyExpansion(Item.ZetAspectFrenzied, Equip.AffixFrenzied);
				CopyExpansion(Item.ZetAspectVolatile, Equip.AffixVolatile);
				CopyExpansion(Item.ZetAspectEcho, Equip.AffixEcho);
			}

			private static void CopyModelPrefabs()
			{
				CopyEquipmentPrefab(Item.ZetAspectEmpowering, Equip.AffixEmpowering);
				CopyEquipmentPrefab(Item.ZetAspectFrenzied, Equip.AffixFrenzied);
				CopyEquipmentPrefab(Item.ZetAspectVolatile, Equip.AffixVolatile);
				CopyEquipmentPrefab(Item.ZetAspectEcho, Equip.AffixEcho);
			}

			private static void ApplyEquipmentIcons()
			{
				if (!iconsReplaced)
				{
					ReplaceEquipmentIcon(Equip.AffixEmpowering, Sprites.AffixBuffing, Sprites.OutlineOrange);
					ReplaceEquipmentIcon(Equip.AffixFrenzied, Sprites.AffixFrenzied, Sprites.OutlineOrange);
					ReplaceEquipmentIcon(Equip.AffixVolatile, Sprites.AffixVolatile, Sprites.OutlineOrange);
					ReplaceEquipmentIcon(Equip.AffixEcho, Sprites.AffixEcho, Sprites.OutlineOrange);
					iconsReplaced = true;
				}
			}

			internal static void EquipmentEntries(bool shown)
			{
				SetEquipmentState(Equip.AffixEmpowering, shown);
				SetEquipmentState(Equip.AffixFrenzied, shown);
				SetEquipmentState(Equip.AffixVolatile, shown);
				SetEquipmentState(Equip.AffixEcho, shown);
			}

			internal static void EquipmentColor()
			{
				ColorEquipmentDroplet(Equip.AffixEmpowering);
				ColorEquipmentDroplet(Equip.AffixFrenzied);
				ColorEquipmentDroplet(Equip.AffixVolatile);
				ColorEquipmentDroplet(Equip.AffixEcho);
			}

			internal static void FillEqualities()
			{
				CreateEquality(Equip.AffixEmpowering, Buff.AffixEmpowering, Item.ZetAspectEmpowering);
				CreateEquality(Equip.AffixFrenzied, Buff.AffixFrenzied, Item.ZetAspectFrenzied);
				CreateEquality(Equip.AffixVolatile, Buff.AffixVolatile, Item.ZetAspectVolatile);
				CreateEquality(Equip.AffixEcho, Buff.AffixEcho, Item.ZetAspectEcho);
			}
		}

		public static class EliteVariety
		{
			private static bool equipDefPopulated = false;

			private static bool buffDefPopulated = false;

			private static bool iconsReplaced = false;

			public static bool populated = false;

			private static int state = -1;

			public static bool Enabled
			{
				get
				{
					if (state == -1)
					{
						if (PluginLoaded("com.themysticsword.elitevariety"))
						{
							state = 1;
						}
						else
						{
							state = 0;
						}
					}
					return state == 1;
				}
			}

			internal static void PreInit()
			{
				if (Enabled)
				{
					PopulateEquipment();
					DisableInactiveItems();
					ApplyEquipmentIcons();
				}
			}

			internal static void Init()
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				if (Enabled)
				{
					tinkerDroneBodyIndex = BodyCatalog.FindBodyIndex("EliteVariety_TinkererDroneBody");
					PopulateEquipment();
					PopulateBuffs();
					DisableInactiveItems();
					SetupText();
					ItemEntries(DropHooks.CanObtainItem());
					CopyExpansionReq();
					CopyModelPrefabs();
					ApplyEquipmentIcons();
					if (DropHooks.CanObtainEquipment())
					{
						EquipmentEntries(shown: true);
					}
					EquipmentColor();
					FillEqualities();
					populated = true;
				}
			}

			private static void PopulateEquipment()
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Invalid comparison between Unknown and I4
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Invalid comparison between Unknown and I4
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Invalid comparison between Unknown and I4
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Invalid comparison between Unknown and I4
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Invalid comparison between Unknown and I4
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Invalid comparison between Unknown and I4
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				if (!equipDefPopulated)
				{
					EquipmentIndex val = EquipmentCatalog.FindEquipmentIndex("EliteVariety_AffixArmored");
					if ((int)val != -1)
					{
						Equip.AffixArmored = EquipmentCatalog.GetEquipmentDef(val);
					}
					val = EquipmentCatalog.FindEquipmentIndex("EliteVariety_AffixBuffing");
					if ((int)val != -1)
					{
						Equip.AffixBuffing = EquipmentCatalog.GetEquipmentDef(val);
					}
					val = EquipmentCatalog.FindEquipmentIndex("EliteVariety_AffixImpPlane");
					if ((int)val != -1)
					{
						Equip.AffixImpPlane = EquipmentCatalog.GetEquipmentDef(val);
					}
					val = EquipmentCatalog.FindEquipmentIndex("EliteVariety_AffixPillaging");
					if ((int)val != -1)
					{
						Equip.AffixPillaging = EquipmentCatalog.GetEquipmentDef(val);
					}
					val = EquipmentCatalog.FindEquipmentIndex("EliteVariety_AffixSandstorm");
					if ((int)val != -1)
					{
						Equip.AffixSandstorm = EquipmentCatalog.GetEquipmentDef(val);
					}
					val = EquipmentCatalog.FindEquipmentIndex("EliteVariety_AffixTinkerer");
					if ((int)val != -1)
					{
						Equip.AffixTinkerer = EquipmentCatalog.GetEquipmentDef(val);
					}
					equipDefPopulated = true;
				}
			}

			private static void PopulateBuffs()
			{
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Invalid comparison between Unknown and I4
				//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
				if (!buffDefPopulated)
				{
					if (Object.op_Implicit((Object)(object)Equip.AffixArmored))
					{
						Buff.AffixArmored = Equip.AffixArmored.passiveBuffDef;
					}
					if (Object.op_Implicit((Object)(object)Equip.AffixBuffing))
					{
						Buff.AffixBuffing = Equip.AffixBuffing.passiveBuffDef;
					}
					if (Object.op_Implicit((Object)(object)Equip.AffixImpPlane))
					{
						Buff.AffixImpPlane = Equip.AffixImpPlane.passiveBuffDef;
					}
					if (Object.op_Implicit((Object)(object)Equip.AffixPillaging))
					{
						Buff.AffixPillaging = Equip.AffixPillaging.passiveBuffDef;
					}
					if (Object.op_Implicit((Object)(object)Equip.AffixSandstorm))
					{
						Buff.AffixSandstorm = Equip.AffixSandstorm.passiveBuffDef;
					}
					if (Object.op_Implicit((Object)(object)Equip.AffixTinkerer))
					{
						Buff.AffixTinkerer = Equip.AffixTinkerer.passiveBuffDef;
					}
					BuffIndex val = BuffCatalog.FindBuffIndex("EliteVariety_SandstormBlind");
					if ((int)val != -1)
					{
						Buff.SandBlind = BuffCatalog.GetBuffDef(val);
					}
					buffDefPopulated = true;
				}
			}

			private static void DisableInactiveItems()
			{
				int populatedState = GetPopulatedState(equipDefPopulated, buffDefPopulated);
				DisableInactiveItem(Item.ZetAspectArmor, ref Equip.AffixArmored, ref Buff.AffixArmored, populatedState);
				DisableInactiveItem(Item.ZetAspectBanner, ref Equip.AffixBuffing, ref Buff.AffixBuffing, populatedState);
				DisableInactiveItem(Item.ZetAspectImpale, ref Equip.AffixImpPlane, ref Buff.AffixImpPlane, populatedState);
				DisableInactiveItem(Item.ZetAspectGolden, ref Equip.AffixPillaging, ref Buff.AffixPillaging, populatedState);
				DisableInactiveItem(Item.ZetAspectCyclone, ref Equip.AffixSandstorm, ref Buff.AffixSandstorm, populatedState);
				DisableInactiveItem(Item.ZetAspectTinker, ref Equip.AffixTinkerer, ref Buff.AffixTinkerer, populatedState);
			}

			private static void SetupText()
			{
				ZetAspectArmor.SetupTokens();
				ZetAspectBanner.SetupTokens();
				ZetAspectImpale.SetupTokens();
				ZetAspectGolden.SetupTokens();
				ZetAspectCyclone.SetupTokens();
				ZetAspectTinker.SetupTokens();
			}

			internal static void ItemEntries(bool shown)
			{
				SetItemState(Item.ZetAspectArmor, shown);
				SetItemState(Item.ZetAspectBanner, shown);
				SetItemState(Item.ZetAspectImpale, shown);
				SetItemState(Item.ZetAspectGolden, shown);
				SetItemState(Item.ZetAspectCyclone, shown);
				SetItemState(Item.ZetAspectTinker, shown);
			}

			private static void CopyExpansionReq()
			{
				CopyExpansion(Item.ZetAspectArmor, Equip.AffixArmored);
				CopyExpansion(Item.ZetAspectBanner, Equip.AffixBuffing);
				CopyExpansion(Item.ZetAspectImpale, Equip.AffixImpPlane);
				CopyExpansion(Item.ZetAspectGolden, Equip.AffixPillaging);
				CopyExpansion(Item.ZetAspectCyclone, Equip.AffixSandstorm);
				CopyExpansion(Item.ZetAspectTinker, Equip.AffixTinkerer);
			}

			private static void CopyModelPrefabs()
			{
				CopyEquipmentPrefab(Item.ZetAspectArmor, Equip.AffixArmored);
				CopyEquipmentPrefab(Item.ZetAspectBanner, Equip.AffixBuffing);
				CopyEquipmentPrefab(Item.ZetAspectImpale, Equip.AffixImpPlane);
				CopyEquipmentPrefab(Item.ZetAspectGolden, Equip.AffixPillaging);
				CopyEquipmentPrefab(Item.ZetAspectCyclone, Equip.AffixSandstorm);
				CopyEquipmentPrefab(Item.ZetAspectTinker, Equip.AffixTinkerer);
			}

			private static void ApplyEquipmentIcons()
			{
				if (!iconsReplaced)
				{
					ReplaceEquipmentIcon(Equip.AffixArmored, Sprites.AffixArmored, Sprites.OutlineOrange);
					ReplaceEquipmentIcon(Equip.AffixBuffing, Sprites.AffixBuffing_EV, Sprites.OutlineOrange);
					ReplaceEquipmentIcon(Equip.AffixImpPlane, Sprites.AffixImpPlane, Sprites.OutlineOrange);
					ReplaceEquipmentIcon(Equip.AffixPillaging, Sprites.AffixPillaging, Sprites.OutlineOrange);
					ReplaceEquipmentIcon(Equip.AffixSandstorm, Sprites.AffixSandstorm, Sprites.OutlineOrange);
					ReplaceEquipmentIcon(Equip.AffixTinkerer, Sprites.AffixTinkerer, Sprites.OutlineOrange);
					iconsReplaced = true;
				}
			}

			internal static void EquipmentEntries(bool shown)
			{
				SetEquipmentState(Equip.AffixArmored, shown);
				SetEquipmentState(Equip.AffixBuffing, shown);
				SetEquipmentState(Equip.AffixImpPlane, shown);
				SetEquipmentState(Equip.AffixPillaging, shown);
				SetEquipmentState(Equip.AffixSandstorm, shown);
				SetEquipmentState(Equip.AffixTinkerer, shown);
			}

			internal static void EquipmentColor()
			{
				ColorEquipmentDroplet(Equip.AffixArmored);
				ColorEquipmentDroplet(Equip.AffixBuffing);
				ColorEquipmentDroplet(Equip.AffixImpPlane);
				ColorEquipmentDroplet(Equip.AffixPillaging);
				ColorEquipmentDroplet(Equip.AffixSandstorm);
				ColorEquipmentDroplet(Equip.AffixTinkerer);
			}

			internal static void FillEqualities()
			{
				CreateEquality(Equip.AffixArmored, Buff.AffixArmored, Item.ZetAspectArmor);
				CreateEquality(Equip.AffixBuffing, Buff.AffixBuffing, Item.ZetAspectBanner);
				CreateEquality(Equip.AffixImpPlane, Buff.AffixImpPlane, Item.ZetAspectImpale);
				CreateEquality(Equip.AffixPillaging, Buff.AffixPillaging, Item.ZetAspectGolden);
				CreateEquality(Equip.AffixSandstorm, Buff.AffixSandstorm, Item.ZetAspectCyclone);
				CreateEquality(Equip.AffixTinkerer, Buff.AffixTinkerer, Item.ZetAspectTinker);
			}
		}

		public static class Augmentum
		{
			private static bool equipDefPopulated = false;

			private static bool buffDefPopulated = false;

			private static bool iconsReplaced = false;

			public static bool populated = false;

			private static int state = -1;

			public static bool Enabled
			{
				get
				{
					if (state == -1)
					{
						if (PluginLoaded("com.BrandonRosa.Augmentum"))
						{
							state = 1;
						}
						else
						{
							state = 0;
						}
					}
					return state == 1;
				}
			}

			internal static void PreInit()
			{
				if (Enabled)
				{
					PopulateEquipment();
					DisableInactiveItems();
					ApplyEquipmentIcons();
				}
				else
				{
					PopulateEquipment();
					DisableInactiveItems();
				}
			}

			internal static void Init()
			{
				if (Enabled)
				{
					PopulateEquipment();
					PopulateBuffs();
					DisableInactiveItems();
					SetupText();
					ItemEntries(DropHooks.CanObtainItem());
					CopyExpansionReq();
					CopyModelPrefabs();
					ApplyEquipmentIcons();
					if (DropHooks.CanObtainEquipment())
					{
						EquipmentEntries(shown: true);
					}
					EquipmentColor();
					FillEqualities();
					populated = true;
				}
				else
				{
					PopulateEquipment();
					DisableInactiveItems();
				}
			}

			private static void PopulateEquipment()
			{
				//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_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Invalid comparison between Unknown and I4
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				if (!equipDefPopulated)
				{
					EquipmentIndex val = EquipmentCatalog.FindEquipmentIndex("BRANS_ELITE_EQUIPMENT_AFFIX_ADAPTIVE");
					if ((int)val != -1)
					{
						Equip.AffixAdaptive = EquipmentCatalog.GetEquipmentDef(val);
					}
					equipDefPopulated = true;
				}
			}

			private static void PopulateBuffs()
			{
				if (!buffDefPopulated)
				{
					if (Object.op_Implicit((Object)(object)Equip.AffixAdaptive))
					{
						Buff.AffixAdaptive = Equip.AffixAdaptive.passiveBuffDef;
					}
					buffDefPopulated = true;
				}
			}

			private static void DisableInactiveItems()
			{
				int populatedState = GetPopulatedState(equipDefPopulated, buffDefPopulated);
				DisableInactiveItem(Item.ZetAspectAdaptive, ref Equip.AffixAdaptive, ref Buff.AffixAdaptive, populatedState);
			}

			private static void SetupText()
			{
				ZetAspectAdaptive.SetupTokens();
			}

			internal static void ItemEntries(bool shown)
			{
				SetItemState(Item.ZetAspectAdaptive, shown);
			}

			private static void CopyExpansionReq()
			{
				CopyExpansion(Item.ZetAspectAdaptive, Equip.AffixAdaptive);
			}

			private static void CopyModelPrefabs()
			{
				CopyEquipmentPrefab(Item.ZetAspectAdaptive, Equip.AffixAdaptive);
			}

			private static void ApplyEquipmentIcons()
			{
				if (!iconsReplaced)
				{
					ReplaceEquipmentIcon(Equip.AffixAdaptive, Sprites.AffixAdaptive, Sprites.OutlineOrange);
					iconsReplaced = true;
				}
			}

			internal static void EquipmentEntries(bool shown)
			{
				SetEquipmentState(Equip.AffixAdaptive, shown);
			}

			internal static void EquipmentColor()
			{
				ColorEquipmentDroplet(Equip.AffixAdaptive);
			}

			internal static void FillEqualities()
			{
				CreateEquality(Equip.AffixAdaptive, Buff.AffixAdaptive, Item.ZetAspectAdaptive);
			}
		}

		public static class Sandswept
		{
			private static bool equipDefPopulated = false;

			private static bool buffDefPopulated = false;

			private static bool iconsReplaced = false;

			public static bool populated = false;

			private static int state = -1;

			public static bool Enabled
			{
				get
				{
					if (state == -1)
					{
						if (PluginLoaded("com.TeamSandswept.Sandswept"))
						{
							state = 1;
						}
						else
						{
							state = 0;
						}
					}
					return state == 1;
				}
			}

			internal static void PreInit()
			{
				if (Enabled)
				{
					PopulateEquipment();
					DisableInactiveItems();
					ApplyEquipmentIcons();
				}
				else
				{
					PopulateEquipment();
					DisableInactiveItems();
				}
			}

			internal static void Init()
			{
				if (Enabled)
				{
					PopulateEquipment();
					PopulateBuffs();
					DisableInactiveItems();
					SetupText();
					ItemEntries(DropHooks.CanObtainItem());
					CopyExpansionReq();
					CopyModelPrefabs();
					ApplyEquipmentIcons();
					if (DropHooks.CanObtainEquipment())
					{
						EquipmentEntries(shown: true);
					}
					EquipmentColor();
					FillEqualities();
					populated = true;
				}
				else
				{
					PopulateEquipment();
					DisableInactiveItems();
				}
			}

			private static void PopulateEquipment()
			{
				//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_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Invalid comparison between Unknown and I4
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Invalid comparison between Unknown and I4
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				if (!equipDefPopulated)
				{
					EquipmentIndex val = EquipmentCatalog.FindEquipmentIndex("ELITE_EQUIPMENT_MOTIVATING");
					if ((int)val != -1)
					{
						Equip.AffixMotivator = EquipmentCatalog.GetEquipmentDef(val);
					}
					val = EquipmentCatalog.FindEquipmentIndex("ELITE_EQUIPMENT_OSMIUM");
					if ((int)val != -1)
					{
						Equip.AffixOsmium = EquipmentCatalog.GetEquipmentDef(val);
					}
					equipDefPopulated = true;
				}
			}

			private static void PopulateBuffs()
			{
				if (!buffDefPopulated)
				{
					if (Object.op_Implicit((Object)(object)Equip.AffixMotivator))
					{
						Buff.AffixMotivator = Equip.AffixMotivator.passiveBuffDef;
					}
					if (Object.op_Implicit((Object)(object)Equip.AffixOsmium))
					{
						Buff.AffixOsmium = Equip.AffixOsmium.passiveBuffDef;
					}
					buffDefPopulated = true;
				}
			}

			private static void DisableInactiveItems()
			{
				int populatedState = GetPopulatedState(equipDefPopulated, buffDefPopulated);
				DisableInactiveItem(Item.ZetAspectMotivator, ref Equip.AffixMotivator, ref Buff.AffixMotivator, populatedState);
				DisableInactiveItem(Item.ZetAspectOsmium, ref Equip.AffixOsmium, ref Buff.AffixOsmium, populatedState);
			}

			private static void SetupText()
			{
				ZetAspectMotivator.SetupTokens();
				ZetAspectOsmium.SetupTokens();
			}

			internal static void ItemEntries(bool shown)
			{
				SetItemState(Item.ZetAspectMotivator, shown);
				SetItemState(Item.ZetAspectOsmium, shown);
			}

			private static void CopyExpansionReq()
			{
				CopyExpansion(Item.ZetAspectMotivator, Equip.AffixMotivator);
				CopyExpansion(Item.ZetAspectOsmium, Equip.AffixOsmium);
			}

			private static void CopyModelPrefabs()
			{
				CopyEquipmentPrefab(Item.ZetAspectMotivator, Equip.AffixMotivator);
				CopyEquipmentPrefab(Item.ZetAspectOsmium, Equip.AffixOsmium);
			}

			private static void ApplyEquipmentIcons()
			{
				if (!iconsReplaced)
				{
					ReplaceEquipmentIcon(Equip.AffixMotivator, Sprites.AffixMotivator, Sprites.OutlineOrange);
					ReplaceEquipmentIcon(Equip.AffixOsmium, Sprites.AffixOsmium, Sprites.OutlineOrange);
					iconsReplaced = true;
				}
			}

			internal static void EquipmentEntries(bool shown)
			{
				SetEquipmentState(Equip.AffixMotivator, shown);
				SetEquipmentState(Equip.AffixOsmium, shown);
			}

			internal static void EquipmentColor()
			{
				ColorEquipmentDroplet(Equip.AffixMotivator);
				ColorEquipmentDroplet(Equip.AffixOsmium);
			}

			internal static void FillEqualities()
			{
				CreateEquality(Equip.AffixMotivator, Buff.AffixMotivator, Item.ZetAspectMotivator);
				CreateEquality(Equip.AffixOsmium, Buff.AffixOsmium, Item.ZetAspectOsmium);
			}
		}

		public static class Sprites
		{
			public static Sprite OutlineRed;

			public static Sprite OutlineOrange;

			public static Sprite OutlineYellow;

			public static Sprite OutlineBlue;

			public static Sprite OutlineVoid;

			public static Sprite NullOutlineRed;

			public static Sprite NullOutlineOrange;

			public static Sprite NullOutlineYellow;

			public static Sprite CrackedOutlineRed;

			public static Sprite CrackedOutlineOrange;

			public static Sprite CrackedOutlineYellow;

			public static Sprite AffixWhite;

			public static Sprite AffixBlue;

			public static Sprite AffixRed;

			public static Sprite AffixHaunted;

			public static Sprite AffixPoison;

			public static Sprite AffixLunar;

			public static Sprite AffixEarth;

			public static Sprite AffixVoid;

			public static Sprite AffixPlated;

			public static Sprite AffixWarped;

			public static Sprite AffixVeiled;

			public static Sprite AffixAragonite;

			public static Sprite AffixGold;

			public static Sprite AffixSanguine;

			public static Sprite AffixSepia;

			public static Sprite SepiaElite;

			public static Sprite AffixNullifier;

			public static Sprite AffixBlighted;

			public static Sprite AffixBackup;

			public static Sprite BackupDebuff;

			public static Sprite AffixPurity;

			public static Sprite AffixBarrier;

			public static Sprite AffixBlackHole;

			public static Sprite AffixMoney;

			public static Sprite AffixNight;

			public static Sprite AffixWater;

			public static Sprite AffixRealgar;

			public static Sprite AffixBuffered;

			public static Sprite AffixOppressive;

			public static Sprite AffixBuffing;

			public static Sprite AffixFrenzied;

			public static Sprite AffixVolatile;

			public static Sprite AffixEcho;

			public static Sprite AffixArmored;

			public static Sprite AffixBuffing_EV;

			public static Sprite AffixImpPlane;

			public static Sprite AffixPillaging;

			public static Sprite AffixSandstorm;

			public static Sprite AffixTinkerer;

			public static Sprite AffixAdaptive;

			public static Sprite AffixMotivator;

			public static Sprite AffixOsmium;

			public static Sprite HauntCloak;

			public static Sprite ZetHeadHunter;

			public static Sprite ZetSapped;

			public static Sprite ZetShredded;

			public static Sprite ZetPoached;

			public static Sprite ZetSepiaBlind;

			public static Sprite ZetElusive;

			public static Sprite ZetWarped;

			public static void Load()
			{
				OutlineRed = Assets.LoadAsset<Sprite>("Assets/Icons/texOutlineRed.png");
				OutlineOrange = Assets.LoadAsset<Sprite>("Assets/Icons/texOutlineOrange.png");
				OutlineYellow = Assets.LoadAsset<Sprite>("Assets/Icons/texOutlineYellow.png");
				OutlineBlue = Assets.LoadAsset<Sprite>("Assets/Icons/texOutlineBlue.png");
				OutlineVoid = Assets.LoadAsset<Sprite>("Assets/Icons/texOutlineVoid.png");
				AffixWhite = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixWhite.png");
				AffixBlue = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixBlue.png");
				AffixRed = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixRed.png");
				AffixHaunted = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixHaunted.png");
				AffixPoison = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixPoison.png");
				AffixLunar = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixLunar.png");
				AffixEarth = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixEarth.png");
				AffixVoid = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixVoid.png");
				if (SpikeStrip.Enabled)
				{
					AffixPlated = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixPlated.png");
					AffixWarped = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixWarped.png");
					AffixVeiled = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixVeiled.png");
					AffixAragonite = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixAragonite.png");
					ZetElusive = Assets.LoadAsset<Sprite>("Assets/Icons/texBuffElusive.png");
					ZetWarped = LegacyResourcesAPI.Load<BuffDef>("BuffDefs/Slow80").iconSprite;
				}
				if (GoldenCoastPlus.Enabled)
				{
					AffixGold = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixPillaging.png");
				}
				if (Aetherium.Enabled)
				{
					AffixSanguine = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixSanguine.png");
				}
				if (Bubbet.Enabled)
				{
					AffixSepia = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixSepia.png");
					SepiaElite = Assets.LoadAsset<Sprite>("Assets/Icons/texBuffAffixSepia.png");
					ZetSepiaBlind = Assets.LoadAsset<Sprite>("Assets/Icons/texBuffSepiaBlind.png");
				}
				if (WarWisp.Enabled)
				{
					NullOutlineRed = Assets.LoadAsset<Sprite>("Assets/Icons/texNullOutlineRed.png");
					NullOutlineOrange = Assets.LoadAsset<Sprite>("Assets/Icons/texNullOutlineOrange.png");
					NullOutlineYellow = Assets.LoadAsset<Sprite>("Assets/Icons/texNullOutlineYellow.png");
					AffixNullifier = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixNullifier.png");
				}
				AffixBlighted = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixBlighted.png");
				if (GOTCE.Enabled)
				{
					CrackedOutlineRed = Assets.LoadAsset<Sprite>("Assets/Icons/texCrackedOutlineRed.png");
					CrackedOutlineOrange = Assets.LoadAsset<Sprite>("Assets/Icons/texCrackedOutlineOrange.png");
					CrackedOutlineYellow = Assets.LoadAsset<Sprite>("Assets/Icons/texCrackedOutlineYellow.png");
					AffixBackup = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixBackup.png");
					BackupDebuff = Assets.LoadAsset<Sprite>("Assets/Icons/texBuffNoSecondary.png");
				}
				if (Thalasso.Enabled)
				{
					AffixPurity = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixPurity.png");
				}
				if (RisingTides.Enabled)
				{
					AffixBarrier = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixBarrier.png");
					AffixBlackHole = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixBlackHole.png");
					AffixMoney = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixArmored.png");
					AffixNight = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixNight.png");
					AffixWater = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixWater.png");
					AffixRealgar = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixImpPlane.png");
				}
				AffixBuffered = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixBuffered.png");
				AffixOppressive = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixOppressive.png");
				if (MoreElites.Enabled)
				{
					AffixBuffing = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixBuffing.png");
					AffixFrenzied = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixFrenzied.png");
					AffixVolatile = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixVolatile.png");
					AffixEcho = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixEcho.png");
				}
				if (EliteVariety.Enabled)
				{
					AffixArmored = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixArmored.png");
					AffixBuffing_EV = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixBuffing.png");
					AffixImpPlane = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixImpPlane.png");
					AffixPillaging = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixPillaging.png");
					AffixSandstorm = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixSandstorm.png");
					AffixTinkerer = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixTinkerer.png");
				}
				if (Augmentum.Enabled)
				{
					AffixAdaptive = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixAdaptive.png");
				}
				if (Sandswept.Enabled)
				{
					AffixMotivator = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixMotivator.png");
					AffixOsmium = Assets.LoadAsset<Sprite>("Assets/Icons/texAffixOsmium.png");
				}
				HauntCloak = Assets.LoadAsset<Sprite>("Assets/Icons/texBuffHauntCloak.png");
				ZetHeadHunter = Assets.LoadAsset<Sprite>("Assets/Icons/texBuffHeadHunter.png");
				ZetSapped = Assets.LoadAsset<Sprite>("Assets/Icons/texBuffSapped.png");
				ZetShredded = Assets.LoadAsset<Sprite>("Assets/Icons/texBuffShredded.png");
				ZetPoached = Assets.LoadAsset<Sprite>("Assets/Icons/texBuffPoached.png");
			}
		}

		public static class Prefabs
		{
			public static GameObject AffixVoid;

			public static GameObject AffixSepia;

			public static GameObject AffixPure;

			public static void Load()
			{
				AffixVoid = Assets.LoadAsset<GameObject>("Assets/Prefabs/prefabAffixVoid.prefab");
				if (Bubbet.Enabled)
				{
					AffixSepia = Assets.LoadAsset<GameObject>("Assets/Prefabs/prefabAffixSepia.prefab");
				}
				if (Thalasso.Enabled)
				{
					AffixPure = Assets.LoadAsset<GameObject>("Assets/Prefabs/prefabAffixPure.prefab");
				}
			}
		}

		public static class Buff
		{
			public static BuffDef ZetHeadHunter;

			public static BuffDef ZetSapped;

			public static BuffDef ZetShredded;

			public static BuffDef ZetPoached;

			public static BuffDef ZetSepiaBlind;

			public static BuffDef ZetElusive;

			public static BuffDef ZetWarped;

			public static BuffDef ZetEchoPrimer;

			public static BuffDef BackupDebuff;

			public static BuffDef NightSpeed;

			public static BuffDef NightBlind;

			public static BuffDef SandBlind;

			public static BuffDef AffixWhite;

			public static BuffDef AffixBlue;

			public static BuffDef AffixRed;

			public static BuffDef AffixHaunted;

			public static BuffDef AffixPoison;

			public static BuffDef AffixLunar;

			public static BuffDef AffixEarth;

			public static BuffDef AffixVoid;

			public static BuffDef AffixPlated;

			public static BuffDef AffixWarped;

			public static BuffDef AffixVeiled;

			public static BuffDef AffixAragonite;

			public static BuffDef AffixGold;

			public static BuffDef AffixSanguine;

			public static BuffDef AffixSepia;

			public static BuffDef AffixNullifier;

			public static BuffDef AffixBlighted;

			public static BuffDef AffixBackup;

			public static BuffDef AffixPurity;

			public static BuffDef AffixBarrier;

			public static BuffDef AffixBlackHole;

			public static BuffDef AffixMoney;

			public static BuffDef AffixNight;

			public static BuffDef AffixWater;

			public static BuffDef AffixRealgar;

			public static BuffDef AffixBuffered;

			public static BuffDef AffixOppressive;

			public static BuffDef AffixEmpowering;

			public static BuffDef AffixFrenzied;

			public static BuffDef AffixVolatile;

			public static BuffDef AffixEcho;

			public static BuffDef AffixArmored;

			public static BuffDef AffixBuffing;

			public static BuffDef AffixImpPlane;

			public static BuffDef AffixPillaging;

			public static BuffDef AffixSandstorm;

			public static BuffDef AffixTinkerer;

			public static BuffDef AffixAdaptive;

			public static BuffDef AffixMotivator;

			public static BuffDef AffixOsmium;
		}

		public static class Equip
		{
			public static EquipmentDef AffixWhite;

			public static EquipmentDef AffixBlue;

			public static EquipmentDef AffixRed;

			public static EquipmentDef AffixHaunted;

			public static EquipmentDef AffixPoison;

			public static EquipmentDef AffixLunar;

			public static EquipmentDef AffixEarth;

			public static EquipmentDef AffixVoid;

			public static EquipmentDef AffixPlated;

			public static EquipmentDef AffixWarped;

			public static EquipmentDef AffixVeiled;

			public static EquipmentDef AffixAragonite;

			public static EquipmentDef AffixGold;

			public static EquipmentDef AffixSanguine;

			public static EquipmentDef AffixSepia;

			public static EquipmentDef AffixNullifier;

			public static EquipmentDef AffixBlighted;

			public static EquipmentDef AffixBackup;

			public static EquipmentDef AffixPurity;

			public static EquipmentDef AffixBarrier;

			public static EquipmentDef AffixBlackHole;

			public static EquipmentDef AffixMoney;

			public static EquipmentDef AffixNight;

			public static EquipmentDef AffixWater;

			public static EquipmentDef AffixRealgar;

			public static EquipmentDef AffixBuffered;

			public static EquipmentDef AffixOppressive;

			public static EquipmentDef AffixEmpowering;

			public static EquipmentDef AffixFrenzied;

			public static EquipmentDef AffixVolatile;

			public static EquipmentDef AffixEcho;

			public static EquipmentDef AffixArmored;

			public static EquipmentDef AffixBuffing;

			public static EquipmentDef AffixImpPlane;

			public static EquipmentDef AffixPillaging;

			public static EquipmentDef AffixSandstorm;

			public static EquipmentDef AffixTinkerer;

			public static EquipmentDef AffixAdaptive;

			public static EquipmentDef AffixMotivator;

			public static EquipmentDef AffixOsmium;
		}

		public static class Item
		{
			public static ItemDef ZetAspectsDropCountTracker;

			public static ItemDef ZetAspectsUpdateInventory;

			public static ItemDef ZetAspectWhite;

			public static ItemDef ZetAspectBlue;

			public static ItemDef ZetAspectRed;

			public static ItemDef ZetAspectHaunted;

			public static ItemDef ZetAspectPoison;

			public static ItemDef ZetAspectLunar;

			public static ItemDef ZetAspectEarth;

			public static ItemDef ZetAspectVoid;

			public static ItemDef ZetAspectPlated;

			public static ItemDef ZetAspectWarped;

			public static ItemDef ZetAspectVeiled;

			public static ItemDef ZetAspectAragonite;

			public static ItemDef ZetAspectGold;

			public static ItemDef ZetAspectSanguine;

			public static ItemDef ZetAspectSepia;

			public static ItemDef ZetAspectNullifier;

			public static ItemDef ZetAspectBlighted;

			public static ItemDef ZetAspectBackup;

			public static ItemDef ZetAspectPurity;

			public static ItemDef ZetAspectBarrier;

			public static ItemDef ZetAspectBlackHole;

			public static ItemDef ZetAspectMoney;

			public static ItemDef ZetAspectNight;

			public static ItemDef ZetAspectWater;

			public static ItemDef ZetAspectRealgar;

			public static ItemDef ZetAspectBuffered;

			public static ItemDef ZetAspectOppressive;

			public static ItemDef ZetAspectEmpowering;

			public static ItemDef ZetAspectFrenzied;

			public static ItemDef ZetAspectVolatile;

			public static ItemDef ZetAspectEcho;

			public static ItemDef ZetAspectArmor;

			public static ItemDef ZetAspectBanner;

			public static ItemDef ZetAspectImpale;

			public static ItemDef ZetAspectGolden;

			public static ItemDef ZetAspectCyclone;

			public static ItemDef ZetAspectTinker;

			public static ItemDef ZetAspectAdaptive;

			public static ItemDef ZetAspectMotivator;

			public static ItemDef ZetAspectOsmium;
		}

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

			public static hook_Init <>9__96_0;

			public static hook_RebuildPickupGroups <>9__98_0;

			public static hook_Init <>9__99_0;

			public static hook_BuildStaticData <>9__100_0;

			public static hook_OnEnter <>9__101_0;

			public static hook_CanSelectItemEntry <>9__102_0;

			public static hook_CanSelectEquipmentEntry <>9__103_0;

			internal void <SetupItemTransformations>b__96_0(orig_Init orig)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				List<Pair> list = ItemCatalog.itemRelationships[ItemRelationshipTypes.ContagiousItem].ToList();
				foreach (ItemDef transformableAspectItemDef in transformableAspectItemDefs)
				{
					list.Add(new Pair
					{
						itemDef1 = transformableAspectItemDef,
						itemDef2 = Item.ZetAspectVoid
					});
					Logger.Info("Successfully added aspect transformation for " + ((Object)transformableAspectItemDef).name);
				}
				ItemCatalog.itemRelationships[ItemRelationshipTypes.ContagiousItem] = list.ToArray();
				orig.Invoke();
			}

			internal void <OnTransmuteManagerInit>b__98_0(orig_RebuildPickupGroups orig)
			{
				try
				{
					PreInitValidation();
				}
				catch (Exception data)
				{
					Logger.Error(data);
				}
				orig.Invoke();
			}

			internal void <OnRuleCatalogInit>b__99_0(orig_Init orig)
			{
				try
				{
					PreInitValidation();
				}
				catch (Exception data)
				{
					Logger.Error(data);
				}
				orig.Invoke();
			}

			internal void <OnLogBookInit>b__100_0(orig_BuildStaticData orig)
			{
				try
				{
					SetupCatalog();
				}
				catch (Exception data)
				{
					Logger.Warn("Failed To Setup Catalog!");
					Logger.Error(data);
				}
				orig.Invoke();
			}

			internal void <OnMainMenuEnter>b__101_0(orig_OnEnter orig, BaseMainMenuScreen self, MainMenuController controller)
			{
				orig.Invoke(self, controller);
				try
				{
					OnMenuEnteredFirstTime();
				}
				catch (Exception data)
				{
					Logger.Error(data);
				}
			}

			internal bool <ItemEntrySelectableHook>b__102_0(orig_CanSelectItemEntry orig, ItemDef itemDef, Dictionary<ExpansionDef, bool> expAva)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				if (Object.op_Implicit((Object)(object)itemDef) && aspectItemIndexes.Contains(itemDef.itemInde