using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using DefenseMatrixManager;
using EntityStates;
using EntityStates.Captain.Weapon;
using EntityStates.CaptainDefenseMatrixItem;
using EntityStates.CaptainSupplyDrop;
using EntityStates.Chef;
using EntityStates.Commando;
using EntityStates.Croco;
using EntityStates.Engi.EngiBubbleShield;
using EntityStates.Engi.Mine;
using EntityStates.FalseSon;
using EntityStates.Headstompers;
using EntityStates.Loader;
using EntityStates.Mage;
using EntityStates.TeleporterHealNovaController;
using EntityStates.Toolbot;
using EntityStates.VoidSurvivor;
using HG.Reflection;
using HarmonyLib;
using IL.EntityStates;
using IL.EntityStates.Bandit2.Weapon;
using IL.EntityStates.Chef;
using IL.EntityStates.Commando;
using IL.EntityStates.Croco;
using IL.EntityStates.Engi.Mine;
using IL.EntityStates.FalseSon;
using IL.EntityStates.Headstompers;
using IL.EntityStates.Loader;
using IL.EntityStates.Mage;
using IL.EntityStates.Merc;
using IL.EntityStates.Seeker;
using IL.EntityStates.TeleporterHealNovaController;
using IL.EntityStates.Toolbot;
using IL.EntityStates.Treebot.Weapon;
using IL.EntityStates.VoidSurvivor;
using IL.EntityStates.VoidSurvivor.Weapon;
using IL.RoR2;
using IL.RoR2.Items;
using IL.RoR2.Projectile;
using IL.RoR2.Skills;
using IL.RoR2.UI;
using KinematicCharacterController;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using NetworkedPrayerBeads;
using On;
using On.EntityStates;
using On.EntityStates.Captain.Weapon;
using On.EntityStates.CaptainDefenseMatrixItem;
using On.EntityStates.CaptainSupplyDrop;
using On.EntityStates.Chef;
using On.EntityStates.Commando;
using On.EntityStates.Croco;
using On.EntityStates.Engi.EngiBubbleShield;
using On.EntityStates.FalseSon;
using On.EntityStates.Headstompers;
using On.EntityStates.Mage;
using On.EntityStates.TeleporterHealNovaController;
using On.EntityStates.Toolbot;
using On.RoR2;
using On.RoR2.Items;
using On.RoR2.Orbs;
using On.RoR2.Projectile;
using R2API;
using RainstormRefinery.Difficulty;
using RainstormRefinery.Items;
using RainstormRefinery.Items.BossTier;
using RainstormRefinery.Items.CommonTier;
using RainstormRefinery.Items.LegendaryTier;
using RainstormRefinery.Items.UncommonTier;
using RainstormRefinery.Items.VoidTier;
using RainstormRefinery.Survivors;
using RainstormRefinery.Survivors.Acrid;
using RainstormRefinery.Survivors.Artificer;
using RainstormRefinery.Survivors.Bandit;
using RainstormRefinery.Survivors.Captain;
using RainstormRefinery.Survivors.Chef;
using RainstormRefinery.Survivors.Commando;
using RainstormRefinery.Survivors.Engineer;
using RainstormRefinery.Survivors.FalseSon;
using RainstormRefinery.Survivors.Huntress;
using RainstormRefinery.Survivors.Loader;
using RainstormRefinery.Survivors.Mercenary;
using RainstormRefinery.Survivors.MulT;
using RainstormRefinery.Survivors.Railgunner;
using RainstormRefinery.Survivors.Rex;
using RainstormRefinery.Survivors.Seeker;
using RainstormRefinery.Survivors.VoidFiend;
using RainstormRefinery.Utils;
using RainstormRefinery.Utils.AssetLibrary;
using RoR2;
using RoR2.Audio;
using RoR2.CharacterAI;
using RoR2.EntitlementManagement;
using RoR2.ExpansionManagement;
using RoR2.Items;
using RoR2.Navigation;
using RoR2.Orbs;
using RoR2.Projectile;
using RoR2.Skills;
using RoR2.UI;
using TMPro;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.AddressableAssets;
using UnityEngine.Audio;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.UIElements;

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

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace RainstormRefinery
{
	public static class ConfigSetup
	{
		public static ConfigFile SurvivorCfg;

		public static ConfigFile ItemCfg;

		public static ConfigFile DifficultyCfg;

		private const string commandoString = "Survivors - Commando";

		private const string huntressString = "Survivors - Huntress";

		private const string banditString = "Survivors - Bandit";

		private const string toolbotString = "Survivors - MUL-T";

		private const string engiString = "Survivors - Engineer";

		private const string mageString = "Survivors - Artificer";

		private const string mercString = "Survivors - Mercenary";

		private const string treebotString = "Survivors - REX";

		private const string loaderString = "Survivors - Loader";

		private const string crocoString = "Survivors - Acrid";

		private const string captainString = "Survivors - Captain";

		private const string railgunnerString = "Survivors - Railgunner";

		private const string viendString = "Survivors - Void Fiend";

		private const string seekerString = "Survivors - Seeker";

		private const string chefString = "Survivors - Chef";

		private const string falseSonString = "Survivors - False Son";

		private const string commonString = "Items - Common";

		private const string uncommonString = "Items - Uncommon";

		private const string legendaryString = "Items - Legendary";

		private const string voidString = "Items - Void";

		private const string difficultyString = "Base Difficulty";

		public static string ConfigFolderPath => Path.Combine(Paths.ConfigPath, RainstormRefinery.pluginInfo.Metadata.GUID);

		public static void Init()
		{
			SetupConfigSurvivors();
			SetupConfigItems();
			SetupConfigDifficulty();
		}

		private static void SetupConfigSurvivors()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			SurvivorCfg = new ConfigFile(Path.Combine(ConfigFolderPath, "RainstormRefinery_Survivors.cfg"), true);
			ConfigCommando();
			ConfigHuntress();
			ConfigBandit();
			ConfigMULT();
			ConfigEngi();
			ConfigArtificer();
			ConfigMercenary();
			ConfigRex();
			ConfigLoader();
			ConfigAcrid();
			ConfigCaptain();
			ConfigRailgunner();
			ConfigViend();
			ConfigSeeker();
			ConfigChef();
			ConfigFalseSon();
		}

		private static void ConfigCommando()
		{
			MagneticGrenade.enabled = SurvivorCfg.Bind<bool>("Survivors - Commando", "Frag Grenade -> Magnetic Grenade", true, "Sticks to enemies.").Value;
		}

		private static void ConfigHuntress()
		{
		}

		private static void ConfigBandit()
		{
			BanditRefined.enabledSecondaries = SurvivorCfg.Bind<bool>("Survivors - Bandit", "Serrated Dagger/Shiv", true, "Various tweaks including having multiple variants of hemorrhage.").Value;
		}

		private static void ConfigMULT()
		{
			PowerMode.enabled = SurvivorCfg.Bind<bool>("Survivors - MUL-T", "Power Mode", true, "Power Mode has a limited duration and increased cooldown.").Value;
		}

		private static void ConfigEngi()
		{
			BubbleShield.enabled = SurvivorCfg.Bind<bool>("Survivors - Engineer", "Bubble Shield", true, "Bubble Shield received several adjustments to make it more flexible.").Value;
		}

		private static void ConfigArtificer()
		{
			IonSurge.changeToUtility = SurvivorCfg.Bind<bool>("Survivors - Artificer", "Ion Surge - Utility", true, "Ion Surge moved to a utility skill.").Value;
			IonSurge.enabled = SurvivorCfg.Bind<bool>("Survivors - Artificer", "Ion Surge - Hit and Run", true, "Ion Surge made to fit a hit and run playstyle, has a short cooldown but only recharges on the ground.").Value;
		}

		private static void ConfigMercenary()
		{
		}

		private static void ConfigRex()
		{
			RexRefined.enableHealthCosts = SurvivorCfg.Bind<bool>("Survivors - REX", "Plant Skills", true, "Skills with a health cost have slightly reduced costs, but ignore armor and block chance. However, they also are unaffected by E8 permanent damage.").Value;
		}

		private static void ConfigLoader()
		{
			GrappleFist.enabled = SurvivorCfg.Bind<bool>("Survivors - Loader", "Spiked Fist", true, "Physics of the alt grapple are reworked.").Value;
		}

		private static void ConfigAcrid()
		{
		}

		private static void ConfigCaptain()
		{
		}

		private static void ConfigRailgunner()
		{
		}

		private static void ConfigViend()
		{
			CorruptionRework.enabled = SurvivorCfg.Bind<bool>("Survivors - Void Fiend", "Corruption rework", true, "Corruption is no longer affected by damage, healing, or crits, and has modified interactions with void items.").Value;
			Suppress.enableCooldown = SurvivorCfg.Bind<bool>("Survivors - Void Fiend", "Suppress Cooldown", true, "Both forms of Suppress now have a cooldown, but Corrupted Suppress no longer has limited uses.").Value;
		}

		private static void ConfigSeeker()
		{
			SeekerRevive.enabled = SurvivorCfg.Bind<bool>("Survivors - Seeker", "Saving Grace", true, "Major nerfs to Seeker's revive to make it more limited in use.").Value;
		}

		private static void ConfigChef()
		{
			RollingPin.enabled = SurvivorCfg.Bind<bool>("Survivors - Chef", "Rolling Pin", true, "Major changes to rolling pin and entirely reworked boosted version to be synergistic with the rest of CHEF's kit.").Value;
		}

		private static void ConfigFalseSon()
		{
		}

		private static void SetupConfigItems()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			ItemCfg = new ConfigFile(Path.Combine(ConfigFolderPath, "RainstormRefinery_Items.cfg"), true);
			ConfigCommonItems();
			ConfigUncommonItems();
			ConfigLegendaryItems();
			ConfigVoidItems();
		}

		private static void ConfigCommonItems()
		{
			Fireworks.enabled = ItemCfg.Bind<bool>("Items - Common", "Fireworks", true, "Fireworks ignite enemies.").Value;
			RollOfPennies.enabled = ItemCfg.Bind<bool>("Items - Common", "Roll of Pennies", true, "Reworked gold calculations and now grants armor based on recently collected gold.").Value;
			StunGrenade.enabled = ItemCfg.Bind<bool>("Items - Common", "Stun Grenade", true, "Deals damage on proc.").Value;
			WarBanner.enabled = ItemCfg.Bind<bool>("Items - Common", "Warbanner", true, "Completely reworked to trigger upon entering combat.").Value;
		}

		private static void ConfigUncommonItems()
		{
			Bandolier.enabled = ItemCfg.Bind<bool>("Items - Uncommon", "Bandolier", true, "Can overstock skills.").Value;
			BreachingFin.enabled = ItemCfg.Bind<bool>("Items - Uncommon", "Breaching Fin", true, "Reworked to be a chance on hit.").Value;
			ConsumableInfusion.enabled = ItemCfg.Bind<bool>("Items - Uncommon", "Infusion", true, "Item is consumed when maxed out to grant bonus regen.").Value;
			DeathMark.enabled = ItemCfg.Bind<bool>("Items - Uncommon", "Death Mark", true, "Debuff strength reduced but grants a passive damage increase per afflicted debuff.").Value;
			HarvestersScythe.enabled = ItemCfg.Bind<bool>("Items - Uncommon", "Harvesters Scythe", true, "Heals a percentage of damage dealt.").Value;
			HuntersHarpoon.enabled = ItemCfg.Bind<bool>("Items - Uncommon", "Hunters Harpoon", true, "Duration can be extended like in Returns.").Value;
			LeechingSeed.enabled = ItemCfg.Bind<bool>("Items - Uncommon", "Leeching Seed", true, "Doubled healing and partially unaffected by proc coefficient.").Value;
			Stealthkit.enabled = ItemCfg.Bind<bool>("Items - Uncommon", "Old War Stealthkit", true, "Reworked to have a chance to trigger when hurt.").Value;
			UnstableTransmitter.enabled = ItemCfg.Bind<bool>("Items - Uncommon", "Unstable Transmitter", true, "Returned to being a cooldown.").Value;
		}

		private static void ConfigLegendaryItems()
		{
			DiosBestFriend.enabled = ItemCfg.Bind<bool>("Items - Legendary", "Dios Best Friend", true, "Drops 3 common items upon reviving a player.").Value;
			FrostRelic.enabled = ItemCfg.Bind<bool>("Items - Legendary", "Frost Relic", true, "Reduced damage but inflicts the Frost debuff.").Value;
			FrostRelic.disableCamera = ItemCfg.Bind<bool>("Items - Legendary", "Frost Relic - Disable Camera Change", true, "Disable the zoomout that occurs while Frost Relic is active.").Value;
			PocketICBM.enabled = ItemCfg.Bind<bool>("Items - Legendary", "Pocket ICBM", true, "Reworked stacking behavior, now fires missiles while in combat.").Value;
			SpareDroneParts.doBlacklist = ItemCfg.Bind<bool>("Items - Legendary", "Spare Drone Parts", true, "No longer affects all mechanical allies, just drones.").Value;
			HappiestMaskYellow.changeToYellow = ItemCfg.Bind<bool>("Items - Legendary", "Happiest Mask", true, "Make this a yellow item that drops from Hordes of Many.").Value;
		}

		private static void ConfigVoidItems()
		{
			BenthicBloom.enabled = ItemCfg.Bind<bool>("Items - Void", "Benthic Bloom", true, "Converts individual items at consistent rates.").Value;
			VoidGlasses.enabled = ItemCfg.Bind<bool>("Items - Void", "Lost Seers Lenses", true, "Deals damage on proc with reworked execute mechanics.").Value;
		}

		private static void SetupConfigDifficulty()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			DifficultyCfg = new ConfigFile(Path.Combine(ConfigFolderPath, "RainstormRefinery_Difficulty.cfg"), true);
			GoldScaling.enabled = DifficultyCfg.Bind<bool>("Base Difficulty", "Reduced Gold Scaling", true, "Gold drops from enemies slightly increased at base, but drastically fall off as the run goes on to make up for the fact that more enemies are spawning.").Value;
		}
	}
	internal static class Log
	{
		private static ManualLogSource _logSource;

		internal static void Init(ManualLogSource logSource)
		{
			_logSource = logSource;
		}

		internal static void Debug(object data)
		{
			_logSource.LogDebug(data);
		}

		internal static void Error(object data)
		{
			_logSource.LogError(data);
		}

		internal static void Fatal(object data)
		{
			_logSource.LogFatal(data);
		}

		internal static void Info(object data)
		{
			_logSource.LogInfo(data);
		}

		internal static void Message(object data)
		{
			_logSource.LogMessage(data);
		}

		internal static void Warning(object data)
		{
			_logSource.LogWarning(data);
		}
	}
	internal class ModAssets
	{
		public static AssetBundle mainBundle;

		public const string bundleName = "RainstormRefinery.mainAssetBundle";

		public static void Init()
		{
			using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("RainstormRefinery.mainAssetBundle");
			mainBundle = AssetBundle.LoadFromStream(stream);
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("OblivionAXiS.RainstormRefinery", "RainstormRefinery", "1.0.1")]
	public class RainstormRefinery : BaseUnityPlugin
	{
		public const string PluginGUID = "OblivionAXiS.RainstormRefinery";

		public const string PluginAuthor = "OblivionAXiS";

		public const string PluginName = "RainstormRefinery";

		public const string PluginVersion = "1.0.1";

		public static PluginInfo pluginInfo;

		public void Awake()
		{
			Log.Init(((BaseUnityPlugin)this).Logger);
			ModAssets.Init();
			pluginInfo = ((BaseUnityPlugin)this).Info;
			ConfigSetup.Init();
			new SurvivorsRefined();
			new ItemsRefined();
			new DifficultyController();
			SharedHooks.Setup();
		}
	}
}
namespace RainstormRefinery.Utils
{
	public class SharedHooks
	{
		public delegate void Handle_GetStatCoefficients(CharacterBody sender, StatHookEventArgs args, Inventory inventory);

