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 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+dce07b362a2f0b278571f479f14fa61056f96499")]
[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.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class SkillsConfiguratorPlugin : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass19_0
		{
			public ParallelCoroutine loadCoroutine;
		}

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

		[CompilerGenerated]
		private sealed class <>c__DisplayClass20_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__DisplayClass20_0 CS$<>8__locals1;
		}

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

			private object <>2__current;

			public SkillDef skillDef;

			public int loc;

			private <>c__DisplayClass20_0 <>8__1;

			private string <sectionName>5__2;

			private int <namesCount>5__3;

			private List<ConfigEntryBase> <configEntryBases>5__4;

			private ConfigEntry<bool> <enable>5__5;

			private <>c__DisplayClass20_1 <>8__6;

			private List<ConfigEntryBase>.Enumerator <>s__7;

			private ConfigEntryBase <configEntryBase>5__8;

			private ConfigEntry<float> <configEntry>5__9;

			private ConfigEntry<int> <configEntry2>5__10;

			private ConfigEntry<bool> <configEntry1>5__11;

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

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

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

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

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

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

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

		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 void Awake()
		{
			configFile = ((BaseUnityPlugin)this).Config;
			Log = ((BaseUnityPlugin)this).Logger;
			riskOfOptionsEnabled = Chainloader.PluginInfos.ContainsKey("com.rune580.riskofoptions");
		}

		[SystemInitializer(new Type[] { typeof(SkillCatalog) })]
		private static void ConfigureSkillsStart()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			<>c__DisplayClass19_0 CS$<>8__locals0 = new <>c__DisplayClass19_0();
			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__DisplayClass19_0.<<ConfigureSkillsStart>g__runLoadCoroutine|0>d))]
			IEnumerator runLoadCoroutine()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass19_0.<<ConfigureSkillsStart>g__runLoadCoroutine|0>d(0)
				{
					<>4__this = CS$<>8__locals0
				};
			}
		}

		[IteratorStateMachine(typeof(<ConfigureSkillThread>d__20))]
		private static IEnumerator ConfigureSkillThread(SkillDef skillDef, int loc)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ConfigureSkillThread>d__20(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;
		}
	}
}