using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using Microsoft.CodeAnalysis;
using RoR2;
using SurvivorConfig.Characters;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("SurvivorConfig")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("SurvivorConfig")]
[assembly: AssemblyTitle("SurvivorConfig")]
[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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace SurvivorConfig
{
	internal class SurvivorBase
	{
		public static GameObject CommandoPrefab;

		public static CharBase CommandoStats;

		public static GameObject HuntressPrefab;

		public static CharBase HuntressStats;

		public static GameObject BanditPrefab;

		public static CharBase BanditStats;

		public static GameObject MULTPrefab;

		public static CharBase MULTStats;

		public static GameObject EngineerPrefab;

		public static CharBase EngineerStats;

		public static GameObject ArtificerPrefab;

		public static CharBase ArtificerStats;

		public static GameObject MercenaryPrefab;

		public static CharBase MercenaryStats;

		public static GameObject REXPrefab;

		public static CharBase REXStats;

		public static GameObject LoaderPrefab;

		public static CharBase LoaderStats;

		public static GameObject AcridPrefab;

		public static CharBase AcridStats;

		public static GameObject CaptainPrefab;

		public static CharBase CaptainStats;

		public static GameObject HereticPrefab;

		public static CharBase HereticStats;

		public static GameObject VoidFiendPrefab;

		public static CharBase VoidFiendStats;

		public static GameObject RailgunnerPrefab;

		public static CharBase RailgunnerStats;

		public static GameObject SeekerPrefab;

		public static CharBase SeekerStats;

		public static GameObject FalseSonPrefab;

		public static CharBase FalseSonStats;

		public static GameObject CHEFPrefab;

		public static CharBase CHEFStats;

		public static GameObject OperatorPrefab;

		public static CharBase OperatorStats;

		public static GameObject DrifterPrefab;

		public static CharBase DrifterStats;

		public static GameObject robpaladinPrefab = Resources.Load<GameObject>("Prefabs/CharacterBodies/PaladinBody");

		public static CharBase robpaladinStats = new CharBase();

		public static GameObject nemesisenforcerPrefab = Resources.Load<GameObject>("Prefabs/CharacterBodies/NemesisEnforcerBody");

		public static CharBase nemesisenforcerStats = new CharBase();

		public static GameObject minerPrefab = Resources.Load<GameObject>("Prefabs/CharacterBodies/MinerBody");

		public static CharBase minerStats = new CharBase();

		public static void Rebalance()
		{
			SurvivorConfig.ConfigSetup();
			((ResourceAvailability)(ref BodyCatalog.availability)).CallWhenAvailable((Action)CharChanges.Gaming);
		}
	}
	internal class SurvivorConfig : SurvivorBase
	{
		public static ConfigFile StatConfig { get; set; }

		public static ConfigEntry<float> MandoBaseHealth { get; set; }

		public static ConfigEntry<float> MandoLevelHealth { get; set; }

		public static ConfigEntry<float> MandoBaseShield { get; set; }

		public static ConfigEntry<float> MandoLevelShield { get; set; }

		public static ConfigEntry<float> MandoBaseRegen { get; set; }

		public static ConfigEntry<float> MandoLevelRegen { get; set; }

		public static ConfigEntry<float> MandoBaseDamage { get; set; }

		public static ConfigEntry<float> MandoLevelDamage { get; set; }

		public static ConfigEntry<float> MandoArmor { get; set; }

		public static ConfigEntry<float> MandoSpeed { get; set; }

		public static ConfigEntry<float> HuntBaseHealth { get; set; }

		public static ConfigEntry<float> HuntLevelHealth { get; set; }

		public static ConfigEntry<float> HuntBaseShield { get; set; }

		public static ConfigEntry<float> HuntLevelShield { get; set; }

		public static ConfigEntry<float> HuntBaseRegen { get; set; }

		public static ConfigEntry<float> HuntLevelRegen { get; set; }

		public static ConfigEntry<float> HuntBaseDamage { get; set; }

		public static ConfigEntry<float> HuntLevelDamage { get; set; }

		public static ConfigEntry<float> HuntArmor { get; set; }

		public static ConfigEntry<float> HuntSpeed { get; set; }

		public static ConfigEntry<float> BndtBaseHealth { get; set; }

		public static ConfigEntry<float> BndtLevelHealth { get; set; }

		public static ConfigEntry<float> BndtBaseShield { get; set; }

		public static ConfigEntry<float> BndtLevelShield { get; set; }

		public static ConfigEntry<float> BndtBaseRegen { get; set; }

		public static ConfigEntry<float> BndtLevelRegen { get; set; }

		public static ConfigEntry<float> BndtBaseDamage { get; set; }

		public static ConfigEntry<float> BndtLevelDamage { get; set; }

		public static ConfigEntry<float> BndtArmor { get; set; }

		public static ConfigEntry<float> BndtSpeed { get; set; }

		public static ConfigEntry<float> MulTBaseHealth { get; set; }

		public static ConfigEntry<float> MulTLevelHealth { get; set; }

		public static ConfigEntry<float> MulTBaseShield { get; set; }

		public static ConfigEntry<float> MulTLevelShield { get; set; }

		public static ConfigEntry<float> MulTBaseRegen { get; set; }

		public static ConfigEntry<float> MulTLevelRegen { get; set; }

		public static ConfigEntry<float> MulTBaseDamage { get; set; }

		public static ConfigEntry<float> MulTLevelDamage { get; set; }

		public static ConfigEntry<float> MulTArmor { get; set; }

		public static ConfigEntry<float> MulTSpeed { get; set; }

		public static ConfigEntry<float> EngiBaseHealth { get; set; }

		public static ConfigEntry<float> EngiLevelHealth { get; set; }

		public static ConfigEntry<float> EngiBaseShield { get; set; }

		public static ConfigEntry<float> EngiLevelShield { get; set; }

		public static ConfigEntry<float> EngiBaseRegen { get; set; }

		public static ConfigEntry<float> EngiLevelRegen { get; set; }

		public static ConfigEntry<float> EngiBaseDamage { get; set; }

		public static ConfigEntry<float> EngiLevelDamage { get; set; }

		public static ConfigEntry<float> EngiArmor { get; set; }

		public static ConfigEntry<float> EngiSpeed { get; set; }

		public static ConfigEntry<float> ArtiBaseHealth { get; set; }

		public static ConfigEntry<float> ArtiLevelHealth { get; set; }

		public static ConfigEntry<float> ArtiBaseShield { get; set; }

		public static ConfigEntry<float> ArtiLevelShield { get; set; }

		public static ConfigEntry<float> ArtiBaseRegen { get; set; }

		public static ConfigEntry<float> ArtiLevelRegen { get; set; }

		public static ConfigEntry<float> ArtiBaseDamage { get; set; }

		public static ConfigEntry<float> ArtiLevelDamage { get; set; }

		public static ConfigEntry<float> ArtiArmor { get; set; }

		public static ConfigEntry<float> ArtiSpeed { get; set; }

		public static ConfigEntry<float> MercBaseHealth { get; set; }

		public static ConfigEntry<float> MercLevelHealth { get; set; }

		public static ConfigEntry<float> MercBaseShield { get; set; }

		public static ConfigEntry<float> MercLevelShield { get; set; }

		public static ConfigEntry<float> MercBaseRegen { get; set; }

		public static ConfigEntry<float> MercLevelRegen { get; set; }

		public static ConfigEntry<float> MercBaseDamage { get; set; }

		public static ConfigEntry<float> MercLevelDamage { get; set; }

		public static ConfigEntry<float> MercArmor { get; set; }

		public static ConfigEntry<float> MercSpeed { get; set; }

		public static ConfigEntry<float> RexBaseHealth { get; set; }

		public static ConfigEntry<float> RexLevelHealth { get; set; }

		public static ConfigEntry<float> RexBaseShield { get; set; }

		public static ConfigEntry<float> RexLevelShield { get; set; }

		public static ConfigEntry<float> RexBaseRegen { get; set; }

		public static ConfigEntry<float> RexLevelRegen { get; set; }

		public static ConfigEntry<float> RexBaseDamage { get; set; }

		public static ConfigEntry<float> RexLevelDamage { get; set; }

		public static ConfigEntry<float> RexArmor { get; set; }

		public static ConfigEntry<float> RexSpeed { get; set; }

		public static ConfigEntry<float> LodrBaseHealth { get; set; }

		public static ConfigEntry<float> LodrLevelHealth { get; set; }

		public static ConfigEntry<float> LodrBaseShield { get; set; }

		public static ConfigEntry<float> LodrLevelShield { get; set; }

		public static ConfigEntry<float> LodrBaseRegen { get; set; }

		public static ConfigEntry<float> LodrLevelRegen { get; set; }

		public static ConfigEntry<float> LodrBaseDamage { get; set; }

		public static ConfigEntry<float> LodrLevelDamage { get; set; }

		public static ConfigEntry<float> LodrArmor { get; set; }

		public static ConfigEntry<float> LodrSpeed { get; set; }

		public static ConfigEntry<float> CrocBaseHealth { get; set; }

		public static ConfigEntry<float> CrocLevelHealth { get; set; }

		public static ConfigEntry<float> CrocBaseShield { get; set; }

		public static ConfigEntry<float> CrocLevelShield { get; set; }

		public static ConfigEntry<float> CrocBaseRegen { get; set; }

		public static ConfigEntry<float> CrocLevelRegen { get; set; }

		public static ConfigEntry<float> CrocBaseDamage { get; set; }

		public static ConfigEntry<float> CrocLevelDamage { get; set; }

		public static ConfigEntry<float> CrocArmor { get; set; }

		public static ConfigEntry<float> CrocSpeed { get; set; }

		public static ConfigEntry<float> CaptBaseHealth { get; set; }

		public static ConfigEntry<float> CaptLevelHealth { get; set; }

		public static ConfigEntry<float> CaptBaseShield { get; set; }

		public static ConfigEntry<float> CaptLevelShield { get; set; }

		public static ConfigEntry<float> CaptBaseRegen { get; set; }

		public static ConfigEntry<float> CaptLevelRegen { get; set; }

		public static ConfigEntry<float> CaptBaseDamage { get; set; }

		public static ConfigEntry<float> CaptLevelDamage { get; set; }

		public static ConfigEntry<float> CaptArmor { get; set; }

		public static ConfigEntry<float> CaptSpeed { get; set; }

		public static ConfigEntry<float> BirbBaseHealth { get; set; }

		public static ConfigEntry<float> BirbLevelHealth { get; set; }

		public static ConfigEntry<float> BirbBaseShield { get; set; }

		public static ConfigEntry<float> BirbLevelShield { get; set; }

		public static ConfigEntry<float> BirbBaseRegen { get; set; }

		public static ConfigEntry<float> BirbLevelRegen { get; set; }

		public static ConfigEntry<float> BirbBaseDamage { get; set; }

		public static ConfigEntry<float> BirbLevelDamage { get; set; }

		public static ConfigEntry<float> BirbArmor { get; set; }

		public static ConfigEntry<float> BirbSpeed { get; set; }

		public static ConfigEntry<float> VoidSurvivorBaseHealth { get; set; }

		public static ConfigEntry<float> VoidSurvivorLevelHealth { get; set; }

		public static ConfigEntry<float> VoidSurvivorBaseShield { get; set; }

		public static ConfigEntry<float> VoidSurvivorLevelShield { get; set; }

		public static ConfigEntry<float> VoidSurvivorBaseRegen { get; set; }

		public static ConfigEntry<float> VoidSurvivorLevelRegen { get; set; }

		public static ConfigEntry<float> VoidSurvivorBaseDamage { get; set; }

		public static ConfigEntry<float> VoidSurvivorLevelDamage { get; set; }

		public static ConfigEntry<float> VoidSurvivorArmor { get; set; }

		public static ConfigEntry<float> VoidSurvivorSpeed { get; set; }

		public static ConfigEntry<float> RailGunnerBaseHealth { get; set; }

		public static ConfigEntry<float> RailGunnerLevelHealth { get; set; }

		public static ConfigEntry<float> RailGunnerBaseShield { get; set; }

		public static ConfigEntry<float> RailGunnerLevelShield { get; set; }

		public static ConfigEntry<float> RailGunnerBaseRegen { get; set; }

		public static ConfigEntry<float> RailGunnerLevelRegen { get; set; }

		public static ConfigEntry<float> RailGunnerBaseDamage { get; set; }

		public static ConfigEntry<float> RailGunnerLevelDamage { get; set; }

		public static ConfigEntry<float> RailGunnerArmor { get; set; }

		public static ConfigEntry<float> RailGunnerSpeed { get; set; }

		public static ConfigEntry<float> SeekerBaseHealth { get; set; }

		public static ConfigEntry<float> SeekerLevelHealth { get; set; }

		public static ConfigEntry<float> SeekerBaseShield { get; set; }

		public static ConfigEntry<float> SeekerLevelShield { get; set; }

		public static ConfigEntry<float> SeekerBaseRegen { get; set; }

		public static ConfigEntry<float> SeekerLevelRegen { get; set; }

		public static ConfigEntry<float> SeekerBaseDamage { get; set; }

		public static ConfigEntry<float> SeekerLevelDamage { get; set; }

		public static ConfigEntry<float> SeekerArmor { get; set; }

		public static ConfigEntry<float> SeekerSpeed { get; set; }

		public static ConfigEntry<float> FalseSonBaseHealth { get; set; }

		public static ConfigEntry<float> FalseSonLevelHealth { get; set; }

		public static ConfigEntry<float> FalseSonBaseShield { get; set; }

		public static ConfigEntry<float> FalseSonLevelShield { get; set; }

		public static ConfigEntry<float> FalseSonBaseRegen { get; set; }

		public static ConfigEntry<float> FalseSonLevelRegen { get; set; }

		public static ConfigEntry<float> FalseSonBaseDamage { get; set; }

		public static ConfigEntry<float> FalseSonLevelDamage { get; set; }

		public static ConfigEntry<float> FalseSonArmor { get; set; }

		public static ConfigEntry<float> FalseSonSpeed { get; set; }

		public static ConfigEntry<float> CHEFBaseHealth { get; set; }

		public static ConfigEntry<float> CHEFLevelHealth { get; set; }

		public static ConfigEntry<float> CHEFBaseShield { get; set; }

		public static ConfigEntry<float> CHEFLevelShield { get; set; }

		public static ConfigEntry<float> CHEFBaseRegen { get; set; }

		public static ConfigEntry<float> CHEFLevelRegen { get; set; }

		public static ConfigEntry<float> CHEFBaseDamage { get; set; }

		public static ConfigEntry<float> CHEFLevelDamage { get; set; }

		public static ConfigEntry<float> CHEFArmor { get; set; }

		public static ConfigEntry<float> CHEFSpeed { get; set; }

		public static ConfigEntry<float> OperatorBaseHealth { get; set; }

		public static ConfigEntry<float> OperatorLevelHealth { get; set; }

		public static ConfigEntry<float> OperatorBaseShield { get; set; }

		public static ConfigEntry<float> OperatorLevelShield { get; set; }

		public static ConfigEntry<float> OperatorBaseRegen { get; set; }

		public static ConfigEntry<float> OperatorLevelRegen { get; set; }

		public static ConfigEntry<float> OperatorBaseDamage { get; set; }

		public static ConfigEntry<float> OperatorLevelDamage { get; set; }

		public static ConfigEntry<float> OperatorArmor { get; set; }

		public static ConfigEntry<float> OperatorSpeed { get; set; }

		public static ConfigEntry<float> DrifterBaseHealth { get; set; }

		public static ConfigEntry<float> DrifterLevelHealth { get; set; }

		public static ConfigEntry<float> DrifterBaseShield { get; set; }

		public static ConfigEntry<float> DrifterLevelShield { get; set; }

		public static ConfigEntry<float> DrifterBaseRegen { get; set; }

		public static ConfigEntry<float> DrifterLevelRegen { get; set; }

		public static ConfigEntry<float> DrifterBaseDamage { get; set; }

		public static ConfigEntry<float> DrifterLevelDamage { get; set; }

		public static ConfigEntry<float> DrifterArmor { get; set; }

		public static ConfigEntry<float> DrifterSpeed { get; set; }

		public static ConfigEntry<float> RobPaladinBaseHealth { get; set; }

		public static ConfigEntry<float> RobPaladinLevelHealth { get; set; }

		public static ConfigEntry<float> RobPaladinBaseShield { get; set; }

		public static ConfigEntry<float> RobPaladinLevelShield { get; set; }

		public static ConfigEntry<float> RobPaladinBaseRegen { get; set; }

		public static ConfigEntry<float> RobPaladinLevelRegen { get; set; }

		public static ConfigEntry<float> RobPaladinBaseDamage { get; set; }

		public static ConfigEntry<float> RobPaladinLevelDamage { get; set; }

		public static ConfigEntry<float> RobPaladinArmor { get; set; }

		public static ConfigEntry<float> RobPaladinSpeed { get; set; }

		public static ConfigEntry<float> NemesisEnforcerBaseHealth { get; set; }

		public static ConfigEntry<float> NemesisEnforcerLevelHealth { get; set; }

		public static ConfigEntry<float> NemesisEnforcerBaseShield { get; set; }

		public static ConfigEntry<float> NemesisEnforcerLevelShield { get; set; }

		public static ConfigEntry<float> NemesisEnforcerBaseRegen { get; set; }

		public static ConfigEntry<float> NemesisEnforcerLevelRegen { get; set; }

		public static ConfigEntry<float> NemesisEnforcerBaseDamage { get; set; }

		public static ConfigEntry<float> NemesisEnforcerLevelDamage { get; set; }

		public static ConfigEntry<float> NemesisEnforcerArmor { get; set; }

		public static ConfigEntry<float> NemesisEnforcerSpeed { get; set; }

		public static ConfigEntry<float> MinerBaseHealth { get; set; }

		public static ConfigEntry<float> MinerLevelHealth { get; set; }

		public static ConfigEntry<float> MinerBaseShield { get; set; }

		public static ConfigEntry<float> MinerLevelShield { get; set; }

		public static ConfigEntry<float> MinerBaseRegen { get; set; }

		public static ConfigEntry<float> MinerLevelRegen { get; set; }

		public static ConfigEntry<float> MinerBaseDamage { get; set; }

		public static ConfigEntry<float> MinerLevelDamage { get; set; }

		public static ConfigEntry<float> MinerArmor { get; set; }

		public static ConfigEntry<float> MinerSpeed { get; set; }

		public static void ConfigSetup()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			StatConfig = new ConfigFile(Paths.ConfigPath + "\\SurvivorConfig.cfg", true);
			MandoConfig();
			HuntConfig();
			BndtConfig();
			MulTConfig();
			EngiConfig();
			ArtiConfig();
			MercConfig();
			RexConfig();
			LodrConfig();
			CrocConfig();
			CaptConfig();
			BirbConfig();
			VoidSurvivorConfig();
			RailGunnerConfig();
			SeekerConfig();
			FalseSonConfig();
			CHEFConfig();
			OperatorConfig();
			DrifterConfig();
			RobPaladinConfig();
			NemesisEnforcerConfig();
			MinerConfig();
		}

		public static void MandoConfig()
		{
			MandoBaseHealth = StatConfig.Bind<float>("Commando", "Base Health", 110f, (ConfigDescription)null);
			MandoLevelHealth = StatConfig.Bind<float>("Commando", "Health by level", 33f, (ConfigDescription)null);
			MandoBaseShield = StatConfig.Bind<float>("Commando", "Base Shield", 0f, (ConfigDescription)null);
			MandoLevelShield = StatConfig.Bind<float>("Commando", "Shield by level", 0f, (ConfigDescription)null);
			MandoBaseRegen = StatConfig.Bind<float>("Commando", "Base Regen", 1f, (ConfigDescription)null);
			MandoLevelRegen = StatConfig.Bind<float>("Commando", "Regen by level", 0.2f, (ConfigDescription)null);
			MandoBaseDamage = StatConfig.Bind<float>("Commando", "Base Damage", 12f, (ConfigDescription)null);
			MandoLevelDamage = StatConfig.Bind<float>("Commando", "Damage by level", 2.4f, (ConfigDescription)null);
			MandoArmor = StatConfig.Bind<float>("Commando", "Armor", 0f, (ConfigDescription)null);
			MandoSpeed = StatConfig.Bind<float>("Commando", "Base Speed", 7f, (ConfigDescription)null);
			SurvivorBase.CommandoStats = new CharBase
			{
				healthBase = MandoBaseHealth.Value,
				healthLevel = MandoLevelHealth.Value,
				regenBase = MandoBaseRegen.Value,
				regenLevel = MandoLevelRegen.Value,
				damageBase = MandoBaseDamage.Value,
				damageLevel = MandoLevelDamage.Value,
				shieldBase = MandoBaseShield.Value,
				shieldLevel = MandoLevelShield.Value,
				armor = MandoArmor.Value,
				moveSpeed = MandoSpeed.Value
			};
		}

		public static void HuntConfig()
		{
			HuntBaseHealth = StatConfig.Bind<float>("Huntress", "Base Health", 90f, (ConfigDescription)null);
			HuntLevelHealth = StatConfig.Bind<float>("Huntress", "Health by level", 27f, (ConfigDescription)null);
			HuntBaseShield = StatConfig.Bind<float>("Huntress", "Base Shield", 0f, (ConfigDescription)null);
			HuntLevelShield = StatConfig.Bind<float>("Huntress", "Shield by level", 0f, (ConfigDescription)null);
			HuntBaseRegen = StatConfig.Bind<float>("Huntress", "Base Regen", 1f, (ConfigDescription)null);
			HuntLevelRegen = StatConfig.Bind<float>("Huntress", "Regen by level", 0.2f, (ConfigDescription)null);
			HuntBaseDamage = StatConfig.Bind<float>("Huntress", "Base Damage", 12f, (ConfigDescription)null);
			HuntLevelDamage = StatConfig.Bind<float>("Huntress", "Damage by level", 2.4f, (ConfigDescription)null);
			HuntArmor = StatConfig.Bind<float>("Huntress", "Armor", 0f, (ConfigDescription)null);
			HuntSpeed = StatConfig.Bind<float>("Huntress", "Base Speed", 7f, (ConfigDescription)null);
			SurvivorBase.HuntressStats = new CharBase
			{
				healthBase = HuntBaseHealth.Value,
				healthLevel = HuntLevelHealth.Value,
				regenBase = HuntBaseRegen.Value,
				regenLevel = HuntLevelRegen.Value,
				damageBase = HuntBaseDamage.Value,
				damageLevel = HuntLevelDamage.Value,
				shieldBase = HuntBaseShield.Value,
				shieldLevel = HuntLevelShield.Value,
				armor = HuntArmor.Value,
				moveSpeed = HuntSpeed.Value
			};
		}

		public static void BndtConfig()
		{
			BndtBaseHealth = StatConfig.Bind<float>("Bandit", "Base Health", 110f, (ConfigDescription)null);
			BndtLevelHealth = StatConfig.Bind<float>("Bandit", "Health by level", 33f, (ConfigDescription)null);
			BndtBaseShield = StatConfig.Bind<float>("Bandit", "Base Shield", 0f, (ConfigDescription)null);
			BndtLevelShield = StatConfig.Bind<float>("Bandit", "Shield by level", 0f, (ConfigDescription)null);
			BndtBaseRegen = StatConfig.Bind<float>("Bandit", "Base Regen", 1f, (ConfigDescription)null);
			BndtLevelRegen = StatConfig.Bind<float>("Bandit", "Regen by level", 0.24f, (ConfigDescription)null);
			BndtBaseDamage = StatConfig.Bind<float>("Bandit", "Base Damage", 12f, (ConfigDescription)null);
			BndtLevelDamage = StatConfig.Bind<float>("Bandit", "Damage by level", 2.4f, (ConfigDescription)null);
			BndtArmor = StatConfig.Bind<float>("Bandit", "Armor", 0f, (ConfigDescription)null);
			BndtSpeed = StatConfig.Bind<float>("Bandit", "Base Speed", 7f, (ConfigDescription)null);
			SurvivorBase.BanditStats = new CharBase
			{
				healthBase = BndtBaseHealth.Value,
				healthLevel = BndtLevelHealth.Value,
				regenBase = BndtBaseRegen.Value,
				regenLevel = BndtLevelRegen.Value,
				damageBase = BndtBaseDamage.Value,
				damageLevel = BndtLevelDamage.Value,
				shieldBase = BndtBaseShield.Value,
				shieldLevel = BndtLevelShield.Value,
				armor = BndtArmor.Value,
				moveSpeed = BndtSpeed.Value
			};
		}

		public static void MulTConfig()
		{
			MulTBaseHealth = StatConfig.Bind<float>("MUL-T", "Base Health", 200f, (ConfigDescription)null);
			MulTLevelHealth = StatConfig.Bind<float>("MUL-T", "Health by level", 60f, (ConfigDescription)null);
			MulTBaseShield = StatConfig.Bind<float>("MUL-T", "Base Shield", 0f, (ConfigDescription)null);
			MulTLevelShield = StatConfig.Bind<float>("MUL-T", "Shield by level", 0f, (ConfigDescription)null);
			MulTBaseRegen = StatConfig.Bind<float>("MUL-T", "Base Regen", 1f, (ConfigDescription)null);
			MulTLevelRegen = StatConfig.Bind<float>("MUL-T", "Regen by level", 0.2f, (ConfigDescription)null);
			MulTBaseDamage = StatConfig.Bind<float>("MUL-T", "Base Damage", 11f, (ConfigDescription)null);
			MulTLevelDamage = StatConfig.Bind<float>("MUL-T", "Damage by level", 2.2f, (ConfigDescription)null);
			MulTArmor = StatConfig.Bind<float>("MUL-T", "Armor", 14f, (ConfigDescription)null);
			MulTSpeed = StatConfig.Bind<float>("MUL-T", "Base Speed", 7f, (ConfigDescription)null);
			SurvivorBase.MULTStats = new CharBase
			{
				healthBase = MulTBaseHealth.Value,
				healthLevel = MulTLevelHealth.Value,
				regenBase = MulTBaseRegen.Value,
				regenLevel = MulTLevelRegen.Value,
				damageBase = MulTBaseDamage.Value,
				damageLevel = MulTLevelDamage.Value,
				shieldBase = MulTBaseShield.Value,
				shieldLevel = MulTLevelShield.Value,
				armor = MulTArmor.Value,
				moveSpeed = MulTSpeed.Value
			};
		}

		public static void EngiConfig()
		{
			EngiBaseHealth = StatConfig.Bind<float>("Engineer", "Base Health", 130f, (ConfigDescription)null);
			EngiLevelHealth = StatConfig.Bind<float>("Engineer", "Health by level", 39f, (ConfigDescription)null);
			EngiBaseShield = StatConfig.Bind<float>("Engineer", "Base Shield", 0f, (ConfigDescription)null);
			EngiLevelShield = StatConfig.Bind<float>("Engineer", "Shield by level", 0f, (ConfigDescription)null);
			EngiBaseRegen = StatConfig.Bind<float>("Engineer", "Base Regen", 1f, (ConfigDescription)null);
			EngiLevelRegen = StatConfig.Bind<float>("Engineer", "Regen by level", 0.2f, (ConfigDescription)null);
			EngiBaseDamage = StatConfig.Bind<float>("Engineer", "Base Damage", 14f, (ConfigDescription)null);
			EngiLevelDamage = StatConfig.Bind<float>("Engineer", "Damage by level", 2.8f, (ConfigDescription)null);
			EngiArmor = StatConfig.Bind<float>("Engineer", "Armor", 0f, (ConfigDescription)null);
			EngiSpeed = StatConfig.Bind<float>("Engineer", "Base Speed", 7f, (ConfigDescription)null);
			SurvivorBase.EngineerStats = new CharBase
			{
				healthBase = EngiBaseHealth.Value,
				healthLevel = EngiLevelHealth.Value,
				regenBase = EngiBaseRegen.Value,
				regenLevel = EngiLevelRegen.Value,
				damageBase = EngiBaseDamage.Value,
				damageLevel = EngiLevelDamage.Value,
				shieldBase = EngiBaseShield.Value,
				shieldLevel = EngiLevelShield.Value,
				armor = EngiArmor.Value,
				moveSpeed = EngiSpeed.Value
			};
		}

		public static void ArtiConfig()
		{
			ArtiBaseHealth = StatConfig.Bind<float>("Artificer", "Base Health", 110f, (ConfigDescription)null);
			ArtiLevelHealth = StatConfig.Bind<float>("Artificer", "Health by level", 33f, (ConfigDescription)null);
			ArtiBaseShield = StatConfig.Bind<float>("Artificer", "Base Shield", 0f, (ConfigDescription)null);
			ArtiLevelShield = StatConfig.Bind<float>("Artificer", "Shield by level", 0f, (ConfigDescription)null);
			ArtiBaseRegen = StatConfig.Bind<float>("Artificer", "Base Regen", 1f, (ConfigDescription)null);
			ArtiLevelRegen = StatConfig.Bind<float>("Artificer", "Regen by level", 0.2f, (ConfigDescription)null);
			ArtiBaseDamage = StatConfig.Bind<float>("Artificer", "Base Damage", 12f, (ConfigDescription)null);
			ArtiLevelDamage = StatConfig.Bind<float>("Artificer", "Damage by level", 2.4f, (ConfigDescription)null);
			ArtiArmor = StatConfig.Bind<float>("Artificer", "Armor", 0f, (ConfigDescription)null);
			ArtiSpeed = StatConfig.Bind<float>("Artificer", "Base Speed", 7f, (ConfigDescription)null);
			SurvivorBase.ArtificerStats = new CharBase
			{
				healthBase = ArtiBaseHealth.Value,
				healthLevel = ArtiLevelHealth.Value,
				regenBase = ArtiBaseRegen.Value,
				regenLevel = ArtiLevelRegen.Value,
				damageBase = ArtiBaseDamage.Value,
				damageLevel = ArtiLevelDamage.Value,
				shieldBase = ArtiBaseShield.Value,
				shieldLevel = ArtiLevelShield.Value,
				armor = ArtiArmor.Value,
				moveSpeed = ArtiSpeed.Value
			};
		}

		public static void MercConfig()
		{
			MercBaseHealth = StatConfig.Bind<float>("Mercenary", "Base Health", 110f, (ConfigDescription)null);
			MercLevelHealth = StatConfig.Bind<float>("Mercenary", "Health by level", 33f, (ConfigDescription)null);
			MercBaseShield = StatConfig.Bind<float>("Mercenary", "Base Shield", 0f, (ConfigDescription)null);
			MercLevelShield = StatConfig.Bind<float>("Mercenary", "Shield by level", 0f, (ConfigDescription)null);
			MercBaseRegen = StatConfig.Bind<float>("Mercenary", "Base Regen", 1f, (ConfigDescription)null);
			MercLevelRegen = StatConfig.Bind<float>("Mercenary", "Regen by level", 0.2f, (ConfigDescription)null);
			MercBaseDamage = StatConfig.Bind<float>("Mercenary", "Base Damage", 12f, (ConfigDescription)null);
			MercLevelDamage = StatConfig.Bind<float>("Mercenary", "Damage by level", 2.4f, (ConfigDescription)null);
			MercArmor = StatConfig.Bind<float>("Mercenary", "Armor", 20f, (ConfigDescription)null);
			MercSpeed = StatConfig.Bind<float>("Mercenary", "Base Speed", 7f, (ConfigDescription)null);
			SurvivorBase.MercenaryStats = new CharBase
			{
				healthBase = MercBaseHealth.Value,
				healthLevel = MercLevelHealth.Value,
				regenBase = MercBaseRegen.Value,
				regenLevel = MercLevelRegen.Value,
				damageBase = MercBaseDamage.Value,
				damageLevel = MercLevelDamage.Value,
				shieldBase = MercBaseShield.Value,
				shieldLevel = MercLevelShield.Value,
				armor = MercArmor.Value,
				moveSpeed = MercSpeed.Value
			};
		}

		public static void RexConfig()
		{
			RexBaseHealth = StatConfig.Bind<float>("REX", "Base Health", 130f, (ConfigDescription)null);
			RexLevelHealth = StatConfig.Bind<float>("REX", "Health by level", 39f, (ConfigDescription)null);
			RexBaseShield = StatConfig.Bind<float>("REX", "Base Shield", 0f, (ConfigDescription)null);
			RexLevelShield = StatConfig.Bind<float>("REX", "Shield by level", 0f, (ConfigDescription)null);
			RexBaseRegen = StatConfig.Bind<float>("REX", "Base Regen", 1f, (ConfigDescription)null);
			RexLevelRegen = StatConfig.Bind<float>("REX", "Regen by level", 0.2f, (ConfigDescription)null);
			RexBaseDamage = StatConfig.Bind<float>("REX", "Base Damage", 12f, (ConfigDescription)null);
			RexLevelDamage = StatConfig.Bind<float>("REX", "Damage by level", 2.4f, (ConfigDescription)null);
			RexArmor = StatConfig.Bind<float>("REX", "Armor", 20f, (ConfigDescription)null);
			RexSpeed = StatConfig.Bind<float>("REX", "Base Speed", 7f, (ConfigDescription)null);
			SurvivorBase.REXStats = new CharBase
			{
				healthBase = RexBaseHealth.Value,
				healthLevel = RexLevelHealth.Value,
				regenBase = RexBaseRegen.Value,
				regenLevel = RexLevelRegen.Value,
				damageBase = RexBaseDamage.Value,
				damageLevel = RexLevelDamage.Value,
				shieldBase = RexBaseShield.Value,
				shieldLevel = RexLevelShield.Value,
				armor = RexArmor.Value,
				moveSpeed = RexSpeed.Value
			};
		}

		public static void LodrConfig()
		{
			LodrBaseHealth = StatConfig.Bind<float>("Loader", "Base Health", 160f, (ConfigDescription)null);
			LodrLevelHealth = StatConfig.Bind<float>("Loader", "Health by level", 48f, (ConfigDescription)null);
			LodrBaseShield = StatConfig.Bind<float>("Loader", "Base Shield", 0f, (ConfigDescription)null);
			LodrLevelShield = StatConfig.Bind<float>("Loader", "Shield by level", 0f, (ConfigDescription)null);
			LodrBaseRegen = StatConfig.Bind<float>("Loader", "Base Regen", 2.5f, (ConfigDescription)null);
			LodrLevelRegen = StatConfig.Bind<float>("Loader", "Regen by level", 0.5f, (ConfigDescription)null);
			LodrBaseDamage = StatConfig.Bind<float>("Loader", "Base Damage", 12f, (ConfigDescription)null);
			LodrLevelDamage = StatConfig.Bind<float>("Loader", "Damage by level", 2.4f, (ConfigDescription)null);
			LodrArmor = StatConfig.Bind<float>("Loader", "Armor", 20f, (ConfigDescription)null);
			LodrSpeed = StatConfig.Bind<float>("Loader", "Base Speed", 7f, (ConfigDescription)null);
			SurvivorBase.LoaderStats = new CharBase
			{
				healthBase = LodrBaseHealth.Value,
				healthLevel = LodrLevelHealth.Value,
				regenBase = LodrBaseRegen.Value,
				regenLevel = LodrLevelRegen.Value,
				damageBase = LodrBaseDamage.Value,
				damageLevel = LodrLevelDamage.Value,
				shieldBase = LodrBaseShield.Value,
				shieldLevel = LodrLevelShield.Value,
				armor = LodrArmor.Value,
				moveSpeed = LodrSpeed.Value
			};
		}

		public static void CrocConfig()
		{
			CrocBaseHealth = StatConfig.Bind<float>("Acrid", "Base Health", 160f, (ConfigDescription)null);
			CrocLevelHealth = StatConfig.Bind<float>("Acrid", "Health by level", 48f, (ConfigDescription)null);
			CrocBaseShield = StatConfig.Bind<float>("Acrid", "Base Shield", 0f, (ConfigDescription)null);
			CrocLevelShield = StatConfig.Bind<float>("Acrid", "Shield by level", 0f, (ConfigDescription)null);
			CrocBaseRegen = StatConfig.Bind<float>("Acrid", "Base Regen", 2.5f, (ConfigDescription)null);
			CrocLevelRegen = StatConfig.Bind<float>("Acrid", "Regen by level", 0.5f, (ConfigDescription)null);
			CrocBaseDamage = StatConfig.Bind<float>("Acrid", "Base Damage", 15f, (ConfigDescription)null);
			CrocLevelDamage = StatConfig.Bind<float>("Acrid", "Damage by level", 3f, (ConfigDescription)null);
			CrocArmor = StatConfig.Bind<float>("Acrid", "Armor", 20f, (ConfigDescription)null);
			CrocSpeed = StatConfig.Bind<float>("Acrid", "Base Speed", 7f, (ConfigDescription)null);
			SurvivorBase.AcridStats = new CharBase
			{
				healthBase = CrocBaseHealth.Value,
				healthLevel = CrocLevelHealth.Value,
				regenBase = CrocBaseRegen.Value,
				regenLevel = CrocLevelRegen.Value,
				damageBase = CrocBaseDamage.Value,
				damageLevel = CrocLevelDamage.Value,
				shieldBase = CrocBaseShield.Value,
				shieldLevel = CrocLevelShield.Value,
				armor = CrocArmor.Value,
				moveSpeed = CrocSpeed.Value
			};
		}

		public static void CaptConfig()
		{
			CaptBaseHealth = StatConfig.Bind<float>("Captain", "Base Health", 110f, (ConfigDescription)null);
			CaptLevelHealth = StatConfig.Bind<float>("Captain", "Health by level", 33f, (ConfigDescription)null);
			CaptBaseShield = StatConfig.Bind<float>("Captain", "Base Shield", 0f, (ConfigDescription)null);
			CaptLevelShield = StatConfig.Bind<float>("Captain", "Shield by level", 0f, (ConfigDescription)null);
			CaptBaseRegen = StatConfig.Bind<float>("Captain", "Base Regen", 1f, (ConfigDescription)null);
			CaptLevelRegen = StatConfig.Bind<float>("Captain", "Regen by level", 0.2f, (ConfigDescription)null);
			CaptBaseDamage = StatConfig.Bind<float>("Captain", "Base Damage", 12f, (ConfigDescription)null);
			CaptLevelDamage = StatConfig.Bind<float>("Captain", "Damage by level", 2.4f, (ConfigDescription)null);
			CaptArmor = StatConfig.Bind<float>("Captain", "Armor", 0f, (ConfigDescription)null);
			CaptSpeed = StatConfig.Bind<float>("Captain", "Base Speed", 7f, (ConfigDescription)null);
			SurvivorBase.CaptainStats = new CharBase
			{
				healthBase = CaptBaseHealth.Value,
				healthLevel = CaptLevelHealth.Value,
				regenBase = CaptBaseRegen.Value,
				regenLevel = CaptLevelRegen.Value,
				damageBase = CaptBaseDamage.Value,
				damageLevel = CaptLevelDamage.Value,
				shieldBase = CaptBaseShield.Value,
				shieldLevel = CaptLevelShield.Value,
				armor = CaptArmor.Value,
				moveSpeed = CaptSpeed.Value
			};
		}

		public static void BirbConfig()
		{
			BirbBaseHealth = StatConfig.Bind<float>("Heretic", "Base Health", 440f, (ConfigDescription)null);
			BirbLevelHealth = StatConfig.Bind<float>("Heretic", "Health by level", 132f, (ConfigDescription)null);
			BirbBaseShield = StatConfig.Bind<float>("Heretic", "Base Shield", 0f, (ConfigDescription)null);
			BirbLevelShield = StatConfig.Bind<float>("Heretic", "Shield by level", 0f, (ConfigDescription)null);
			BirbBaseRegen = StatConfig.Bind<float>("Heretic", "Base Regen", -6f, (ConfigDescription)null);
			BirbLevelRegen = StatConfig.Bind<float>("Heretic", "Regen by level", -1.2f, (ConfigDescription)null);
			BirbBaseDamage = StatConfig.Bind<float>("Heretic", "Base Damage", 18f, (ConfigDescription)null);
			BirbLevelDamage = StatConfig.Bind<float>("Heretic", "Damage by level", 3.6f, (ConfigDescription)null);
			BirbArmor = StatConfig.Bind<float>("Heretic", "Armor", 0f, (ConfigDescription)null);
			BirbSpeed = StatConfig.Bind<float>("Heretic", "Base Speed", 8f, (ConfigDescription)null);
			SurvivorBase.HereticStats = new CharBase
			{
				healthBase = BirbBaseHealth.Value,
				healthLevel = BirbLevelHealth.Value,
				regenBase = BirbBaseRegen.Value,
				regenLevel = BirbLevelRegen.Value,
				damageBase = BirbBaseDamage.Value,
				damageLevel = BirbLevelDamage.Value,
				shieldBase = BirbBaseShield.Value,
				shieldLevel = BirbLevelShield.Value,
				armor = BirbArmor.Value,
				moveSpeed = BirbSpeed.Value
			};
		}

		public static void VoidSurvivorConfig()
		{
			VoidSurvivorBaseHealth = StatConfig.Bind<float>("Voidfiend", "Base Health", 110f, (ConfigDescription)null);
			VoidSurvivorLevelHealth = StatConfig.Bind<float>("Voidfiend", "Health by level", 33f, (ConfigDescription)null);
			VoidSurvivorBaseShield = StatConfig.Bind<float>("Voidfiend", "Base Shield", 0f, (ConfigDescription)null);
			VoidSurvivorLevelShield = StatConfig.Bind<float>("Voidfiend", "Shield by level", 0f, (ConfigDescription)null);
			VoidSurvivorBaseRegen = StatConfig.Bind<float>("Voidfiend", "Base Regen", 1f, (ConfigDescription)null);
			VoidSurvivorLevelRegen = StatConfig.Bind<float>("Voidfiend", "Regen by level", 0.2f, (ConfigDescription)null);
			VoidSurvivorBaseDamage = StatConfig.Bind<float>("Voidfiend", "Base Damage", 12f, (ConfigDescription)null);
			VoidSurvivorLevelDamage = StatConfig.Bind<float>("Voidfiend", "Damage by level", 2.4f, (ConfigDescription)null);
			VoidSurvivorArmor = StatConfig.Bind<float>("Voidfiend", "Armor", 0f, (ConfigDescription)null);
			VoidSurvivorSpeed = StatConfig.Bind<float>("Voidfiend", "Base Speed", 7f, (ConfigDescription)null);
			SurvivorBase.VoidFiendStats = new CharBase
			{
				healthBase = VoidSurvivorBaseHealth.Value,
				healthLevel = VoidSurvivorLevelHealth.Value,
				regenBase = VoidSurvivorBaseRegen.Value,
				regenLevel = VoidSurvivorLevelRegen.Value,
				damageBase = VoidSurvivorBaseDamage.Value,
				damageLevel = VoidSurvivorLevelDamage.Value,
				shieldBase = VoidSurvivorBaseShield.Value,
				shieldLevel = VoidSurvivorLevelShield.Value,
				armor = VoidSurvivorArmor.Value,
				moveSpeed = VoidSurvivorSpeed.Value
			};
		}

		public static void RailGunnerConfig()
		{
			RailGunnerBaseHealth = StatConfig.Bind<float>("Railgunner", "Base Health", 110f, (ConfigDescription)null);
			RailGunnerLevelHealth = StatConfig.Bind<float>("Railgunner", "Health by level", 33f, (ConfigDescription)null);
			RailGunnerBaseShield = StatConfig.Bind<float>("Railgunner", "Base Shield", 0f, (ConfigDescription)null);
			RailGunnerLevelShield = StatConfig.Bind<float>("Railgunner", "Shield by level", 0f, (ConfigDescription)null);
			RailGunnerBaseRegen = StatConfig.Bind<float>("Railgunner", "Base Regen", 1f, (ConfigDescription)null);
			RailGunnerLevelRegen = StatConfig.Bind<float>("Railgunner", "Regen by level", 0.2f, (ConfigDescription)null);
			RailGunnerBaseDamage = StatConfig.Bind<float>("Railgunner", "Base Damage", 12f, (ConfigDescription)null);
			RailGunnerLevelDamage = StatConfig.Bind<float>("Railgunner", "Damage by level", 2.4f, (ConfigDescription)null);
			RailGunnerArmor = StatConfig.Bind<float>("Railgunner", "Armor", 0f, (ConfigDescription)null);
			RailGunnerSpeed = StatConfig.Bind<float>("Railgunner", "Base Speed", 7f, (ConfigDescription)null);
			SurvivorBase.RailgunnerStats = new CharBase
			{
				healthBase = RailGunnerBaseHealth.Value,
				healthLevel = RailGunnerLevelHealth.Value,
				regenBase = RailGunnerBaseRegen.Value,
				regenLevel = RailGunnerLevelRegen.Value,
				damageBase = RailGunnerBaseDamage.Value,
				damageLevel = RailGunnerLevelDamage.Value,
				shieldBase = RailGunnerBaseShield.Value,
				shieldLevel = RailGunnerLevelShield.Value,
				armor = RailGunnerArmor.Value,
				moveSpeed = RailGunnerSpeed.Value
			};
		}

		public static void SeekerConfig()
		{
			SeekerBaseHealth = StatConfig.Bind<float>("Seeker", "Base Health", 115f, (ConfigDescription)null);
			SeekerLevelHealth = StatConfig.Bind<float>("Seeker", "Health by level", 34f, (ConfigDescription)null);
			SeekerBaseShield = StatConfig.Bind<float>("Seeker", "Base Shield", 0f, (ConfigDescription)null);
			SeekerLevelShield = StatConfig.Bind<float>("Seeker", "Shield by level", 0f, (ConfigDescription)null);
			SeekerBaseRegen = StatConfig.Bind<float>("Seeker", "Base Regen", 0.75f, (ConfigDescription)null);
			SeekerLevelRegen = StatConfig.Bind<float>("Seeker", "Regen by level", 0.15f, (ConfigDescription)null);
			SeekerBaseDamage = StatConfig.Bind<float>("Seeker", "Base Damage", 12f, (ConfigDescription)null);
			SeekerLevelDamage = StatConfig.Bind<float>("Seeker", "Damage by level", 2.4f, (ConfigDescription)null);
			SeekerArmor = StatConfig.Bind<float>("Seeker", "Armor", 20f, (ConfigDescription)null);
			SeekerSpeed = StatConfig.Bind<float>("Seeker", "Base Speed", 7f, (ConfigDescription)null);
			SurvivorBase.SeekerStats = new CharBase
			{
				healthBase = SeekerBaseHealth.Value,
				healthLevel = SeekerLevelHealth.Value,
				regenBase = SeekerBaseRegen.Value,
				regenLevel = SeekerLevelRegen.Value,
				damageBase = SeekerBaseDamage.Value,
				damageLevel = SeekerLevelDamage.Value,
				shieldBase = SeekerBaseShield.Value,
				shieldLevel = SeekerLevelShield.Value,
				armor = SeekerArmor.Value,
				moveSpeed = SeekerSpeed.Value
			};
		}

		public static void FalseSonConfig()
		{
			FalseSonBaseHealth = StatConfig.Bind<float>("FalseSon", "Base Health", 180f, (ConfigDescription)null);
			FalseSonLevelHealth = StatConfig.Bind<float>("FalseSon", "Health by level", 54f, (ConfigDescription)null);
			FalseSonBaseShield = StatConfig.Bind<float>("FalseSon", "Base Shield", 0f, (ConfigDescription)null);
			FalseSonLevelShield = StatConfig.Bind<float>("FalseSon", "Shield by level", 0f, (ConfigDescription)null);
			FalseSonBaseRegen = StatConfig.Bind<float>("FalseSon", "Base Regen", 1f, (ConfigDescription)null);
			FalseSonLevelRegen = StatConfig.Bind<float>("FalseSon", "Regen by level", 0.2f, (ConfigDescription)null);
			FalseSonBaseDamage = StatConfig.Bind<float>("FalseSon", "Base Damage", 12f, (ConfigDescription)null);
			FalseSonLevelDamage = StatConfig.Bind<float>("FalseSon", "Damage by level", 2.4f, (ConfigDescription)null);
			FalseSonArmor = StatConfig.Bind<float>("FalseSon", "Armor", 20f, (ConfigDescription)null);
			FalseSonSpeed = StatConfig.Bind<float>("FalseSon", "Base Speed", 7f, (ConfigDescription)null);
			SurvivorBase.FalseSonStats = new CharBase
			{
				healthBase = FalseSonBaseHealth.Value,
				healthLevel = FalseSonLevelHealth.Value,
				regenBase = FalseSonBaseRegen.Value,
				regenLevel = FalseSonLevelRegen.Value,
				damageBase = FalseSonBaseDamage.Value,
				damageLevel = FalseSonLevelDamage.Value,
				shieldBase = FalseSonBaseShield.Value,
				shieldLevel = FalseSonLevelShield.Value,
				armor = FalseSonArmor.Value,
				moveSpeed = FalseSonSpeed.Value
			};
		}

		public static void CHEFConfig()
		{
			CHEFBaseHealth = StatConfig.Bind<float>("CHEF", "Base Health", 110f, (ConfigDescription)null);
			CHEFLevelHealth = StatConfig.Bind<float>("CHEF", "Health by level", 33f, (ConfigDescription)null);
			CHEFBaseShield = StatConfig.Bind<float>("CHEF", "Base Shield", 0f, (ConfigDescription)null);
			CHEFLevelShield = StatConfig.Bind<float>("CHEF", "Shield by level", 0f, (ConfigDescription)null);
			CHEFBaseRegen = StatConfig.Bind<float>("CHEF", "Base Regen", 1f, (ConfigDescription)null);
			CHEFLevelRegen = StatConfig.Bind<float>("CHEF", "Regen by level", 0.2f, (ConfigDescription)null);
			CHEFBaseDamage = StatConfig.Bind<float>("CHEF", "Base Damage", 12f, (ConfigDescription)null);
			CHEFLevelDamage = StatConfig.Bind<float>("CHEF", "Damage by level", 2.4f, (ConfigDescription)null);
			CHEFArmor = StatConfig.Bind<float>("CHEF", "Armor", 0f, (ConfigDescription)null);
			CHEFSpeed = StatConfig.Bind<float>("CHEF", "Base Speed", 7f, (ConfigDescription)null);
			SurvivorBase.CHEFStats = new CharBase
			{
				healthBase = CHEFBaseHealth.Value,
				healthLevel = CHEFLevelHealth.Value,
				regenBase = CHEFBaseRegen.Value,
				regenLevel = CHEFLevelRegen.Value,
				damageBase = CHEFBaseDamage.Value,
				damageLevel = CHEFLevelDamage.Value,
				shieldBase = CHEFBaseShield.Value,
				shieldLevel = CHEFLevelShield.Value,
				armor = CHEFArmor.Value,
				moveSpeed = CHEFSpeed.Value
			};
		}

		public static void OperatorConfig()
		{
			OperatorBaseHealth = StatConfig.Bind<float>("Operator", "Base Health", 90f, (ConfigDescription)null);
			OperatorLevelHealth = StatConfig.Bind<float>("Operator", "Health by level", 27f, (ConfigDescription)null);
			OperatorBaseShield = StatConfig.Bind<float>("Operator", "Base Shield", 0f, (ConfigDescription)null);
			OperatorLevelShield = StatConfig.Bind<float>("Operator", "Shield by level", 0f, (ConfigDescription)null);
			OperatorBaseRegen = StatConfig.Bind<float>("Operator", "Base Regen", 1f, (ConfigDescription)null);
			OperatorLevelRegen = StatConfig.Bind<float>("Operator", "Regen by level", 0.2f, (ConfigDescription)null);
			OperatorBaseDamage = StatConfig.Bind<float>("Operator", "Base Damage", 12f, (ConfigDescription)null);
			OperatorLevelDamage = StatConfig.Bind<float>("Operator", "Damage by level", 2.4f, (ConfigDescription)null);
			OperatorArmor = StatConfig.Bind<float>("Operator", "Armor", 0f, (ConfigDescription)null);
			OperatorSpeed = StatConfig.Bind<float>("Operator", "Base Speed", 7f, (ConfigDescription)null);
			SurvivorBase.OperatorStats = new CharBase
			{
				healthBase = OperatorBaseHealth.Value,
				healthLevel = OperatorLevelHealth.Value,
				regenBase = OperatorBaseRegen.Value,
				regenLevel = OperatorLevelRegen.Value,
				damageBase = OperatorBaseDamage.Value,
				damageLevel = OperatorLevelDamage.Value,
				shieldBase = OperatorBaseShield.Value,
				shieldLevel = OperatorLevelShield.Value,
				armor = OperatorArmor.Value,
				moveSpeed = OperatorSpeed.Value
			};
		}

		public static void DrifterConfig()
		{
			DrifterBaseHealth = StatConfig.Bind<float>("Drifter", "Base Health", 170f, (ConfigDescription)null);
			DrifterLevelHealth = StatConfig.Bind<float>("Drifter", "Health by level", 52f, (ConfigDescription)null);
			DrifterBaseShield = StatConfig.Bind<float>("Drifter", "Base Shield", 0f, (ConfigDescription)null);
			DrifterLevelShield = StatConfig.Bind<float>("Drifter", "Shield by level", 0f, (ConfigDescription)null);
			DrifterBaseRegen = StatConfig.Bind<float>("Drifter", "Base Regen", 1f, (ConfigDescription)null);
			DrifterLevelRegen = StatConfig.Bind<float>("Drifter", "Regen by level", 0.2f, (ConfigDescription)null);
			DrifterBaseDamage = StatConfig.Bind<float>("Drifter", "Base Damage", 12f, (ConfigDescription)null);
			DrifterLevelDamage = StatConfig.Bind<float>("Drifter", "Damage by level", 2.4f, (ConfigDescription)null);
			DrifterArmor = StatConfig.Bind<float>("Drifter", "Armor", 20f, (ConfigDescription)null);
			DrifterSpeed = StatConfig.Bind<float>("Drifter", "Base Speed", 7f, (ConfigDescription)null);
			SurvivorBase.DrifterStats = new CharBase
			{
				healthBase = DrifterBaseHealth.Value,
				healthLevel = DrifterLevelHealth.Value,
				regenBase = DrifterBaseRegen.Value,
				regenLevel = DrifterLevelRegen.Value,
				damageBase = DrifterBaseDamage.Value,
				damageLevel = DrifterLevelDamage.Value,
				shieldBase = DrifterBaseShield.Value,
				shieldLevel = DrifterLevelShield.Value,
				armor = DrifterArmor.Value,
				moveSpeed = DrifterSpeed.Value
			};
		}

		public static void RobPaladinConfig()
		{
			RobPaladinBaseHealth = StatConfig.Bind<float>("RobPaladin", "Base Health", 110f, (ConfigDescription)null);
			RobPaladinLevelHealth = StatConfig.Bind<float>("RobPaladin", "Health by level", 33f, (ConfigDescription)null);
			RobPaladinBaseShield = StatConfig.Bind<float>("RobPaladin", "Base Shield", 0f, (ConfigDescription)null);
			RobPaladinLevelShield = StatConfig.Bind<float>("RobPaladin", "Shield by level", 0f, (ConfigDescription)null);
			RobPaladinBaseRegen = StatConfig.Bind<float>("RobPaladin", "Base Regen", 1f, (ConfigDescription)null);
			RobPaladinLevelRegen = StatConfig.Bind<float>("RobPaladin", "Regen by level", 0.2f, (ConfigDescription)null);
			RobPaladinBaseDamage = StatConfig.Bind<float>("RobPaladin", "Base Damage", 12f, (ConfigDescription)null);
			RobPaladinLevelDamage = StatConfig.Bind<float>("RobPaladin", "Damage by level", 2.4f, (ConfigDescription)null);
			RobPaladinArmor = StatConfig.Bind<float>("RobPaladin", "Armor", 12f, (ConfigDescription)null);
			RobPaladinSpeed = StatConfig.Bind<float>("RobPaladin", "Base Speed", 7f, (ConfigDescription)null);
			SurvivorBase.robpaladinStats = new CharBase
			{
				healthBase = RobPaladinBaseHealth.Value,
				healthLevel = RobPaladinLevelHealth.Value,
				regenBase = RobPaladinBaseRegen.Value,
				regenLevel = RobPaladinLevelRegen.Value,
				damageBase = RobPaladinBaseDamage.Value,
				damageLevel = RobPaladinLevelDamage.Value,
				shieldBase = RobPaladinBaseShield.Value,
				shieldLevel = RobPaladinLevelShield.Value,
				armor = RobPaladinArmor.Value,
				moveSpeed = RobPaladinSpeed.Value
			};
		}

		public static void NemesisEnforcerConfig()
		{
			NemesisEnforcerBaseHealth = StatConfig.Bind<float>("NemesisEnforcer", "Base Health", 224f, (ConfigDescription)null);
			NemesisEnforcerLevelHealth = StatConfig.Bind<float>("NemesisEnforcer", "Health by level", 56f, (ConfigDescription)null);
			NemesisEnforcerBaseShield = StatConfig.Bind<float>("NemesisEnforcer", "Base Shield", 0f, (ConfigDescription)null);
			NemesisEnforcerLevelShield = StatConfig.Bind<float>("NemesisEnforcer", "Shield by level", 0f, (ConfigDescription)null);
			NemesisEnforcerBaseRegen = StatConfig.Bind<float>("NemesisEnforcer", "Base Regen", 0.5f, (ConfigDescription)null);
			NemesisEnforcerLevelRegen = StatConfig.Bind<float>("NemesisEnforcer", "Regen by level", 0.25f, (ConfigDescription)null);
			NemesisEnforcerBaseDamage = StatConfig.Bind<float>("NemesisEnforcer", "Base Damage", 12f, (ConfigDescription)null);
			NemesisEnforcerLevelDamage = StatConfig.Bind<float>("NemesisEnforcer", "Damage by level", 2.4f, (ConfigDescription)null);
			NemesisEnforcerArmor = StatConfig.Bind<float>("NemesisEnforcer", "Armor", 0f, (ConfigDescription)null);
			NemesisEnforcerSpeed = StatConfig.Bind<float>("NemesisEnforcer", "Base Speed", 7f, (ConfigDescription)null);
			SurvivorBase.nemesisenforcerStats = new CharBase
			{
				healthBase = NemesisEnforcerBaseHealth.Value,
				healthLevel = NemesisEnforcerLevelHealth.Value,
				regenBase = NemesisEnforcerBaseRegen.Value,
				regenLevel = NemesisEnforcerLevelRegen.Value,
				damageBase = NemesisEnforcerBaseDamage.Value,
				damageLevel = NemesisEnforcerLevelDamage.Value,
				shieldBase = NemesisEnforcerBaseShield.Value,
				shieldLevel = NemesisEnforcerLevelShield.Value,
				armor = NemesisEnforcerArmor.Value,
				moveSpeed = NemesisEnforcerSpeed.Value
			};
		}

		public static void MinerConfig()
		{
			MinerBaseHealth = StatConfig.Bind<float>("Miner", "Base Health", 140f, (ConfigDescription)null);
			MinerLevelHealth = StatConfig.Bind<float>("Miner", "Health by level", 42f, (ConfigDescription)null);
			MinerBaseShield = StatConfig.Bind<float>("Miner", "Base Shield", 0f, (ConfigDescription)null);
			MinerLevelShield = StatConfig.Bind<float>("Miner", "Shield by level", 0f, (ConfigDescription)null);
			MinerBaseRegen = StatConfig.Bind<float>("Miner", "Base Regen", 1f, (ConfigDescription)null);
			MinerLevelRegen = StatConfig.Bind<float>("Miner", "Regen by level", 0.2f, (ConfigDescription)null);
			MinerBaseDamage = StatConfig.Bind<float>("Miner", "Base Damage", 12f, (ConfigDescription)null);
			MinerLevelDamage = StatConfig.Bind<float>("Miner", "Damage by level", 2.4f, (ConfigDescription)null);
			MinerArmor = StatConfig.Bind<float>("Miner", "Armor", 20f, (ConfigDescription)null);
			MinerSpeed = StatConfig.Bind<float>("Miner", "Base Speed", 7f, (ConfigDescription)null);
			SurvivorBase.minerStats = new CharBase
			{
				healthBase = MinerBaseHealth.Value,
				healthLevel = MinerLevelHealth.Value,
				regenBase = MinerBaseRegen.Value,
				regenLevel = MinerLevelRegen.Value,
				damageBase = MinerBaseDamage.Value,
				damageLevel = MinerLevelDamage.Value,
				shieldBase = MinerBaseShield.Value,
				shieldLevel = MinerLevelShield.Value,
				armor = MinerArmor.Value,
				moveSpeed = MinerSpeed.Value
			};
		}
	}
	[BepInPlugin("com.KingOblivion.UpdatedSurvivorStatConfig", "UpdatedSurvivorStatConfig", "0.1")]
	public class SurvivorPlugin : BaseUnityPlugin
	{
		public void Awake()
		{
			SurvivorBase.Rebalance();
		}
	}
}
namespace SurvivorConfig.Characters
{
	public class CharBase
	{
		public float healthBase;