		public delegate void Handle_GlobalKillEvent(DamageReport damageReport);

		public delegate void Handle_GlobalDamageEvent(DamageReport damageReport);

		public delegate void Handle_GlobalHitEvent(CharacterBody victim, CharacterBody attacker, DamageInfo damageInfo);

		public delegate void Handle_CharacterMaster_OnBodyDeath(CharacterMaster master, CharacterBody body);

		public delegate void Handle_GlobalInventoryChangedEvent(CharacterBody self);

		public delegate void Handle_PreTakeDamageProcessEvent(HealthComponent self, ref DamageInfo damageInfo);

		public delegate void Handle_PostTakeDamageProcessEvent(HealthComponent self, DamageInfo damageInfo, CharacterBody? attackerBody);

		public delegate void Handle_AddRefreshBuffStackBuffs(ILContext il);

		[CompilerGenerated]
		private static class <>O
		{
			public static StatHookEventHandler <0>__GetStatCoefficients;

			public static Action<DamageReport> <1>__GlobalEventManager_onCharacterDeathGlobal;

			public static Action<DamageReport> <2>__GlobalEventManager_DamageDealt;

			public static hook_OnHitEnemy <3>__GlobalEventManager_HitEnemy;

			public static Action<CharacterBody> <4>__GlobalEventManager_OnInventoryChanged;

			public static hook_OnBodyDeath <5>__CharacterMaster_OnBodyDeath;

			public static hook_TakeDamageProcess <6>__HealthComponent_PreTakeDamageProcess;

			public static hook_TakeDamageProcess <7>__HealthComponent_PostTakeDamageProcess;

			public static Manipulator <8>__CharacterBody_AddTimedBuff_BuffDef_float;
		}

		public static Handle_GetStatCoefficients Handle_GetStatCoefficients_Actions;

		public static Handle_GlobalKillEvent Handle_GlobalKillEvent_Actions;

		public static Handle_GlobalDamageEvent Handle_GlobalDamageEvent_Actions;

		public static Handle_GlobalHitEvent Handle_GlobalHitEvent_Actions;

		public static Handle_CharacterMaster_OnBodyDeath Handle_CharacterMaster_OnBodyDeath_Actions;

		public static Handle_GlobalInventoryChangedEvent Handle_GlobalInventoryChangedEvent_Actions;

		public static Handle_PreTakeDamageProcessEvent Handle_PreTakeDamageProcess_Actions;

		public static Handle_PostTakeDamageProcessEvent Handle_PostTakeDamageProcess_Actions;

		public static List<BuffDef> List_AddRefreshBuffStackBuffs = new List<BuffDef>();

