using System;
using System.Collections;
using System.Collections.Generic;
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.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HG.Coroutines;
using HG.Reflection;
using Microsoft.CodeAnalysis;
using On.RoR2;
using RiskOfOptions;
using RiskOfOptions.Options;
using RoR2;
using RoR2.Skills;
using UnityEngine;

[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("SkillsConfigurator")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+0ff8c0689331e0d3cd97adef6e6ffc972fbc8758")]
[assembly: AssemblyProduct("SkillsConfigurator")]
[assembly: AssemblyTitle("SkillsConfigurator")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
[module: UnverifiableCode]
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 SkillsConfigurator
{
	public static class ModCompatabilities
	{
		public static class RiskOfOptionsCompatability
		{
			public const string GUID = "com.rune580.riskofoptions";

			public static void AddConfig<T>(T config) where T : ConfigEntryBase
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Expected O, but got Unknown
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Expected O, but got Unknown
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Expected O, but got Unknown
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Expected O, but got Unknown
				if (config is ConfigEntry<float>)
				{
					ModSettingsManager.AddOption((BaseOption)new FloatFieldOption(config as ConfigEntry<float>));
				}
				if (config is ConfigEntry<bool>)
				{
					ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(config as ConfigEntry<bool>));
				}
				if (config is ConfigEntry<int>)
				{
					ModSettingsManager.AddOption((BaseOption)new IntFieldOption(config as ConfigEntry<int>));
				}
				if (config is ConfigEntry<string>)
				{
					ModSettingsManager.AddOption((BaseOption)new StringInputFieldOption(config as ConfigEntry<string>));
				}
			}
		}
	}
	[Serializable]
	[BepInPlugin("com.brynzananas.skillsconfigurator", "Skills Configurator", "1.2.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class SkillsConfiguratorPlugin : BaseUnityPlugin
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_SetSkillVariant <0>__BodyLoadoutManager_SetSkillVariant;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass27_0
		{
			public ParallelCoroutine loadCoroutine;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass29_0
		{
			public SkillDef skillDef;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass29_1
		{
			public ConfigEntry<float> baseRechargeInterval;

			public ConfigEntry<int> baseMaxStock;

			public ConfigEntry<int> rechargeStock;

			public ConfigEntry<int> requiredStock;

			public ConfigEntry<int> stockToConsume;

			public ConfigEntry<bool> attackSpeedBuffsRestockSpeed;

			public ConfigEntry<float> attackSpeedBuffsRestockSpeed_Multiplier;

			public ConfigEntry<bool> resetCooldownTimerOnUse;

			public ConfigEntry<bool> fullRestockOnAssign;

			public ConfigEntry<bool> dontAllowPastMaxStocks;

			public ConfigEntry<bool> beginSkillCooldownOnSkillEnd;

			public ConfigEntry<bool> isCooldownBlockedUntilManuallyReset;

			public ConfigEntry<bool> cancelSprintingOnActivation;

			public ConfigEntry<bool> forceSprintDuringState;

			public ConfigEntry<bool> canceledFromSprinting;

			public ConfigEntry<bool> isCombatSkill;

			public ConfigEntry<bool> mustKeyPress;

			public ConfigEntry<bool> triggeredByPressRelease;

			public ConfigEntry<bool> autoHandleLuminousShot;

			public ConfigEntry<bool> suppressSkillActivation;

			public <>c__DisplayClass29_0 CS$<>8__locals1;
		}

		[CompilerGenerated]
		private sealed class <ConfigureSkillThread>d__29 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SkillDef skillDef;

			public int loc;

			private <>c__DisplayClass29_0 <>8__1;

			private string <sectionName>5__2;

			private List<ConfigEntryBase> <configEntryBases>5__3;

			private ConfigEntry<bool> <enable>5__4;

			private <>c__DisplayClass29_1 <>8__5;

			private List<ConfigEntryBase>.Enumerator <>s__6;

			private ConfigEntryBase <configEntryBase>5__7;

			private ConfigEntry<float> <configEntry>5__8;

			private ConfigEntry<int> <configEntry2>5__9;

			private ConfigEntry<bool> <configEntry1>5__10;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ConfigureSkillThread>d__29(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<sectionName>5__2 = null;
				<configEntryBases>5__3 = null;
				<enable>5__4 = null;
				<>8__5 = null;
				<>s__6 = default(List<ConfigEntryBase>.Enumerator);
				<configEntryBase>5__7 = null;
				<configEntry>5__8 = null;
				<configEntry2>5__9 = null;
				<configEntry1>5__10 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				<>8__1 = new <>c__DisplayClass29_0();
				<>8__1.skillDef = skillDef;
				<sectionName>5__2 = ((Object)<>8__1.skillDef).name;
				<sectionName>5__2 = HandleString(<sectionName>5__2);
				if (Utility.IsNullOrWhiteSpace(<sectionName>5__2))
				{
					<sectionName>5__2 = HandleString(<>8__1.skillDef.skillName);
				}
				if (Utility.IsNullOrWhiteSpace(<sectionName>5__2))
				{
					return false;
				}
				if (skillConfigs.ContainsKey(<>8__1.skillDef))
				{
					return false;
				}
				skillToNewName.Add(<>8__1.skillDef, <sectionName>5__2);
				<configEntryBases>5__3 = new List<ConfigEntryBase>();
				skillConfigs.Add(<>8__1.skillDef, <configEntryBases>5__3);
				<enable>5__4 = CreateConfig(<sectionName>5__2, "Enable Config", defaultValue: false, "Enable configuration for this skill? AKA \"" + <>8__1.skillDef.skillName + "\" and \"" + Language.GetString(<>8__1.skillDef.skillNameToken) + "\"", null, enableRiskOfOptions: false);
				if (<enable>5__4.Value)
				{
					<>8__5 = new <>c__DisplayClass29_1();
					<>8__5.CS$<>8__locals1 = <>8__1;
					<>8__5.baseRechargeInterval = CreateConfig(<sectionName>5__2, "Base Recharge Interval", <>8__5.CS$<>8__locals1.skillDef.baseRechargeInterval, "How long it takes for this skill to recharge after being used.", <configEntryBases>5__3, enableRiskOfOptions: true);
					<>8__5.baseMaxStock = CreateConfig(<sectionName>5__2, "Base Max Stock", <>8__5.CS$<>8__locals1.skillDef.baseMaxStock, "Maximum number of charges this skill can carry.", <configEntryBases>5__3, enableRiskOfOptions: true);
					<>8__5.rechargeStock = CreateConfig(<sectionName>5__2, "Recharge Stock", <>8__5.CS$<>8__locals1.skillDef.rechargeStock, "How much stock to restore on a recharge.", <configEntryBases>5__3, enableRiskOfOptions: true);
					<>8__5.requiredStock = CreateConfig(<sectionName>5__2, "Required Stock", <>8__5.CS$<>8__locals1.skillDef.requiredStock, "How much stock is required to activate this skill.", <configEntryBases>5__3, enableRiskOfOptions: true);
					<>8__5.stockToConsume = CreateConfig(<sectionName>5__2, "Stock To Consume", <>8__5.CS$<>8__locals1.skillDef.stockToConsume, "How much stock to deduct when the skill is activated.", <configEntryBases>5__3, enableRiskOfOptions: true);
					<>8__5.attackSpeedBuffsRestockSpeed = CreateConfig(<sectionName>5__2, "Attack Speed Buffs Restock Speed", <>8__5.CS$<>8__locals1.skillDef.attackSpeedBuffsRestockSpeed, "Makes the skill restock interval divided by attack speed if checked.", <configEntryBases>5__3, enableRiskOfOptions: true);
					<>8__5.attackSpeedBuffsRestockSpeed_Multiplier = CreateConfig(<sectionName>5__2, "Attack Speed Buffs Restock Speed Multiplier", <>8__5.CS$<>8__locals1.skillDef.attackSpeedBuffsRestockSpeed_Multiplier, "Increases the efficacy of attack speed on restock time.", <configEntryBases>5__3, enableRiskOfOptions: true);
					<>8__5.resetCooldownTimerOnUse = CreateConfig(<sectionName>5__2, "Reset Cooldown Timer On Use", <>8__5.CS$<>8__locals1.skillDef.resetCooldownTimerOnUse, "Whether or not it resets any progress on cooldowns.", <configEntryBases>5__3, enableRiskOfOptions: true);
					<>8__5.fullRestockOnAssign = CreateConfig(<sectionName>5__2, "Full Restock On Assign", <>8__5.CS$<>8__locals1.skillDef.fullRestockOnAssign, "Whether or not to fully restock this skill when it's assigned.", <configEntryBases>5__3, enableRiskOfOptions: true);
					<>8__5.dontAllowPastMaxStocks = CreateConfig(<sectionName>5__2, "Dont Allow Past Max Stocks", <>8__5.CS$<>8__locals1.skillDef.dontAllowPastMaxStocks, "Whether or not this skill can hold past it's maximum stock.", <configEntryBases>5__3, enableRiskOfOptions: true);
					<>8__5.beginSkillCooldownOnSkillEnd = CreateConfig(<sectionName>5__2, "Begin Skill Colldown On Skill End", <>8__5.CS$<>8__locals1.skillDef.beginSkillCooldownOnSkillEnd, "Whether or not the cooldown waits until it leaves the set state.", <configEntryBases>5__3, enableRiskOfOptions: true);
					<>8__5.isCooldownBlockedUntilManuallyReset = CreateConfig(<sectionName>5__2, "Is Cooldown Blocked Until Manually Reset", <>8__5.CS$<>8__locals1.skillDef.isCooldownBlockedUntilManuallyReset, "Whether or not the skill is blocked from being used until it is manually reset", <configEntryBases>5__3, enableRiskOfOptions: true);
					<>8__5.cancelSprintingOnActivation = CreateConfig(<sectionName>5__2, "Cancel Sprinting On Activation", <>8__5.CS$<>8__locals1.skillDef.cancelSprintingOnActivation, "Whether or not activating the skill forces off sprinting.", <configEntryBases>5__3, enableRiskOfOptions: true);
					<>8__5.forceSprintDuringState = CreateConfig(<sectionName>5__2, "Force Sprint During State", <>8__5.CS$<>8__locals1.skillDef.forceSprintDuringState, "Whether or not this skill is considered 'mobility'. Currently just forces sprint.", <configEntryBases>5__3, enableRiskOfOptions: true);
					<>8__5.canceledFromSprinting = CreateConfig(<sectionName>5__2, "Canceled From Sprinting", <>8__5.CS$<>8__locals1.skillDef.canceledFromSprinting, "Whether or not sprinting sets the skill's state to be reset.", <configEntryBases>5__3, enableRiskOfOptions: true);
					<>8__5.isCombatSkill = CreateConfig(<sectionName>5__2, "Is Combat Skill", <>8__5.CS$<>8__locals1.skillDef.isCombatSkill, "Whether or not this is considered a combat skill.", <configEntryBases>5__3, enableRiskOfOptions: true);
					<>8__5.mustKeyPress = CreateConfig(<sectionName>5__2, "Must Key Press", <>8__5.CS$<>8__locals1.skillDef.mustKeyPress, "The skill can't be activated if the key is held.", <configEntryBases>5__3, enableRiskOfOptions: true);
					<>8__5.triggeredByPressRelease = CreateConfig(<sectionName>5__2, "Triggered By Press Release", <>8__5.CS$<>8__locals1.skillDef.triggeredByPressRelease, "Can this skill be triggered by an key release event?", <configEntryBases>5__3, enableRiskOfOptions: true);
					<>8__5.autoHandleLuminousShot = CreateConfig(<sectionName>5__2, "Auto Handle Luminous Shot", <>8__5.CS$<>8__locals1.skillDef.autoHandleLuminousShot, "If true, CharacterBody handles LuminiousShot buffs. If false, the skill must handle it.", <configEntryBases>5__3, enableRiskOfOptions: true);
					<>8__5.suppressSkillActivation = CreateConfig(<sectionName>5__2, "Suppress Skill Activation", <>8__5.CS$<>8__locals1.skillDef.suppressSkillActivation, "If true, CharacterBody.OnSkillActivated will not be called.", <configEntryBases>5__3, enableRiskOfOptions: true);
					<>s__6 = <configEntryBases>5__3.GetEnumerator();
					try
					{
						while (<>s__6.MoveNext())
						{
							<configEntryBase>5__7 = <>s__6.Current;
							<configEntry>5__8 = <configEntryBase>5__7 as ConfigEntry<float>;
							if (<configEntry>5__8 == null)
							{
								<configEntry2>5__9 = <configEntryBase>5__7 as ConfigEntry<int>;
								if (<configEntry2>5__9 == null)
								{
									<configEntry1>5__10 = <configEntryBase>5__7 as ConfigEntry<bool>;
									if (<configEntry1>5__10 == null)
									{
										continue;
									}
									<configEntry1>5__10.SettingChanged += ConfigEntry_SettingChanged;
									<configEntry1>5__10 = null;
								}
								else
								{
									<configEntry2>5__9.SettingChanged += ConfigEntry_SettingChanged;
								}
								<configEntry2>5__9 = null;
							}
							else
							{
								<configEntry>5__8.SettingChanged += ConfigEntry_SettingChanged;
							}
							<configEntry>5__8 = null;
							<configEntryBase>5__7 = null;
						}
					}
					finally
					{
						((IDisposable)<>s__6).Dispose();
					}
					<>s__6 = default(List<ConfigEntryBase>.Enumerator);
					UpdateSkillDef();
					<>8__5 = null;
				}
				return false;
				void ConfigEntry_SettingChanged(object sender, EventArgs e)
				{
					UpdateSkillDef();
				}
				void UpdateSkillDef()
				{
					((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.baseRechargeInterval = ((<>c__DisplayClass29_1)this).baseRechargeInterval.Value;
					((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.baseMaxStock = ((<>c__DisplayClass29_1)this).baseMaxStock.Value;
					((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.rechargeStock = ((<>c__DisplayClass29_1)this).rechargeStock.Value;
					((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.requiredStock = ((<>c__DisplayClass29_1)this).requiredStock.Value;
					((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.stockToConsume = ((<>c__DisplayClass29_1)this).stockToConsume.Value;
					((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.attackSpeedBuffsRestockSpeed = ((<>c__DisplayClass29_1)this).attackSpeedBuffsRestockSpeed.Value;
					((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.attackSpeedBuffsRestockSpeed_Multiplier = ((<>c__DisplayClass29_1)this).attackSpeedBuffsRestockSpeed_Multiplier.Value;
					((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.resetCooldownTimerOnUse = ((<>c__DisplayClass29_1)this).resetCooldownTimerOnUse.Value;
					((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.fullRestockOnAssign = ((<>c__DisplayClass29_1)this).fullRestockOnAssign.Value;
					((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.dontAllowPastMaxStocks = ((<>c__DisplayClass29_1)this).dontAllowPastMaxStocks.Value;
					((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.beginSkillCooldownOnSkillEnd = ((<>c__DisplayClass29_1)this).beginSkillCooldownOnSkillEnd.Value;
					((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.isCooldownBlockedUntilManuallyReset = ((<>c__DisplayClass29_1)this).isCooldownBlockedUntilManuallyReset.Value;
					((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.cancelSprintingOnActivation = ((<>c__DisplayClass29_1)this).cancelSprintingOnActivation.Value;
					((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.forceSprintDuringState = ((<>c__DisplayClass29_1)this).forceSprintDuringState.Value;
					((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.canceledFromSprinting = ((<>c__DisplayClass29_1)this).canceledFromSprinting.Value;
					((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.isCombatSkill = ((<>c__DisplayClass29_1)this).isCombatSkill.Value;
					((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.mustKeyPress = ((<>c__DisplayClass29_1)this).mustKeyPress.Value;
					((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.triggeredByPressRelease = ((<>c__DisplayClass29_1)this).triggeredByPressRelease.Value;
					((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.autoHandleLuminousShot = ((<>c__DisplayClass29_1)this).autoHandleLuminousShot.Value;
					((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.suppressSkillActivation = ((<>c__DisplayClass29_1)this).suppressSkillActivation.Value;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public const string ModGuid = "com.brynzananas.skillsconfigurator";

		public const string ModName = "Skills Configurator";

		public const string ModVer = "1.2.0";

		public static Dictionary<SkillDef, List<ConfigEntryBase>> skillConfigs = new Dictionary<SkillDef, List<ConfigEntryBase>>();

		public static Dictionary<string, int> names = new Dictionary<string, int>();

		public static Dictionary<SkillDef, string> skillToNewName = new Dictionary<SkillDef, string>();

		private static bool _debug;

		private static Stopwatch stopwatch;

		public static bool riskOfOptionsEnabled { get; private set; }

		public static ConfigFile configFile { get; private set; }

		public static ManualLogSource Log { get; private set; }

		public static bool debug
		{
			get
			{
				return _debug;
			}
			set
			{
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Expected O, but got Unknown
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				if (value == _debug)
				{
					return;
				}
				_debug = value;
				if (value)
				{
					object obj = <>O.<0>__BodyLoadoutManager_SetSkillVariant;
					if (obj == null)
					{
						hook_SetSkillVariant val = BodyLoadoutManager_SetSkillVariant;
						<>O.<0>__BodyLoadoutManager_SetSkillVariant = val;
						obj = (object)val;
					}
					BodyLoadoutManager.SetSkillVariant += (hook_SetSkillVariant)obj;
				}
				else
				{
					object obj2 = <>O.<0>__BodyLoadoutManager_SetSkillVariant;
					if (obj2 == null)
					{
						hook_SetSkillVariant val2 = BodyLoadoutManager_SetSkillVariant;
						<>O.<0>__BodyLoadoutManager_SetSkillVariant = val2;
						obj2 = (object)val2;
					}
					BodyLoadoutManager.SetSkillVariant -= (hook_SetSkillVariant)obj2;
				}
			}
		}

		public void Awake()
		{
			configFile = ((BaseUnityPlugin)this).Config;
			Log = ((BaseUnityPlugin)this).Logger;
			riskOfOptionsEnabled = Chainloader.PluginInfos.ContainsKey("com.rune580.riskofoptions");
		}

		public void OnDestroy()
		{
			debug = false;
		}

		private static void BodyLoadoutManager_SetSkillVariant(orig_SetSkillVariant orig, BodyLoadoutManager self, BodyIndex bodyIndex, int skillSlot, uint skillVariant)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected I4, but got Unknown
			orig.Invoke(self, bodyIndex, skillSlot, skillVariant);
			if (skillSlot < 0 || skillVariant < 0)
			{
				return;
			}
			int num = (int)bodyIndex;
			if (num < 0 || num >= BodyLoadoutManager.allBodyInfos.Length)
			{
				return;
			}
			GenericSkill[] prefabSkillSlots = BodyLoadoutManager.allBodyInfos[num].prefabSkillSlots;
			if (prefabSkillSlots == null || skillSlot >= prefabSkillSlots.Length)
			{
				return;
			}
			GenericSkill val = prefabSkillSlots[skillSlot];
			if (!Object.op_Implicit((Object)(object)val))
			{
				return;
			}
			SkillFamily skillFamily = val.skillFamily;
			if (Object.op_Implicit((Object)(object)skillFamily) && skillVariant < skillFamily.variants.Length)
			{
				SkillDef skillDef = skillFamily.variants[skillVariant].skillDef;
				if (Object.op_Implicit((Object)(object)skillDef))
				{
					string text = ((!skillToNewName.ContainsKey(skillDef)) ? ((Object)skillDef).name : skillToNewName[skillDef]);
					Log.LogMessage((object)("Selected skill: \"" + text + "\" AKA \"" + skillDef.skillName + "\" and \"" + Language.GetString(skillDef.skillNameToken) + "\""));
				}
			}
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public static void CCReset(ConCommandArgs args)
		{
			debug = ((ConCommandArgs)(ref args)).GetArgBool(0);
			if (debug)
			{
				Log.LogMessage((object)"Enabled debug");
			}
			else
			{
				Log.LogMessage((object)"Disabled debug");
			}
		}

		[SystemInitializer(new Type[] { typeof(SkillCatalog) })]
		private static void ConfigureSkillsStart()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			<>c__DisplayClass27_0 CS$<>8__locals0 = new <>c__DisplayClass27_0();
			configFile.SaveOnConfigSet = false;
			Log.LogMessage((object)"Begin configuring skills");
			CS$<>8__locals0.loadCoroutine = new ParallelCoroutine();
			stopwatch = Stopwatch.StartNew();
			stopwatch.Start();
			int num = 0;
			foreach (SkillDef allSkillDef in SkillCatalog.allSkillDefs)
			{
				num++;
				CS$<>8__locals0.loadCoroutine.Add(ConfigureSkillThread(allSkillDef, num));
			}
			((MonoBehaviour)RoR2Application.instance).StartCoroutine(runLoadCoroutine());
			[IteratorStateMachine(typeof(<>c__DisplayClass27_0.<<ConfigureSkillsStart>g__runLoadCoroutine|0>d))]
			IEnumerator runLoadCoroutine()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass27_0.<<ConfigureSkillsStart>g__runLoadCoroutine|0>d(0)
				{
					<>4__this = CS$<>8__locals0
				};
			}
		}

		private static string HandleString(string @string)
		{
			if (Utility.IsNullOrWhiteSpace(@string))
			{
				return @string;
			}
			char[] array = new char[6] { '\n', '\t', '"', '\'', '[', ']' };
			char[] array2 = array;
			foreach (char c in array2)
			{
				while (@string.Contains(c))
				{
					@string = @string.Replace(c, ' ');
				}
			}
			@string.Trim();
			int j;
			for (j = 0; names.ContainsKey(@string + ((j == 0) ? "" : ((object)j))); j++)
			{
			}
			@string += ((j == 0) ? "" : ((object)j));
			names.Add(@string, j);
			return @string;
		}

		[IteratorStateMachine(typeof(<ConfigureSkillThread>d__29))]
		private static IEnumerator ConfigureSkillThread(SkillDef skillDef, int loc)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ConfigureSkillThread>d__29(0)
			{
				skillDef = skillDef,
				loc = loc
			};
		}

		private static ConfigEntry<T> CreateConfig<T>(string section, string key, T defaultValue, string description, List<ConfigEntryBase> configEntryBases, bool enableRiskOfOptions)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Expected O, but got Unknown
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			ConfigDefinition val = new ConfigDefinition(section, key);
			ConfigDescription val2 = new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>());
			ConfigEntry<T> val3 = configFile.Bind<T>(val, defaultValue, val2);
			configEntryBases?.Add((ConfigEntryBase)(object)val3);
			if (enableRiskOfOptions && riskOfOptionsEnabled)
			{
				ModCompatabilities.RiskOfOptionsCompatability.AddConfig<ConfigEntry<T>>(val3);
			}
			return val3;
		}
	}
}