		public float healthLevel;

		public float regenBase;

		public float regenLevel;

		public float shieldBase;

		public float shieldLevel;

		public float damageBase;

		public float damageLevel;

		public float armor;

		public float moveSpeed;
	}
	internal class CharChanges : SurvivorBase
	{
		public static void Gaming()
		{
			Debug.Log((object)"Importing changes...");
			SurvivorBase.CommandoPrefab = BodyCatalog.FindBodyPrefab("CommandoBody");
			ApplyChanges(SurvivorBase.CommandoPrefab.GetComponent<CharacterBody>(), SurvivorBase.CommandoStats);
			Debug.Log((object)"Commando done.");
			SurvivorBase.HuntressPrefab = BodyCatalog.FindBodyPrefab("HuntressBody");
			ApplyChanges(SurvivorBase.HuntressPrefab.GetComponent<CharacterBody>(), SurvivorBase.HuntressStats);
			Debug.Log((object)"Huntress done.");
			SurvivorBase.BanditPrefab = BodyCatalog.FindBodyPrefab("Bandit2Body");
			ApplyChanges(SurvivorBase.BanditPrefab.GetComponent<CharacterBody>(), SurvivorBase.BanditStats);
			Debug.Log((object)"Bandit done.");
			SurvivorBase.MULTPrefab = BodyCatalog.FindBodyPrefab("ToolbotBody");
			ApplyChanges(SurvivorBase.MULTPrefab.GetComponent<CharacterBody>(), SurvivorBase.MULTStats);
			Debug.Log((object)"MUL-T done.");
			SurvivorBase.EngineerPrefab = BodyCatalog.FindBodyPrefab("EngiBody");
			ApplyChanges(SurvivorBase.EngineerPrefab.GetComponent<CharacterBody>(), SurvivorBase.EngineerStats);
			Debug.Log((object)"Engineer done.");
			SurvivorBase.ArtificerPrefab = BodyCatalog.FindBodyPrefab("MageBody");
			ApplyChanges(SurvivorBase.ArtificerPrefab.GetComponent<CharacterBody>(), SurvivorBase.ArtificerStats);
			Debug.Log((object)"Artificer done.");
			SurvivorBase.MercenaryPrefab = BodyCatalog.FindBodyPrefab("MercBody");
			ApplyChanges(SurvivorBase.MercenaryPrefab.GetComponent<CharacterBody>(), SurvivorBase.MercenaryStats);
			Debug.Log((object)"Mercenary done.");
			SurvivorBase.REXPrefab = BodyCatalog.FindBodyPrefab("TreebotBody");
			ApplyChanges(SurvivorBase.REXPrefab.GetComponent<CharacterBody>(), SurvivorBase.REXStats);
			Debug.Log((object)"REX done.");
			SurvivorBase.LoaderPrefab = BodyCatalog.FindBodyPrefab("LoaderBody");
			ApplyChanges(SurvivorBase.LoaderPrefab.GetComponent<CharacterBody>(), SurvivorBase.LoaderStats);
			Debug.Log((object)"Loader done.");
			SurvivorBase.AcridPrefab = BodyCatalog.FindBodyPrefab("CrocoBody");
			ApplyChanges(SurvivorBase.AcridPrefab.GetComponent<CharacterBody>(), SurvivorBase.AcridStats);
			Debug.Log((object)"Acrid done.");
			SurvivorBase.CaptainPrefab = BodyCatalog.FindBodyPrefab("CaptainBody");
			ApplyChanges(SurvivorBase.CaptainPrefab.GetComponent<CharacterBody>(), SurvivorBase.CaptainStats);
			Debug.Log((object)"Captain done.");
			SurvivorBase.HereticPrefab = BodyCatalog.FindBodyPrefab("HereticBody");
			ApplyChanges(SurvivorBase.HereticPrefab.GetComponent<CharacterBody>(), SurvivorBase.HereticStats);
			Debug.Log((object)"Heretic done.");
			SurvivorBase.VoidFiendPrefab = BodyCatalog.FindBodyPrefab("VoidSurvivorBody");
			ApplyChanges(SurvivorBase.VoidFiendPrefab.GetComponent<CharacterBody>(), SurvivorBase.VoidFiendStats);
			Debug.Log((object)"Voidfiend done.");
			SurvivorBase.RailgunnerPrefab = BodyCatalog.FindBodyPrefab("RailgunnerBody");
			ApplyChanges(SurvivorBase.RailgunnerPrefab.GetComponent<CharacterBody>(), SurvivorBase.RailgunnerStats);
			Debug.Log((object)"RailGunner done.");
			SurvivorBase.SeekerPrefab = BodyCatalog.FindBodyPrefab("SeekerBody");
			ApplyChanges(SurvivorBase.SeekerPrefab.GetComponent<CharacterBody>(), SurvivorBase.SeekerStats);
			Debug.Log((object)"Seeker done.");
			SurvivorBase.FalseSonPrefab = BodyCatalog.FindBodyPrefab("FalseSonBody");
			ApplyChanges(SurvivorBase.FalseSonPrefab.GetComponent<CharacterBody>(), SurvivorBase.FalseSonStats);
			Debug.Log((object)"False Son done.");
			SurvivorBase.CHEFPrefab = BodyCatalog.FindBodyPrefab("ChefBody");
			ApplyChanges(SurvivorBase.CHEFPrefab.GetComponent<CharacterBody>(), SurvivorBase.CHEFStats);
			Debug.Log((object)"CHEF done.");
			SurvivorBase.DrifterPrefab = BodyCatalog.FindBodyPrefab("DrifterBody");
			ApplyChanges(SurvivorBase.DrifterPrefab.GetComponent<CharacterBody>(), SurvivorBase.DrifterStats);
			Debug.Log((object)"Drifter done.");
			SurvivorBase.OperatorPrefab = BodyCatalog.FindBodyPrefab("DroneTechBody");
			ApplyChanges(SurvivorBase.OperatorPrefab.GetComponent<CharacterBody>(), SurvivorBase.OperatorStats);
			Debug.Log((object)"Operator done.");
			SurvivorBase.robpaladinPrefab = BodyCatalog.FindBodyPrefab("RobPaladinBody");
			if (Object.op_Implicit((Object)(object)SurvivorBase.robpaladinPrefab))
			{
				ApplyChanges(SurvivorBase.robpaladinPrefab.GetComponent<CharacterBody>(), SurvivorBase.robpaladinStats);
				Debug.Log((object)"RobPaladin done.");
			}
			SurvivorBase.nemesisenforcerPrefab = BodyCatalog.FindBodyPrefab("NemesisEnforcerBody");
			if (Object.op_Implicit((Object)(object)SurvivorBase.nemesisenforcerPrefab))
			{
				ApplyChanges(SurvivorBase.nemesisenforcerPrefab.GetComponent<CharacterBody>(), SurvivorBase.nemesisenforcerStats);
				Debug.Log((object)"NemesisEnforcer done.");
			}
			SurvivorBase.minerPrefab = BodyCatalog.FindBodyPrefab("MinerBody");
			if (Object.op_Implicit((Object)(object)SurvivorBase.minerPrefab))
			{
				ApplyChanges(SurvivorBase.minerPrefab.GetComponent<CharacterBody>(), SurvivorBase.minerStats);
				Debug.Log((object)"Miner done.");
			}
		}

		public static void ApplyChanges(CharacterBody body, CharBase charBase)
		{
			body.baseMaxHealth = charBase.healthBase;
			body.levelMaxHealth = charBase.healthLevel;
			body.baseRegen = charBase.regenBase;
			body.levelRegen = charBase.regenLevel;
			body.baseMaxShield = charBase.shieldBase;
			body.levelMaxShield = charBase.shieldLevel;
			body.baseDamage = charBase.damageBase;
			body.levelDamage = charBase.damageLevel;
			body.baseArmor = charBase.armor;
			body.baseMoveSpeed = charBase.moveSpeed;
		}
	}
}