		public static void Setup()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Expected O, but got Unknown
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Expected O, but got Unknown
			if (Handle_GetStatCoefficients_Actions != null)
			{
				object obj = <>O.<0>__GetStatCoefficients;
				if (obj == null)
				{
					StatHookEventHandler val = GetStatCoefficients;
					<>O.<0>__GetStatCoefficients = val;
					obj = (object)val;
				}
				RecalculateStatsAPI.GetStatCoefficients += (StatHookEventHandler)obj;
			}
			if (Handle_GlobalKillEvent_Actions != null)
			{
				GlobalEventManager.onCharacterDeathGlobal += GlobalEventManager_onCharacterDeathGlobal;
			}
			if (Handle_GlobalDamageEvent_Actions != null)
			{
				GlobalEventManager.onServerDamageDealt += GlobalEventManager_DamageDealt;
			}
			if (Handle_GlobalHitEvent_Actions != null)
			{
				object obj2 = <>O.<3>__GlobalEventManager_HitEnemy;
				if (obj2 == null)
				{
					hook_OnHitEnemy val2 = GlobalEventManager_HitEnemy;
					<>O.<3>__GlobalEventManager_HitEnemy = val2;
					obj2 = (object)val2;
				}
				GlobalEventManager.OnHitEnemy += (hook_OnHitEnemy)obj2;
			}
			if (Handle_GlobalInventoryChangedEvent_Actions != null)
			{
				CharacterBody.onBodyInventoryChangedGlobal += GlobalEventManager_OnInventoryChanged;
			}
			if (Handle_CharacterMaster_OnBodyDeath_Actions != null)
			{
				object obj3 = <>O.<5>__CharacterMaster_OnBodyDeath;
				if (obj3 == null)
				{
					hook_OnBodyDeath val3 = CharacterMaster_OnBodyDeath;
					<>O.<5>__CharacterMaster_OnBodyDeath = val3;
					obj3 = (object)val3;
				}
				CharacterMaster.OnBodyDeath += (hook_OnBodyDeath)obj3;
			}
			if (Handle_PreTakeDamageProcess_Actions != null)
			{
				object obj4 = <>O.<6>__HealthComponent_PreTakeDamageProcess;
				if (obj4 == null)
				{
					hook_TakeDamageProcess val4 = HealthComponent_PreTakeDamageProcess;
					<>O.<6>__HealthComponent_PreTakeDamageProcess = val4;
					obj4 = (object)val4;
				}
				HealthComponent.TakeDamageProcess += (hook_TakeDamageProcess)obj4;
			}
			if (Handle_PostTakeDamageProcess_Actions != null)
			{
				object obj5 = <>O.<7>__HealthComponent_PostTakeDamageProcess;
				if (obj5 == null)
				{
					hook_TakeDamageProcess val5 = HealthComponent_PostTakeDamageProcess;
					<>O.<7>__HealthComponent_PostTakeDamageProcess = val5;
					obj5 = (object)val5;
				}
				HealthComponent.TakeDamageProcess += (hook_TakeDamageProcess)obj5;
			}
			if (List_AddRefreshBuffStackBuffs.Count > 0)
			{
				object obj6 = <>O.<8>__CharacterBody_AddTimedBuff_BuffDef_float;
				if (obj6 == null)
				{
					Manipulator val6 = CharacterBody_AddTimedBuff_BuffDef_float;
					<>O.<8>__CharacterBody_AddTimedBuff_BuffDef_float = val6;
					obj6 = (object)val6;
				}
				CharacterBody.AddTimedBuff_BuffDef_float += (Manipulator)obj6;
			}
		}

		internal static void GetStatCoefficients(CharacterBody sender, StatHookEventArgs args)
		{
			if (Object.op_Implicit((Object)(object)sender.inventory))
			{
				Handle_GetStatCoefficients_Actions(sender, args, sender.inventory);
			}
		}

		internal static void GlobalEventManager_onCharacterDeathGlobal(DamageReport damageReport)
		{
			if (NetworkServer.active && Object.op_Implicit((Object)(object)damageReport.attacker) && Object.op_Implicit((Object)(object)damageReport.attackerBody))
			{
				Handle_GlobalKillEvent_Actions(damageReport);
			}
		}

		internal static void GlobalEventManager_DamageDealt(DamageReport damageReport)
		{
			if (NetworkServer.active && Object.op_Implicit((Object)(object)damageReport.attacker) && Object.op_Implicit((Object)(object)damageReport.attackerBody))
			{
				Handle_GlobalDamageEvent_Actions(damageReport);
			}
		}

		internal static void GlobalEventManager_HitEnemy(orig_OnHitEnemy orig, GlobalEventManager self, DamageInfo damageInfo, GameObject victim)
		{
			orig.Invoke(self, damageInfo, victim);
			if (NetworkServer.active && Object.op_Implicit((Object)(object)victim) && Object.op_Implicit((Object)(object)damageInfo.attacker))
			{
				CharacterBody component = damageInfo.attacker.GetComponent<CharacterBody>();
				CharacterBody component2 = victim.GetComponent<CharacterBody>();
				if (Object.op_Implicit((Object)(object)component) && Object.op_Implicit((Object)(object)component2))
				{
					Handle_GlobalHitEvent_Actions(component2, component, damageInfo);
				}
			}
		}

		internal static void CharacterMaster_OnBodyDeath(orig_OnBodyDeath orig, CharacterMaster self, CharacterBody body)
		{
			orig.Invoke(self, body);
			if (NetworkServer.active)
			{
				Handle_CharacterMaster_OnBodyDeath_Actions(self, body);
			}
		}

		internal static void GlobalEventManager_OnInventoryChanged(CharacterBody self)
		{
			if (NetworkServer.active)
			{
				Handle_GlobalInventoryChangedEvent_Actions(self);
			}
		}

		internal static void HealthComponent_PreTakeDamageProcess(orig_TakeDamageProcess orig, HealthComponent self, DamageInfo damageInfo)
		{
			if (NetworkServer.active)
			{
				Handle_PreTakeDamageProcess_Actions(self, ref damageInfo);
			}
			orig.Invoke(self, damageInfo);
		}

		internal static void HealthComponent_PostTakeDamageProcess(orig_TakeDamageProcess orig, HealthComponent self, DamageInfo damageInfo)
		{
			orig.Invoke(self, damageInfo);
			if (NetworkServer.active && !self.body.HasBuff(Buffs.HiddenRejectAllDamage) && !damageInfo.rejected && self.alive && !self.godMode && !(self.ospTimer > 0f))
			{
				CharacterBody attackerBody = null;
				if (Object.op_Implicit((Object)(object)damageInfo.attacker))
				{
					attackerBody = damageInfo.attacker.GetComponent<CharacterBody>();
				}
				Handle_PostTakeDamageProcess_Actions(self, damageInfo, attackerBody);
			}
		}

		internal static void CharacterBody_AddTimedBuff_BuffDef_float(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			ILCursor val = new ILCursor(il);
			if (!val.TryGotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, typeof(Buffs).GetField("Overheat"))
			}))
			{
				Debug.LogError((object)"RainstormRefinery.Utils.SharedHooks: Handle_AddRefreshBuffStackBuffs hook failed");
				return;
			}
			int index = val.Index;
			val.Index = index + 1;
			val.EmitDelegate<Func<BuffDef, BuffDef, bool>>((Func<BuffDef, BuffDef, bool>)((BuffDef buffDef, BuffDef overheatDef) => List_AddRefreshBuffStackBuffs.Contains(buffDef) || (Object)(object)buffDef == (Object)(object)overheatDef));
			val.Remove();
		}
	}
	internal class SneedUtils
	{
		public static bool SetEntityStateField(string entityStateName, string fieldName, GameObject newObject)
		{
			EntityStateConfiguration val = LegacyResourcesAPI.Load<EntityStateConfiguration>("entitystateconfigurations/" + entityStateName);
			for (int i = 0; i < val.serializedFieldsCollection.serializedFields.Length; i++)
			{
				if (val.serializedFieldsCollection.serializedFields[i].fieldName == fieldName)
				{
					val.serializedFieldsCollection.serializedFields[i].fieldValue.objectValue = (Object)(object)newObject;
					return true;
				}
			}
			return false;
		}

		public static bool SetAddressableEntityStateField(string fullEntityStatePath, string fieldName, string value)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			EntityStateConfiguration val = Addressables.LoadAssetAsync<EntityStateConfiguration>((object)fullEntityStatePath).WaitForCompletion();
			for (int i = 0; i < val.serializedFieldsCollection.serializedFields.Length; i++)
			{
				if (val.serializedFieldsCollection.serializedFields[i].fieldName == fieldName)
				{
					val.serializedFieldsCollection.serializedFields[i].fieldValue.stringValue = value;
					return true;
				}
			}
			return false;
		}

		public static bool GetKeyPressed(ConfigEntry<KeyboardShortcut> entry)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			KeyboardShortcut value = entry.Value;
			foreach (KeyCode modifier in ((KeyboardShortcut)(ref value)).Modifiers)
			{
				if (!Input.GetKey(modifier))
				{
					return false;
				}
			}
			value = entry.Value;
			return Input.GetKeyDown(((KeyboardShortcut)(ref value)).MainKey);
		}

		public static BuffDef CreateBuffDef(string name, bool canStack, bool isCooldown, bool isDebuff, bool isBuff, Color color, Sprite iconSprite, bool isHidden = false)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			BuffDef val = ScriptableObject.CreateInstance<BuffDef>();
			((Object)val).name = name;
			val.canStack = canStack;
			val.isCooldown = isCooldown;
			val.isDebuff = isDebuff;
			val.ignoreGrowthNectar = !isBuff;
			val.buffColor = color;
			val.iconSprite = iconSprite;
			val.isHidden = isHidden;
			ContentAddition.AddBuffDef(val);
			((Object)val).name = ((Object)val).name;
			return val;
		}

		public static void DumpEntityStateConfig(EntityStateConfiguration esc)
		{
			for (int i = 0; i < esc.serializedFieldsCollection.serializedFields.Length; i++)
			{
				if (Object.op_Implicit(esc.serializedFieldsCollection.serializedFields[i].fieldValue.objectValue))
				{
					Debug.Log((object)(esc.serializedFieldsCollection.serializedFields[i].fieldName + " - " + (object)esc.serializedFieldsCollection.serializedFields[i].fieldValue.objectValue));
				}
				else
				{
					Debug.Log((object)(esc.serializedFieldsCollection.serializedFields[i].fieldName + " - " + esc.serializedFieldsCollection.serializedFields[i].fieldValue.stringValue));
				}
			}
		}

		public static void DumpEntityStateConfig(string entityStateName)
		{
			EntityStateConfiguration esc = LegacyResourcesAPI.Load<EntityStateConfiguration>("entitystateconfigurations/" + entityStateName);
			DumpEntityStateConfig(esc);
		}

		public static void DumpAddressableEntityStateConfig(string addressablePath)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			EntityStateConfiguration esc = Addressables.LoadAssetAsync<EntityStateConfiguration>((object)addressablePath).WaitForCompletion();
			DumpEntityStateConfig(esc);
		}

		public static void RemoveItemTag(ItemDef itemDef, ItemTag tag)
		{
			//IL_0002: 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)
			if (itemDef.ContainsTag(tag))
			{
				List<ItemTag> list = itemDef.tags.ToList();
				list.Remove(tag);
				itemDef.tags = list.ToArray();
			}
			else
			{
				Log.Warning("RainstormRefinery: failed to remove item tag from " + itemDef.nameToken + "; tag not present");
			}
		}

		public static void AddItemTag(ItemDef itemDef, ItemTag tag)
		{
			//IL_0002: 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)
			if (!itemDef.ContainsTag(tag))
			{
				List<ItemTag> list = itemDef.tags.ToList();
				list.Add(tag);
				itemDef.tags = list.ToArray();
			}
			else
			{
				Log.Warning("RainstormRefinery: failed to add item tag to " + itemDef.nameToken + "; tag already present");
			}
		}
	}
}
namespace RainstormRefinery.Utils.AssetLibrary
{
	public static class AssetCollection
	{
		public static AssetCollection CalmWaterShadersCollection => Addressables.LoadAssetAsync<AssetCollection>((object)"Calm Water/CalmWaterShadersCollection.asset").WaitForCompletion();

		public static AssetCollection DecaliciousShadersCollection => Addressables.LoadAssetAsync<AssetCollection>((object)"Decalicious/DecaliciousShadersCollection.asset").WaitForCompletion();

		public static AssetCollection TranslucentImageShadersCollection => Addressables.LoadAssetAsync<AssetCollection>((object)"TranslucentImage/TranslucentImageShadersCollection.asset").WaitForCompletion();

		public static AssetCollection CustomPostProcessShaders => Addressables.LoadAssetAsync<AssetCollection>((object)"RoR2/Base/Shaders/CustomPostProcessShaders.asset").WaitForCompletion();

		public static AssetCollection DeferredShaders => Addressables.LoadAssetAsync<AssetCollection>((object)"RoR2/Base/Shaders/DeferredShaders.asset").WaitForCompletion();

		public static AssetCollection EnvironmentShaders => Addressables.LoadAssetAsync<AssetCollection>((object)"RoR2/Base/Shaders/EnvironmentShaders.asset").WaitForCompletion();

		public static AssetCollection FXShaders => Addressables.LoadAssetAsync<AssetCollection>((object)"RoR2/Base/Shaders/FXShaders.asset").WaitForCompletion();

		public static AssetCollection PostProcesShaders => Addressables.LoadAssetAsync<AssetCollection>((object)"RoR2/Base/Shaders/PostProcesShaders.asset").WaitForCompletion();

		public static AssetCollection ShadersCollection => Addressables.LoadAssetAsync<AssetCollection>((object)"RoR2/Base/Shaders/ShadersCollection.asset").WaitForCompletion();

		public static AssetCollection SpeedtreeOverrideShaders => Addressables.LoadAssetAsync<AssetCollection>((object)"RoR2/Base/Shaders/SpeedtreeOverrideShaders.asset").WaitForCompletion();

		public static AssetCollection UIShaders => Addressables.LoadAssetAsync<AssetCollection>((object)"RoR2/Base/Shaders/UIShaders.asset").WaitForCompletion();
	}
	public static class Material
	{
		public static Material Blue => Addressables.LoadAssetAsync<Material>((object)"Calm Water/Blue.mat").WaitForCompletion();

		public static Material Caustics => Addressables.LoadAssetAsync<Material>((object)"Calm Water/Caustics.mat").WaitForCompletion();

		public static Material Green => Addressables.LoadAssetAsync<Material>((object)"Calm Water/Green.mat").WaitForCompletion();

		public static Material Ground => Addressables.LoadAssetAsync<Material>((object)"Calm Water/Ground.mat").WaitForCompletion();

		public static Material IslandClassic => Addressables.LoadAssetAsync<Material>((object)"Calm Water/Island - Classic.mat").WaitForCompletion();

		public static Material PondClassic => Addressables.LoadAssetAsync<Material>((object)"Calm Water/Pond - Classic.mat").WaitForCompletion();

		public static Material PondDX11 => Addressables.LoadAssetAsync<Material>((object)"Calm Water/Pond - DX11.mat").WaitForCompletion();

		public static Material PondSwampDX11 => Addressables.LoadAssetAsync<Material>((object)"Calm Water/PondSwamp - DX11.mat").WaitForCompletion();

		public static Material Red => Addressables.LoadAssetAsync<Material>((object)"Calm Water/Red.mat").WaitForCompletion();

		public static Material matWaterTest => Addressables.LoadAssetAsync<Material>((object)"Calm Water/matWaterTest.mat").WaitForCompletion();

		public static Material DefaultTranslucent => Addressables.LoadAssetAsync<Material>((object)"TranslucentImage/Default-Translucent.mat").WaitForCompletion();

		public static Material matArtifactCompoundCircle => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/ArtifactCompounds/matArtifactCompoundCircle.mat").WaitForCompletion();

		public static Material matArtifactCompoundDiamond => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/ArtifactCompounds/matArtifactCompoundDiamond.mat").WaitForCompletion();

		public static Material matArtifactCompoundFrame => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/ArtifactCompounds/matArtifactCompoundFrame.mat").WaitForCompletion();

		public static Material matArtifactCompoundSquare => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/ArtifactCompounds/matArtifactCompoundSquare.mat").WaitForCompletion();

		public static Material matArtifactCompoundTriangle => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/ArtifactCompounds/matArtifactCompoundTriangle.mat").WaitForCompletion();

		public static Material matArtifactScavScar => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/ArtifactCompounds/matArtifactScavScar.mat").WaitForCompletion();

		public static Material matArtifactEnigmaGlow => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Enigma/matArtifactEnigmaGlow.mat").WaitForCompletion();

		public static Material matWispSoul => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/WispOnDeath/matWispSoul.mat").WaitForCompletion();

		public static Material matWispSoulFire => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/WispOnDeath/matWispSoulFire.mat").WaitForCompletion();

		public static Material matAltarSkeleton => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/AltarSkeleton/matAltarSkeleton.mat").WaitForCompletion();

		public static Material matAltarSkeletonGlow => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/AltarSkeleton/matAltarSkeletonGlow.mat").WaitForCompletion();

		public static Material matBandit2Knife => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2Knife.mat").WaitForCompletion();

		public static Material matBandit2Revolver => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2Revolver.mat").WaitForCompletion();

		public static Material matBandit2Shotgun => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2Shotgun.mat").WaitForCompletion();

		public static Material matBandit2ShotgunAlt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2ShotgunAlt.mat").WaitForCompletion();

		public static Material matBandit => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit.mat").WaitForCompletion();

		public static Material matBandit2 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2.mat").WaitForCompletion();

		public static Material matBandit2Coat => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2Coat.mat").WaitForCompletion();

		public static Material matBandit2AltColossus => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2AltColossus.mat").WaitForCompletion();

		public static Material matBandit2AltColossusWeapons => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2AltColossusWeapons.mat").WaitForCompletion();

		public static Material matBandit2Alt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2Alt.mat").WaitForCompletion();

		public static Material matBandit2CoatAlt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2CoatAlt.mat").WaitForCompletion();

		public static Material matBackstabIndicatorParticle => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBackstabIndicatorParticle.mat").WaitForCompletion();

		public static Material matBandit2Explosion => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2Explosion.mat").WaitForCompletion();

		public static Material matBandit2Hitspark => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2Hitspark.mat").WaitForCompletion();

		public static Material matBandit2HitsparkBackstab => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2HitsparkBackstab.mat").WaitForCompletion();

		public static Material matBandit2PistolSpin => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2PistolSpin.mat").WaitForCompletion();

		public static Material matBandit2Ring => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2Ring.mat").WaitForCompletion();

		public static Material matBandit2Shell => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2Shell.mat").WaitForCompletion();

		public static Material matBandit2Skull => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2Skull.mat").WaitForCompletion();

		public static Material matBandit2SlashBlade => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2SlashBlade.mat").WaitForCompletion();

		public static Material matBandit2SmokebombDonut => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2SmokebombDonut.mat").WaitForCompletion();

		public static Material matBandit2SmokebombSphere => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2SmokebombSphere.mat").WaitForCompletion();

		public static Material matBandit2Splatter1 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2Splatter1.mat").WaitForCompletion();

		public static Material matBandit2SplatterBillboard => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2SplatterBillboard.mat").WaitForCompletion();

		public static Material matBandit2SplatterBillboardAlt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2SplatterBillboardAlt.mat").WaitForCompletion();

		public static Material matBandit2SplatterDirectional => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2SplatterDirectional.mat").WaitForCompletion();

		public static Material matBandit2SplatterDirectionalAlt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2SplatterDirectionalAlt.mat").WaitForCompletion();

		public static Material matBandit2SplatterOpaqueTrail => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2SplatterOpaqueTrail.mat").WaitForCompletion();

		public static Material matBandit2SplatterOpaqueTrailAlt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2SplatterOpaqueTrailAlt.mat").WaitForCompletion();

		public static Material matBandit2TracerTrail => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matBandit2TracerTrail.mat").WaitForCompletion();

		public static Material matDestealth => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matDestealth.mat").WaitForCompletion();

		public static Material matOmniExplosion1Bandit => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matOmniExplosion1Bandit.mat").WaitForCompletion();

		public static Material matOmniHitspark2Bandit => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matOmniHitspark2Bandit.mat").WaitForCompletion();

		public static Material matOmniHitspark2BanditAlt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bandit2/matOmniHitspark2BanditAlt.mat").WaitForCompletion();

		public static Material matBeetle => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Beetle/matBeetle.mat").WaitForCompletion();

		public static Material matBeetleopt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Beetle/matBeetle_opt.mat").WaitForCompletion();

		public static Material matSulfurBeetle => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Beetle/matSulfurBeetle.mat").WaitForCompletion();

		public static Material matBeetleGuard => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleGuard/matBeetleGuard.mat").WaitForCompletion();

		public static Material matBeetleGuardTrail => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleGuard/matBeetleGuardTrail.mat").WaitForCompletion();

		public static Material matAuraPulse => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleGuard/matAuraPulse.mat").WaitForCompletion();

		public static Material matAuraPulseBeetleGuardopt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleGuard/matAuraPulse_BeetleGuard_opt.mat").WaitForCompletion();

		public static Material matBeetleGuardCharge => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleGuard/matBeetleGuardCharge.mat").WaitForCompletion();

		public static Material matDefenseUpShield => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleGuard/matDefenseUpShield.mat").WaitForCompletion();

		public static Material matDefenseUpShieldopt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleGuard/matDefenseUpShield_opt.mat").WaitForCompletion();

		public static Material matSulfurBeetleGuard => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleGuard/matSulfurBeetleGuard.mat").WaitForCompletion();

		public static Material matBeetleBreath => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleQueen/matBeetleBreath.mat").WaitForCompletion();

		public static Material matBeetleQueen => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleQueen/matBeetleQueen.mat").WaitForCompletion();

		public static Material matBeetleBugs1 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleQueen/matBeetleBugs1.mat").WaitForCompletion();

		public static Material matBeetleBugs2 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleQueen/matBeetleBugs2.mat").WaitForCompletion();

		public static Material matBeetleQueen1 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleQueen/matBeetleQueen 1.mat").WaitForCompletion();

		public static Material matBeetleQueenAcidDecal => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleQueen/matBeetleQueenAcidDecal.mat").WaitForCompletion();

		public static Material matBeetleQueenAcidFizz => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleQueen/matBeetleQueenAcidFizz.mat").WaitForCompletion();

		public static Material matBeetleSpit => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleQueen/matBeetleSpit.mat").WaitForCompletion();

		public static Material matBeetleSpitLarge => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleQueen/matBeetleSpitLarge.mat").WaitForCompletion();

		public static Material matBeetleSpitShockwave => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleQueen/matBeetleSpitShockwave.mat").WaitForCompletion();

		public static Material matBeetleSpitTrail1 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleQueen/matBeetleSpitTrail1.mat").WaitForCompletion();

		public static Material matBeetleSpitTrail2 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleQueen/matBeetleSpitTrail2.mat").WaitForCompletion();

		public static Material matSulfurBeetleQueen => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleQueen/matSulfurBeetleQueen.mat").WaitForCompletion();

		public static Material matBeetleJuice => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleGroup/BeetleWard/matBeetleJuice.mat").WaitForCompletion();

		public static Material matBeetleQueenSphere => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleGroup/BeetleWard/matBeetleQueenSphere.mat").WaitForCompletion();

		public static Material matBeetleGuardSlamDecal => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleGroup/matBeetleGuardSlamDecal.mat").WaitForCompletion();

		public static Material matBeetleImpact => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleGroup/matBeetleImpact.mat").WaitForCompletion();

		public static Material matGroundSlamIndicator => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/BeetleGroup/matGroundSlamIndicator.mat").WaitForCompletion();

		public static Material matBell => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bell/matBell.mat").WaitForCompletion();

		public static Material matBellBall => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bell/matBellBall.mat").WaitForCompletion();

		public static Material matBellBuffBeam => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bell/matBellBuffBeam.mat").WaitForCompletion();

		public static Material matBellDevice => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bell/matBellDevice.mat").WaitForCompletion();

		public static Material matBellFlashBright => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bell/matBellFlashBright.mat").WaitForCompletion();

		public static Material matOmniExplosion1Bell => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bell/matOmniExplosion1Bell.mat").WaitForCompletion();

		public static Material matOmniHitspark1Bell => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bell/matOmniHitspark1Bell.mat").WaitForCompletion();

		public static Material matBirdshark => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Birdshark/matBirdshark.mat").WaitForCompletion();

		public static Material matBirdsharkFeather => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Birdshark/matBirdsharkFeather.mat").WaitForCompletion();

		public static Material matBison => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bison/matBison.mat").WaitForCompletion();

		public static Material matBisonopt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bison/matBison_opt.mat").WaitForCompletion();

		public static Material matBisonHair => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bison/matBisonHair.mat").WaitForCompletion();

		public static Material matBisonHairopt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bison/matBisonHair_opt.mat").WaitForCompletion();

		public static Material matBisonMetalBall => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bison/matBisonMetalBall.mat").WaitForCompletion();

		public static Material matBisonMetalBallopt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bison/matBisonMetalBall_opt.mat").WaitForCompletion();

		public static Material matBisonSnowSphere => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bison/matBisonSnowSphere.mat").WaitForCompletion();

		public static Material matBisonSnowSphereopt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bison/matBisonSnowSphere_opt.mat").WaitForCompletion();

		public static Material matGenericChargeIndicator => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bison/matGenericChargeIndicator.mat").WaitForCompletion();

		public static Material matGenericChargeIndicatorbisonopt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bison/matGenericChargeIndicator_bison_opt.mat").WaitForCompletion();

		public static Material matSnowyOverlay => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Bison/matSnowyOverlay.mat").WaitForCompletion();

		public static Material maBrotherDustSpeckledLarge => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/maBrotherDustSpeckledLarge.mat").WaitForCompletion();

		public static Material maBrotherGlassOverlay => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/maBrotherGlassOverlay.mat").WaitForCompletion();

		public static Material matBrotherDissolveParticle => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherDissolveParticle.mat").WaitForCompletion();

		public static Material matBrotherEnergizedWaveTell => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherEnergizedWaveTell.mat").WaitForCompletion();

		public static Material matBrotherEyeTrail => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherEyeTrail.mat").WaitForCompletion();

		public static Material matBrotherFirePillarIndicator => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherFirePillarIndicator.mat").WaitForCompletion();

		public static Material matBrotherGlassDistortion => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherGlassDistortion.mat").WaitForCompletion();

		public static Material matBrotherPostBossSphere => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherPostBossSphere.mat").WaitForCompletion();

		public static Material matBrotherPreBossSphere => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherPreBossSphere.mat").WaitForCompletion();

		public static Material matBrotherSlamDecal => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherSlamDecal.mat").WaitForCompletion();

		public static Material matBrotherSlamDecalCracks => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherSlamDecalCracks.mat").WaitForCompletion();

		public static Material matBrotherStealAura => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherStealAura.mat").WaitForCompletion();

		public static Material matBrotherSwing => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherSwing.mat").WaitForCompletion();

		public static Material matBrotherSwingDistortion => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherSwingDistortion.mat").WaitForCompletion();

		public static Material matBrotherUltIndicator => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherUltIndicator.mat").WaitForCompletion();

		public static Material matBrotherUltIndicatorTall => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherUltIndicatorTall.mat").WaitForCompletion();

		public static Material matLunarShardImpactEffect => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matLunarShardImpactEffect.mat").WaitForCompletion();

		public static Material matLunarShardTrail => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matLunarShardTrail.mat").WaitForCompletion();

		public static Material matBrotherInfectionBlue => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherInfectionBlue.mat").WaitForCompletion();

		public static Material matBrotherInfectionGreen => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherInfectionGreen.mat").WaitForCompletion();

		public static Material matBrotherInfectionRed => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherInfectionRed.mat").WaitForCompletion();

		public static Material matBrotherInfectionWhite => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherInfectionWhite.mat").WaitForCompletion();

		public static Material matBrother => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrother.mat").WaitForCompletion();

		public static Material matBrotherArmor => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherArmor.mat").WaitForCompletion();

		public static Material matBrotherCloth => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherCloth.mat").WaitForCompletion();

		public static Material matBrotherEye => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherEye.mat").WaitForCompletion();

		public static Material matBrotherEyeHurt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherEyeHurt.mat").WaitForCompletion();

		public static Material matBrotherGem => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherGem.mat").WaitForCompletion();

		public static Material matBrotherHammer => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherHammer.mat").WaitForCompletion();

		public static Material matBrotherStib => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Brother/matBrotherStib.mat").WaitForCompletion();

		public static Material matCaptainColossusAltArmor => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainColossusAltArmor.mat").WaitForCompletion();

		public static Material matCaptainColossusAltClothes => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainColossusAltClothes.mat").WaitForCompletion();

		public static Material matCaptainAirstrikeAltAreaIndicatorInner => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainAirstrikeAltAreaIndicatorInner.mat").WaitForCompletion();

		public static Material matCaptainAirstrikeAltAreaIndicatorOuter => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainAirstrikeAltAreaIndicatorOuter.mat").WaitForCompletion();

		public static Material matCaptainAirstrikeAltLaser => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainAirstrikeAltLaser.mat").WaitForCompletion();

		public static Material matCaptainAirstrikeAltRadiusWarning => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainAirstrikeAltRadiusWarning.mat").WaitForCompletion();

		public static Material matCaptainAirstrikeAreaIndicator => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainAirstrikeAreaIndicator.mat").WaitForCompletion();

		public static Material matCaptainAirstrikeCore => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainAirstrikeCore.mat").WaitForCompletion();

		public static Material matCaptainAirstrikeFlechetteBurning => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainAirstrikeFlechetteBurning.mat").WaitForCompletion();

		public static Material matCaptainAirstrikeTrail => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainAirstrikeTrail.mat").WaitForCompletion();

		public static Material matCaptainBlueprintsInvalid => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainBlueprintsInvalid.mat").WaitForCompletion();

		public static Material matCaptainBlueprintsOK => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainBlueprintsOK.mat").WaitForCompletion();

		public static Material matCaptainBlueprintsWarningInvalid => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainBlueprintsWarningInvalid.mat").WaitForCompletion();

		public static Material matCaptainBlueprintsWarningOK => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainBlueprintsWarningOK.mat").WaitForCompletion();

		public static Material matCaptainBodyArmorRing => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainBodyArmorRing.mat").WaitForCompletion();

		public static Material matCaptainBodyArmorShield => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainBodyArmorShield.mat").WaitForCompletion();

		public static Material matCaptainBodyArmorSphere => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainBodyArmorSphere.mat").WaitForCompletion();

		public static Material matCaptainDefenseMatrixLaser => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainDefenseMatrixLaser.mat").WaitForCompletion();

		public static Material matCaptainFlareRing => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainFlareRing.mat").WaitForCompletion();

		public static Material matCaptainFlareTiling => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainFlareTiling.mat").WaitForCompletion();

		public static Material matCaptainSignal => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainSignal.mat").WaitForCompletion();

		public static Material matCaptainSupplyDropAreaIndicator2 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainSupplyDropAreaIndicator2.mat").WaitForCompletion();

		public static Material matCaptainSupplyDropAreaIndicatorInner => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainSupplyDropAreaIndicatorInner.mat").WaitForCompletion();

		public static Material matCaptainSupplyDropAreaIndicatorOuter => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainSupplyDropAreaIndicatorOuter.mat").WaitForCompletion();

		public static Material matCaptainSupplyHackingLine => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainSupplyHackingLine.mat").WaitForCompletion();

		public static Material matCaptainSupplyRadiusHacking => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainSupplyRadiusHacking.mat").WaitForCompletion();

		public static Material matCaptainSupplyRadiusHealing => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainSupplyRadiusHealing.mat").WaitForCompletion();

		public static Material matCaptainSwing => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainSwing.mat").WaitForCompletion();

		public static Material matCaptainTazerCore => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainTazerCore.mat").WaitForCompletion();

		public static Material matCaptainTazerTrail => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainTazerTrail.mat").WaitForCompletion();

		public static Material matCaptainTracerHead => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainTracerHead.mat").WaitForCompletion();

		public static Material matCaptainTracerTrail => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainTracerTrail.mat").WaitForCompletion();

		public static Material matHackingDiscHologram => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matHackingDiscHologram.mat").WaitForCompletion();

		public static Material matCaptain => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptain.mat").WaitForCompletion();

		public static Material matCaptainAirstrikeFletchette => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainAirstrikeFletchette.mat").WaitForCompletion();

		public static Material matCaptainAlt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainAlt.mat").WaitForCompletion();

		public static Material matCaptainArmor => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainArmor.mat").WaitForCompletion();

		public static Material matCaptainArmorAlt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainArmorAlt.mat").WaitForCompletion();

		public static Material matCaptainJacket => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainJacket.mat").WaitForCompletion();

		public static Material matCaptainJacketAlt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainJacketAlt.mat").WaitForCompletion();

		public static Material matCaptainRobotBits => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainRobotBits.mat").WaitForCompletion();

		public static Material matCaptainRobotBitsAlt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainRobotBitsAlt.mat").WaitForCompletion();

		public static Material matCaptainSupplyDropEquipmentRestock => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainSupplyDropEquipmentRestock.mat").WaitForCompletion();

		public static Material matCaptainSupplyDropHacking => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainSupplyDropHacking.mat").WaitForCompletion();

		public static Material matCaptainSupplyDropHealing => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainSupplyDropHealing.mat").WaitForCompletion();

		public static Material matCaptainSupplyDropPlating => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainSupplyDropPlating.mat").WaitForCompletion();

		public static Material matCaptainSupplyDropShocking => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matCaptainSupplyDropShocking.mat").WaitForCompletion();

		public static Material matUIRemapCrosshairCaptain => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Captain/matUIRemapCrosshairCaptain.mat").WaitForCompletion();

		public static Material matClayBossGooDecal => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Clay/matClayBossGooDecal.mat").WaitForCompletion();

		public static Material matClayBubble => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Clay/matClayBubble.mat").WaitForCompletion();

		public static Material matClayBubbleBillboard => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Clay/matClayBubbleBillboard.mat").WaitForCompletion();

		public static Material matClayGooFizzle => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Clay/matClayGooFizzle.mat").WaitForCompletion();

		public static Material matClayBoss => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/ClayBoss/matClayBoss.mat").WaitForCompletion();

		public static Material matClayBossLightshaft => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/ClayBoss/matClayBossLightshaft.mat").WaitForCompletion();

		public static Material matClayPotProjectile => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/ClayBoss/matClayPotProjectile.mat").WaitForCompletion();

		public static Material matDrainSiphon => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/ClayBoss/matDrainSiphon.mat").WaitForCompletion();

		public static Material matTarball => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/ClayBoss/matTarball.mat").WaitForCompletion();

		public static Material matTrailSiphonHealth => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/ClayBoss/matTrailSiphonHealth.mat").WaitForCompletion();

		public static Material matGooMulcher => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/ClayBoss/matGooMulcher.mat").WaitForCompletion();

		public static Material matGooTrail => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/ClayBoss/matGooTrail.mat").WaitForCompletion();

		public static Material matGooTrailLegs => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/ClayBoss/matGooTrailLegs.mat").WaitForCompletion();

		public static Material matClayGooDecalLong => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/ClayBruiser/matClayGooDecalLong.mat").WaitForCompletion();

		public static Material matClayGooDecalSplat => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/ClayBruiser/matClayGooDecalSplat.mat").WaitForCompletion();

		public static Material matClayBruiser => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/ClayBruiser/matClayBruiser.mat").WaitForCompletion();

		public static Material matClayMinigunTracer => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/ClayBruiser/matClayMinigunTracer.mat").WaitForCompletion();

		public static Material matCommandoAltColossus => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Commando/matCommandoAltColossus.mat").WaitForCompletion();

		public static Material matCommandoBaseBullet => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Commando/matCommandoBaseBullet.mat").WaitForCompletion();

		public static Material matCommandoDualies => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Commando/matCommandoDualies.mat").WaitForCompletion();

		public static Material matCommandoDualiesAlt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Commando/matCommandoDualiesAlt.mat").WaitForCompletion();

		public static Material matCommandoDualiesColorShift01 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Commando/matCommandoDualiesColorShift01.mat").WaitForCompletion();

		public static Material matCommandoDualiesColorShift02 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Commando/matCommandoDualiesColorShift02.mat").WaitForCompletion();

		public static Material matCommandoDualiesColorShift03 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Commando/matCommandoDualiesColorShift03.mat").WaitForCompletion();

		public static Material matCommandoDualiesEnforcer => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Commando/matCommandoDualiesEnforcer.mat").WaitForCompletion();

		public static Material matCommandoDualiesScout => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Commando/matCommandoDualiesScout.mat").WaitForCompletion();

		public static Material matCommandoFMJBullet => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Commando/matCommandoFMJBullet.mat").WaitForCompletion();

		public static Material matCommandoFMJRing => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Commando/matCommandoFMJRing.mat").WaitForCompletion();

		public static Material matCommandoGun => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Commando/matCommandoGun.mat").WaitForCompletion();

		public static Material matCommandoShotgunTracerCore => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Commando/matCommandoShotgunTracerCore.mat").WaitForCompletion();

		public static Material matCommandoShotgunTrail => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Commando/matCommandoShotgunTrail.mat").WaitForCompletion();

		public static Material matCommandoSniper => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Commando/matCommandoSniper.mat").WaitForCompletion();

		public static Material matCommandoSpinPistol => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Commando/matCommandoSpinPistol.mat").WaitForCompletion();

		public static Material matCommandoStickyGrenade => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Commando/matCommandoStickyGrenade.mat").WaitForCompletion();

		public static Material matCommandoFmjSweetSpotBurst => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Commando/matCommandoFmjSweetSpotBurst.mat").WaitForCompletion();

		public static Material matCommandoFmjSweetSpotGlow => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Commando/matCommandoFmjSweetSpotGlow.mat").WaitForCompletion();

		public static Material matCrocoColossus => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoColossus.mat").WaitForCompletion();

		public static Material matBlighted => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matBlighted.mat").WaitForCompletion();

		public static Material matCroco => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCroco.mat").WaitForCompletion();

		public static Material matCrocoAlt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoAlt.mat").WaitForCompletion();

		public static Material matCrocoBiteDiseased => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoBiteDiseased.mat").WaitForCompletion();

		public static Material matCrocoBlightBillboard => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoBlightBillboard.mat").WaitForCompletion();

		public static Material matCrocoColorShift01 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoColorShift01.mat").WaitForCompletion();

		public static Material matCrocoColorShift02 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoColorShift02.mat").WaitForCompletion();

		public static Material matCrocoColorShift03 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoColorShift03.mat").WaitForCompletion();

		public static Material matCrocoDiseaseDrippings => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoDiseaseDrippings.mat").WaitForCompletion();

		public static Material matCrocoDiseaseHead => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoDiseaseHead.mat").WaitForCompletion();

		public static Material matCrocoDiseaseSpore => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoDiseaseSpore.mat").WaitForCompletion();

		public static Material matCrocoDiseaseTrail => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoDiseaseTrail.mat").WaitForCompletion();

		public static Material matCrocoDiseaseTrail2 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoDiseaseTrail2.mat").WaitForCompletion();

		public static Material matCrocoDiseaseTrailLesser => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoDiseaseTrailLesser.mat").WaitForCompletion();

		public static Material matCrocoDiseaseTrailOrange => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoDiseaseTrailOrange.mat").WaitForCompletion();

		public static Material matCrocoGooDecal => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoGooDecal.mat").WaitForCompletion();

		public static Material matCrocoGooLarge => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoGooLarge.mat").WaitForCompletion();

		public static Material matCrocoGooSmall => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoGooSmall.mat").WaitForCompletion();

		public static Material matCrocoGooSmall2 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoGooSmall2.mat").WaitForCompletion();

		public static Material matCrocoPoisonBillboard => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoPoisonBillboard.mat").WaitForCompletion();

		public static Material matCrocoSlash => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoSlash.mat").WaitForCompletion();

		public static Material matCrocoSlashDiseased => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoSlashDiseased.mat").WaitForCompletion();

		public static Material matCrocoSlashDiseasedBright => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoSlashDiseasedBright.mat").WaitForCompletion();

		public static Material matCrocoSlashDistortion => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoSlashDistortion.mat").WaitForCompletion();

		public static Material matCrocoSpawnDecal => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoSpawnDecal.mat").WaitForCompletion();

		public static Material matCrocoSpine => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoSpine.mat").WaitForCompletion();

		public static Material matCrocoSpineAlt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoSpineAlt.mat").WaitForCompletion();

		public static Material matCrocoSpineColorShift01 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoSpineColorShift01.mat").WaitForCompletion();

		public static Material matCrocoSpineColorShift02 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoSpineColorShift02.mat").WaitForCompletion();

		public static Material matCrocoSpineColorShift03 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matCrocoSpineColorShift03.mat").WaitForCompletion();

		public static Material matPoisoned => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Croco/matPoisoned.mat").WaitForCompletion();

		public static Material matDrone1 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Drones/matDrone1.mat").WaitForCompletion();

		public static Material matDrone2 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Drones/matDrone2.mat").WaitForCompletion();

		public static Material matDroneBrokenGeneric => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Drones/matDroneBrokenGeneric.mat").WaitForCompletion();

		public static Material matMegaDroneFlare1 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Drones/matMegaDroneFlare1.mat").WaitForCompletion();

		public static Material matMegaDroneFlare2 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Drones/matMegaDroneFlare2.mat").WaitForCompletion();

		public static Material matBackupDrone => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Drones/matBackupDrone.mat").WaitForCompletion();

		public static Material matDroneBlades => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Drones/matDroneBlades.mat").WaitForCompletion();

		public static Material matMissileDrone => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Drones/matMissileDrone.mat").WaitForCompletion();

		public static Material matTurret1 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Drones/matTurret1.mat").WaitForCompletion();

		public static Material matBlueprintsInvalid => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matBlueprintsInvalid.mat").WaitForCompletion();

		public static Material matBlueprintsOk => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matBlueprintsOk.mat").WaitForCompletion();

		public static Material matEngiHarpoonRing => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matEngiHarpoonRing.mat").WaitForCompletion();

		public static Material matEngiHarpoonTrail => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matEngiHarpoonTrail.mat").WaitForCompletion();

		public static Material matEngiTurret => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matEngiTurret.mat").WaitForCompletion();

		public static Material matEngiTrail => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matEngiTrail.mat").WaitForCompletion();

		public static Material matDefenseMatrix => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matDefenseMatrix.mat").WaitForCompletion();

		public static Material matDefenseMatrixCenter => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matDefenseMatrixCenter.mat").WaitForCompletion();

		public static Material matDefenseMatrixCenterOneSided => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matDefenseMatrixCenterOneSided.mat").WaitForCompletion();

		public static Material matDefenseMatrixCenterWithEdges => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matDefenseMatrixCenterWithEdges.mat").WaitForCompletion();

		public static Material matEngi => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matEngi.mat").WaitForCompletion();

		public static Material matEngiAlt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matEngiAlt.mat").WaitForCompletion();

		public static Material matEngiBeam => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matEngiBeam.mat").WaitForCompletion();

		public static Material matEngiBeamTurret => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matEngiBeamTurret.mat").WaitForCompletion();

		public static Material matEngiCone => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matEngiCone.mat").WaitForCompletion();

		public static Material matEngiParts => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matEngiParts.mat").WaitForCompletion();

		public static Material matEngiTracer => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matEngiTracer.mat").WaitForCompletion();

		public static Material matEngiShieldSHards => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matEngiShieldSHards.mat").WaitForCompletion();

		public static Material matEngiExplosion => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matEngiExplosion.mat").WaitForCompletion();

		public static Material matEngiTrailExplosion => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matEngiTrailExplosion.mat").WaitForCompletion();

		public static Material matEngiMineLaser => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matEngiMineLaser.mat").WaitForCompletion();

		public static Material matEngiMineSphere => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matEngiMineSphere.mat").WaitForCompletion();

		public static Material matEngiMineZone => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matEngiMineZone.mat").WaitForCompletion();

		public static Material matEngiMineZoneIntersection => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matEngiMineZoneIntersection.mat").WaitForCompletion();

		public static Material matOmniExplosion1Engi => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matOmniExplosion1Engi.mat").WaitForCompletion();

		public static Material matOmniRing1Engi => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matOmniRing1Engi.mat").WaitForCompletion();

		public static Material matEngiAltColossus => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matEngiAltColossus.mat").WaitForCompletion();

		public static Material matEngiAltColossusTool => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Engi/matEngiAltColossusTool.mat").WaitForCompletion();

		public static Material matGolem => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Golem/matGolem.mat").WaitForCompletion();

		public static Material matGolemDead => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Golem/matGolemDead.mat").WaitForCompletion();

		public static Material matGolemDoll => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Golem/matGolemDoll.mat").WaitForCompletion();

		public static Material matGolemGoldInfused => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Golem/matGolemGoldInfused.mat").WaitForCompletion();

		public static Material matGolemPrint => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Golem/matGolemPrint.mat").WaitForCompletion();

		public static Material matNatureGolem => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Golem/matNatureGolem.mat").WaitForCompletion();

		public static Material matSandyGolem => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Golem/matSandyGolem.mat").WaitForCompletion();

		public static Material matShockwave1 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Golem/matShockwave1.mat").WaitForCompletion();

		public static Material matVFXFlame1 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Golem/matVFXFlame1.mat").WaitForCompletion();

		public static Material matZap1 => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Golem/matZap1.mat").WaitForCompletion();

		public static Material matSnowyGolem => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Golem/matSnowyGolem.mat").WaitForCompletion();

		public static Material matGrandparentTeleportOutBoom => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Grandparent/matGrandparentTeleportOutBoom.mat").WaitForCompletion();

		public static Material matGrandparent => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Grandparent/matGrandparent.mat").WaitForCompletion();

		public static Material matGrandparentBoulderProjectile => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Grandparent/matGrandparentBoulderProjectile.mat").WaitForCompletion();

		public static Material matGrandparentDetails => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Grandparent/matGrandparentDetails.mat").WaitForCompletion();

		public static Material matGrandparentGemPortal => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Grandparent/matGrandparentGemPortal.mat").WaitForCompletion();

		public static Material matGrandParentMoonCore => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Grandparent/matGrandParentMoonCore.mat").WaitForCompletion();

		public static Material matGrandParentSunChannelStartBeam => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Grandparent/matGrandParentSunChannelStartBeam.mat").WaitForCompletion();

		public static Material matGrandParentSunCore => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Grandparent/matGrandParentSunCore.mat").WaitForCompletion();

		public static Material matGrandParentSunFresnel => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Grandparent/matGrandParentSunFresnel.mat").WaitForCompletion();

		public static Material matGrandParentSunGlow => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Grandparent/matGrandParentSunGlow.mat").WaitForCompletion();

		public static Material matGrandParentSunHeatDistortion => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Grandparent/matGrandParentSunHeatDistortion.mat").WaitForCompletion();

		public static Material matGrandparentBombFlare => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Grandparent/matGrandparentBombFlare.mat").WaitForCompletion();

		public static Material matGrandparentBossPortal => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Grandparent/matGrandparentBossPortal.mat").WaitForCompletion();

		public static Material matGrandparentEgg => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Grandparent/matGrandparentEgg.mat").WaitForCompletion();

		public static Material matGrandparentEggDead => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Grandparent/matGrandparentEggDead.mat").WaitForCompletion();

		public static Material matGrandparentFistGlowing => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Grandparent/matGrandparentFistGlowing.mat").WaitForCompletion();

		public static Material matGrandparentGoo => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Grandparent/matGrandparentGoo.mat").WaitForCompletion();

		public static Material matGrandparentGooDecal => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Grandparent/matGrandparentGooDecal.mat").WaitForCompletion();

		public static Material matGrandparentGooOverlay => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Grandparent/matGrandparentGooOverlay.mat").WaitForCompletion();

		public static Material matGrandparentGravArea => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Grandparent/matGrandparentGravArea.mat").WaitForCompletion();

		public static Material matGrandparentOuterGlow => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Grandparent/matGrandparentOuterGlow.mat").WaitForCompletion();

		public static Material matGrandparentPortal => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Grandparent/matGrandparentPortal.mat").WaitForCompletion();

		public static Material matGrandparentSmallBall => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Grandparent/matGrandparentSmallBall.mat").WaitForCompletion();

		public static Material matGrandparentSpawnEggNet => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Grandparent/matGrandparentSpawnEggNet.mat").WaitForCompletion();

		public static Material matArchWispFire => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Gravekeeper/matArchWispFire.mat").WaitForCompletion();

		public static Material matArchWispFireStatic => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Gravekeeper/matArchWispFireStatic.mat").WaitForCompletion();

		public static Material matGravekeeperDiffuse => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Gravekeeper/matGravekeeperDiffuse.mat").WaitForCompletion();

		public static Material matGravekeeperFurDiffuse => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Gravekeeper/matGravekeeperFurDiffuse.mat").WaitForCompletion();

		public static Material matGravekeeperHookChain => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Gravekeeper/matGravekeeperHookChain.mat").WaitForCompletion();

		public static Material matGravekeeperHookHead => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Gravekeeper/matGravekeeperHookHead.mat").WaitForCompletion();

		public static Material matGravekeeperJar => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Gravekeeper/matGravekeeperJar.mat").WaitForCompletion();

		public static Material matGravekeeperTrackingMask => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Gravekeeper/matGravekeeperTrackingMask.mat").WaitForCompletion();

		public static Material matOmniExplosion1ArchWisp => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Gravekeeper/matOmniExplosion1ArchWisp.mat").WaitForCompletion();

		public static Material matOmniRing1ArchWisp => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Gravekeeper/matOmniRing1ArchWisp.mat").WaitForCompletion();

		public static Material matGreaterWisp => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/GreaterWisp/matGreaterWisp.mat").WaitForCompletion();

		public static Material matGreaterWispCracks => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/GreaterWisp/matGreaterWispCracks.mat").WaitForCompletion();

		public static Material matGreaterWispFire => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/GreaterWisp/matGreaterWispFire.mat").WaitForCompletion();

		public static Material matGreaterWispRays => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/GreaterWisp/matGreaterWispRays.mat").WaitForCompletion();

		public static Material matGreaterWispTile => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/GreaterWisp/matGreaterWispTile.mat").WaitForCompletion();

		public static Material matOmniExplosion1GreaterWisp => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/GreaterWisp/matOmniExplosion1GreaterWisp.mat").WaitForCompletion();

		public static Material matOmniHitspark1GreaterWisp => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/GreaterWisp/matOmniHitspark1GreaterWisp.mat").WaitForCompletion();

		public static Material matOmniRing1GreaterWisp => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/GreaterWisp/matOmniRing1GreaterWisp.mat").WaitForCompletion();

		public static Material matHereticBlade => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Heretic/matHereticBlade.mat").WaitForCompletion();

		public static Material matHereticBody => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Heretic/matHereticBody.mat").WaitForCompletion();

		public static Material matHereticClothes => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Heretic/matHereticClothes.mat").WaitForCompletion();

		public static Material matHereticEye => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Heretic/matHereticEye.mat").WaitForCompletion();

		public static Material matHereticFeathers => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Heretic/matHereticFeathers.mat").WaitForCompletion();

		public static Material matHereticSpawnOverlay => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Heretic/matHereticSpawnOverlay.mat").WaitForCompletion();

		public static Material matHermitCrab => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/HermitCrab/matHermitCrab.mat").WaitForCompletion();

		public static Material matHermitCrabopt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/HermitCrab/matHermitCrab_opt.mat").WaitForCompletion();

		public static Material matHermitCrabProjectile => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/HermitCrab/matHermitCrabProjectile.mat").WaitForCompletion();

		public static Material matHermitCrabProjectileopt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/HermitCrab/matHermitCrabProjectile_opt.mat").WaitForCompletion();

		public static Material matHermitCrabProjectileTrail => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/HermitCrab/matHermitCrabProjectileTrail.mat").WaitForCompletion();

		public static Material matHuntressAltColossus => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matHuntressAltColossus.mat").WaitForCompletion();

		public static Material matHuntressAltColossusArrow => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matHuntressAltColossusArrow.mat").WaitForCompletion();

		public static Material matHuntressAltColossusBowString => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matHuntressAltColossusBowString.mat").WaitForCompletion();

		public static Material matHuntressArrowTrailColossus => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matHuntressArrowTrailColossus.mat").WaitForCompletion();

		public static Material matHuntressAlt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matHuntressAlt.mat").WaitForCompletion();

		public static Material matHuntressCapeAlt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matHuntressCapeAlt.mat").WaitForCompletion();

		public static Material matBow => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matBow.mat").WaitForCompletion();

		public static Material matBowString => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matBowString.mat").WaitForCompletion();

		public static Material matHuntress => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matHuntress.mat").WaitForCompletion();

		public static Material matHuntressAreaIndicatorActive => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matHuntressAreaIndicatorActive.mat").WaitForCompletion();

		public static Material matHuntressArrow => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matHuntressArrow.mat").WaitForCompletion();

		public static Material matHuntressArrowBig => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matHuntressArrowBig.mat").WaitForCompletion();

		public static Material matHuntressArrowTrail => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matHuntressArrowTrail.mat").WaitForCompletion();

		public static Material matHuntressCape => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matHuntressCape.mat").WaitForCompletion();

		public static Material matHuntressCharged => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matHuntressCharged.mat").WaitForCompletion();

		public static Material matHuntressFlashBright => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matHuntressFlashBright.mat").WaitForCompletion();

		public static Material matHuntressFlashExpanded => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matHuntressFlashExpanded.mat").WaitForCompletion();

		public static Material matHuntressFlurryArrowCritTrail => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matHuntressFlurryArrowCritTrail.mat").WaitForCompletion();

		public static Material matHuntressFlurryArrowTrail => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matHuntressFlurryArrowTrail.mat").WaitForCompletion();

		public static Material matHuntressGlaive => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matHuntressGlaive.mat").WaitForCompletion();

		public static Material matHuntressSwingTrail => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matHuntressSwingTrail.mat").WaitForCompletion();

		public static Material matHuntressFlash => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matHuntressFlash.mat").WaitForCompletion();

		public static Material matHuntressSwipe => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matHuntressSwipe.mat").WaitForCompletion();

		public static Material matOmniHitspark1Huntress => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matOmniHitspark1Huntress.mat").WaitForCompletion();

		public static Material matOmniHitspark3Huntress => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matOmniHitspark3Huntress.mat").WaitForCompletion();

		public static Material matOmniRing2Huntress => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Huntress/matOmniRing2Huntress.mat").WaitForCompletion();

		public static Material matImp => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Imp/matImp.mat").WaitForCompletion();

		public static Material matImpBoss => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Imp/matImpBoss.mat").WaitForCompletion();

		public static Material matImpBossDissolve => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Imp/matImpBossDissolve.mat").WaitForCompletion();

		public static Material matImpBossPortal => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Imp/matImpBossPortal.mat").WaitForCompletion();

		public static Material matImpClaw => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Imp/matImpClaw.mat").WaitForCompletion();

		public static Material matImpDecal => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Imp/matImpDecal.mat").WaitForCompletion();

		public static Material matImpDissolve => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Imp/matImpDissolve.mat").WaitForCompletion();

		public static Material matImpDust => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Imp/matImpDust.mat").WaitForCompletion();

		public static Material matImpExplosionSphere => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Imp/matImpExplosionSphere.mat").WaitForCompletion();

		public static Material matImpPortalEffect => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Imp/matImpPortalEffect.mat").WaitForCompletion();

		public static Material matImpPortalEffectEdge => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Imp/matImpPortalEffectEdge.mat").WaitForCompletion();

		public static Material matImpSlashImpact => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Imp/matImpSlashImpact.mat").WaitForCompletion();

		public static Material matImpSwipe => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Imp/matImpSwipe.mat").WaitForCompletion();

		public static Material matFlashJellyfish => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Jellyfish/matFlashJellyfish.mat").WaitForCompletion();

		public static Material matJellyfish => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Jellyfish/matJellyfish.mat").WaitForCompletion();

		public static Material matLemurian => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Lemurian/matLemurian.mat").WaitForCompletion();

		public static Material matLemurianBruiser => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Lemurian/matLemurianBruiser.mat").WaitForCompletion();

		public static Material matLemurianBruiseropt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Lemurian/matLemurianBruiser_opt.mat").WaitForCompletion();

		public static Material matLizardBiteTrail => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Lemurian/matLizardBiteTrail.mat").WaitForCompletion();

		public static Material matLoaderAltColossus => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Loader/matLoaderAltColossus.mat").WaitForCompletion();

		public static Material matLoaderCharging => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Loader/matLoaderCharging.mat").WaitForCompletion();

		public static Material matLoaderHookRope => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Loader/matLoaderHookRope.mat").WaitForCompletion();

		public static Material matLoaderLightningLarge => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Loader/matLoaderLightningLarge.mat").WaitForCompletion();

		public static Material matLoaderLightningTile => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Loader/matLoaderLightningTile.mat").WaitForCompletion();

		public static Material matLoaderPilotDiffuse => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Loader/matLoaderPilotDiffuse.mat").WaitForCompletion();

		public static Material matLoaderPilotDiffuseAlt => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Loader/matLoaderPilotDiffuseAlt.mat").WaitForCompletion();

		public static Material matLoaderSlamSphere => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Loader/matLoaderSlamSphere.mat").WaitForCompletion();

		public static Material matLoaderSwingBasic => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Loader/matLoaderSwingBasic.mat").WaitForCompletion();

		public static Material matLoaderSwingThick => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Loader/matLoaderSwingThick.mat").WaitForCompletion();

		public static Material matLoaderTrailImpact => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Loader/matLoaderTrailImpact.mat").WaitForCompletion();

		public static Material matOmniRing2Loader => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Loader/matOmniRing2Loader.mat").WaitForCompletion();

		public static Material matOmniHitspark1Loader => Addressables.LoadAssetAsync<Material>((object)"RoR2/Base/Loader/matOmniHitspark1Loader.mat").W