using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Dynamic;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Linq.Expressions;
using System.Net;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Xml.Serialization;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using ItemDataManager;
using JetBrains.Annotations;
using Jewelcrafting;
using LocalizationManager;
using Microsoft.CodeAnalysis;
using PieceManager;
using ServerSync;
using SkillManager;
using TMPro;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.Events;
using UnityEngine.UI;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Core.ObjectPool;
using YamlDotNet.Core.Tokens;
using YamlDotNet.Helpers;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.BufferedDeserialization;
using YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators;
using YamlDotNet.Serialization.Callbacks;
using YamlDotNet.Serialization.Converters;
using YamlDotNet.Serialization.EventEmitters;
using YamlDotNet.Serialization.NamingConventions;
using YamlDotNet.Serialization.NodeDeserializers;
using YamlDotNet.Serialization.NodeTypeResolvers;
using YamlDotNet.Serialization.ObjectFactories;
using YamlDotNet.Serialization.ObjectGraphTraversalStrategies;
using YamlDotNet.Serialization.ObjectGraphVisitors;
using YamlDotNet.Serialization.Schemas;
using YamlDotNet.Serialization.TypeInspectors;
using YamlDotNet.Serialization.TypeResolvers;
using YamlDotNet.Serialization.Utilities;
using YamlDotNet.Serialization.ValueDeserializers;
using fastJSON;
using kg.ValheimEnchantmentSystem;
using kg.ValheimEnchantmentSystem.Configs;
using kg.ValheimEnchantmentSystem.Integrations;
using kg.ValheimEnchantmentSystem.Items_Structures;
using kg.ValheimEnchantmentSystem.Misc;
using kg.ValheimEnchantmentSystem.Platform;
using kg.ValheimEnchantmentSystem.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ValheimEnchantmentSystem")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ValheimEnchantmentSystem")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("02E7D016-77BE-40E0-9D13-8656CD0A4FD3")]
[assembly: AssemblyFileVersion("1.9.8.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.9.8.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public static class AnimationSpeedManager
{
	public delegate double Handler(Character character, double speed);

	private static readonly Harmony Harmony = new Harmony("kg.ValheimEnchantmentSystem.AnimationSpeedManager");

	private static readonly MethodInfo TargetMethod = AccessTools.DeclaredMethod(typeof(CharacterAnimEvent), "CustomFixedUpdate", (Type[])null, (Type[])null);

	private static readonly Dictionary<int, List<Handler>> HandlersByPriority = new Dictionary<int, List<Handler>>();

	private static Handler[][] _handlers = Array.Empty<Handler[]>();

	private static bool _markerPatchInstalled;

	private static bool _wrapperInstalled;

	private static int _handlerIndex;

	private static bool _changed;

	[PublicAPI]
	public static void Add(Handler handler, int priority = 400)
	{
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Expected O, but got Unknown
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Expected O, but got Unknown
		if (!_markerPatchInstalled)
		{
			Harmony.Patch((MethodBase)TargetMethod, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(AnimationSpeedManager), "MarkerPatch", (Type[])null, (Type[])null)), (HarmonyMethod)null);
			_markerPatchInstalled = true;
		}
		if (!HandlersByPriority.TryGetValue(priority, out List<Handler> value))
		{
			value = new List<Handler>();
			HandlersByPriority.Add(priority, value);
		}
		if (!_wrapperInstalled)
		{
			Harmony.Patch((MethodBase)TargetMethod, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(AnimationSpeedManager), "Wrapper", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			_wrapperInstalled = true;
		}
		value.Add(handler);
		_handlers = (from pair in HandlersByPriority
			orderby pair.Key
			select pair.Value.ToArray()).ToArray();
	}

	private static void Wrapper(Character ___m_character, Animator ___m_animator)
	{
		Character ___m_character2 = ___m_character;
		double num = (double)___m_animator.speed * 10000000.0 % 100.0;
		if ((!(num > 10.0) || !(num < 30.0)) && !(___m_animator.speed <= 0.001f))
		{
			double num2 = ___m_animator.speed;
			double num3 = _handlers[_handlerIndex++].Aggregate(num2, (double current, Handler handler) => handler(___m_character2, current));
			if (Math.Abs(num3 - num2) > double.Epsilon)
			{
				___m_animator.speed = (float)(num3 - num3 % 1E-05);
				_changed = true;
			}
		}
	}

	private static void MarkerPatch(Animator ___m_animator)
	{
		if (_changed)
		{
			float speed = ___m_animator.speed;
			double num = (double)speed * 10000000.0 % 100.0;
			if ((num < 10.0 || num > 30.0) ? true : false)
			{
				___m_animator.speed += 1.9E-06f;
			}
			_changed = false;
		}
		_handlerIndex = 0;
	}
}
namespace PieceManager
{
	[PublicAPI]
	public enum CraftingTable
	{
		None,
		[InternalName("piece_workbench")]
		Workbench,
		[InternalName("piece_cauldron")]
		Cauldron,
		[InternalName("forge")]
		Forge,
		[InternalName("piece_artisanstation")]
		ArtisanTable,
		[InternalName("piece_stonecutter")]
		StoneCutter,
		[InternalName("piece_magetable")]
		MageTable,
		[InternalName("blackforge")]
		BlackForge,
		[InternalName("piece_preptable")]
		FoodPreparationTable,
		[InternalName("piece_MeadCauldron")]
		MeadKetill,
		Custom
	}
	public class InternalName : Attribute
	{
		public readonly string internalName;

		public InternalName(string internalName)
		{
			this.internalName = internalName;
		}
	}
	[PublicAPI]
	public enum BuildPieceCategory
	{
		Misc = 0,
		Crafting = 1,
		BuildingWorkbench = 2,
		BuildingStonecutter = 3,
		Furniture = 4,
		All = 100,
		Custom = 99
	}
	public struct Requirement
	{
		public string itemName;

		public int amount;

		public bool recover;
	}
	[PublicAPI]
	public class RequiredResourcesList
	{
		public readonly List<Requirement> Requirements = new List<Requirement>();

		public void Add(string item, int amount, bool recover)
		{
			Requirements.Add(new Requirement
			{
				itemName = item,
				amount = amount,
				recover = recover
			});
		}
	}
	public struct CraftingStationConfig
	{
		public CraftingTable Table;

		public string? custom;
	}
	[PublicAPI]
	public class CraftingStationList
	{
		public readonly List<CraftingStationConfig> Stations = new List<CraftingStationConfig>();

		public void Set(CraftingTable table)
		{
			Stations.Add(new CraftingStationConfig
			{
				Table = table
			});
		}

		public void Set(string customTable)
		{
			Stations.Add(new CraftingStationConfig
			{
				Table = CraftingTable.Custom,
				custom = customTable
			});
		}
	}
	[PublicAPI]
	public class BuildingPieceCategory
	{
		public BuildPieceCategory Category;

		public string custom = "";

		public void Set(BuildPieceCategory category)
		{
			Category = category;
		}

		public void Set(string customCategory)
		{
			Category = BuildPieceCategory.Custom;
			custom = customCategory;
		}
	}
	[PublicAPI]
	public class PieceTool
	{
		public readonly HashSet<string> Tools = new HashSet<string>();

		public void Add(string tool)
		{
			Tools.Add(tool);
		}
	}
	[PublicAPI]
	public class BuildPiece
	{
		private sealed class PieceConfig
		{
			public ConfigEntry<string>? craft;
		}

		private static class SerializedRequirements
		{
			public static string Serialize(IEnumerable<Requirement> requirements)
			{
				return string.Join(",", requirements.Select((Requirement requirement) => $"{requirement.itemName}:{requirement.amount}:{requirement.recover}"));
			}

			public static Requirement[] ToPieceReqs(ObjectDB objectDb, IEnumerable<Requirement> requirements)
			{
				ObjectDB objectDb2 = objectDb;
				return (from requirement in requirements.Where((Requirement requirement) => !string.IsNullOrWhiteSpace(requirement.itemName)).Select((Func<Requirement, Requirement>)delegate(Requirement requirement)
					{
						//IL_0057: Unknown result type (might be due to invalid IL or missing references)
						//IL_005c: Unknown result type (might be due to invalid IL or missing references)
						//IL_0063: Unknown result type (might be due to invalid IL or missing references)
						//IL_006f: Unknown result type (might be due to invalid IL or missing references)
						//IL_007c: Expected O, but got Unknown
						GameObject itemPrefab = objectDb2.GetItemPrefab(requirement.itemName);
						ItemDrop val = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
						if (!((Object)(object)val == (Object)null))
						{
							return new Requirement
							{
								m_resItem = val,
								m_amount = requirement.amount,
								m_recover = requirement.recover
							};
						}
						Debug.LogWarning((object)(Plugin.Info.Metadata.GUID + ": required build piece item '" + requirement.itemName + "' does not exist."));
						return null;
					})
					where requirement != null
					select requirement).ToArray();
			}

			public static Requirement[] ToPieceReqs(ObjectDB objectDb, string serialized)
			{
				return ToPieceReqs(objectDb, serialized.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(delegate(string entry)
				{
					string[] array = entry.Split(new char[1] { ':' });
					Requirement result = default(Requirement);
					result.itemName = array[0];
					result.amount = ((array.Length <= 1 || !int.TryParse(array[1], out var result2)) ? 1 : result2);
					bool result3 = default(bool);
					result.recover = array.Length <= 2 || !bool.TryParse(array[2], out result3) || result3;
					return result;
				}));
			}
		}

		private static readonly Harmony Harmony;

		internal static readonly List<BuildPiece> registeredPieces;

		private static readonly Dictionary<BuildPiece, PieceConfig> pieceConfigs;

		private static bool configBindingsInitialized;

		[Description("Disables generation of configs for registered pieces.")]
		public static bool ConfigurationEnabled;

		public readonly GameObject Prefab;

		public readonly RequiredResourcesList RequiredItems = new RequiredResourcesList();

		public readonly BuildingPieceCategory Category = new BuildingPieceCategory();

		public readonly PieceTool Tool = new PieceTool();

		public CraftingStationList Crafting = new CraftingStationList();

		public ConfigEntryBase? RecipeIsActive;

		private static BaseUnityPlugin? _plugin;

		private static BaseUnityPlugin Plugin
		{
			get
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Expected O, but got Unknown
				object obj = _plugin;
				if (obj == null)
				{
					BaseUnityPlugin val = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)Assembly.GetExecutingAssembly().DefinedTypes.First((TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
					_plugin = val;
					obj = (object)val;
				}
				return (BaseUnityPlugin)obj;
			}
		}

		static BuildPiece()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Expected O, but got Unknown
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Expected O, but got Unknown
			Harmony = new Harmony("kg.ValheimEnchantmentSystem.ThinPieceManager");
			registeredPieces = new List<BuildPiece>();
			pieceConfigs = new Dictionary<BuildPiece, PieceConfig>();
			ConfigurationEnabled = true;
			Harmony.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(BuildPiece), "Patch_FejdStartup", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Harmony.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(BuildPiece), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Harmony.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "CopyOtherDB", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(BuildPiece), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Harmony.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(BuildPiece), "Patch_ZNetSceneAwake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public BuildPiece(AssetBundle bundle, string prefabName)
		{
			Prefab = bundle.LoadAsset<GameObject>(prefabName) ?? throw new InvalidOperationException("Could not load piece prefab '" + prefabName + "' from asset bundle.");
			((Object)Prefab).name = prefabName;
			ApplyStaticDefaults(this);
			registeredPieces.Add(this);
		}

		private static void Patch_FejdStartup()
		{
			EnsureConfigBindings();
		}

		internal static void Patch_ObjectDBInit(ObjectDB __instance)
		{
			EnsureConfigBindings();
			if ((Object)(object)__instance.GetItemPrefab("Hammer") == (Object)null)
			{
				return;
			}
			foreach (BuildPiece registeredPiece in registeredPieces)
			{
				ApplyRuntimeConfiguration(registeredPiece, __instance, ZNetScene.instance);
			}
		}

		internal static void Patch_ZNetSceneAwake(ZNetScene __instance)
		{
			foreach (BuildPiece registeredPiece in registeredPieces)
			{
				if (!__instance.m_prefabs.Contains(registeredPiece.Prefab))
				{
					__instance.m_prefabs.Add(registeredPiece.Prefab);
				}
				int stableHashCode = StringExtensionMethods.GetStableHashCode(((Object)registeredPiece.Prefab).name);
				if (!__instance.m_namedPrefabs.ContainsKey(stableHashCode))
				{
					__instance.m_namedPrefabs.Add(stableHashCode, registeredPiece.Prefab);
				}
			}
		}

		internal static void EnsureConfigBindings()
		{
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Expected O, but got Unknown
			if (configBindingsInitialized)
			{
				return;
			}
			foreach (BuildPiece piece in registeredPieces)
			{
				ApplyStaticDefaults(piece);
				if (ConfigurationEnabled)
				{
					string token = piece.Prefab.GetComponent<Piece>()?.m_name ?? ((Object)piece.Prefab).name;
					string localizedDisplayName = GetLocalizedDisplayName(token, ((Object)piece.Prefab).name);
					string text = SharedLocalizationCache.LocalizeForConfig(token);
					string group = (string.IsNullOrWhiteSpace(text) ? localizedDisplayName : text);
					PieceConfig pieceConfig2 = (pieceConfigs[piece] = new PieceConfig());
					PieceConfig pieceConfig3 = pieceConfig2;
					pieceConfig3.craft = Config(group, "Crafting Costs", SerializedRequirements.Serialize(piece.RequiredItems.Requirements), new ConfigDescription("Item costs to craft " + localizedDisplayName + ".", (AcceptableValueBase)null, Array.Empty<object>()));
					pieceConfig3.craft.SettingChanged += delegate
					{
						ReapplyRuntimeConfiguration(piece);
					};
				}
			}
			configBindingsInitialized = true;
		}

		private static void ReapplyRuntimeConfiguration(BuildPiece piece)
		{
			if (!((Object)(object)ObjectDB.instance == (Object)null))
			{
				ApplyRuntimeConfiguration(piece, ObjectDB.instance, ZNetScene.instance);
			}
		}

		private static void ApplyStaticDefaults(BuildPiece piece)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			Piece component = piece.Prefab.GetComponent<Piece>();
			if (!((Object)(object)component == (Object)null))
			{
				component.m_category = (PieceCategory)((piece.Category.Category == BuildPieceCategory.Custom) ? BuildPieceCategory.Crafting : piece.Category.Category);
			}
		}

		private static void ApplyRuntimeConfiguration(BuildPiece piece, ObjectDB objectDb, ZNetScene? scene)
		{
			Piece component = piece.Prefab.GetComponent<Piece>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			if (pieceConfigs.TryGetValue(piece, out PieceConfig value))
			{
				ConfigEntry<string> craft = value.craft;
				if (craft != null)
				{
					component.m_resources = SerializedRequirements.ToPieceReqs(objectDb, craft.Value);
					goto IL_005a;
				}
			}
			component.m_resources = SerializedRequirements.ToPieceReqs(objectDb, piece.RequiredItems.Requirements);
			goto IL_005a;
			IL_005a:
			ApplyCraftingStation(piece, component, scene);
			ApplyToolRegistration(piece, objectDb);
			ConfigEntryBase recipeIsActive = piece.RecipeIsActive;
			if (recipeIsActive != null)
			{
				component.m_enabled = Convert.ToInt32(recipeIsActive.BoxedValue) != 0;
			}
		}

		private static void ApplyCraftingStation(BuildPiece piece, Piece pieceComponent, ZNetScene? scene)
		{
			if (piece.Crafting.Stations.Count == 0 || (Object)(object)scene == (Object)null)
			{
				pieceComponent.m_craftingStation = null;
				return;
			}
			CraftingStationConfig craftingStationConfig = piece.Crafting.Stations.First();
			switch (craftingStationConfig.Table)
			{
			case CraftingTable.None:
				pieceComponent.m_craftingStation = null;
				break;
			case CraftingTable.Custom:
			{
				GameObject prefab2 = scene.GetPrefab(craftingStationConfig.custom);
				pieceComponent.m_craftingStation = ((prefab2 != null) ? prefab2.GetComponent<CraftingStation>() : null);
				break;
			}
			default:
			{
				GameObject prefab = scene.GetPrefab(GetInternalName(craftingStationConfig.Table));
				pieceComponent.m_craftingStation = ((prefab != null) ? prefab.GetComponent<CraftingStation>() : null);
				break;
			}
			}
		}

		private static void ApplyToolRegistration(BuildPiece piece, ObjectDB objectDb)
		{
			foreach (GameObject item in objectDb.m_items)
			{
				(item.GetComponent<ItemDrop>()?.m_itemData?.m_shared?.m_buildPieces)?.m_pieces.Remove(piece.Prefab);
			}
			IEnumerable<string> enumerable = piece.Tool.Tools.DefaultIfEmpty("Hammer");
			foreach (string item2 in enumerable)
			{
				GameObject itemPrefab = objectDb.GetItemPrefab(item2);
				if (Object.op_Implicit((Object)(object)itemPrefab))
				{
					PieceTable val = itemPrefab.GetComponent<ItemDrop>()?.m_itemData?.m_shared?.m_buildPieces;
					if ((Object)(object)val != (Object)null && !val.m_pieces.Contains(piece.Prefab))
					{
						val.m_pieces.Add(piece.Prefab);
					}
				}
			}
		}

		private static string GetLocalizedDisplayName(string? token, string fallback)
		{
			if (string.IsNullOrWhiteSpace(token) || Localization.instance == null)
			{
				return fallback;
			}
			string text = Localization.instance.Localize(token).Trim();
			if (!string.IsNullOrWhiteSpace(text) && !string.Equals(text, token, StringComparison.Ordinal))
			{
				return text;
			}
			return fallback;
		}

		private static string GetInternalName(CraftingTable value)
		{
			return ((InternalName)typeof(CraftingTable).GetMember(value.ToString())[0].GetCustomAttributes(typeof(InternalName), inherit: false).First()).internalName;
		}

		private static ConfigEntry<T> Config<T>(string group, string name, T value, ConfigDescription description)
		{
			return ValheimEnchantmentSystem.config(group, name, value, description);
		}
	}
}
namespace SkillManager
{
	[PublicAPI]
	public class Skill
	{
		private readonly struct SavedSkillState
		{
			public readonly float Level;

			public readonly float Accumulator;

			public SavedSkillState(float level, float accumulator)
			{
				Level = level;
				Accumulator = accumulator;
			}
		}

		public static class LocalizationCache
		{
			internal static void LocalizationPostfix(Localization __instance, string language)
			{
				SharedLocalizationCache.Track(__instance, language);
			}

			public static Localization ForLanguage(string? language = null)
			{
				return SharedLocalizationCache.ForLanguage(language);
			}

			public static string LocalizeForConfig(string token, string preferredLanguage = "English")
			{
				return SharedLocalizationCache.LocalizeForConfig(token, preferredLanguage);
			}
		}

		[PublicAPI]
		public class LocalizeKey
		{
			private static readonly List<LocalizeKey> keys = new List<LocalizeKey>();

			public readonly string Key;

			public readonly Dictionary<string, string> Localizations = new Dictionary<string, string>();

			public LocalizeKey(string key)
			{
				Key = key.Replace("$", "");
				keys.Add(this);
			}

			public void Alias(string alias)
			{
				Localizations.Clear();
				if (!alias.Contains("$"))
				{
					alias = "$" + alias;
				}
				Localizations["alias"] = alias;
				if (Localization.m_instance != null)
				{
					Localization.instance.AddWord(Key, Localization.instance.Localize(alias));
				}
			}

			public LocalizeKey English(string key)
			{
				return addForLang("English", key);
			}

			public LocalizeKey Swedish(string key)
			{
				return addForLang("Swedish", key);
			}

			public LocalizeKey French(string key)
			{
				return addForLang("French", key);
			}

			public LocalizeKey Italian(string key)
			{
				return addForLang("Italian", key);
			}

			public LocalizeKey German(string key)
			{
				return addForLang("German", key);
			}

			public LocalizeKey Spanish(string key)
			{
				return addForLang("Spanish", key);
			}

			public LocalizeKey Russian(string key)
			{
				return addForLang("Russian", key);
			}

			public LocalizeKey Romanian(string key)
			{
				return addForLang("Romanian", key);
			}

			public LocalizeKey Bulgarian(string key)
			{
				return addForLang("Bulgarian", key);
			}

			public LocalizeKey Macedonian(string key)
			{
				return addForLang("Macedonian", key);
			}

			public LocalizeKey Finnish(string key)
			{
				return addForLang("Finnish", key);
			}

			public LocalizeKey Danish(string key)
			{
				return addForLang("Danish", key);
			}

			public LocalizeKey Norwegian(string key)
			{
				return addForLang("Norwegian", key);
			}

			public LocalizeKey Icelandic(string key)
			{
				return addForLang("Icelandic", key);
			}

			public LocalizeKey Turkish(string key)
			{
				return addForLang("Turkish", key);
			}

			public LocalizeKey Lithuanian(string key)
			{
				return addForLang("Lithuanian", key);
			}

			public LocalizeKey Czech(string key)
			{
				return addForLang("Czech", key);
			}

			public LocalizeKey Hungarian(string key)
			{
				return addForLang("Hungarian", key);
			}

			public LocalizeKey Slovak(string key)
			{
				return addForLang("Slovak", key);
			}

			public LocalizeKey Polish(string key)
			{
				return addForLang("Polish", key);
			}

			public LocalizeKey Dutch(string key)
			{
				return addForLang("Dutch", key);
			}

			public LocalizeKey Portuguese_European(string key)
			{
				return addForLang("Portuguese_European", key);
			}

			public LocalizeKey Portuguese_Brazilian(string key)
			{
				return addForLang("Portuguese_Brazilian", key);
			}

			public LocalizeKey Chinese(string key)
			{
				return addForLang("Chinese", key);
			}

			public LocalizeKey Japanese(string key)
			{
				return addForLang("Japanese", key);
			}

			public LocalizeKey Korean(string key)
			{
				return addForLang("Korean", key);
			}

			public LocalizeKey Hindi(string key)
			{
				return addForLang("Hindi", key);
			}

			public LocalizeKey Thai(string key)
			{
				return addForLang("Thai", key);
			}

			public LocalizeKey Abenaki(string key)
			{
				return addForLang("Abenaki", key);
			}

			public LocalizeKey Croatian(string key)
			{
				return addForLang("Croatian", key);
			}

			public LocalizeKey Georgian(string key)
			{
				return addForLang("Georgian", key);
			}

			public LocalizeKey Greek(string key)
			{
				return addForLang("Greek", key);
			}

			public LocalizeKey Serbian(string key)
			{
				return addForLang("Serbian", key);
			}

			public LocalizeKey Ukrainian(string key)
			{
				return addForLang("Ukrainian", key);
			}

			private LocalizeKey addForLang(string lang, string value)
			{
				Localizations[lang] = value;
				if (Localization.m_instance != null)
				{
					if (Localization.instance.GetSelectedLanguage() == lang)
					{
						Localization.instance.AddWord(Key, value);
					}
					else if (lang == "English" && !Localization.instance.m_translations.ContainsKey(Key))
					{
						Localization.instance.AddWord(Key, value);
					}
				}
				return this;
			}

			[HarmonyPriority(300)]
			internal static void AddLocalizedKeys(Localization __instance, string language)
			{
				foreach (LocalizeKey key in keys)
				{
					string value2;
					if (key.Localizations.TryGetValue(language, out string value) || key.Localizations.TryGetValue("English", out value))
					{
						__instance.AddWord(key.Key, value);
					}
					else if (key.Localizations.TryGetValue("alias", out value2))
					{
						__instance.AddWord(key.Key, Localization.instance.Localize(value2));
					}
				}
			}
		}

		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public string? Category;
		}

		private static readonly Dictionary<SkillType, Skill> skills;

		internal static readonly Dictionary<string, Skill> skillByName;

		private readonly string skillName;

		private readonly string internalSkillName;

		private readonly SkillDef skillDef;

		public readonly LocalizeKey Name;

		public readonly LocalizeKey Description;

		private float skillEffectFactor = 1f;

		private int skillLoss = 5;

		public bool Configurable;

		private static bool configBindingsInitialized;

		private const string RequiredExperienceFormulaDescription = "Required EXP per level follows: ((current level + 1)^1.5) / 2 + 0.5.";

		private static bool InitializedTerminal;

		private static BaseUnityPlugin? _plugin;

		public float SkillGainFactor
		{
			get
			{
				return skillDef.m_increseStep;
			}
			set
			{
				skillDef.m_increseStep = value;
				this.SkillGainFactorChanged?.Invoke(value);
			}
		}

		public float SkillEffectFactor
		{
			get
			{
				return skillEffectFactor;
			}
			set
			{
				skillEffectFactor = value;
				this.SkillEffectFactorChanged?.Invoke(value);
			}
		}

		public int SkillLoss
		{
			get
			{
				return skillLoss;
			}
			set
			{
				skillLoss = value;
				this.SkillLossChanged?.Invoke(value);
			}
		}

		private static BaseUnityPlugin plugin
		{
			get
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Expected O, but got Unknown
				object obj = _plugin;
				if (obj == null)
				{
					BaseUnityPlugin val = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)Assembly.GetExecutingAssembly().DefinedTypes.First((TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
					_plugin = val;
					obj = (object)val;
				}
				return (BaseUnityPlugin)obj;
			}
		}

		public event Action<float>? SkillGainFactorChanged;

		public event Action<float>? SkillEffectFactorChanged;

		public event Action<float>? SkillLossChanged;

		public Skill(string englishName, string icon)
			: this(englishName, loadSprite(icon, 64, 64))
		{
		}

		public Skill(string englishName, Sprite icon)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			SkillType val = fromName(englishName);
			string text = new Regex("[^a-zA-Z]").Replace(englishName, "_");
			skills[val] = this;
			skillByName[englishName] = this;
			skillDef = new SkillDef
			{
				m_description = "$skilldesc_" + text,
				m_icon = icon,
				m_increseStep = 1f,
				m_skill = val
			};
			internalSkillName = text;
			skillName = englishName;
			Name = new LocalizeKey("skill_" + ((object)(SkillType)(ref val)).ToString()).English(englishName);
			Description = new LocalizeKey("skilldesc_" + text);
		}

		public static SkillType fromName(string englishName)
		{
			return (SkillType)Math.Abs(StringExtensionMethods.GetStableHashCode(englishName));
		}

		static Skill()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Expected O, but got Unknown
			//IL_016a: Expected O, but got Unknown
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Expected O, but got Unknown
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Expected O, but got Unknown
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Expected O, but got Unknown
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Expected O, but got Unknown
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Expected O, but got Unknown
			//IL_02b0: Expected O, but got Unknown
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Expected O, but got Unknown
			//IL_0306: Expected O, but got Unknown
			skills = new Dictionary<SkillType, Skill>();
			skillByName = new Dictionary<string, Skill>();
			InitializedTerminal = false;
			Harmony val = new Harmony("org.bepinex.helpers.skillmanager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_FejdStartup", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNet), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_ZNet_Awake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Skills), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_Skills_Awake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Skills), "GetSkillDef", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_Skills_GetSkillDef", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Skills), "Load", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_Skills_Load_Prefix", (Type[])null, (Type[])null)), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_Skills_Load_Postfix", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Skills), "IsSkillValid", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_Skills_IsSkillValid", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Skills), "CheatRaiseSkill", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_Skills_CheatRaiseskill", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Skills), "CheatResetSkill", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_Skills_CheatResetSkill", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Localization), "LoadCSV", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(LocalizeKey), "AddLocalizedKeys", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Terminal), "InitTerminal", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_Terminal_InitTerminal_Prefix", (Type[])null, (Type[])null)), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_Terminal_InitTerminal", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Skills), "OnDeath", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_Skills_OnDeath_Prefix", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_Skills_OnDeath_Finalizer", (Type[])null, (Type[])null)), (HarmonyMethod)null);
		}

		private static bool IsEnchantmentSkill(Skill skill)
		{
			return string.Equals(skill.internalSkillName, "kg_Enchantment", StringComparison.Ordinal);
		}

		private static string GetConfigGroup(Skill skill)
		{
			if (!IsEnchantmentSkill(skill))
			{
				return skill.internalSkillName;
			}
			return "Enchantment";
		}

		private static string GetConfigCategory(Skill skill, string localizedName)
		{
			if (!IsEnchantmentSkill(skill))
			{
				return localizedName;
			}
			return "Enchantment";
		}

		private static string GetSkillKeyDescription(string skillKey)
		{
			return "Skill key: " + skillKey + ".";
		}

		private static string GetLocalizedDisplayName(string token, string fallback)
		{
			if (Localization.instance == null)
			{
				return fallback;
			}
			string text = Localization.instance.Localize(token).Trim();
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			return fallback;
		}

		private static void Patch_FejdStartup()
		{
			EnsureConfigBindings();
		}

		private static void Patch_ZNet_Awake()
		{
			EnsureConfigBindings();
		}

		private static void Patch_Skills_Awake(Skills __instance)
		{
			EnsureSkillDefinitions(__instance);
		}

		private static void EnsureSkillDefinitions(Skills? skillComponent)
		{
			if ((Object)(object)skillComponent == (Object)null)
			{
				return;
			}
			foreach (Skill customSkill in skills.Values)
			{
				if (!skillComponent.m_skills.Any((SkillDef skillDef) => skillDef?.m_skill == (SkillType?)customSkill.skillDef.m_skill))
				{
					skillComponent.m_skills.Add(customSkill.skillDef);
				}
			}
		}

		private static Dictionary<SkillType, SavedSkillState>? CaptureCustomSkillStates(ZPackage? pkg)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			if (pkg == null || skills.Count == 0)
			{
				return null;
			}
			try
			{
				ZPackage val = new ZPackage(pkg.GetArray());
				val.SetPos(pkg.GetPos());
				int num = val.ReadInt();
				int num2 = val.ReadInt();
				Dictionary<SkillType, SavedSkillState> dictionary = null;
				for (int i = 0; i < num2; i++)
				{
					SkillType key = (SkillType)val.ReadInt();
					float level = val.ReadSingle();
					float accumulator = ((num >= 2) ? val.ReadSingle() : 0f);
					if (skills.ContainsKey(key))
					{
						if (dictionary == null)
						{
							dictionary = new Dictionary<SkillType, SavedSkillState>();
						}
						dictionary[key] = new SavedSkillState(level, accumulator);
					}
				}
				return dictionary;
			}
			catch
			{
				return null;
			}
		}

		private static void RestoreCustomSkillStates(Skills? skillComponent, Dictionary<SkillType, SavedSkillState>? capturedStates)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)skillComponent == (Object)null || capturedStates == null || capturedStates.Count == 0)
			{
				return;
			}
			EnsureSkillDefinitions(skillComponent);
			foreach (KeyValuePair<SkillType, SavedSkillState> capturedState in capturedStates)
			{
				Skill skill = skillComponent.GetSkill(capturedState.Key);
				skill.m_level = capturedState.Value.Level;
				skill.m_accumulator = capturedState.Value.Accumulator;
			}
		}

		private static void Patch_Skills_Load_Prefix(Skills __instance, ZPackage pkg, out Dictionary<SkillType, SavedSkillState>? __state)
		{
			EnsureSkillDefinitions(__instance);
			__state = CaptureCustomSkillStates(pkg);
		}

		private static void Patch_Skills_Load_Postfix(Skills __instance, Dictionary<SkillType, SavedSkillState>? __state)
		{
			RestoreCustomSkillStates(__instance, __state);
		}

		private static void EnsureConfigBindings()
		{
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Expected O, but got Unknown
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Expected O, but got Unknown
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Expected O, but got Unknown
			if (configBindingsInitialized)
			{
				return;
			}
			foreach (Skill skill in skills.Values)
			{
				if (!skill.Configurable)
				{
					continue;
				}
				string key = skill.Name.Key;
				string fallback = new Regex("['[\"\\]]").Replace(LocalizationCache.LocalizeForConfig(key), "").Trim();
				string localizedDisplayName = GetLocalizedDisplayName(key, fallback);
				string configGroup = GetConfigGroup(skill);
				string configCategory = GetConfigCategory(skill, localizedDisplayName);
				ConfigEntry<float> skillGain = config(configGroup, "Skill gain factor", skill.SkillGainFactor, new ConfigDescription("The rate at which you gain experience for the skill. " + GetSkillKeyDescription(key) + " Required EXP per level follows: ((current level + 1)^1.5) / 2 + 0.5.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 5f), new object[1]
				{
					new ConfigurationManagerAttributes
					{
						Category = configCategory
					}
				}));
				skill.SkillGainFactor = skillGain.Value;
				skillGain.SettingChanged += delegate
				{
					skill.SkillGainFactor = skillGain.Value;
				};
				if (!IsEnchantmentSkill(skill))
				{
					ConfigEntry<float> skillEffect = config(configGroup, "Skill effect factor", skill.SkillEffectFactor, new ConfigDescription("The power of the skill, based on the default power.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 5f), new object[1]
					{
						new ConfigurationManagerAttributes
						{
							Category = configCategory
						}
					}));
					skill.SkillEffectFactor = skillEffect.Value;
					skillEffect.SettingChanged += delegate
					{
						skill.SkillEffectFactor = skillEffect.Value;
					};
				}
				ConfigEntry<int> skillLoss = config(configGroup, "Skill loss", skill.skillLoss, new ConfigDescription("How much experience to lose on death. " + GetSkillKeyDescription(key) + " Required EXP per level follows: ((current level + 1)^1.5) / 2 + 0.5.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), new object[1]
				{
					new ConfigurationManagerAttributes
					{
						Category = configCategory
					}
				}));
				skill.skillLoss = skillLoss.Value;
				skillLoss.SettingChanged += delegate
				{
					skill.skillLoss = skillLoss.Value;
				};
			}
			configBindingsInitialized = true;
		}

		private static void Patch_Skills_GetSkillDef(ref SkillDef? __result, List<SkillDef> ___m_skills, SkillType type)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			if (__result == null)
			{
				SkillDef val = GetSkillDef(type);
				if (val != null)
				{
					___m_skills.Add(val);
					__result = val;
				}
			}
		}

		private static bool Patch_Skills_CheatRaiseskill(Skills __instance, string name, float value, Player ___m_player)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			foreach (SkillType key in skills.Keys)
			{
				SkillType current = key;
				Skill skill = skills[current];
				if (string.Equals(skill.internalSkillName, name, StringComparison.CurrentCultureIgnoreCase))
				{
					Skill skill2 = __instance.GetSkill(current);
					skill2.m_level += value;
					skill2.m_level = Mathf.Clamp(skill2.m_level, 0f, 100f);
					((Character)___m_player).Message((MessageType)1, "Skill increased " + Localization.instance.Localize("$skill_" + ((object)(SkillType)(ref current)).ToString()) + ": " + (int)skill2.m_level, 0, skill2.m_info.m_icon);
					Console.instance.Print("Skill " + skill.internalSkillName + " = " + skill2.m_level);
					return false;
				}
			}
			return true;
		}

		private static bool Patch_Skills_CheatResetSkill(Skills __instance, string name)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			foreach (SkillType key in skills.Keys)
			{
				Skill skill = skills[key];
				if (string.Equals(skill.internalSkillName, name, StringComparison.CurrentCultureIgnoreCase))
				{
					__instance.ResetSkill(key);
					Console.instance.Print("Skill " + skill.internalSkillName + " reset");
					return false;
				}
			}
			return true;
		}

		private static void Patch_Skills_OnDeath_Prefix(Skills __instance, ref Dictionary<SkillType, Skill>? __state)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			if (__state == null)
			{
				__state = new Dictionary<SkillType, Skill>();
			}
			foreach (KeyValuePair<SkillType, Skill> skill in skills)
			{
				if (__instance.m_skillData.TryGetValue(skill.Key, out var value))
				{
					__state[skill.Key] = value;
					if (skill.Value.skillLoss > 0)
					{
						Skill obj = value;
						obj.m_level -= value.m_level * (float)skill.Value.SkillLoss / 100f;
						value.m_accumulator = 0f;
					}
					__instance.m_skillData.Remove(skill.Key);
				}
			}
		}

		private static void Patch_Skills_OnDeath_Finalizer(Skills __instance, ref Dictionary<SkillType, Skill>? __state)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (__state == null)
			{
				return;
			}
			foreach (KeyValuePair<SkillType, Skill> item in __state)
			{
				__instance.m_skillData[item.Key] = item.Value;
			}
			__state = null;
		}

		private static void Patch_Terminal_InitTerminal_Prefix()
		{
			InitializedTerminal = Terminal.m_terminalInitialized;
		}

		private static void Patch_Terminal_InitTerminal()
		{
			if (!InitializedTerminal)
			{
				AddSkill(Terminal.commands["raiseskill"]);
				AddSkill(Terminal.commands["resetskill"]);
			}
			static void AddSkill(ConsoleCommand command)
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Expected O, but got Unknown
				ConsoleOptionsFetcher fetcher = command.m_tabOptionsFetcher;
				command.m_tabOptionsFetcher = (ConsoleOptionsFetcher)delegate
				{
					List<string> list = fetcher.Invoke();
					list.AddRange(skills.Values.Select((Skill skill) => skill.internalSkillName));
					return list;
				};
			}
		}

		private static SkillDef? GetSkillDef(SkillType skillType)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (!skills.ContainsKey(skillType))
			{
				return null;
			}
			Skill skill = skills[skillType];
			return skill.skillDef;
		}

		private static void Patch_Skills_IsSkillValid(SkillType type, ref bool __result)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!__result && skills.ContainsKey(type))
			{
				__result = true;
			}
		}

		private static byte[] ReadEmbeddedFileBytes(string name)
		{
			using MemoryStream memoryStream = new MemoryStream();
			Assembly.GetExecutingAssembly().GetManifestResourceStream(Assembly.GetExecutingAssembly().GetName().Name + "." + name).CopyTo(memoryStream);
			return memoryStream.ToArray();
		}

		private static Texture2D loadTexture(string name)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			Texture2D val = new Texture2D(0, 0);
			ImageConversion.LoadImage(val, ReadEmbeddedFileBytes("icons." + name));
			return val;
		}

		private static Sprite loadSprite(string name, int width, int height)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			return Sprite.Create(loadTexture(name), new Rect(0f, 0f, (float)width, (float)height), Vector2.zero);
		}

		private static ConfigEntry<T> config<T>(string group, string name, T value, ConfigDescription description)
		{
			return ValheimEnchantmentSystem.config(group, name, value, description);
		}

		private static ConfigEntry<T> config<T>(string group, string name, T value, string description)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()));
		}
	}
	public static class SkillManagerVersion
	{
		public const string Version = "1.7.0";
	}
	[PublicAPI]
	public static class SkillExtensions
	{
		public static float GetSkillFactor(this Character character, string name)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return character.GetSkillFactor(Skill.fromName(name)) * Skill.skillByName[name].SkillEffectFactor;
		}

		public static float GetSkillFactor(this Skills skills, string name)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return skills.GetSkillFactor(Skill.fromName(name)) * Skill.skillByName[name].SkillEffectFactor;
		}

		public static void RaiseSkill(this Character character, string name, float value = 1f)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			character.RaiseSkill(Skill.fromName(name), value);
		}

		public static void RaiseSkill(this Skills skill, string name, float value = 1f)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			skill.RaiseSkill(Skill.fromName(name), value);
		}

		public static void LowerSkill(this Character character, string name, float factor = 1f)
		{
			character.GetSkills().LowerSkill(name, factor);
		}

		public static void LowerSkill(this Skills skills, string name, float factor)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (factor > 0f && skills.m_skillData.TryGetValue(Skill.fromName(name), out var value))
			{
				Skill obj = value;
				obj.m_level -= value.m_level * factor;
				value.m_accumulator = 0f;
			}
		}
	}
}
namespace LocalizationManager
{
	[PublicAPI]
	public static class SharedLocalizationCache
	{
		private static readonly Dictionary<string, WeakReference<Localization>> Localizations = new Dictionary<string, WeakReference<Localization>>();

		private static readonly object CacheLock = new object();

		public static void Track(Localization localization, string language)
		{
			Localization localization2 = localization;
			lock (CacheLock)
			{
				Localization target;
				string key = Localizations.FirstOrDefault<KeyValuePair<string, WeakReference<Localization>>>((KeyValuePair<string, WeakReference<Localization>> pair) => pair.Value.TryGetTarget(out target) && target == localization2).Key;
				if (key != null)
				{
					Localizations.Remove(key);
				}
				Localizations[language] = new WeakReference<Localization>(localization2);
			}
		}

		public static Localization ForLanguage(string? language = null)
		{
			bool flag = language != null;
			string text = language ?? PlayerPrefs.GetString("language", "English");
			lock (CacheLock)
			{
				if (Localizations.TryGetValue(text, out WeakReference<Localization> value) && value.TryGetTarget(out var target))
				{
					return target;
				}
			}
			if (Localization.m_instance != null)
			{
				Localization instance = Localization.instance;
				string selectedLanguage = instance.GetSelectedLanguage();
				Track(instance, selectedLanguage);
				if (!flag || string.Equals(selectedLanguage, text, StringComparison.OrdinalIgnoreCase))
				{
					return instance;
				}
				throw new InvalidOperationException("Requested localization '" + text + "' is not cached. Active language is '" + selectedLanguage + "'.");
			}
			throw new InvalidOperationException("No localization instance is available for language '" + text + "'.");
		}

		public static string LocalizeForConfig(string token, string preferredLanguage = "English")
		{
			if (string.IsNullOrWhiteSpace(token))
			{
				return string.Empty;
			}
			string text = (token.StartsWith("$", StringComparison.Ordinal) ? token : ("$" + token));
			string key = text.TrimStart(new char[1] { '$' });
			if (Localizer.TryGetConfigText(preferredLanguage, key, out string text2))
			{
				return text2;
			}
			try
			{
				string text3 = ForLanguage(preferredLanguage).Localize(text).Trim();
				if (!string.IsNullOrWhiteSpace(text3) && !string.Equals(text3, text, StringComparison.Ordinal))
				{
					return text3;
				}
			}
			catch
			{
			}
			string text4 = text.TrimStart(new char[1] { '$' }).Replace('_', ' ').Trim();
			if (text4.Length != 0)
			{
				return text4;
			}
			return text;
		}
	}
	[PublicAPI]
	public class Localizer
	{
		private static readonly Dictionary<string, Dictionary<string, Func<string>>> PlaceholderProcessors;

		private static readonly Dictionary<string, Dictionary<string, string>> LoadedTexts;

		private static readonly object LoadedTextsLock;

		private static readonly ConditionalWeakTable<Localization, string> LocalizationLanguage;

		private static readonly List<WeakReference<Localization>> LocalizationObjects;

		private static readonly List<string> FileExtensions;

		private static BaseUnityPlugin? _plugin;

		private static readonly object ExternalLocalizationFilesLock;

		private static Dictionary<string, string>? _externalLocalizationFiles;

		private static BaseUnityPlugin plugin
		{
			get
			{
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Expected O, but got Unknown
				if (_plugin == null)
				{
					IEnumerable<TypeInfo> source;
					try
					{
						source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
					}
					catch (ReflectionTypeLoadException ex)
					{
						source = from t in ex.Types
							where t != null
							select t.GetTypeInfo();
					}
					_plugin = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First((TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
				}
				return _plugin;
			}
		}

		public static event Action? OnLocalizationComplete;

		private static string? TryParseLanguageFromExternalFile(string filePath)
		{
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(filePath);
			string text = plugin.Info.Metadata.GUID + ".";
			if (!fileNameWithoutExtension.StartsWith(text, StringComparison.OrdinalIgnoreCase))
			{
				return null;
			}
			string text2 = fileNameWithoutExtension.Substring(text.Length);
			if (!string.IsNullOrWhiteSpace(text2))
			{
				return text2;
			}
			return null;
		}

		private static bool HasSupportedExtension(string filePath)
		{
			return FileExtensions.Contains<string>(Path.GetExtension(filePath), StringComparer.OrdinalIgnoreCase);
		}

		private static Dictionary<string, string> BuildExternalLocalizationFiles()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			string directoryName = Path.GetDirectoryName(Paths.PluginPath);
			foreach (string item in Directory.GetFiles(directoryName, plugin.Info.Metadata.GUID + ".*", SearchOption.AllDirectories).Where(HasSupportedExtension))
			{
				string text = TryParseLanguageFromExternalFile(item);
				if (text != null)
				{
					if (dictionary.ContainsKey(text))
					{
						Debug.LogWarning((object)("Duplicate key " + text + " found for " + plugin.Info.Metadata.GUID + ". The duplicate file found at " + item + " will be skipped."));
					}
					else
					{
						dictionary[text] = item;
					}
				}
			}
			return dictionary;
		}

		private static Dictionary<string, string> GetExternalLocalizationFiles()
		{
			lock (ExternalLocalizationFilesLock)
			{
				if (_externalLocalizationFiles == null)
				{
					_externalLocalizationFiles = BuildExternalLocalizationFiles();
				}
				return _externalLocalizationFiles;
			}
		}

		private static void UpdatePlaceholderText(Localization localization, string key)
		{
			if (!LocalizationLanguage.TryGetValue(localization, out string value) || !LoadedTexts.TryGetValue(value, out Dictionary<string, string> value2) || !value2.TryGetValue(key, out var value3))
			{
				return;
			}
			if (PlaceholderProcessors.TryGetValue(key, out Dictionary<string, Func<string>> value4))
			{
				value3 = value4.Aggregate(value3, (string current, KeyValuePair<string, Func<string>> kv) => current.Replace("{" + kv.Key + "}", kv.Value()));
			}
			localization.AddWord(key, value3);
		}

		public static void AddPlaceholder<T>(string key, string placeholder, ConfigEntry<T> config, Func<T, string>? convertConfigValue = null) where T : notnull
		{
			string key2 = key;
			string placeholder2 = placeholder;
			Func<T, string> convertConfigValue2 = convertConfigValue;
			ConfigEntry<T> config2 = config;
			if (convertConfigValue2 == null)
			{
				convertConfigValue2 = (T val) => val.ToString();
			}
			if (!PlaceholderProcessors.ContainsKey(key2))
			{
				PlaceholderProcessors[key2] = new Dictionary<string, Func<string>>();
			}
			config2.SettingChanged += delegate
			{
				UpdatePlaceholder();
			};
			if (Localization.instance != null && LoadedTexts.ContainsKey(Localization.instance.GetSelectedLanguage()))
			{
				UpdatePlaceholder();
			}
			void UpdatePlaceholder()
			{
				if (Localization.instance != null)
				{
					PlaceholderProcessors[key2][placeholder2] = () => convertConfigValue2(config2.Value);
					UpdatePlaceholderText(Localization.instance, key2);
				}
			}
		}

		public static void AddText(string key, string text)
		{
			List<WeakReference<Localization>> list = new List<WeakReference<Localization>>();
			foreach (WeakReference<Localization> localizationObject in LocalizationObjects)
			{
				if (localizationObject.TryGetTarget(out var target))
				{
					string orCreateValue = LocalizationLanguage.GetOrCreateValue(target);
					if (!LoadedTexts.TryGetValue(orCreateValue, out Dictionary<string, string> value))
					{
						value = new Dictionary<string, string>();
						LoadedTexts[orCreateValue] = value;
					}
					if (!target.m_translations.ContainsKey(key))
					{
						value[key] = text;
						target.AddWord(key, text);
					}
				}
				else
				{
					list.Add(localizationObject);
				}
			}
			foreach (WeakReference<Localization> item in list)
			{
				LocalizationObjects.Remove(item);
			}
		}

		public static bool TryGetConfigText(string language, string key, out string text)
		{
			text = string.Empty;
			if (string.IsNullOrWhiteSpace(language) || string.IsNullOrWhiteSpace(key))
			{
				return false;
			}
			Dictionary<string, string> dictionary = EnsureConfigTextsLoaded(language);
			if (dictionary == null || !dictionary.TryGetValue(key, out var value) || string.IsNullOrWhiteSpace(value))
			{
				return false;
			}
			text = value.Trim();
			return text.Length > 0;
		}

		public static void Load()
		{
			_ = plugin;
		}

		public static void LoadLocalizationLater(Localization __instance)
		{
			LoadLocalization(Localization.instance, __instance.GetSelectedLanguage());
		}

		public static void SafeCallLocalizeComplete()
		{
			Localizer.OnLocalizationComplete?.Invoke();
		}

		private static void LoadLocalization(Localization __instance, string language)
		{
			if (!LocalizationLanguage.Remove(__instance))
			{
				LocalizationObjects.Add(new WeakReference<Localization>(__instance));
			}
			LocalizationLanguage.Add(__instance, language);
			SharedLocalizationCache.Track(__instance, language);
			Dictionary<string, string> externalLocalizationFiles = GetExternalLocalizationFiles();
			byte[] array = LoadTranslationFromAssembly("English");
			if (array == null)
			{
				throw new Exception("Found no English localizations in mod " + plugin.Info.Metadata.Name + ". Expected an embedded resource translations/English.json or translations/English.yml.");
			}
			Dictionary<string, string> dictionary = new DeserializerBuilder().IgnoreFields().Build().Deserialize<Dictionary<string, string>>(Encoding.UTF8.GetString(array));
			if (dictionary == null)
			{
				throw new Exception("Localization for mod " + plugin.Info.Metadata.Name + " failed: Localization file was empty.");
			}
			string text = null;
			if (language != "English")
			{
				if (externalLocalizationFiles.TryGetValue(language, out var value))
				{
					text = File.ReadAllText(value);
				}
				else
				{
					byte[] array2 = LoadTranslationFromAssembly(language);
					if (array2 != null)
					{
						text = Encoding.UTF8.GetString(array2);
					}
				}
			}
			if (text == null && externalLocalizationFiles.TryGetValue("English", out var value2))
			{
				text = File.ReadAllText(value2);
			}
			if (text != null)
			{
				foreach (KeyValuePair<string, string> item in new DeserializerBuilder().IgnoreFields().Build().Deserialize<Dictionary<string, string>>(text) ?? new Dictionary<string, string>())
				{
					dictionary[item.Key] = item.Value;
				}
			}
			LoadedTexts[language] = dictionary;
			foreach (KeyValuePair<string, string> item2 in dictionary)
			{
				UpdatePlaceholderText(__instance, item2.Key);
			}
		}

		static Localizer()
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			PlaceholderProcessors = new Dictionary<string, Dictionary<string, Func<string>>>();
			LoadedTexts = new Dictionary<string, Dictionary<string, string>>();
			LoadedTextsLock = new object();
			LocalizationLanguage = new ConditionalWeakTable<Localization, string>();
			LocalizationObjects = new List<WeakReference<Localization>>();
			FileExtensions = new List<string>(2) { ".json", ".yml" };
			ExternalLocalizationFilesLock = new object();
			Harmony val = new Harmony("org.bepinex.helpers.LocalizationManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Localization), "SetupLanguage", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Localizer), "LoadLocalization", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "SetupGui", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Localizer), "LoadLocalizationLater", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "Start", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Localizer), "SafeCallLocalizeComplete", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static byte[]? LoadTranslationFromAssembly(string language)
		{
			Assembly assembly = typeof(Localizer).Assembly;
			foreach (string fileExtension in FileExtensions)
			{
				byte[] array = ReadEmbeddedFileBytes("translations." + language + fileExtension, assembly);
				if (array != null)
				{
					return array;
				}
			}
			return null;
		}

		private static Dictionary<string, string>? EnsureConfigTextsLoaded(string language)
		{
			lock (LoadedTextsLock)
			{
				if (LoadedTexts.TryGetValue(language, out Dictionary<string, string> value))
				{
					return value;
				}
				Dictionary<string, string> externalLocalizationFiles = GetExternalLocalizationFiles();
				string text = null;
				if (externalLocalizationFiles.TryGetValue(language, out var value2))
				{
					text = File.ReadAllText(value2);
				}
				else
				{
					byte[] array = LoadTranslationFromAssembly(language);
					if (array != null)
					{
						text = Encoding.UTF8.GetString(array);
					}
				}
				if (text == null)
				{
					return null;
				}
				Dictionary<string, string> dictionary = new DeserializerBuilder().IgnoreFields().Build().Deserialize<Dictionary<string, string>>(text);
				if (dictionary == null)
				{
					return null;
				}
				LoadedTexts[language] = dictionary;
				return dictionary;
			}
		}

		public static byte[]? ReadEmbeddedFileBytes(string resourceFileName, Assembly? containingAssembly = null)
		{
			string resourceFileName2 = resourceFileName;
			using MemoryStream memoryStream = new MemoryStream();
			if ((object)containingAssembly == null)
			{
				containingAssembly = Assembly.GetCallingAssembly();
			}
			string text = containingAssembly.GetManifestResourceNames().FirstOrDefault((string str) => str.EndsWith(resourceFileName2, StringComparison.Ordinal));
			if (text != null)
			{
				containingAssembly.GetManifestResourceStream(text)?.CopyTo(memoryStream);
			}
			return (memoryStream.Length == 0L) ? null : memoryStream.ToArray();
		}
	}
	public static class LocalizationManagerVersion
	{
		public const string Version = "1.4.2";
	}
}
namespace ItemDataManager
{
	[PublicAPI]
	public abstract class ItemData
	{
		internal static WeakReference<ItemInfo> constructingInfo = null;

		internal WeakReference<ItemInfo>? info;

		private static readonly FieldInfo parameterInfoClassImpl = AccessTools.DeclaredField(typeof(ParameterInfo), "ClassImpl");

		private static Dictionary<Type, Dictionary<string, FieldInfo>> serializedFields = new Dictionary<Type, Dictionary<string, FieldInfo>>();

		public string CustomDataKey { get; internal set; }

		protected virtual bool AllowStackingIdenticalValues { get; set; }

		public string Value
		{
			get
			{
				if (!Item.m_customData.TryGetValue(CustomDataKey, out var value))
				{
					return "";
				}
				return value;
			}
			set
			{
				Item.m_customData[CustomDataKey] = value;
			}
		}

		public string Key { get; internal set; }

		public bool IsCloned => Info.isCloned.Contains(CustomDataKey);

		public bool IsAlive
		{
			get
			{
				ItemInfo target;
				return (info ?? constructingInfo).TryGetTarget(out target);
			}
		}

		public ItemData Item => Info.ItemData;

		public ItemInfo Info
		{
			get
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				if (!(info ?? constructingInfo).TryGetTarget(out ItemInfo target))
				{
					return new ItemInfo(new ItemData());
				}
				return target;
			}
		}

		public virtual void FirstLoad()
		{
		}

		public virtual void Load()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			Dictionary<string, FieldInfo> dictionary = fetchSerializedFields();
			if (dictionary == null || dictionary.Count <= 0 || Value == "")
			{
				return;
			}
			List<object> list = new List<object>();
			string[] array = Value.Split(new char[1] { '|' });
			foreach (string text in array)
			{
				string[] array2 = text.Split(new char[1] { ':' });
				if (array2.Length == 2 && dictionary.TryGetValue(array2[0], out var value))
				{
					ZPackage val = new ZPackage(array2[1]);
					ParameterInfo parameterInfo = (ParameterInfo)FormatterServices.GetUninitializedObject(typeof(ParameterInfo));
					parameterInfoClassImpl.SetValue(parameterInfo, value.FieldType);
					list.Clear();
					ZRpc.Deserialize(new ParameterInfo[2] { null, parameterInfo }, val, ref list);
					if (list.Count > 0)
					{
						value.SetValue(this, list[0]);
					}
				}
			}
		}

		public virtual void Save()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			Dictionary<string, FieldInfo> dictionary = fetchSerializedFields();
			if (dictionary == null || dictionary.Count <= 0)
			{
				return;
			}
			StringBuilder stringBuilder = new StringBuilder();
			foreach (FieldInfo value in dictionary.Values)
			{
				ZPackage val = new ZPackage();
				ZRpc.Serialize(new object[1] { value.GetValue(this) }, ref val);
				stringBuilder.Append(value.Name);
				stringBuilder.Append(':');
				stringBuilder.Append(val.GetBase64());
				stringBuilder.Append('|');
			}
			int length = stringBuilder.Length - 1;
			stringBuilder.Length = length;
			Value = stringBuilder.ToString();
		}

		public virtual void Unload()
		{
		}

		public virtual void Upgraded()
		{
		}

		public virtual string? TryStack(ItemData? data)
		{
			if (!AllowStackingIdenticalValues || !(data?.Value == Value))
			{
				return null;
			}
			return Value;
		}

		private Dictionary<string, FieldInfo> fetchSerializedFields()
		{
			Type type = GetType();
			if (serializedFields.TryGetValue(type, out Dictionary<string, FieldInfo> value))
			{
				return value;
			}
			return serializedFields[type] = (from f in type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
				where f.GetCustomAttributes(typeof(SerializeField), inherit: true).Length != 0
				select f).ToDictionary((FieldInfo f) => f.Name, (FieldInfo f) => f);
		}
	}
	public sealed class StringItemData : ItemData
	{
	}
	[PublicAPI]
	public class ItemInfo : IEnumerable<ItemData>, IEnumerable
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass57_0
		{
			public Label target;

			public CodeInstruction targetedInstr;

			internal bool <CheckStackableInFindFreeStackMethods>b__1(CodeInstruction i)
			{
				return i.labels.Contains(target);
			}

			internal bool <CheckStackableInFindFreeStackMethods>b__2(CodeInstruction i)
			{
				Label? label = default(Label?);
				if (CodeInstructionExtensions.Branches(i, ref label))
				{
					return targetedInstr.labels.Contains(label.Value);
				}
				return false;
			}
		}

		[CompilerGenerated]
		private sealed class <CheckStackableInFindFreeStackMethods>d__57 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private CodeInstruction <>2__current;

			private int <>l__initialThreadId;

			private IEnumerable<CodeInstruction> instructionsEnumerable;

			public IEnumerable<CodeInstruction> <>3__instructionsEnumerable;

			private <>c__DisplayClass57_0 <>8__1;

			private CodeInstruction[] <instructions>5__2;

			private CodeInstruction <lastBranch>5__3;

			private CodeInstruction <loadingInstruction>5__4;

			private int <i>5__5;

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

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

			[DebuggerHidden]
			public <CheckStackableInFindFreeStackMethods>d__57(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<instructions>5__2 = null;
				<lastBranch>5__3 = null;
				<loadingInstruction>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_023c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0246: Expected O, but got Unknown
				//IL_0272: Unknown result type (might be due to invalid IL or missing references)
				//IL_027c: Expected O, but got Unknown
				//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ac: Expected O, but got Unknown
				int num;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass57_0();
					<instructions>5__2 = instructionsEnumerable.ToArray();
					<>8__1.target = (Label)<instructions>5__2.First((CodeInstruction i) => i.opcode == OpCodes.Br || i.opcode == OpCodes.Br_S).operand;
					<>8__1.targetedInstr = <instructions>5__2.First((CodeInstruction i) => i.labels.Contains(<>8__1.target));
					Label? label = default(Label?);
					<lastBranch>5__3 = <instructions>5__2.Reverse().First((CodeInstruction i) => CodeInstructionExtensions.Branches(i, ref label) && <>8__1.targetedInstr.labels.Contains(label.Value));
					<loadingInstruction>5__4 = null;
					<i>5__5 = 0;
					break;
				}
				case 1:
					<>1__state = -1;
					if (<loadingInstruction>5__4 == null && <instructions>5__2[<i>5__5].opcode == OpCodes.Call && ((MethodInfo)<instructions>5__2[<i>5__5].operand).Name == "get_Current")
					{
						<loadingInstruction>5__4 = <instructions>5__2[<i>5__5 + 1].Clone();
						<loadingInstruction>5__4.opcode = new Dictionary<OpCode, OpCode>
						{
							{
								OpCodes.Stloc_0,
								OpCodes.Ldloc_0
							},
							{
								OpCodes.Stloc_1,
								OpCodes.Ldloc_1
							},
							{
								OpCodes.Stloc_2,
								OpCodes.Ldloc_2
							},
							{
								OpCodes.Stloc_3,
								OpCodes.Ldloc_3
							},
							{
								OpCodes.Stloc_S,
								OpCodes.Ldloc_S
							}
						}[<loadingInstruction>5__4.opcode];
					}
					if (<instructions>5__2[<i>5__5] == <lastBranch>5__3)
					{
						<>2__current = <loadingInstruction>5__4;
						<>1__state = 2;
						return true;
					}
					goto IL_02bc;
				case 2:
					<>1__state = -1;
					<>2__current = new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.DeclaredField(typeof(ItemInfo), "checkingForStackableItemData"));
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(ItemInfo), "CheckItemDataIsStackableFindFree", (Type[])null, (Type[])null));
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					<>2__current = new CodeInstruction(OpCodes.Brfalse, (object)<>8__1.target);
					<>1__state = 5;
					return true;
				case 5:
					{
						<>1__state = -1;
						goto IL_02bc;
					}
					IL_02bc:
					num = <i>5__5 + 1;
					<i>5__5 = num;
					break;
				}
				if (<i>5__5 < <instructions>5__2.Length)
				{
					<>2__current = <instructions>5__2[<i>5__5];
					<>1__state = 1;
					return true;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
			{
				<CheckStackableInFindFreeStackMethods>d__57 <CheckStackableInFindFreeStackMethods>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<CheckStackableInFindFreeStackMethods>d__ = this;
				}
				else
				{
					<CheckStackableInFindFreeStackMethods>d__ = new <CheckStackableInFindFreeStackMethods>d__57(0);
				}
				<CheckStackableInFindFreeStackMethods>d__.instructionsEnumerable = <>3__instructionsEnumerable;
				return <CheckStackableInFindFreeStackMethods>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <ImportCustomDataOnUpgrade>d__71 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private CodeInstruction <>2__current;

			private int <>l__initialThreadId;

			private IEnumerable<CodeInstruction> instructionList;

			public IEnumerable<CodeInstruction> <>3__instructionList;

			private List<CodeInstruction>.Enumerator <>7__wrap1;

			private CodeInstruction <instruction>5__3;

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

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

			[DebuggerHidden]
			public <ImportCustomDataOnUpgrade>d__71(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 2u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = default(List<CodeInstruction>.Enumerator);
				<instruction>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Expected O, but got Unknown
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cc: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						List<CodeInstruction> list = instructionList.ToList();
						<>7__wrap1 = list.GetEnumerator();
						<>1__state = -3;
						break;
					}
					case 1:
						<>1__state = -3;
						if (<instruction>5__3.opcode == OpCodes.Stfld && CodeInstructionExtensions.OperandIs(<instruction>5__3, (MemberInfo)AccessTools.DeclaredField(typeof(ItemData), "m_dropPrefab")))
						{
							<>2__current = new CodeInstruction(OpCodes.Ldarg_0, (object)null);
							<>1__state = 2;
							return true;
						}
						goto IL_0118;
					case 2:
						<>1__state = -3;
						<>2__current = new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(ItemInfo), "CopyCustomDataFromUpgradedItem", (Type[])null, (Type[])null));
						<>1__state = 3;
						return true;
					case 3:
						{
							<>1__state = -3;
							goto IL_0118;
						}
						IL_0118:
						<instruction>5__3 = null;
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						<instruction>5__3 = <>7__wrap1.Current;
						<>2__current = <instruction>5__3;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap1 = default(List<CodeInstruction>.Enumerator);
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>7__wrap1).Dispose();
			}

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

			[DebuggerHidden]
			IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
			{
				<ImportCustomDataOnUpgrade>d__71 <ImportCustomDataOnUpgrade>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<ImportCustomDataOnUpgrade>d__ = this;
				}
				else
				{
					<ImportCustomDataOnUpgrade>d__ = new <ImportCustomDataOnUpgrade>d__71(0);
				}
				<ImportCustomDataOnUpgrade>d__.instructionList = <>3__instructionList;
				return <ImportCustomDataOnUpgrade>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <TransferCustomItemDataOnUpgrade>d__68 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private CodeInstruction <>2__current;

			private int <>l__initialThreadId;

			private IEnumerable<CodeInstruction> instructions;

			public IEnumerable<CodeInstruction> <>3__instructions;

			private MethodInfo <itemDeleter>5__2;

			private IEnumerator<CodeInstruction> <>7__wrap2;

			private CodeInstruction <instruction>5__4;

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

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

			[DebuggerHidden]
			public <TransferCustomItemDataOnUpgrade>d__68(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 2u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<itemDeleter>5__2 = null;
				<>7__wrap2 = null;
				<instruction>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Expected O, but got Unknown
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<itemDeleter>5__2 = AccessTools.DeclaredMethod(typeof(Inventory), "RemoveItem", new Type[1] { typeof(ItemData) }, (Type[])null);
						<>7__wrap2 = instructions.GetEnumerator();
						<>1__state = -3;
						goto IL_0136;
					case 1:
						<>1__state = -3;
						<>2__current = new CodeInstruction(OpCodes.Stsfld, (object)AccessTools.DeclaredField(typeof(ItemInfo), "currentlyUpgradingItem"));
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -3;
						goto IL_0110;
					case 3:
						{
							<>1__state = -3;
							<instruction>5__4 = null;
							goto IL_0136;
						}
						IL_0136:
						if (<>7__wrap2.MoveNext())
						{
							<instruction>5__4 = <>7__wrap2.Current;
							if (<instruction>5__4.opcode == OpCodes.Callvirt && CodeInstructionExtensions.OperandIs(<instruction>5__4, (MemberInfo)<itemDeleter>5__2))
							{
								<>2__current = new CodeInstruction(OpCodes.Dup, (object)null);
								<>1__state = 1;
								return true;
							}
							goto IL_0110;
						}
						<>m__Finally1();
						<>7__wrap2 = null;
						return false;
						IL_0110:
						<>2__current = <instruction>5__4;
						<>1__state = 3;
						return true;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap2 != null)
				{
					<>7__wrap2.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
			{
				<TransferCustomItemDataOnUpgrade>d__68 <TransferCustomItemDataOnUpgrade>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<TransferCustomItemDataOnUpgrade>d__ = this;
				}
				else
				{
					<TransferCustomItemDataOnUpgrade>d__ = new <TransferCustomItemDataOnUpgrade>d__68(0);
				}
				<TransferCustomItemDataOnUpgrade>d__.instructions = <>3__instructions;
				return <TransferCustomItemDataOnUpgrade>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
			}
		}

		public static HashSet<Type> ForceLoadTypes;

		internal static string? _modGuid;

		private static Dictionary<Type, HashSet<Type>> typeInheritorsCache;

		private static HashSet<string> knownTypes;

		private Dictionary<string, ItemData> data = new Dictionary<string, ItemData>();

		private WeakReference<ItemInfo>? selfReference;

		internal HashSet<string> isCloned = new HashSet<string>();

		private static ItemData? awakeningItem;

		private static Assembly primaryAssembly;

		private static Dictionary<Assembly, string> assemblyNameCache;

		private static Dictionary<Type, string> classKeyCache;

		private HashSet<string> fetchedClassKeys = new HashSet<string>();

		private static MethodInfo removeMethod;

		private static ItemData? checkingForStackableItemData;

		private static Dictionary<string, string>? newValuesOnStackable;

		private static ItemData? currentlyUpgradingItem;

		internal static string modGuid => _modGuid ?? (_modGuid = ((Func<string>)delegate
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			IEnumerable<TypeInfo> source;
			try
			{
				source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
			}
			catch (ReflectionTypeLoadException ex)
			{
				source = from t in ex.Types
					where t != null
					select t.GetTypeInfo();
			}
			BaseUnityPlugin val = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First((TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
			return val.Info.Metadata.GUID;
		})());

		public string Mod => modGuid;

		public ItemData ItemData { get; private set; }

		public string? this[string key]
		{
			get
			{
				return Get<StringItemData>(key)?.Value;
			}
			set
			{
				GetOrCreate<StringItemData>(key).Value = value ?? "";
			}
		}

		internal static void addTypeToInheritorsCache(Type type, string typeKey)
		{
			Type type2 = type;
			if (!knownTypes.Contains(typeKey))
			{
				knownTypes.Add(typeKey);
				Type type3 = type2;
				while ((object)type3 != null)
				{
					AddInterfaces(type3);
					type3 = type3.BaseType;
				}
			}
			void AddInterfaces(Type baseType)
			{
				if (!typeInheritorsCache.TryGetValue(baseType, out HashSet<Type> value))
				{
					HashSet<Type> hashSet2 = (typeInheritorsCache[baseType] = new HashSet<Type>());
					value = hashSet2;
				}
				value.Add(type2);
				Type[] interfaces = baseType.GetInterfaces();
				foreach (Type baseType2 in interfaces)
				{
					AddInterfaces(baseType2);
				}
			}
		}

		private static string cachedAssemblyName(Assembly assembly)
		{
			if (assemblyNameCache.TryGetValue(assembly, out string value))
			{
				return value;
			}
			return assemblyNameCache[assembly] = assembly.GetName().Name;
		}

		internal static string classKey(Type type, string key)
		{
			if (!classKeyCache.TryGetValue(type, out string value))
			{
				value = type.FullName + ((type.Assembly != primaryAssembly) ? ("," + cachedAssemblyName(type.Assembly)) : "");
				addTypeToInheritorsCache(type, value);
			}
			if (key == "")
			{
				return value;
			}
			return value + "#" + key;
		}

		internal static string dataKey(string key)
		{
			return modGuid + "#" + key;
		}

		internal ItemInfo(ItemData itemData)
		{
			ItemData = itemData;
			string text = dataKey("");
			List<string> list = ItemData.m_customData.Keys.ToList();
			foreach (string item in list)
			{
				if (!item.StartsWith(text))
				{
					continue;
				}
				string text2 = item.Substring(text.Length);
				string[] array = text2.Split(new char[1] { '#' }, 2);
				if (!knownTypes.Contains(array[0]))
				{
					Type type = Type.GetType(array[0]);
					if ((object)type != null && typeof(ItemData).IsAssignableFrom(type))
					{
						addTypeToInheritorsCache(type, array[0]);
					}
				}
			}
		}

		public T GetOrCreate<T>(string key = "") where T : ItemData, new()
		{
			return Add<T>(key) ?? Get<T>(key);
		}

		public T? Add<T>(string key = "") where T : ItemData, new()
		{
			string text = classKey(typeof(T), key);
			if (fetchedClassKeys.Contains(text) && data.ContainsKey(text))
			{
				return null;
			}
			string text2 = dataKey(text);
			if (ItemData.m_customData.ContainsKey(text2) || (awakeningItem != ItemData && data.ContainsKey(text)))
			{
				return null;
			}
			ItemData.m_customData[text2] = "";
			ItemDataManager.ItemData.constructingInfo = selfReference ?? (selfReference = new WeakReference<ItemInfo>(this));
			T val = new T
			{
				info = selfReference,
				Key = key,
				CustomDataKey = text2
			};
			data[text] = val;
			val.Value = "";
			val.FirstLoad();
			return val;
		}

		public T? Get<T>(string key = "") where T : class
		{
			if (!typeInheritorsCache.TryGetValue(typeof(T), out HashSet<Type> value))
			{
				if (!typeof(ItemData).IsAssignableFrom(typeof(T)) || typeof(T) == typeof(ItemData))
				{
					throw new Exception("Trying to get value from ItemDataManager for class not inheriting from ItemData");
				}
				return null;
			}
			foreach (Type item in value)
			{
				string text = classKey(item, key);
				if (data.TryGetValue(text, out ItemData value2))
				{
					return (T)(object)value2;
				}
				if (!fetchedClassKeys.Contains(text) && awakeningItem != ItemData)
				{
					string text2 = dataKey(text);
					fetchedClassKeys.Add(text);
					if (ItemData.m_customData.ContainsKey(text2))
					{
						return (T)(object)constructDataObj(text2, text);
					}
				}
			}
			return null;
		}

		public Dictionary<string, T> GetAll<T>() where T : ItemData
		{
			LoadAll();
			return data.Values.Where((ItemData o) => o is T).ToDictionary((ItemData o) => o.Key, (ItemData o) => (T)o);
		}

		public bool Remove(string key = "")
		{
			return Remove<StringItemData>(key);
		}

		public bool Remove<T>(string key = "") where T : ItemData
		{
			string key2 = classKey(typeof(T), key);
			string key3 = dataKey(key2);
			if (ItemData.m_customData.Remove(key3))
			{
				if (data.TryGetValue(key2, out ItemData value))
				{
					value.Unload();
					data.Remove(key2);
				}
				return true;
			}
			return false;
		}

		public bool Remove<T>(T itemData) where T : ItemData
		{
			if (typeof(T) == itemData.GetType())
			{
				return Remove<T>(itemData.Key);
			}
			return (bool)removeMethod.MakeGenericMethod(itemData.GetType()).Invoke(this, new object[1] { itemData.Key });
		}

		private ItemData? constructDataObj(string fullkey, string key)
		{
			string[] array = key.Split(new char[1] { '#' }, 2);
			Type type = Type.GetType(array[0]);
			if ((object)type == null || !typeof(ItemData).IsAssignableFrom(type))
			{
				return null;
			}
			ItemDataManager.ItemData.constructingInfo = selfReference ?? (selfReference = new WeakReference<ItemInfo>(this));
			ItemData itemData = (ItemData)Activator.CreateInstance(type);
			data[key] = itemData;
			itemData.info = selfReference;
			itemData.Key = ((array.Length > 1) ? array[1] : "");
			itemData.CustomDataKey = fullkey;
			itemData.Load();
			return itemData;
		}

		public void Save()
		{
			foreach (ItemData value in data.Values)
			{
				value.Save();
			}
		}

		public void LoadAll()
		{
			if (awakeningItem == ItemData)
			{
				return;
			}
			string text = dataKey("");
			List<string> list = ItemData.m_customData.Keys.ToList();
			foreach (string item in list)
			{
				if (item.StartsWith(text))
				{
					string key = item.Substring(text.Length);
					if (!data.ContainsKey(key))
					{
						constructDataObj(item, key);
					}
				}
			}
		}

		public IEnumerator<ItemData> GetEnumerator()
		{
			LoadAll();
			return data.Values.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		private static void SavePrefix(ItemData __instance)
		{
			SaveItem(__instance);
		}

		private static void SaveInventoryPrefix(Inventory __instance)
		{
			foreach (ItemData item in __instance.m_inventory)
			{
				SaveItem(item);
			}
		}

		private static void SaveItem(ItemData item)
		{
			if (ItemExtensions.itemInfo.TryGetValue(item, out ItemInfo value))
			{
				value.Save();
			}
		}

		public Dictionary<string, string>? IsStackableWithOtherInfo(ItemInfo? info)
		{
			LoadAll();
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			if (info != null)
			{
				info.LoadAll();
				HashSet<string> hashSet = new HashSet<string>(info.data.Keys.Intersect(data.Keys));
				foreach (string item in hashSet)
				{
					string text = data[item].TryStack(info.data[item]);
					if (text == null)
					{
						return null;
					}
					dictionary[item] = text;
				}
				foreach (KeyValuePair<string, ItemData> datum in info.data)
				{
					if (!dictionary.ContainsKey(datum.Key))
					{
						string text2 = info.data[datum.Key].TryStack(null);
						if (text2 == null)
						{
							return null;
						}
						dictionary[datum.Key] = text2;
					}
				}
			}
			foreach (KeyValuePair<string, ItemData> datum2 in data)
			{
				if (!dictionary.ContainsKey(datum2.Key))
				{
					string text3 = data[datum2.Key].TryStack(null);
					if (text3 == null)
					{
						return null;
					}
					dictionary[datum2.Key] = text3;
				}
			}
			return dictionary.ToDictionary((KeyValuePair<string, string> kv) => dataKey(kv.Key), (KeyValuePair<string, string> kv) => kv.Value);
		}

		private static void RegisterForceLoadedTypesAddItem(ItemData? __result)
		{
			awakeningItem = null;
			if (__result != null)
			{
				RegisterForceLoadedTypes(__result);
			}
		}

		private static void RegisterForceLoadedTypes(ItemData itemData)
		{
			foreach (Type forceLoadType in ForceLoadTypes)
			{
				string key = classKey(forceLoadType, "");
				string text = dataKey(key);
				if (itemData.m_customData.ContainsKey(text))
				{
					itemData.Data().constructDataObj(text, key);
				}
			}
		}

		private static void ItemDropAwake(ItemDrop __instance)
		{
			GameObject dropPrefab = __instance.m_itemData.m_dropPrefab;
			if (dropPrefab != null && ItemExtensions.itemInfo.TryGetValue(dropPrefab.GetComponent<ItemDrop>().m_itemData, out ItemInfo value))
			{
				__instance.m_itemData.Data().isCloned = new HashSet<string>(value.data.Values.Select((ItemData i) => i.CustomDataKey));
			}
		}

		private static void ItemDropAwakeDelayed(ItemDrop __instance)
		{
			if (!ZNetView.m_forceDisableInit)
			{
				RegisterForceLoadedTypes(__instance.m_itemData);
			}
		}

		private static void ItemDataClonePrefix(ItemData __instance, ItemData __result)
		{
			SaveItem(__instance);
		}

		private static void ItemDataClonePostfix(ItemData __instance, ItemData __result)
		{
			if (ItemExtensions.itemInfo.TryGetValue(__instance, out ItemInfo value))
			{
				__result.Data().isCloned = new HashSet<string>(value.data.Values.Select((ItemData i) => i.CustomDataKey));
			}
		}

		private static void ItemDataClonePostfixDelayed(ItemData __result)
		{
			RegisterForceLoadedTypes(__result);
		}

		private static void RegisterForceLoadedTypesOnPlayerLoaded(Player __instance)
		{
			foreach (Food food in __instance.m_foods)
			{
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(food.m_name);
				if (itemPrefab.GetComponent<ItemDrop>().m_itemData == food.m_item)
				{
					food.m_item = food.m_item.Clone();
					food.m_item.m_dropPrefab = itemPrefab;
				}
				RegisterForceLoadedTypes(food.m_item);
			}
		}

		private static void SaveCheckingForStackableItemData(ItemData item)
		{
			checkingForStackableItemData = item;
		}

		private static void ResetCheckingForStackableItemData()
		{
			checkingForStackableItemData = null;
		}

		[IteratorStateMachine(typeof(<CheckStackableInFindFreeStackMethods>d__57))]
		private static IEnumerable<CodeInstruction> CheckStackableInFindFreeStackMethods(IEnumerable<CodeInstruction> instructionsEnumerable)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CheckStackableInFindFreeStackMethods>d__57(-2)
			{
				<>3__instructionsEnumerable = instructionsEnumerable
			};
		}

		private static bool CheckItemDataIsStackableFindFree(ItemData item, ItemData? target)
		{
			if (target == null)
			{
				return true;
			}
			Dictionary<string, string> dictionary = IsStackable(item, target);
			if (dictionary != null)
			{
				newValuesOnStackable = dictionary;
				return true;
			}
			return false;
		}

		private static void ResetNewValuesOnStackable()
		{
			newValuesOnStackable = null;
		}

		private static void ApplyNewValuesOnStackable(ItemData? __result)
		{
			if (__result == null || newValuesOnStackable == null)
			{
				return;
			}
			foreach (KeyValuePair<string, string> item in newValuesOnStackable)
			{
				__result.m_customData[item.Key] = item.Value;
			}
		}

		private static Dictionary<string, string>? IsStackable(ItemData a, ItemData b)
		{
			ItemInfo itemInfo = a.Data();
			if (itemInfo != null)
			{
				return itemInfo.IsStackableWithOtherInfo(b.Data());
			}
			ItemInfo itemInfo2 = b.Data();
			if (itemInfo2 != null)
			{
				return itemInfo2.IsStackableWithOtherInfo(null);
			}
			return new Dictionary<string, string>();
		}

		private static bool CheckItemDataStackableAddItem(Inventory __instance, ItemData item, int x, int y, ref Dictionary<string, string>? __state, ref bool __result)
		{
			ItemData itemAt = __instance.GetItemAt(x, y);
			if (itemAt != null)
			{
				Dictionary<string, string> dictionary = IsStackable(item, itemAt);
				if (dictionary == null)
				{
					__result = false;
					return false;
				}
				__state = dictionary;
			}
			return true;
		}

		private static void ApplyCustomItemDataStackableAddItem(Inventory __instance, int x, int y, Dictionary<string, string>? __state, bool __result)
		{
			if (!__result || __state == null)
			{
				return;
			}
			foreach (KeyValuePair<string, string> item in __state)
			{
				__instance.GetItemAt(x, y).m_customData[item.Key] = item.Value;
			}
		}

		private static void ApplyCustomItemDataStackableAutoStack(ItemDrop item, Dictionary<string, string> customData)
		{
			item.m_itemData.m_customData = customData;
		}

		private static Dictionary<string, string>? IsStackableItemDrop(ItemDrop drop, ItemData item)
		{
			return IsStackable(drop.m_itemData, item);
		}

		private static IEnumerable<CodeInstruction> HandleAutostackableItems(IEnumerable<CodeInstruction> instructionList, ILGenerator ilg)
		{
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected O, but got Unknown
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Expected O, but got Unknown
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Expected O, but got Unknown
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Expected O, but got Unknown
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Expected O, but got Unknown
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Expected O, but got Unknown
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Expected O, but got Unknown
			List<CodeInstruction> list = instructionList.ToList();
			FieldInfo fieldInfo = AccessTools.DeclaredField(typeof(ItemData), "m_stack");
			FieldInfo fieldInfo2 = AccessTools.DeclaredField(typeof(ItemDrop), "m_itemData");
			Label? label = default(Label?);
			for (int i = 0; i < list.Count; i++)
			{
				if (!CodeInstructionExtensions.StoresField(list[i], fieldInfo))
				{
					continue;
				}
				for (int num = i; num > 0; num--)
				{
					if (CodeInstructionExtensions.Branches(list[num], ref label))
					{
						for (int num2 = num; num2 > 0; num2--)
						{
							if (CodeInstructionExtensions.LoadsField(list[num2], fieldInfo2, false))
							{
								LocalBuilder localBuilder = ilg.DeclareLocal(typeof(Dictionary<string, string>));
								LocalBuilder localBuilder2 = ilg.DeclareLocal(typeof(ItemData));
								list.Insert(i + 1, new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(ItemInfo), "ApplyCustomItemDataStackableAutoStack", (Type[])null, (Type[])null)));
								list.Insert(i + 1, new CodeInstruction(OpCodes.Ldloc, (object)localBuilder.LocalIndex));
								list.Insert(i + 1, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
								list.Insert(num + 1, new CodeInstruction(OpCodes.Brfalse, (object)label));
								list.Insert(num + 1, new CodeInstruction(OpCodes.Stloc, (object)localBuilder.LocalIndex));
								list.Insert(num + 1, new CodeInstruction(OpCodes.Dup, (object)localBuilder.LocalIndex));
								list.Insert(num + 1, new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(ItemInfo), "IsStackableItemDrop", (Type[])null, (Type[])null)));
								list.Insert(num + 1, new CodeInstruction(OpCodes.Ldloc, (object)localBuilder2.LocalIndex));
								list.Insert(num + 1, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
								list.Insert(num2 + 1, new CodeInstruction(OpCodes.Stloc, (object)localBuilder2.LocalIndex));
								list.Insert(num2 + 1, new CodeInstruction(OpCodes.Dup, (object)null));
								return list;
							}
						}
					}
				}
			}
			throw new Exception("Found no stack store in a branch");
		}

		[IteratorStateMachine(typeof(<TransferCustomItemDataOnUpgrade>d__68))]
		private static IEnumerable<CodeInstruction> TransferCustomItemDataOnUpgrade(IEnumerable<CodeInstruction> instructions, ILGenerator ilg)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TransferCustomItemDataOnUpgrade>d__68(-2)
			{
				<>3__instructions = instructions
			};
		}

		private static void ResetCurrentlyUpgradingItem()
		{
			currentlyUpgradingItem = null;
		}

		private static void CopyCustomDataFromUpgradedItem(ItemDrop item)
		{
			if (currentlyUpgradingItem != null)
			{
				item.m_itemData.m_customData = currentlyUpgradingItem.m_customData;
				ItemInfo itemInfo = currentlyUpgradingItem.Data();
				ItemExtensions.itemInfo.Remove(currentlyUpgradingItem);
				ItemExtensions.itemInfo.Add(item.m_itemData, itemInfo);
				item.m_itemData.m_quality = currentlyUpgradingItem.m_quality + 1;
				item.m_itemData.m_variant = currentlyUpgradingItem.m_variant;
				itemInfo.ItemData = item.m_itemData;
				itemInfo.LoadAll();
				foreach (ItemData value in itemInfo.data.Values)
				{
					value.Upgraded();
				}
				currentlyUpgradingItem = null;
				awakeningItem = null;
				return;
			}
			GameObject dropPrefab = item.m_itemData.m_dropPrefab;
			if (dropPrefab == null || item.m_itemData.m_customData.Count != 0)
			{
				return;
			}
			ZNetView component = ((Component)item).GetComponent<ZNetView>();
			ZDO val = ((Object.op_Implicit((Object)(object)component) && component.IsValid()) ? component.GetZDO() : null);
			if (val != null && val.GetInt(ZDOVars.s_dataCount, -1) != -1)
			{
				return;
			}
			item.m_itemData.m_customData = new Dictionary<string, string>(dropPrefab.GetComponent<ItemDrop>().m_itemData.m_customData);
			if (val == null)
			{
				return;
			}
			int num = 0;
			val.Set(ZDOVars.s_dataCount, item.m_itemData.m_customData.Count, false);
			foreach (KeyValuePair<string, string> customDatum in item.m_itemData.m_customData)
			{
				val.Set($"data_{num}", customDatum.Key);
				val.Set($"data__{num++}", customDatum.Value);
			}
		}

		[IteratorStateMachine(typeof(<ImportCustomDataOnUpgrade>d__71))]
		private static IEnumerable<CodeInstruction> ImportCustomDataOnUpgrade(IEnumerable<CodeInstruction> instructionList)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ImportCustomDataOnUpgrade>d__71(-2)
			{
				<>3__instructionList = instructionList
			};
		}

		private static void TrackAwakeningItem(ItemDrop __instance)
		{
			if (ZNetView.m_forceDisableInit)
			{
				awakeningItem = __instance.m_itemData;
			}
		}

		static ItemInfo()
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Expected O, but got Unknown
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Expected O, but got Unknown
			//IL_01d0: Expected O, but got Unknown
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Expected O, but got Unknown
			//IL_023f: Expected O, but got Unknown
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Expected O, but got Unknown
			//IL_02a1: Expected O, but got Unknown
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Expected O, but got Unknown
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Expected O, but got Unknown
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: Expected O, but got Unknown
			//IL_0351: Expected O, but got Unknown
			//IL_0381: Unknown result type (might be due to invalid IL or missing references)
			//IL_038d: Expected O, but got Unknown
			//IL_03bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e3: Expected O, but got Unknown
			//IL_03e3: Expected O, but got Unknown
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_0443: Expected O, but got Unknown
			//IL_0499: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a6: Expected O, but got Unknown
			//IL_0552: Unknown result type (might be due to invalid IL or missing references)
			//IL_055f: Expected O, but got Unknown
			//IL_058d: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bf: Expected O, but got Unknown
			//IL_05e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f3: Expected O, but got Unknown
			//IL_05f3: Expected O, but got Unknown
			//IL_0632: Unknown result type (might be due to invalid IL or missing references)
			//IL_063f: Expected O, but got Unknown
			//IL_066d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0698: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a5: Expected O, but got Unknown
			//IL_06a5: Expected O, but got Unknown
			//IL_06e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f1: Expected O, but got Unknown
			ForceLoadTypes = new HashSet<Type>();
			typeInheritorsCache = new Dictionary<Type, HashSet<Type>>();
			knownTypes = new HashSet<string>();
			awakeningItem = null;
			primaryAssembly = Assembly.GetExecutingAssembly();
			assemblyNameCache = new Dictionary<Assembly, string>();
			classKeyCache = new Dictionary<Type, string>();
			removeMethod = typeof(ItemInfo).GetMethods().Single((MethodInfo m) => m.Name == "Remove" && m.IsGenericMethod && m.GetParameters()[0].ParameterType == typeof(string));
			Harmony val = new Harmony("org.bepinex.helpers.ItemDataManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Inventory), "Save", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "SaveInventoryPrefix", (Type[])null, (Type[])null), 800, (string[])null, (string[])null, (bool?)null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			foreach (MethodInfo item in from m in typeof(ItemData).GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
				where m.Name == "SaveToZDO"
				select m)
			{
				val.Patch((MethodBase)item, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "SavePrefix", (Type[])null, (Type[])null), 800, (string[])null, (string[])null, (bool?)null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Inventory), "AddItem", new Type[4]
			{
				typeof(ItemData),
				typeof(int),
				typeof(int),
				typeof(int)
			}, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "CheckItemDataStackableAddItem", (Type[])null, (Type[])null)), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ApplyCustomItemDataStackableAddItem", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Inventory), "CanAddItem", new Type[2]
			{
				typeof(ItemData),
				typeof(int)
			}, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "SaveCheckingForStackableItemData", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(ItemInfo), "ResetCheckingForStackableItemData", (Type[])null), (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Inventory), "AddItem", new Type[1] { typeof(ItemData) }, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "SaveCheckingForStackableItemData", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(ItemInfo), "ResetCheckingForStackableItemData", (Type[])null), (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Inventory), "FindFreeStackSpace", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "CheckStackableInFindFreeStackMethods", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
			MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(Inventory), "FindFreeStackItem", (Type[])null, (Type[])null);
			HarmonyMethod val2 = new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "CheckStackableInFindFreeStackMethods", (Type[])null, (Type[])null));
			val.Patch((MethodBase)methodInfo, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ResetNewValuesOnStackable", (Type[])null, (Type[])null)), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ApplyNewValuesOnStackable", (Type[])null, (Type[])null)), val2, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ItemDrop), "AutoStackItems", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "HandleAutostackableItems", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(InventoryGui), "DoCrafting", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "TransferCustomItemDataOnUpgrade", (Type[])null, (Type[])null)), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ResetCurrentlyUpgradingItem", (Type[])null, (Type[])null)), (HarmonyMethod)null);
			foreach (MethodInfo item2 in from m in typeof(ItemData).GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
				where m.Name == "LoadFromZDO"
				select m)
			{
				val.Patch((MethodBase)item2, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "RegisterForceLoadedTypes", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Player), "Load", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "RegisterForceLoadedTypesOnPlayerLoaded", (Type[])null, (Type[])null), 700, (string[])null, (string[])null, (bool?)null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Inventory), "AddItem", new Type[8]
			{
				typeof(string),
				typeof(int),
				typeof(int),
				typeof(int),
				typeof(long),
				typeof(string),
				typeof(Vector2i),
				typeof(bool)
			}, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "RegisterForceLoadedTypesAddItem", (Type[])null, (Type[])null), 800, (string[])null, (string[])null, (bool?)null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			MethodInfo methodInfo2 = AccessTools.DeclaredMethod(typeof(ItemDrop), "Awake", (Type[])null, (Type[])null);
			HarmonyMethod val3 = new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "TrackAwakeningItem", (Type[])null, (Type[])null));
			val2 = new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ImportCustomDataOnUpgrade", (Type[])null, (Type[])null), 800, (string[])null, (string[])null, (bool?)null);
			val.Patch((MethodBase)methodInfo2, val3, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ItemDropAwake", (Type[])null, (Type[])null), 800, (string[])null, (string[])null, (bool?)null), val2, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ItemDrop), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ItemDropAwakeDelayed", (Type[])null, (Type[])null), 799, (string[])null, (string[])null, (bool?)null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ItemData), "Clone", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ItemDataClonePrefix", (Type[])null, (Type[])null)), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ItemDataClonePostfix", (Type[])null, (Type[])null), 500, (string[])null, (string[])null, (bool?)null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ItemData), "Clone", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ItemDataClonePostfixDelayed", (Type[])null, (Type[])null), 499, (string[])null, (string[])null, (bool?)null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
	}
	[PublicAPI]
	public class ForeignItemInfo : IEnumerable<object>, IEnumerable
	{
		private readonly object foreignItemInfo;

		public string Mod => ((string)foreignItemInfo.GetType().GetProperty("Mod")?.GetValue(foreignItemInfo)) ?? "";

		public ItemData ItemData { get; private set; }

		public string? this[string key]
		{
			get
			{
				object obj = foreignItemInfo.GetType().InvokeMember("Item", BindingFlags.Instance | BindingFlags.Public | BindingFlags.GetProperty, null, foreignItemInfo, new object[1] { key });
				if (obj != null)
				{
					return (string)obj.GetType().GetProperty("Value")?.GetValue(obj);
				}
				return null;
			}
			set
			{
				foreignItemInfo.GetType().GetMethod("set_Item", BindingFlags.Instance | BindingFlags.Public)?.Invoke(foreignItemInfo, new object[2] { key, value });
			}
		}

		internal ForeignItemInfo(ItemData itemData, object foreignItemInfo)
		{
			ItemData = itemData;
			this.foreignItemInfo = foreignItemInfo;
		}

		public T GetOrCreate<T>(string key = "") where T : class, new()
		{
			return Add<T>(key) ?? Get<T>(key);
		}

		private object? call(string name, object?[] values, Type?[] args, Type? generic = null)
		{
			MethodInfo[] methods = foreignItemInfo.GetType().GetMethods();
			foreach (MethodInfo methodInfo in methods)
			{
				if (methodInfo.Name == name && (from p in methodInfo.GetParameters()
					select (!p.ParameterType.IsGenericParameter) ? p.ParameterType : null).SequenceEqual<Type>(args) && (object)generic != null == methodInfo.IsGenericMethod)
				{
					MethodInfo methodInfo2 = methodInfo;
					if ((object)generic != null)
					{
						methodInfo2 = methodInfo2.MakeGenericMethod(generic);
					}
					return methodInfo2.Invoke(foreignItemInfo, values);
				}
			}
			return null;
		}

		public T? Add<T>(string key = "") where T : class, new()
		{
			return call("Add", new object[1] { key }, new Type[1] { typeof(string) }, typeof(T)) as T;
		}

		public T? Get<T>(string key = "") where T : class
		{
			return call("Get", new object[1] { key }, new Type[1] { typeof(string) }, typeof(T)) as T;
		}

		public Dictionary<string, T> GetAll<T>() where T : class
		{
			return ((call("GetAll", Array.Empty<object>(), Array.Empty<Type>(), typeof(T)) as T) as Dictionary<string, T>) ?? new Dictionary<string, T>();
		}

		public bool Remove(string key = "")
		{
			return (call("Add", new object[1] { key }, new Type[1] { typeof(string) }) as bool?).GetValueOrDefault();
		}

		public bool Remove<T>(string key = "") where T : class
		{
			return (call("Remove", new object[1] { key }, new Type[1] { typeof(string) }, typeof(T)) as bool?).GetValueOrDefault();
		}

		public bool Remove<T>(T itemData) where T : class
		{
			return (call("Remove", new object[1] { itemData }, new Type[1], typeof(T)) as bool?).GetValueOrDefault();
		}

		public void Save()
		{
			call("Save", Array.Empty<object>(), Array.Empty<Type>());
		}

		public void LoadAll()
		{
			call("LoadAll", Array.Empty<object>(), Array.Empty<Type>());
		}

		public IEnumerator<object> GetEnumerator()
		{
			return (IEnumerator<object>)((call("GetEnumerator", Array.Empty<object>(), Array.Empty<Type>()) as IEnumerator<object>) ?? ((object)new List<object>().GetEnumerator()));
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	[PublicAPI]
	public static class ItemExtensions
	{
		private const string className = "ItemDataManager.ItemExtensions";

		internal static readonly ConditionalWeakTable<ItemData, ItemInfo> itemInfo = new ConditionalWeakTable<ItemData, ItemInfo>();

		private static readonly ConditionalWeakTable<ItemData, Dictionary<string, ForeignItemInfo?>> foreignItemInfo = new ConditionalWeakTable<ItemData, Dictionary<string, ForeignItemInfo>>();

		public static ItemInfo Data(this ItemData item)
		{
			if (itemInfo.TryGetValue(item, out ItemInfo value))
			{
				return value;
			}
			itemInfo.Add(item, value = new ItemInfo(item));
			return value;
		}

		public static ForeignItemInfo? Data(this ItemData item, string mod)
		{
			Dictionary<string, ForeignItemInfo> orCreateValue = ItemExtensions.foreignItemInfo.GetOrCreateValue(item);
			if (orCreateValue.TryGetValue(mod, out var value))
			{
				return value;
			}
			if (!Chainloader.PluginInfos.TryGetValue(mod, out var value2))
			{
				return null;
			}
			object obj = ((object)value2.Instance).GetType().Assembly.GetType("ItemDataManager.ItemExtensions")?.GetMethod("Data", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(ItemData) }, Array.Empty<ParameterModifier>())?.Invoke(null, new object[1] { item });
			if (obj != null)
			{
				return orCreateValue[mod] = new ForeignItemInfo(item, obj);
			}
			Debug.LogWarning((object)("Mod " + mod + " has an ItemDataManager.ItemExtensions class, but no Data(ItemDrop.ItemData) method could be called on it."));
			return orCreateValue[mod] = null;
		}
	}
}
namespace kg.ValheimEnchantmentSystem
{
	[VES_Autoload(VES_Autoload.Priority.Last, "OnInit", new Type[]
	{
		typeof(SyncedData),
		typeof(Enchantment_Skill),
		typeof(IntegrationRegistry),
		typeof(Notifications_UI),
		typeof(Enchantment_VFX)
	})]
	public static class Enchantment_Core
	{
		public class Enchanted : ItemData
		{
			public int level;

			public SyncedData.Stat_Data Stats => SyncedData.GetStatIncrease(this);

			public override void Save()
			{
				base.Value = level.ToString();
			}

			public override void Load()
			{
				if (!string.IsNullOrEmpty(base.Value))
				{
					level = (int.TryParse(base.Value, out var result) ? result : 0);
				}
			}

			public override void Upgraded()
			{
				EnchantmentSideEffects.HandleUpgrade(this);
			}

			public float GetEnchantmentChance()
			{
				return SyncedData.GetEnchantmentChance(this).success;
			}

			public EnchantmentResult Enchant(Player player, bool useBlessedScroll, bool blessedScrollPreventsBreak)
			{
				return EnchantmentService.Execute(this, player, useBlessedScroll, blessedScrollPreventsBreak);
			}

			public static implicit operator bool(Enchanted en)
			{
				return en != null;
			}
		}

		[HarmonyPatch(typeof(InventoryGrid), "CreateItemTooltip")]
		[ClientOnlyPatch]
		private static class InventoryGrid_CreateItemTooltip_Patch
		{
			[UsedImplicitly]
			private static void Prefix(InventoryGrid __instance, ItemData item, out string __state)
			{
				__state = null;
				Enchanted enchanted = item?.Data().Get<Enchanted>();
				if (enchanted != null && enchanted.level > 0)
				{
					__state = item.m_shared.m_name;
					int variant;
					string arg = SyncedData.GetColor(enchanted, out variant, trimApha: true).IncreaseColorLight();
					SharedData shared = item.m_shared;
					shared.m_name += $" (<color={arg}>+{enchanted.level}</color>)";
				}
			}

			[UsedImplicitly]
			private static void Postfix(InventoryGrid __instance, ItemData item, string __state)
			{
				if (__state != null)
				{
					item.m_shared.m_name = __state;
				}
			}
		}

		[HarmonyPatch(typeof(ItemDrop), "GetHoverText")]
		[ClientOnlyPatch]
		private static class ItemDrop_GetHoverText_Patch
		{
			[UsedImplicitly]
			private static void Prefix(ItemDrop __instance, out string __state)
			{
				__state = null;
				Enchanted enchanted = __instance.m_itemData?.Data().Get<Enchanted>();
				if (enchanted != null && enchanted.level > 0)
				{
					__state = __instance.m_itemData.m_shared.m_name;
					int variant;
					string arg = SyncedData.GetColor(enchanted, out variant, trimApha: true).IncreaseColorLight();
					SharedData shared = __instance.m_itemData.m_shared;
					shared.m_name += $" (<color={arg}>+{enchanted.level}</color>)";
				}
			}

			[UsedImplicitly]
			private static void Postfix(ItemDrop __instance, string __state)
			{
				if (__state != null)
				{
					__instance.m_itemData.m_shared.m_name = __state;
				}
			}
		}

		[HarmonyPatch(typeof(ItemData), "GetTooltip", new Type[]
		{
			typeof(ItemData),
			typeof(int),
			typeof(bool),
			typeof(float),
			typeof(int)
		})]
		[ClientOnlyPatch]
		public class TooltipPatch
		{
			[UsedImplicitly]
			public static void Postfix(ItemData item, bool crafting, int qualityLevel, ref string __result)
			{
				//IL_0119: Unknown result type (might be due to invalid IL or missing references)
				//IL_012c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_0142: Unknown result type (might be due to invalid IL or missing references)
				//IL_0160: Unknown result type (might be due to invalid IL or missing references)
				//IL_0198: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_020c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0244: Unknown result type (might be due to invalid IL or missing references)
				//IL_0262: Unknown result type (might be due to invalid IL or missing references)
				//IL_029a: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_030e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0346: Unknown result type (might be due to invalid IL or missing references)
				//IL_0364: Unknown result type (might be due to invalid IL or missing references)
				//IL_039c: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_03f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0410: Unknown result type (might be due to invalid IL or missing references)
				Enchanted enchanted = item.Data().Get<Enchanted>();
				int num = (enchanted ? enchanted.level : 0);
				string text = (Object.op_Implicit((Object)(object)item.m_dropPrefab) ? ((Object)item.m_dropPrefab).name : Utils.GetPrefabNameByItemName(item.m_shared.m_name));
				SyncedData.EnchantmentReqs reqs = SyncedData.GetReqs(text);
				string text2 = BuildTooltipStatusLine(reqs, text, num, item);
				if (num > 0)
				{
					SyncedData.Stat_Data statIncrease = SyncedData.GetStatIncrease(enchanted);
					int variant;
					string text3 = SyncedData.GetColor(enchanted, out variant, trimApha: true).IncreaseColorLight();
					if (statIncrease != null)
					{
						int damage_percentage = statIncrease.damage_percentage;
						if (statIncrease.durability > 0)
						{
							__result = ItemDurabilityRegex.Replace(__result, $"$1 (<color={text3}>+{statIncrease.durability}</color>)");
						}
						if (statIncrease.durability_percentage > 0)
						{
							__result = ItemDurabilityRegex.Replace(__result, $"$1 (<color={text3}>+{statIncrease.durability_percentage}%</color>)");
						}
						__result += "\n";
						if (damage_percentage > 0)
						{
							float num2 = default(float);
							float num3 = default(float);
							((Character)Player.m_localPlayer).GetSkills().GetRandomSkillRange(ref num2, ref num3, item.m_shared.m_skillType);
							DamageTypes damage = item.GetDamage(qualityLevel, (float)item.m_worldLevel);
							__result = InventoryDamageRegex.Replace(__result, $"$1 (<color={text3}>+{(damage.m_damage * (float)damage_percentage / 100f * num2).RoundOne()} - {(damage.m_damage * (float)damage_percentage / 100f * num3).RoundOne()}</color>)");
							__result = InventoryBluntRegex.Replace(__result, $"$1 (<color={text3}>+{(damage.m_blunt * (float)damage_percentage / 100f * num2).RoundOne()} - {(damage.m_blunt * (float)damage_percentage / 100f * num3).RoundOne()}</color>)");
							__result = InventorySlashRegex.Replace(__result, $"$1 (<color={text3}>+{(damage.m_slash * (float)damage_percentage / 100f * num2).RoundOne()} - {(damage.m_slash * (float)damage_percentage / 100f * num3).RoundOne()}</color>)");
							__result = InventoryPierceRegex.Replace(__result, $"$1 (<color={text3}>+{(damage.m_pierce * (float)damage_percentage / 100f * num2).RoundOne()} - {(damage.m_pierce * (float)damage_percentage / 100f * num3).RoundOne()}</color>)");
							__result = InventoryFireRegex.Replace(__result, $"$1 (<color={text3}>+{(damage.m_fire * (float)damage_percentage / 100f * num2).RoundOne()} - {(damage.m_fire * (float)damage_percentage / 100f * num3).RoundOne()}</color>)");
							__result = InventoryFrostRegex.Replace(__result, $"$1 (<color={text3}>+{(damage.m_frost * (float)damage_percentage / 100f * num2).RoundOne()} - {(damage.m_frost * (float)damage_percentage / 100f * num3).RoundOne()}</color>)");
							__result = InventoryLightningRegex.Replace(__result, $"$1 (<color={text3}>+{(damage.m_lightning * (float)damage_percentage / 100f * num2).RoundOne()} - {(damage.m_lightning * (float)damage_percentage / 100f * num3).RoundOne()}</color>)");
							__result = InventoryPoisonRegex.Replace(__result, $"$1 (<color={text3}>+{(damage.m_poison * (float)damage_percentage / 100f * num2).RoundOne()} - {(damage.m_poison * (float)damage_percentage / 100f * num3).RoundOne()}</color>)");
							__result = InventorySpiritRegex.Replace(__result, $"$1 (<color={text3}>+{(damage.m_spirit * (float)damage_percentage / 100f * num2).RoundOne()} - {(damage.m_spirit * (float)damage_percentage / 100f * num3).RoundOne()}</color>)");
							__result += $"\n<color={text3}>•</color> $enchantment_bonusespercentdamage (<color={text3}>+{damage_percentage}%</color>)";
						}
						float armor_percentage = statIncrease.armor_percentage;
						if (armor_percentage > 0f)
						{
							__result = ItemBlockArmorRegex.Replace(__result, $"$1 (<color={text3}>+{(item.GetBaseBlockPower(qualityLevel) * armor_percentage / 100f).RoundOne()}({armor_percentage}%)</color>)");
							__result = ItemArmorRegex.Replace(__result, $"$1 (<color={text3}>+{(item.GetArmor(qualityLevel, (float)item.m_worldLevel) * armor_percentage / 100f).RoundOne()}({armor_percentage}%)</color>)");
							__result += $"\n<color={text3}>•</color> $enchantment_bonusespercentarmor (<color={text3}>+{armor_percentage}%</color>)";
						}
						float armor = statIncrease.armor;
						if (armor > 0f)
						{
							__result = ItemBlockArmorRegex.Replace(__result, $"$1 (<color={text3}>+{statIncrease.armor}</color>)");
							__result = ItemArmorRegex.Replace(__result, $"$1 (<color={text3}>+{statIncrease.armor}</color>)");
						}
						__result += EnchantmentStatFormatter.BuildAdditionalStats(statIncrease, text3);
						if (!string.IsNullOrWhiteSpace(text2))
						{
							__result += text2;
						}
					}
				}
				if (num <= 0 && !string.IsNullOrWhiteSpace(text2))
				{
					__result = __result + "\n" + text2;
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "UpdateRecipe")]
		[ClientOnlyPatch]
		private static class InventoryGui_UpdateRecipe_Patch
		{
			[UsedImplicitly]
			private static void Postfix(InventoryGui __instance)
			{
				Enchanted enchanted = ((RecipeDataPair)(ref __instance.m_selectedRecipe)).ItemData?.Data().Get<Enchanted>();
				if ((bool)enchanted)
				{
					int variant;
					string arg = SyncedData.GetColor(enchanted, out variant, trimApha: true).IncreaseColorLight();
					TMP_Text recipeName = __instance.m_recipeName;
					recipeName.text += $" (<color={arg}>+{enchanted.level}</color>)";
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "AddRecipeToList")]
		[ClientOnlyPatch]
		private static class InventoryGui_AddRecipeToList_Patch
		{
			private static void Modify(ref string text, ItemData item)
			{
				Enchanted enchanted = item?.Data().Get<Enchanted>();
				if ((bool)enchanted)
				{
					int variant;
					string arg = SyncedData.GetColor(enchanted, out variant, trimApha: true).IncreaseColorLight();
					text += $" (<color={arg}>+{enchanted.level}</color>)";
				}
			}

			[UsedImplicitly]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> code)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Expected O, but got Unknown
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Expected O, but got Unknown
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Expected O, but got Unknown
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Expected O, but got Unknown
				CodeMatcher val = new CodeMatcher(code, (ILGenerator)null);
				val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Stloc_2, (object)null, (string)null)
				});
				if (val.IsInvalid)
				{
					return val.InstructionEnumeration();
				}
				MethodInfo methodInfo = AccessTools.Method(typeof(InventoryGui_AddRecipeToList_Patch), "Modify", (Type[])null, (Type[])null);
				val.Advance(1).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Ldloca_S, (object)2)
				}).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Ldarg_3, (object)null)
				})
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Call, (object)methodInfo)
					});
				return val.InstructionEnumeration();
			}
		}

		[HarmonyPatch(typeof(ItemData), "GetBlockPower", new Type[] { typeof(float) })]
		[ClientOnlyPatch]
		private static class ModifyBlockPower
		{
			[UsedImplicitly]
			private static void Postfix(ItemData __instance, ref float __result)
			{
				Enchanted enchanted = __instance.Data().Get<Enchanted>();
				if (enchanted != null && enchanted.level > 0)
				{
					SyncedData.Stat_Data statIncrease = SyncedData.GetStatIncrease(enchanted);
					if (statIncrease != null)
					{
						__result *= 1f + statIncrease.armor_percentage / 100f;
						__result += statIncrease.armor;
					}
				}
			}
		}

		[HarmonyPatch]
		[ClientOnlyPatch]
		private static class ModifyArmor
		{
			[UsedImplicitly]
			private static MethodInfo TargetMethod()
			{
				return AccessTools.Method(typeof(ItemData), "GetArmor", (Type[])null, (Type[])null);
			}

			[UsedImplicitly]
			private static void Postfix(ItemData __instance, ref float __result)
			{
				Enchanted enchanted = __instance.Data().Get<Enchanted>();
				if (enchanted != null && enchanted.level > 0)
				{
					SyncedData.Stat_Data statIncrease = SyncedData.GetStatIncrease(enchanted);
					if (statIncrease != null)
					{
						__result *= 1f + statIncrease.armor_percentage / 100f;
						__result += statIncrease.armor;
					}
				}
			}
		}

		[HarmonyPatch]
		[ClientOnlyPatch]
		private static class ModifyDamage
		{
			[UsedImplicitly]
			private static MethodInfo TargetMethod()
			{
				return AccessTools.Method(typeof(ItemData), "GetDamage", (Type[])null, (Type[])null);
			}

			[UsedImplicitly]
			private static void Postfix(ItemData __instance, ref DamageTypes __result)
			{
				Enchanted enchanted = __instance.Data().Get<Enchanted>();
				if (enchanted != null && enchanted.level > 0)
				{
					SyncedData.Stat_Data statIncrease = SyncedData.GetStatIncrease(enchanted);
					if (statIncrease != null)
					{
						((DamageTypes)(ref __result)).Modify(1f + (float)statIncrease.damage_percentage / 100f);
						__result.m_blunt += statIncrease.damage_blunt;
						__result.m_slash += statIncrease.damage_slash;
						__result.m_pierce += statIncrease.damage_pierce;
						__result.m_fire += statIncrease.damage_fire;
						__result.m_frost += statIncrease.damage_frost;
						__result.m_lightning += statIncrease.damage_lightning;
						__result.m_poison += statIncrease.damage_poison;
						__result.m_spirit += statIncrease.damage_spirit;
						__result.m_damage += statIncrease.damage_true;
						__result.m_chop += statIncrease.damage_chop;
						__result.m_pickaxe += statIncrease.damage_pickaxe;
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "ApplyArmorDamageMods")]
		[ClientOnlyPatch]
		private static class Player_ApplyArmorDamageMods_Patch
		{
			[UsedImplicitly]
			private static void Postfix(Player __instance, ref DamageModifiers mods)
			{
				EquippedEnchantmentSnapshotService.Snapshot snapshot = EquippedEnchantmentSnapshotService.GetSnapshot(__instance);
				if (snapshot.ResistancePairs.Count > 0)
				{
					((DamageModifiers)(ref mods)).Apply(snapshot.ResistancePairs);
				}
			}
		}

		[HarmonyPatch(typeof(Character), "SetMaxHealth")]
		[ClientOnlyPatch]
		private static class Character_SetMaxHealth_Patch
		{
			[UsedImplicitly]
			private static void Prefix(Character __instance, ref float health)
			{
				Player val = (Player)(object)((__instance is Player) ? __instance : null);
				if (val != null)
				{
					health += EquippedEnchantmentSnapshotService.GetSnapshot(val).MaxHealthBonus;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "SetMaxStamina")]
		[ClientOnlyPatch]
		private static class Player_SetMaxStamina_Patch
		{
			[UsedImplicitly]
			private static void Prefix(Player __instance, ref float stamina)
			{
				stamina += EquippedEnchantmentSnapshotService.GetSnapshot(__instance).MaxStaminaBonus;
			}
		}

		[HarmonyPatch(typeof(Player), "GetEquipmentMovementModifier")]
		[ClientOnlyPatch]
		private static class Player_UpdateMovementModifier_Patch
		{
			[UsedImplicitly]
			private static void Postfix(Player __instance, ref float __result)
			{
				__result += EquippedEnchantmentSnapshotService.GetSnapshot(__instance).MovementModifier;
			}
		}

		[HarmonyPatch(typeof(ItemData), "GetMaxDurability", new Type[] { typeof(int) })]
		[ClientOnlyPatch]
		public class ApplySkillToDurability
		{
			[UsedImplicitly]
			private static void Postfix(ItemData __instance, ref float __result)
			{
				Enchanted enchanted = __instance.Data().Get<Enchanted>();
				if (enchanted != null && enchanted.level > 0)
				{
					SyncedData.Stat_Data statIncrease = SyncedData.GetStatIncrease(enchanted);
					if (statIncrease != null)
					{
						__result *= 1f + (float)statIncrease.durability_percentage / 100f;
						__result += statIncrease.durability;
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "FixedUpdate")]
		[ClientOnlyPatch]
		public static class Player_FixedUpdate_Patch
		{
			[UsedImplicitly]
			private static void Postfix(Player __instance)
			{
				if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer && !((Character)__instance).IsDead())
				{
					float fixedDeltaTime = Time.fixedDeltaTime;
					__instance.UpdateEnchantmentRegen(fixedDeltaTime);
				}
			}
		}

		[HarmonyPatch(typeof(Player), "UpdateStats", new Type[] { typeof(float) })]
		[ClientOnlyPatch]
		public static class Player_UpdateStats_Patch
		{
			private static readonly FieldInfo CharacterNViewField = AccessTools.Field(typeof(Character), "m_nview");

			private static readonly MethodInfo ZNetViewGetZdoMethod = AccessTools.Method(typeof(ZNetView), "GetZDO", (Type[])null, (Type[])null);

			private static readonly FieldInfo ZdoVarsStaminaField = AccessTools.Field(typeof(ZDOVars), "s_stamina");

			private static readonly FieldInfo PlayerStaminaField = AccessTools.Field(typeof(Player), "m_stamina");

			private static readonly MethodInfo ZdoSetFloatMethod = AccessTools.Method(typeof(ZDO), "Set", new Type[2]
			{
				typeof(int),
				typeof(float)
			}, (Type[])null);

			private static readonly MethodInfo ApplyEnchantmentStaminaRegenMethod = AccessTools.DeclaredMethod(typeof(PlayerExtensions), "UpdateEnchantmentStaminaRegen", (Type[])null, (Type[])null);

			[UsedImplicitly]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Expected O, but got Unknown
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Expected O, but got Unknown
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Expected O, but got Unknown
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Expected O, but got Unknown
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Expected O, but got Unknown
				//IL_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Expected O, but got Unknown
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Expected O, but got Unknown
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Expected O, but got Unknown
				//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Expected O, but got Unknown
				//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0101: Expected O, but got Unknown
				CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
				val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[7]
				{
					new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)CharacterNViewField, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)ZNetViewGetZdoMethod, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldsfld, (object)ZdoVarsStaminaField, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)PlayerStaminaField, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)ZdoSetFloatMethod, (string)null)
				});
				if (val.IsInvalid)
				{
					Utils.print("Failed to inject enchantment stamina regen into Player.UpdateStats; using vanilla stamina regen only.", ConsoleColor.Yellow);
					return instructions;
				}
				val.Insert((CodeInstruction[])(object)new CodeInstruction[3]
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldarg_1, (object)null),
					new CodeInstruction(OpCodes.Call, (object)ApplyEnchantmentStaminaRegenMethod)
				});
				return val.InstructionEnumeration();
			}
		}

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

			private object <>2__current;

			public ItemData weapon;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Expected O, but got Unknown
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Expected O, but got Unknown
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Expected O, but got Unknown
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Expected O, but got Unknown
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f6: Expected O, but got Unknown
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!((Humanoid)Player.m_localPlayer).IsItemEquiped(weapon) || !weapon.IsWeapon())
					{
						return false;
					}
					((Humanoid)Player.m_localPlayer).UnequipItem(weapon, true);
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 6;
					return true;
				case 6:
					<>1__state = -1;
					if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && ((Humanoid)Player.m_localPlayer).m_inventory.ContainsItem(weapon))
					{
						Player localPlayer = Player.m_localPlayer;
						if (localPlayer != null)
						{
							((Humanoid)localPlayer).EquipItem(weapon, true);
						}
					}
					return false;
				}
			}

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

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

		private static readonly Regex ItemDurabilityRegex = new Regex("(\\$item_durability.*)", RegexOptions.Compiled);

		private static readonly Regex InventoryDamageRegex = new Regex("(\\$inventory_damage.*)", RegexOptions.Compiled);

		private static readonly Regex InventoryBluntRegex = new Regex("(\\$inventory_blunt.*)", RegexOptions.Compiled);

		private static readonly Regex InventorySlashRegex = new Regex("(\\$inventory_slash.*)", RegexOptions.Compiled);

		private static readonly Regex InventoryPierceRegex = new Regex("(\\$inventory_pierce.*)", RegexOptions.Compiled);

		private static readonly Regex InventoryFireRegex = new Regex("(\\$inventory_fire.*)", RegexOptions.Compiled);

		private static readonly Regex InventoryFrostRegex = new Regex("(\\$inventory_frost.*)", RegexOptions.Compiled);

		private static readonly Regex InventoryLightningRegex = new Regex("(\\$inventory_lightning.*)", RegexOptions.Compiled);

		private static readonly Regex InventoryPoisonRegex = new Regex("(\\$inventory_poison.*)", RegexOptions.Compiled);

		private static readonly Regex InventorySpiritRegex = new Regex("(\\$inventory_spirit.*)", RegexOptions.Compiled);

		private static readonly Regex ItemBlockArmorRegex = new Regex("(\\$item_blockarmor.*)", RegexOptions.Compiled);

		private static readonly Regex ItemArmorRegex = new Regex("(\\$item_armor.*)", RegexOptions.Compiled);

		[UsedImplicitly]
		private static void OnInit()
		{
			if (!ValheimEnchantmentSystem.NoGraphics)
			{
				AnimationSpeedManager.Add(ModifyAttackSpeed);
			}
		}

		[IteratorStateMachine(typeof(<FrameSkipEquip>d__13))]
		public static IEnumerator FrameSkipEquip(ItemData weapon)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FrameSkipEquip>d__13(0)
			{
				weapon = weapon
			};
		}

		private static string BuildTooltipStatusLine(SyncedData.EnchantmentReqs reqs, string dropName, int currentLevel, ItemData item)
		{
			if (reqs == null || item == null)
			{
				return string.Empty;
			}
			int variant;
			string text = SyncedData.GetColor(dropName, currentLevel, out variant, trimApha: true).IncreaseColorLight();
			if (currentLevel == 0)
			{
				text = "white";
			}
			if (!SyncedData.IsLevelEnchantable(dropName, currentLevel, item.IsWeapon()))
			{
				return ("<color=" + text + ">•</color> $enchantment_maxedout").Localize();
			}
			string text2 = ResolveTooltipScrollName(reqs.enchant_prefab);
			if (string.IsNullOrWhiteSpace(text2))
			{
				text2 = ResolveTooltipScrollName(reqs.blessed_enchant_prefab);
			}
			if (!string.IsNullOrWhiteSpace(text2))
			{
				return ("<color=" + text + ">•</color> $enchantment_canbeenchantedwith <color=yellow>" + text2 + "</color>").Localize();
			}
			return string.Empty;
		}

		private static string ResolveTooltipScrollName(SyncedData.SingleReq requirement)
		{
			if (requirement == null || !requirement.IsValid())
			{
				return string.Empty;
			}
			ZNetScene instance = ZNetScene.instance;
			object obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				GameObject prefab = instance.GetPrefab(requirement.prefab);
				obj = ((prefab == null) ? null : prefab.GetComponent<ItemDrop>()?.m_itemData?.m_shared?.m_name);
			}
			if (obj == null)
			{
				obj = string.Empty;
			}
			return (string)obj;
		}

		private static double ModifyAttackSpeed(Character c, double speed)
		{
			if ((Object)(object)c != (Object)(object)Player.m_localPlayer || !c.InAttack())
			{
				return speed;
			}
			ItemData currentWeapon = ((Humanoid)Player.m_localPlayer).GetCurrentWeapon();
			if (currentWeapon == null)
			{
				return speed;
			}
			Enchanted enchanted = currentWeapon.Data().Get<Enchanted>();
			if (enchanted != null && enchanted.level > 0)
			{
				SyncedData.Stat_Data statIncrease = SyncedData.GetStatIncrease(enchanted);
				if (statIncrease != null && statIncrease.attack_speed > 0)
				{
					return speed * (double)(1f + (float)statIncrease.attack_speed / 100f);
				}
			}
			return speed;
		}
	}
	public static class PlayerExtensions
	{
		private static float enchantmentRegenTimer;

		public static void UpdateEnchantmentRegen(this Player player, float dt)
		{
			enchantmentRegenTimer += dt;
			if (enchantmentRegenTimer >= 10f)
			{
				enchantmentRegenTimer = 0f;
				float healthRegen = EquippedEnchantmentSnapshotService.GetSnapshot(player).HealthRegen;
				if (healthRegen > 0f)
				{
					((Character)player).Heal(healthRegen, true);
				}
			}
		}

		public static void UpdateEnchantmentStaminaRegen(this Player player, float dt)
		{
			if (!((Object)(object)player != (Object)(object)Player.m_localPlayer) && !((Character)player).IsDead())
			{
				bool flag = ((Character)player).IsEncumbered();
				float maxStamina = ((Character)player).GetMaxStamina();
				float num = 1f;
				if (((Character)player).IsBlocking())
				{
					num *= 0.8f;
				}
				if ((((Character)player).IsSwimming() && !((Character)player).IsOnGround()) || ((Character)player).InAttack() || ((Character)player).InDodge() || ((Character)player).m_wallRunning || flag)
				{
					num = 0f;
				}
				float staminaRegen = EquippedEnchantmentSnapshotService.GetSnapshot(player).StaminaRegen;
				if (staminaRegen > 0f)
				{
					float num2 = 1f;
					((Character)player).m_seman.ModifyStaminaRegen(ref num2);
					float num3 = staminaRegen * num2 * num * dt;
					player.m_stamina = Mathf.Min(maxStamina, player.m_stamina + num3 * Game.m_staminaRegenRate);
				}
			}
		}
	}
	[VES_Autoload(VES_Autoload.Priority.Last, "OnInit", new Type[] { })]
	public static class Enchantment_Skill
	{
		public static SkillType SkillType_Enchantment;

		[UsedImplicitly]
		private static void OnInit()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			SkillType_Enchantment = SkillRegistrationService.RegisterConfigurableSkill("kg_Enchantment", "enchantment.png");
		}
	}
	[VES_Autoload(VES_Autoload.Priority.Normal, "OnInit", new Type[] { typeof(SyncedData) })]
	public static class Enchantment_VFX
	{
		private sealed class ManagedMeshEffectState : MonoBehaviour
		{
			public RendererEntry[] Entries = Array.Empty<RendererEntry>();

			public Light? ManagedLight;

			public Color LastColor = Color.clear;

			public int LastVariant = -1;

			public int LastConfigRevision = -1;

			public bool LastEnabled;

			public bool LastIsArmor = true;
		}

		private sealed class RendererEntry
		{
			public Renderer? Renderer;

			public int RendererInstanceId;

			public int ManagedMaterialIndex = -1;

			public GameObject? ParticleRoot;

			public ParticleSystem[] ParticleSystems = Array.Empty<ParticleSystem>();

			public float[] BaseStartSizeMultipliers = Array.Empty<float>();

			public RendererEntry(Renderer renderer)
			{
				Renderer = renderer;
				RendererInstanceId = ((Object)renderer).GetInstanceID();
			}
		}

		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public int? Order;
		}

		private static readonly int TintColor = Shader.PropertyToID("_TintColor");

		private const int MainVfxParticleBrightnessOrder = 98;

		private const int MainVfxLightIntensityOrder = 99;

		private const int MainVfxTintIntensityOrder = 100;

		private const int ArmorVfxTintIntensityOrder = 101;

		private const int EnableWeaponVfxOrder = 102;

		private const int EnableArmorVfxOrder = 103;

		private const string ManagedLightName = "VES_Light";

		private const string MeshParticleEffectPrefix = "VES_MPE_";

		private static readonly MaterialPropertyBlock PropertyBlock = new MaterialPropertyBlock();

		private static GameObject VES_MPE;

		private static readonly float[] VariantTintMultipliers = new float[4] { 1f, 0.65f, 1.8f, 0.35f };

		public static readonly List<Material> VFXs = new List<Material>();

		public static ConfigEntry<bool> _enableWeaponVFX;

		public static ConfigEntry<bool> _enableArmorVFX;

		public static ConfigEntry<float> _mainVfxTintIntensity;

		public static ConfigEntry<float> _mainVfxLightIntensity;

		public static ConfigEntry<float> _mainVfxParticleBrightness;

		public static ConfigEntry<float> _armorVfxTintIntensity;

		private static int _visualConfigRevision;

		private static bool _sceneVisualRefreshScheduled;

		private static bool IsManagedVfxMaterial(Material? material)
		{
			if ((Object)(object)material != (Object)null)
			{
				if (!VFXs.Contains(material))
				{
					return ((Object)material).name.IndexOf("Enchantment_VFX_Mat", StringComparison.Ordinal) >= 0;
				}
				return true;
			}
			return false;
		}

		private static int FindManagedMaterialIndex(Material[] materials)
		{
			for (int i = 0; i < materials.Length; i++)
			{
				if (IsManagedVfxMaterial(materials[i]))
				{
					return i;
				}
			}
			return -1;
		}

		private static int EnsureRendererVfxMaterial(RendererEntry entry, int variant)
		{
			if ((Object)(object)entry.Renderer == (Object)null)
			{
				entry.ManagedMaterialIndex = -1;
				return -1;
			}
			Material[] array = entry.Renderer.sharedMaterials ?? Array.Empty<Material>();
			int num = entry.ManagedMaterialIndex;
			if (num < 0 || num >= array.Length || !IsManagedVfxMaterial(array[num]))
			{
				num = FindManagedMaterialIndex(array);
			}
			if (num >= 0)
			{
				if ((Object)(object)array[num] != (Object)(object)VFXs[variant])
				{
					Material[] array2 = (Material[])array.Clone();
					array2[num] = VFXs[variant];
					entry.Renderer.sharedMaterials = array2;
				}
				entry.ManagedMaterialIndex = num;
				return num;
			}
			Material[] array3 = (Material[])(object)new Material[array.Length + 1];
			if (array.Length != 0)
			{
				Array.Copy(array, array3, array.Length);
			}
			array3[array.Length] = VFXs[variant];
			entry.Renderer.sharedMaterials = array3;
			entry.ManagedMaterialIndex = array.Length;
			return entry.ManagedMaterialIndex;
		}

		private static void RemoveRendererVfxMaterial(RendererEntry entry)
		{
			if ((Object)(object)entry.Renderer == (Object)null)
			{
				entry.ManagedMaterialIndex = -1;
				return;
			}
			Material[] array = entry.Renderer.sharedMaterials ?? Array.Empty<Material>();
			if (array.Length == 0)
			{
				entry.ManagedMaterialIndex = -1;
				return;
			}
			int num = entry.ManagedMaterialIndex;
			if (num < 0 || num >= array.Length || !IsManagedVfxMaterial(array[num]))
			{
				num = FindManagedMaterialIndex(array);
			}
			if (num < 0)
			{
				entry.ManagedMaterialIndex = -1;
				return;
			}
			if (array.Length == 1)
			{
				entry.Renderer.sharedMaterials = Array.Empty<Material>();
			}
			else
			{
				Material[] array2 = (Material[])(object)new Material[array.Length - 1];
				if (num > 0)
				{
					Array.Copy(array, 0, array2, 0, num);
				}
				if (num < array.Length - 1)
				{
					Array.Copy(array, num + 1, array2, num, array.Length - num - 1);
				}
				entry.Renderer.sharedMaterials = array2;
			}
			PropertyBlock.Clear();
			entry.Renderer.SetPropertyBlock(PropertyBlock);
			entry.ManagedMaterialIndex = -1;
		}

		private static void SetRendererTint(Renderer renderer, Color tint)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			PropertyBlock.Clear();
			renderer.GetPropertyBlock(PropertyBlock);
			PropertyBlock.SetColor(TintColor, tint);
			renderer.SetPropertyBlock(PropertyBlock);
		}

		private static GameObject GetOrCreateMeshParticleEffect(GameObject item, Renderer renderer)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			string text = "VES_MPE_" + ((Object)renderer).GetInstanceID();
			Transform val = item.transform.Find(text);
			if ((Object)(object)val != (Object)null)
			{
				return ((Component)val).gameObject;
			}
			GameObject val2 = Object.Instantiate<GameObject>(VES_MPE, item.transform);
			((Object)val2).name = text;
			val2.transform.localPosition = Vector3.zero;
			val2.transform.localRotation = Quaternion.identity;
			val2.transform.localScale = Vector3.one;
			return val2;
		}

		private static Light GetOrCreateManagedLight(GameObject item)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			Transform val = item.transform.Find("VES_Light");
			GameObject val2;
			if ((Object)(object)val != (Object)null)
			{
				val2 = ((Component)val).gameObject;
			}
			else
			{
				val2 = new GameObject("VES_Light");
				val2.transform.SetParent(item.transform, false);
			}
			return val2.GetComponent<Light>() ?? val2.AddComponent<Light>();
		}

		private static IEnumerable<Renderer> EnumerateEffectRenderers(GameObject item)
		{
			return item.GetComponentsInChildren<SkinnedMeshRenderer>(true).Cast<Renderer>().Concat((IEnumerable<Renderer>)(object)item.GetComponentsInChildren<MeshRenderer>(true));
		}

		private static ManagedMeshEffectState GetOrCreateManagedMeshEffectState(GameObject item)
		{
			ManagedMeshEffectState component = item.GetComponent<ManagedMeshEffectState>();
			if (!((Object)(object)component != (Object)null))
			{
				return item.AddComponent<ManagedMeshEffectState>();
			}
			return component;
		}

		private static void EnsureParticleSystems(GameObject item, RendererEntry entry, Renderer renderer)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)entry.ParticleRoot == (Object)null)
			{
				entry.ParticleRoot = GetOrCreateMeshParticleEffect(item, renderer);
			}
			if (entry.ParticleSystems.Length == 0 || !entry.ParticleSystems.All((ParticleSystem ps) => (Object)(object)ps != (Object)null))
			{
				entry.ParticleSystems = entry.ParticleRoot.GetComponentsInChildren<ParticleSystem>(true);
				entry.BaseStartSizeMultipliers = new float[entry.ParticleSystems.Length];
				for (int i = 0; i < entry.ParticleSystems.Length; i++)
				{
					float[] baseStartSizeMultipliers = entry.BaseStartSizeMultipliers;
					int num = i;
					MainModule main = entry.ParticleSystems[i].main;
					baseStartSizeMultipliers[num] = ((MainModule)(ref main)).startSizeMultiplier;
				}
			}
		}

		private static void SetParticleRootActive(RendererEntry entry, bool active)
		{
			if ((Object)(object)entry.ParticleRoot != (Object)null && entry.ParticleRoot.activeSelf != active)
			{
				entry.ParticleRoot.SetActive(active);
			}
		}

		private static bool TryConfigureParticleEffects(GameObject item, RendererEntry entry, Renderer renderer, Color color)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			bool flag = renderer is SkinnedMeshRenderer;
			if (flag)
			{
				SkinnedMeshRenderer val = (SkinnedMeshRenderer)(object)((renderer is SkinnedMeshRenderer) ? renderer : null);
				if ((Object)(object)((val != null) ? val.sharedMesh : null) == (Object)null || !val.sharedMesh.isReadable)
				{
					SetParticleRootActive(entry, active: false);
					return false;
				}
			}
			else
			{
				MeshFilter component = ((Component)renderer).GetComponent<MeshFilter>();
				if (!Object.op_Implicit((Object)(object)component) || (Object)(object)component.sharedMesh == (Object)null || !component.sharedMesh.isReadable)
				{
					SetParticleRootActive(entry, active: false);
					return false;
				}
			}
			EnsureParticleSystems(item, entry, renderer);
			SetParticleRootActive(entry, active: true);
			Bounds bounds = renderer.bounds;
			Vector3 val2 = ((Bounds)(ref bounds)).size;
			float magnitude = ((Vector3)(ref val2)).magnitude;
			val2 = item.transform.lossyScale;
			float num = ((Vector3)(ref val2)).magnitude;
			if (num <= 0f)
			{
				num = 1f;
			}
			float num2 = magnitude / num;
			Color particleColor = GetParticleColor(color);
			for (int i = 0; i < entry.ParticleSystems.Length; i++)
			{
				ParticleSystem val3 = entry.ParticleSystems[i];
				if (!((Object)(object)val3 == (Object)null))
				{
					MainModule main = val3.main;
					((MainModule)(ref main)).startColor = MinMaxGradient.op_Implicit(particleColor);
					float num3 = ((i < entry.BaseStartSizeMultipliers.Length) ? entry.BaseStartSizeMultipliers[i] : ((MainModule)(ref main)).startSizeMultiplier);
					((MainModule)(ref main)).startSizeMultiplier = num3 * num2;
					ShapeModule shape = val3.shape;
					((ShapeModule)(ref shape)).shapeType = (ParticleSystemShapeType)(flag ? 14 : 13);
					if (flag)
					{
						((ShapeModule)(ref shape)).skinnedMeshRenderer = (SkinnedMeshRenderer)(object)((renderer is SkinnedMeshRenderer) ? renderer : null);
						((ShapeModule)(ref shape)).meshRenderer = null;
					}
					else
					{
						((ShapeModule)(ref shape)).skinnedMeshRenderer = null;
						((ShapeModule)(ref shape)).meshRenderer = (MeshRenderer)(object)((renderer is MeshRenderer) ? renderer : null);
					}
					((Component)val3).gameObject.SetActive(true);
				}
			}
			return true;
		}

		private static void DestroyRendererEntry(RendererEntry entry)
		{
			if ((Object)(object)entry.ParticleRoot != (Object)null)
			{
				Object.Destroy((Object)(object)entry.ParticleRoot);
			}
		}

		private static void RebuildRendererEntries(ManagedMeshEffectState state, bool includeParticles)
		{
			GameObject gameObject = ((Component)state).gameObject;
			Dictionary<int, RendererEntry> dictionary = new Dictionary<int, RendererEntry>();
			RendererEntry[] entries = state.Entries;
			foreach (RendererEntry rendererEntry in entries)
			{
				if ((Object)(object)rendererEntry.Renderer != (Object)null)
				{
					dictionary[rendererEntry.RendererInstanceId] = rendererEntry;
				}
				else
				{
					DestroyRendererEntry(rendererEntry);
				}
			}
			Renderer[] array = (from renderer in EnumerateEffectRenderers(gameObject)
				where (Object)(object)renderer != (Object)null
				select renderer).ToArray();
			RendererEntry[] array2 = new RendererEntry[array.Length];
			for (int j = 0; j < array.Length; j++)
			{
				Renderer val = array[j];
				int instanceID = ((Object)val).GetInstanceID();
				if (!dictionary.TryGetValue(instanceID, out var value))
				{
					value = new RendererEntry(val);
				}
				else
				{
					dictionary.Remove(instanceID);
					value.Renderer = val;
				}
				value.ManagedMaterialIndex = -1;
				if (!includeParticles)
				{
					SetParticleRootActive(value, active: false);
				}
				array2[j] = value;
			}
			foreach (RendererEntry value2 in dictionary.Values)
			{
				DestroyRendererEntry(value2);
			}
			state.Entries = array2;
		}

		private static void DisableManagedMeshEffect(ManagedMeshEffectState state)
		{
			if ((Object)(object)state.ManagedLight != (Object)null)
			{
				((Behaviour)state.ManagedLight).enabled = false;
				((Component)state.ManagedLight).gameObject.SetActive(false);
			}
			RendererEntry[] entries = state.Entries;
			foreach (RendererEntry entry in entries)
			{
				RemoveRendererVfxMaterial(entry);
				SetParticleRootActive(entry, active: false);
			}
		}

		private static void ApplyManagedMeshEffect(ManagedMeshEffectState state, Color color, int variant, bool isArmor)
		{
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			if (state.Entries.Length == 0 || state.LastIsArmor != isArmor || state.Entries.Any((RendererEntry entry) => (Object)(object)entry.Renderer == (Object)null))
			{
				RebuildRendererEntries(state, !isArmor);
			}
			if (!isArmor)
			{
				Light val = (state.ManagedLight = (Light?)(((Object)(object)state.ManagedLight != (Object)null) ? ((object)state.ManagedLight) : ((object)GetOrCreateManagedLight(((Component)state).gameObject))));
				((Component)val).gameObject.SetActive(true);
				((Behaviour)val).enabled = true;
				val.type = (LightType)2;
				val.color = color;
				val.intensity = _mainVfxLightIntensity.Value * color.a;
				val.range = 9f;
			}
			else if ((Object)(object)state.ManagedLight != (Object)null)
			{
				((Behaviour)state.ManagedLight).enabled = false;
				((Component)state.ManagedLight).gameObject.SetActive(false);
			}
			Color tint = (isArmor ? (color * GetArmorTintIntensity(variant)) : (color * GetTintIntensity(variant)));
			RendererEntry[] entries = state.Entries;
			foreach (RendererEntry rendererEntry in entries)
			{
				Renderer renderer = rendererEntry.Renderer;
				if (!((Object)(object)renderer == (Object)null))
				{
					EnsureRendererVfxMaterial(rendererEntry, variant);
					SetRendererTint(renderer, tint);
					if (isArmor)
					{
						SetParticleRootActive(rendererEntry, active: false);
					}
					else
					{
						TryConfigureParticleEffects(((Component)state).gameObject, rendererEntry, renderer, color);
					}
				}
			}
		}

		private static void SetMeshEffectState(GameObject item, bool enabled, Color color, int variant, bool isArmor)
		{
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)item))
			{
				return;
			}
			ManagedMeshEffectState managedMeshEffectState = item.GetComponent<ManagedMeshEffectState>();
			if (!enabled || VFXs.Count <= 0 || !IsEffectEnabledForClass(isArmor))
			{
				if (!((Object)(object)managedMeshEffectState == (Object)null))
				{
					if (managedMeshEffectState.LastEnabled || managedMeshEffectState.LastConfigRevision != _visualConfigRevision)
					{
						DisableManagedMeshEffect(managedMeshEffectState);
					}
					managedMeshEffectState.LastEnabled = false;
					managedMeshEffectState.LastColor = color;
					managedMeshEffectState.LastVariant = variant;
					managedMeshEffectState.LastIsArmor = isArmor;
					managedMeshEffectState.LastConfigRevision = _visualConfigRevision;
				}
				return;
			}
			if (managedMeshEffectState == null)
			{
				managedMeshEffectState = GetOrCreateManagedMeshEffectState(item);
			}
			variant = Mathf.Clamp(variant, 0, VFXs.Count - 1);
			if (!managedMeshEffectState.LastEnabled || managedMeshEffectState.LastVariant != variant || managedMeshEffectState.LastIsArmor != isArmor || managedMeshEffectState.LastConfigRevision != _visualConfigRevision || !((Color)(ref managedMeshEffectState.LastColor)).Equals(color))
			{
				ApplyManagedMeshEffect(managedMeshEffectState, color, variant, isArmor);
				managedMeshEffectState.LastEnabled = true;
				managedMeshEffectState.LastColor = color;
				managedMeshEffectState.LastVariant = variant;
				managedMeshEffectState.LastIsArmor = isArmor;
				managedMeshEffectState.LastConfigRevision = _visualConfigRevision;
			}
		}

		internal static void RemoveMeshEffects(GameObject item)
		{
			if (!Object.op_Implicit((Object)(object)item))
			{
				return;
			}
			ManagedMeshEffectState component = item.GetComponent<ManagedMeshEffectState>();
			if (component != null)
			{
				DisableManagedMeshEffect(component);
				RendererEntry[] entries = component.Entries;
				foreach (RendererEntry entry in entries)
				{
					DestroyRendererEntry(entry);
				}
				if ((Object)(object)component.ManagedLight != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)component.ManagedLight).gameObject);
				}
				Object.Destroy((Object)(object)component);
			}
			Transform[] array = (from Transform child in (IEnumerable)item.transform
				where ((Object)child).name == "VES_Light" || ((Object)child).name.StartsWith("VES_MPE_", StringComparison.Ordinal)
				select child).ToArray();
			foreach (Transform val in array)
			{
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
			foreach (Renderer item2 in EnumerateEffectRenderers(item))
			{
				Material[] array2 = item2.sharedMaterials ?? Array.Empty<Material>();
				int num = FindManagedMaterialIndex(array2);
				if (num >= 0)
				{
					Material[] array3 = (Material[])(object)new Material[array2.Length - 1];
					if (num > 0)
					{
						Array.Copy(array2, 0, array3, 0, num);
					}
					if (num < array2.Length - 1)
					{
						Array.Copy(array2, num + 1, array3, num, array2.Length - num - 1);
					}
					item2.sharedMaterials = array3;
					PropertyBlock.Clear();
					item2.SetPropertyBlock(PropertyBlock);
				}
			}
		}

		private static ConfigDescription OrderedDescription(string description, int order)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			return new ConfigDescription(description, (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = order
				}
			});
		}

		private static ConfigDescription OrderedRangeDescription(string description, int order, float min, float max)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			return new ConfigDescription(description, (AcceptableValueBase)(object)new AcceptableValueRange<float>(min, max), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = order
				}
			});
		}

		[UsedImplicitly]
		private static void OnInit()
		{
			if (!ValheimEnchantmentSystem.NoGraphics)
			{
				VFXs.Add(ValheimEnchantmentSystem._asset.LoadAsset<Material>("Enchantment_VFX_Mat1"));
				VFXs.Add(ValheimEnchantmentSystem._asset.LoadAsset<Material>("Enchantment_VFX_Mat2"));
				VFXs.Add(ValheimEnchantmentSystem._asset.LoadAsset<Material>("Enchantment_VFX_Mat3"));
				VFXs.Add(ValheimEnchantmentSystem._asset.LoadAsset<Material>("Enchantment_VFX_Mat4"));
				VES_MPE = ValheimEnchantmentSystem._asset.LoadAsset<GameObject>("VES_MPE");
				_mainVfxParticleBrightness = ValheimEnchantmentSystem.ClientConfig("", "MainVFXParticleBrightness", 1.5f, OrderedRangeDescription("Brightness of weapon/world/stand particle VFX.", 98, 0f, 5f));
				_mainVfxLightIntensity = ValheimEnchantmentSystem.ClientConfig("", "MainVFXLightIntensity", 1f, OrderedRangeDescription("Light intensity added by weapon/world/stand VFX.", 99, 0f, 5f));
				_mainVfxTintIntensity = ValheimEnchantmentSystem.ClientConfig("", "MainVFXTintIntensity", 8f, OrderedRangeDescription("Emission intensity of weapon/world/stand VFX materials.", 100, 0f, 50f));
				_armorVfxTintIntensity = ValheimEnchantmentSystem.ClientConfig("", "ArmorVFXTintIntensity", 2f, OrderedRangeDescription("Emission intensity of armor/cape/utility VFX materials.", 101, 0f, 20f));
				_enableWeaponVFX = ValheimEnchantmentSystem.ClientConfig("", "EnableWeaponVFX", value: true, OrderedDescription("Enable enchantment VFX for held items like weapons, shields, tools, torches, and their stands.", 102));
				_enableArmorVFX = ValheimEnchantmentSystem.ClientConfig("", "EnableArmorVFX", value: true, OrderedDescription("Enable enchantment VFX for worn items like armor, capes, utility items, and their stands.", 103));
				_enableWeaponVFX.SettingChanged += delegate
				{
					OnEquipmentVisualSettingChanged();
				};
				_enableArmorVFX.SettingChanged += delegate
				{
					OnEquipmentVisualSettingChanged();
				};
				_mainVfxParticleBrightness.SettingChanged += delegate
				{
					OnEquipmentVisualSettingChanged();
				};
				_mainVfxLightIntensity.SettingChanged += delegate
				{
					OnEquipmentVisualSettingChanged();
				};
				_mainVfxTintIntensity.SettingChanged += delegate
				{
					OnEquipmentVisualSettingChanged();
				};
				_armorVfxTintIntensity.SettingChanged += delegate
				{
					OnEquipmentVisualSettingChanged();
				};
			}
		}

		private static void OnEquipmentVisualSettingChanged()
		{
			_visualConfigRevision++;
			RequestSceneVisualRefresh();
		}

		internal static void RequestSceneVisualRefresh()
		{
			if (ValheimEnchantmentSystem.NoGraphics)
			{
				return;
			}
			if ((Object)(object)ValheimEnchantmentSystem._thistype == (Object)null)
			{
				RefreshSceneVisuals();
			}
			else if (!_sceneVisualRefreshScheduled)
			{
				_sceneVisualRefreshScheduled = true;
				((MonoBehaviour)(object)ValheimEnchantmentSystem._thistype).DelayedInvoke(delegate
				{
					_sceneVisualRefreshScheduled = false;
					RefreshSceneVisuals();
				}, 1);
			}
		}

		internal static bool IsWeaponVfxEnabled()
		{
			return _enableWeaponVFX.Value;
		}

		internal static bool IsArmorVfxEnabled()
		{
			return _enableArmorVFX.Value;
		}

		internal static bool IsEffectEnabledForClass(bool isArmor)
		{
			if (!isArmor)
			{
				return IsWeaponVfxEnabled();
			}
			return IsArmorVfxEnabled();
		}

		internal static void InsertColor(ZDO zdo, string key, string color, int variant)
		{
			if (zdo != null)
			{
				if (color == null)
				{
					color = string.Empty;
				}
				variant = Mathf.Max(0, variant);
				if (!string.Equals(zdo.GetString(key, ""), color, StringComparison.Ordinal))
				{
					zdo.Set(key, color);
				}
				string text = key + "_variant";
				if (zdo.GetInt(text, 0) != variant)
				{
					zdo.Set(text, variant);
				}
			}
		}

		internal static string GetItemEnchantmentColor(ItemData item, out int variant, bool trimAlpha = false)
		{
			variant = 0;
			Enchantment_Core.Enchanted enchanted = item?.Data().Get<Enchantment_Core.Enchanted>();
			if (enchanted != null && enchanted.level > 0)
			{
				return SyncedData.GetColor(enchanted, out variant, trimAlpha);
			}
			return string.Empty;
		}

		internal static bool TryGetVisSlotColorKey(VisSlot slot, out string colorKey, out bool isArmor)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected I4, but got Unknown
			switch ((int)slot)
			{
			case 0:
				colorKey = "VES_leftitemColor";
				isArmor = false;
				return true;
			case 1:
				colorKey = "VES_rightitemColor";
				isArmor = false;
				return true;
			case 2:
				colorKey = "VES_leftbackitemColor";
				isArmor = false;
				return true;
			case 3:
				colorKey = "VES_rightbackitemColor";
				isArmor = false;
				return true;
			case 4:
				colorKey = "VES_chestitemColor";
				isArmor = true;
				return true;
			case 5:
				colorKey = "VES_legsitemColor";
				isArmor = true;
				return true;
			case 6:
				colorKey = "VES_helmetitemColor";
				isArmor = true;
				return true;
			case 7:
				colorKey = "VES_shoulderitemColor";
				isArmor = true;
				return true;
			default:
				colorKey = string.Empty;
				isArmor = true;
				return false;
			}
		}

		internal static bool IsArmorVisual(ItemData itemData)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected I4, but got Unknown
			if (itemData == null)
			{
				return true;
			}
			ItemType itemType = itemData.m_shared.m_itemType;
			return (itemType - 3) switch
			{
				16 => false, 
				12 => false, 
				0 => false, 
				2 => false, 
				1 => false, 
				11 => false, 
				19 => false, 
				3 => true, 
				4 => true, 
				8 => true, 
				14 => true, 
				15 => true, 
				_ => !itemData.IsWeapon(), 
			};
		}

		private static float GetTintIntensity(int variant)
		{
			variant = Mathf.Clamp(variant, 0, VariantTintMultipliers.Length - 1);
			return _mainVfxTintIntensity.Value * VariantTintMultipliers[variant];
		}

		private static float GetArmorTintIntensity(int variant)
		{
			variant = Mathf.Clamp(variant, 0, VariantTintMultipliers.Length - 1);
			return _armorVfxTintIntensity.Value * VariantTintMultipliers[variant];
		}

		private static Color GetParticleColor(Color color)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			float num = default(float);
			float num2 = default(float);
			float num3 = default(float);
			Color.RGBToHSV(color, ref num, ref num2, ref num3);
			float num4 = Mathf.Clamp01(num3 * _mainVfxParticleBrightness.Value);
			Color result = Color.HSVToRGB(num, num2, num4, false);
			result.a = color.a;
			return result;
		}

		public static void RefreshEquipmentVisuals()
		{
			if (!ValheimEnchantmentSystem.NoGraphics)
			{
				ArmorStandVfx.RefreshAllArmorStandVisuals();
				EquipmentWorldVfx.RefreshEquipmentVisuals();
			}
		}

		public static void RefreshArmorStandVisuals(ArmorStand armorStand)
		{
			if (!ValheimEnchantmentSystem.NoGraphics)
			{
				ArmorStandVfx.RefreshArmorStandVisuals(armorStand);
			}
		}

		public static void RefreshWorldItemVisuals()
		{
			if (!ValheimEnchantmentSystem.NoGraphics)
			{
				EquipmentWorldVfx.RefreshWorldItemVisuals();
			}
		}

		public static void RefreshSceneVisuals()
		{
			if (!ValheimEnchantmentSystem.NoGraphics)
			{
				RefreshEquipmentVisuals();
				RefreshWorldItemVisuals();
			}
		}

		public static void RefreshLiveVisuals()
		{
			if (!ValheimEnchantmentSystem.NoGraphics)
			{
				UpdateGrid();
				RefreshSceneVisuals();
			}
		}

		public static void AttachMeshEffect(GameObject item, Color c, int variant, bool isArmor = false)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			SetMeshEffectState(item, enabled: true, c, variant, isArmor);
		}

		internal static void DisableMeshEffect(GameObject item, bool isArmor = false)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			SetMeshEffectState(item, enabled: false, Color.clear, 0, isArmor);
		}

		public static void UpdateGrid()
		{
			InventoryOverlayVfx.UpdateGrid();
		}
	}
	internal static class ArmorStandVfx
	{
		[HarmonyPatch(typeof(ArmorStand), "UpdateVisual")]
		[ClientOnlyPatch]
		private static class ArmorStand_UpdateVisual_Patch
		{
			[UsedImplicitly]
			private static void Prefix(ArmorStand __instance)
			{
				if (!((Object)(object)__instance == (Object)null))
				{
					ArmorStandBatchRefreshes.Add(((Object)__instance).GetInstanceID());
				}
			}

			[UsedImplicitly]
			private static void Postfix(ArmorStand __instance)
			{
				if (!((Object)(object)__instance == (Object)null))
				{
					ArmorStandBatchRefreshes.Remove(((Object)__instance).GetInstanceID());
					RefreshArmorStandVisuals(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(ArmorStand), "SetVisualItem", new Type[]
		{
			typeof(int),
			typeof(string),
			typeof(int)
		})]
		[ClientOnlyPatch]
		private static class ArmorStand_SetVisualItem_Patch
		{
			[UsedImplicitly]
			private static void Postfix(ArmorStand __instance, int index)
			{
				if (!((Object)(object)__instance != (Object)null) || !ArmorStandBatchRefreshes.Contains(((Object)__instance).GetInstanceID()))
				{
					RefreshArmorStandVisuals(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(ArmorStand), "Awake")]
		[ClientOnlyPatch]
		private static class ArmorStand_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix(ArmorStand __instance)
			{
				ArmorStand __instance2 = __instance;
				if (!((Object)(object)ValheimEnchantmentSystem._thistype == (Object)null) && !((Object)(object)__instance2 == (Object)null))
				{
					((MonoBehaviour)(object)ValheimEnchantmentSystem._thistype).DelayedInvoke(delegate
					{
						ForceInitialArmorStandRefresh(__instance2);
					}, 1);
					((MonoBehaviour)(object)ValheimEnchantmentSystem._thistype).DelayedInvoke(delegate
					{
						ForceInitialArmorStandRefresh(__instance2);
					}, 30);
				}
			}
		}

		private static readonly MethodInfo ArmorStandUpdateVisualMethod = AccessTools.Method(typeof(ArmorStand), "UpdateVisual", (Type[])null, (Type[])null);

		private static readonly HashSet<int> ArmorStandBatchRefreshes = new HashSet<int>();

		private static void RefreshArmorStandSlotVisual(ArmorStand armorStand, ZDO armorStandZdo, ZDO visEquipmentZdo, int slotIndex, bool writeMetadata)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (armorStand.m_slots == null || slotIndex < 0 || slotIndex >= armorStand.m_slots.Count || !Enchantment_VFX.TryGetVisSlotColorKey(armorStand.m_slots[slotIndex].m_slot, out string colorKey, out bool _))
			{
				return;
			}
			string visualName = armorStand.m_slots[slotIndex].m_visualName;
			if (string.IsNullOrEmpty(visualName))
			{
				if (writeMetadata)
				{
					Enchantment_VFX.InsertColor(visEquipmentZdo, colorKey, string.Empty, 0);
				}
				return;
			}
			GameObject val = (Object.op_Implicit((Object)(object)ObjectDB.instance) ? ObjectDB.instance.GetItemPrefab(visualName) : null);
			if (!Object.op_Implicit((Object)(object)val))
			{
				return;
			}
			ItemDrop component = val.GetComponent<ItemDrop>();
			if (!((Object)(object)component == (Object)null))
			{
				ItemData val2 = component.m_itemData.Clone();
				if (armorStandZdo != null)
				{
					ItemDrop.LoadFromZDO(slotIndex, val2, armorStandZdo);
				}
				else
				{
					val2.m_variant = armorStand.m_slots[slotIndex].m_visualVariant;
				}
				int variant;
				string itemEnchantmentColor = Enchantment_VFX.GetItemEnchantmentColor(val2, out variant);
				if (writeMetadata)
				{
					Enchantment_VFX.InsertColor(visEquipmentZdo, colorKey, itemEnchantmentColor, variant);
				}
			}
		}

		public static void RefreshArmorStandVisuals(ArmorStand armorStand)
		{
			if ((Object)(object)armorStand == (Object)null || (Object)(object)armorStand.m_visEquipment == (Object)null)
			{
				return;
			}
			ZNetView nview = armorStand.m_visEquipment.m_nview;
			ZDO val = ((nview != null) ? nview.GetZDO() : null);
			if (val == null)
			{
				return;
			}
			ZNetView nview2 = armorStand.m_nview;
			ZDO armorStandZdo = ((nview2 != null) ? nview2.GetZDO() : null);
			bool writeMetadata = (Object)(object)armorStand.m_visEquipment.m_nview != (Object)null && armorStand.m_visEquipment.m_nview.IsValid() && armorStand.m_visEquipment.m_nview.IsOwner();
			if (armorStand.m_slots != null)
			{
				for (int i = 0; i < armorStand.m_slots.Count; i++)
				{
					RefreshArmorStandSlotVisual(armorStand, armorStandZdo, val, i, writeMetadata);
				}
			}
			EquipmentWorldVfx.RefreshVisEquipment(armorStand.m_visEquipment);
		}

		public static void RefreshAllArmorStandVisuals()
		{
			if (ValheimEnchantmentSystem.NoGraphics)
			{
				return;
			}
			foreach (ArmorStand item in VfxInstanceRegistry.EnumerateArmorStands())
			{
				RefreshArmorStandVisuals(item);
			}
		}

		private static void ForceInitialArmorStandRefresh(ArmorStand armorStand)
		{
			if ((Object)(object)armorStand == (Object)null || (Object)(object)armorStand.m_nview == (Object)null || !armorStand.m_nview.IsValid())
			{
				return;
			}
			try
			{
				ArmorStandUpdateVisualMethod?.Invoke(armorStand, null);
			}
			catch
			{
			}
		}
	}
	internal static class BloodMagicSummonEnchantmentService
	{
		[HarmonyPatch(typeof(SpawnAbility), "SetupAoe")]
		private static class SpawnAbility_SetupAoe_Patch
		{
			[UsedImplicitly]
			private static void Prefix(SpawnAbility __instance, Character owner)
			{
				if (Object.op_Implicit((Object)(object)owner) && Object.op_Implicit((Object)(object)owner.m_nview) && owner.m_nview.IsValid() && TryGetSourceEnchantment(__instance.m_weapon, out string sourcePrefab, out int sourceLevel))
				{
					ZDO zDO = owner.m_nview.GetZDO();
					if (zDO != null)
					{
						zDO.Set(SourcePrefabHash, sourcePrefab);
						zDO.Set(SourceLevelHash, sourceLevel, false);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Character), "RPC_Damage")]
		private static class Character_RPC_Damage_Patch
		{
			[UsedImplicitly]
			private static void Prefix(HitData hit)
			{
				if (hit != null)
				{
					Character attacker = hit.GetAttacker();
					if (TryGetSummonDamageStats(attacker, out SyncedData.Stat_Data stats))
					{
						ApplyDamageStats(hit, stats);
					}
				}
			}
		}

		private static readonly int SourcePrefabHash = StringExtensionMethods.GetStableHashCode("VES_BloodMagicSummonSourcePrefab");

		private static readonly int SourceLevelHash = StringExtensionMethods.GetStableHashCode("VES_BloodMagicSummonSourceLevel");

		private static bool TryGetSourceEnchantment(ItemData weapon, out string sourcePrefab, out int sourceLevel)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			sourcePrefab = string.Empty;
			sourceLevel = 0;
			if (weapon == null || (int)weapon.m_shared.m_skillType != 10)
			{
				return false;
			}
			Enchantment_Core.Enchanted enchanted = weapon.Data().Get<Enchantment_Core.Enchanted>();
			if (enchanted == null || enchanted.level <= 0)
			{
				return false;
			}
			sourcePrefab = EnchantmentDomainHelper.ResolveItemPrefabName(weapon);
			if (string.IsNullOrWhiteSpace(sourcePrefab))
			{
				return false;
			}
			SyncedData.Stat_Data statIncrease = SyncedData.GetStatIncrease(sourcePrefab, enchanted.level, isWeapon: true);
			if (!HasDamageStats(statIncrease))
			{
				return false;
			}
			sourceLevel = enchanted.level;
			return true;
		}

		private static bool TryGetSummonDamageStats(Character attacker, out SyncedData.Stat_Data stats)
		{
			stats = null;
			if (!Object.op_Implicit((Object)(object)attacker) || !Object.op_Implicit((Object)(object)attacker.m_nview) || !attacker.m_nview.IsValid())
			{
				return false;
			}
			ZDO zDO = attacker.m_nview.GetZDO();
			if (zDO == null)
			{
				return false;
			}
			string @string = zDO.GetString(SourcePrefabHash, "");
			int @int = zDO.GetInt(SourceLevelHash, 0);
			if (string.IsNullOrWhiteSpace(@string) || @int <= 0)
			{
				return false;
			}
			stats = SyncedData.GetStatIncrease(@string, @int, isWeapon: true);
			return HasDamageStats(stats);
		}

		private static bool HasDamageStats(SyncedData.Stat_Data stats)
		{
			if (stats != null)
			{
				if (stats.damage_percentage == 0 && stats.damage_true == 0 && stats.damage_blunt == 0 && stats.damage_slash == 0 && stats.damage_pierce == 0 && stats.damage_chop == 0 && stats.damage_pickaxe == 0 && stats.damage_fire == 0 && stats.damage_frost == 0 && stats.damage_lightning == 0 && stats.damage_poison == 0)
				{
					return stats.damage_spirit != 0;
				}
				return true;
			}
			return false;
		}

		private static void ApplyDamageStats(HitData hit, SyncedData.Stat_Data stats)
		{
			((DamageTypes)(ref hit.m_damage)).Modify(1f + (float)stats.damage_percentage / 100f);
			hit.m_damage.m_blunt += stats.damage_blunt;
			hit.m_damage.m_slash += stats.damage_slash;
			hit.m_damage.m_pierce += stats.damage_pierce;
			hit.m_damage.m_fire += stats.damage_fire;
			hit.m_damage.m_frost += stats.damage_frost;
			hit.m_damage.m_lightning += stats.damage_lightning;
			hit.m_damage.m_poison += stats.damage_poison;
			hit.m_damage.m_spirit += stats.damage_spirit;
			hit.m_damage.m_damage += stats.damage_true;
			hit.m_damage.m_chop += stats.damage_chop;
			hit.m_damage.m_pickaxe += stats.damage_pickaxe;
		}
	}
	internal static class EnchantmentDomainHelper
	{
		public static bool CanEnchant(ItemData item, int currentLevel, string itemPrefabName)
		{
			if (item == null || string.IsNullOrWhiteSpace(itemPrefabName))
			{
				return false;
			}
			if (!SyncedData.IsLevelEnchantable(itemPrefabName, currentLevel, item.IsWeapon()))
			{
				return false;
			}
			return SyncedData.GetReqs(itemPrefabName) != null;
		}

		public static string ResolveItemPrefabName(ItemData item)
		{
			if (Object.op_Implicit((Object)(object)item?.m_dropPrefab))
			{
				return ((Object)item.m_dropPrefab).name;
			}
			return Utils.GetPrefabNameByItemName(item?.m_shared?.m_name);
		}
	}
	public readonly struct EnchantmentAttemptSummary
	{
		public readonly double FinalChancePercent;

		public readonly string ChanceBreakdownText;

		public readonly string FailureBreakdownText;

		public EnchantmentAttemptSummary(double finalChancePercent, string chanceBreakdownText, string failureBreakdownText)
		{
			FinalChancePercent = finalChancePercent;
			ChanceBreakdownText = chanceBreakdownText;
			FailureBreakdownText = failureBreakdownText;
		}
	}
	public sealed class EnchantmentPreview
	{
		public ItemData Item;

		public string ItemDisplayName = string.Empty;

		public string ItemLabel = string.Empty;

		public string BlockedMessage = string.Empty;

		public Sprite RequirementIcon;

		public bool UseBlessedScroll;

		public bool CanSelect;

		public bool CanAttempt;

		public bool IsMaxedOut;

		public bool HasRequirementDefinition;

		public bool HasRequiredItems;

		public Color TrailColor = new Color(1f, 1f, 1f, 0.8f);

		public string RequirementStatusText = string.Empty;

		public EnchantmentAttemptSummary AttemptSummary;

		public string NextStatsTooltipText = string.Empty;
	}
	public static class EnchantmentPreviewService
	{
		private static readonly Color DefaultTrailColor = new Color(1f, 1f, 1f, 0.8f);

		public static EnchantmentPreview GetPreview(ItemData item, bool useBlessedScroll)
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			EnchantmentPreview enchantmentPreview = new EnchantmentPreview
			{
				Item = item,
				UseBlessedScroll = useBlessedScroll,
				ItemDisplayName = (item?.m_shared?.m_name?.Localize() ?? string.Empty),
				RequirementStatusText = "$enchantment_noenchantitems".Localize()
			};
			int num = (item?.Data().Get<Enchantment_Core.Enchanted>())?.level ?? 0;
			string text = EnchantmentDomainHelper.ResolveItemPrefabName(item);
			string text2 = ResolveDisplayColor(text, num);
			enchantmentPreview.ItemLabel = BuildItemLabel(enchantmentPreview.ItemDisplayName, num, text2);
			enchantmentPreview.TrailColor = ((num == 0) ? DefaultTrailColor : text2.ToColorAlpha());
			if (item == null || string.IsNullOrWhiteSpace(text))
			{
				return enchantmentPreview;
			}
			if (!IntegrationRegistry.CanEnchant(item, out string message))
			{
				enchantmentPreview.BlockedMessage = (string.IsNullOrWhiteSpace(message) ? "$enchantment_cannotbe".Localize() : message);
				return enchantmentPreview;
			}
			if (SyncedData.GetReqs(text) == null)
			{
				enchantmentPreview.BlockedMessage = "$enchantment_cannotbe".Localize();
				return enchantmentPreview;
			}
			if (!SyncedData.IsLevelEnchantable(text, num, item.IsWeapon()))
			{
				enchantmentPreview.CanSelect = true;
				enchantmentPreview.IsMaxedOut = true;
				enchantmentPreview.BlockedMessage = "$enchantment_maxedout".Localize();
				enchantmentPreview.RequirementStatusText = enchantmentPreview.BlockedMessage;
				return enchantmentPreview;
			}
			if (!EnchantmentDomainHelper.CanEnchant(item, num, text))
			{
				enchantmentPreview.BlockedMessage = ResolveBlockedMessage(item, text, num);
				return enchantmentPreview;
			}
			enchantmentPreview.CanSelect = true;
			enchantmentPreview.AttemptSummary = BuildAttemptSummary(item, text, num, useBlessedScroll);
			PopulateRequirementPreview(enchantmentPreview, text);
			PopulateNextStatsPreview(enchantmentPreview, text, num);
			enchantmentPreview.CanAttempt = enchantmentPreview.CanSelect && enchantmentPreview.HasRequirementDefinition && enchantmentPreview.HasRequiredItems;
			return enchantmentPreview;
		}

		private static void PopulateRequirementPreview(EnchantmentPreview preview, string itemPrefabName)
		{
			if (preview.Item == null || string.IsNullOrWhiteSpace(itemPrefabName))
			{
				return;
			}
			SyncedData.EnchantmentReqs reqs = SyncedData.GetReqs(itemPrefabName);
			if (reqs == null)
			{
				return;
			}
			SyncedData.SingleReq singleReq = (preview.UseBlessedScroll ? reqs.blessed_enchant_prefab : reqs.enchant_prefab);
			if (singleReq != null && singleReq.IsValid())
			{
				ZNetScene instance = ZNetScene.instance;
				GameObject val = ((instance != null) ? instance.GetPrefab(singleReq.prefab) : null);
				ItemDrop val2 = ((val != null) ? val.GetComponent<ItemDrop>() : null);
				if (val2 != null)
				{
					preview.HasRequirementDefinition = true;
					preview.RequirementIcon = val2.m_itemData.GetIcon();
					string requirementDisplayName = val2.m_itemData.m_shared.m_name.Localize();
					int num = 1;
					int num2 = Utils.CustomCountItemsNoLevel(singleReq.prefab);
					preview.HasRequiredItems = num2 >= num;
					preview.RequirementStatusText = BuildRequirementStatusText(requirementDisplayName, num2, num);
				}
			}
		}

		private static EnchantmentAttemptSummary BuildAttemptSummary(ItemData item, string itemPrefabName, int currentLevel, bool useBlessedScroll)
		{
			if (item == null || string.IsNullOrWhiteSpace(itemPrefabName))
			{
				return default(EnchantmentAttemptSummary);
			}
			EnchantmentRulePreview enchantmentRulePreview = EnchantmentRules.BuildPreview(item, itemPrefabName, currentLevel, Player.m_localPlayer, useBlessedScroll, SyncedData.BlessedScrollsPreventBreak.Value);
			double baseChancePercent = RoundChance(enchantmentRulePreview.BaseChance);
			double skillBonusChancePercent = RoundChance(enchantmentRulePreview.SkillBonus);
			double blessBonusChancePercent = RoundChance(enchantmentRulePreview.BlessBonus);
			double finalChancePercent = RoundChance(enchantmentRulePreview.FinalChance);
			double destroyChancePercent = RoundChance(enchantmentRulePreview.DestroyChance);
			return new EnchantmentAttemptSummary(finalChancePercent, BuildChanceBreakdownText(baseChancePercent, skillBonusChancePercent, blessBonusChancePercent, finalChancePercent), BuildFailureBreakdownText(finalChancePercent, destroyChancePercent, enchantmentRulePreview.CanBreak, enchantmentRulePreview.BlessPreventsBreak, enchantmentRulePreview.FailureType));
		}

		private static void PopulateNextStatsPreview(EnchantmentPreview preview, string itemPrefabName, int currentLevel)
		{
			if (preview.Item != null && !string.IsNullOrWhiteSpace(itemPrefabName))
			{
				bool isWeapon = preview.Item.IsWeapon();
				SyncedData.Stat_Data statIncrease = SyncedData.GetStatIncrease(itemPrefabName, currentLevel, isWeapon);
				SyncedData.Stat_Data statIncrease2 = SyncedData.GetStatIncrease(itemPrefabName, currentLevel + 1, isWeapon);
				string text = EnchantmentStatFormatter.BuildTransitionDescription(statIncrease, statIncrease2);
				if (!string.IsNullOrWhiteSpace(text))
				{
					preview.NextStatsTooltipText = $"<color=orange>+{currentLevel} > +{currentLevel + 1}</color>\n{text}";
				}
			}
		}

		private static string ResolveDisplayColor(string itemPrefabName, int currentLevel)
		{
			if (string.IsNullOrWhiteSpace(itemPrefabName))
			{
				return "white";
			}
			int variant;
			return SyncedData.GetColor(itemPrefabName, currentLevel, out variant, trimApha: true).IncreaseColorLight();
		}

		private static string BuildItemLabel(string itemDisplayName, int currentLevel, string displayColor)
		{
			return $"{itemDisplayName} (<color={displayColor}>+{currentLevel}</color>)";
		}

		private static string ResolveBlockedMessage(ItemData item, string itemPrefabName, int currentLevel)
		{
			if (item == null || string.IsNullOrWhiteSpace(itemPrefabName))
			{
				return string.Empty;
			}
			if (SyncedData.GetReqs(itemPrefabName) == null)
			{
				return "$enchantment_cannotbe".Localize();
			}
			if (SyncedData.IsLevelEnchantable(itemPrefabName, currentLevel, item.IsWeapon()))
			{
				return "$enchantment_cannotbe".Localize();
			}
			return "$enchantment_maxedout".Localize();
		}

		private static string BuildRequirementStatusText(string requirementDisplayName, int requirementCount, int requirementNeededCount)
		{
			return string.Format("{0}: {1} {2}/{3}", "$enchantment_rule_material".Localize(), requirementDisplayName, requirementCount, requirementNeededCount);
		}

		private static string BuildChanceBreakdownText(double baseChancePercent, double skillBonusChancePercent, double blessBonusChancePercent, double finalChancePercent)
		{
			List<string> list = new List<string> { FormatPercent(baseChancePercent) + "%" };
			if (skillBonusChancePercent > 0.0)
			{
				list.Add("$enchantment_rule_skill".Localize() + FormatPercent(skillBonusChancePercent) + "%");
			}
			if (blessBonusChancePercent > 0.0)
			{
				list.Add("$enchantment_rule_bless".Localize() + FormatPercent(blessBonusChancePercent) + "%");
			}
			return FormatPercent(finalChancePercent) + "% (" + string.Join(" + ", list) + ")";
		}

		private static string BuildFailureBreakdownText(double finalChancePercent, double destroyChancePercent, bool canBreak, bool blessPreventsBreak, SyncedData.ItemDesctructionTypeEnum failureType)
		{
			List<string> list = new List<string>();
			double num = 100.0 - finalChancePercent;
			int levelDecrease = Mathf.Clamp(SyncedData.FailedEnchantLevelDecrease.Value, 1, 100);
			if (RoundChance(num) <= 0.0)
			{
				return string.Empty;
			}
			if (blessPreventsBreak || !canBreak)
			{
				AppendFailureChancePart(list, "stay", num);
				return string.Join("\n", list);
			}
			switch (failureType)
			{
			case SyncedData.ItemDesctructionTypeEnum.Destroy:
				AppendFailureChancePart(list, "break", num);
				break;
			case SyncedData.ItemDesctructionTypeEnum.Combined:
				AppendFailureChancePart(list, "decrease", num * ((100.0 - destroyChancePercent) / 100.0), levelDecrease);
				AppendFailureChancePart(list, "break", num * (destroyChancePercent / 100.0));
				break;
			case SyncedData.ItemDesctructionTypeEnum.CombinedEasy:
				AppendFailureChancePart(list, "stay", num * ((100.0 - destroyChancePercent) / 100.0));
				AppendFailureChancePart(list, "decrease", num * (destroyChancePercent / 100.0), levelDecrease);
				break;
			default:
				AppendFailureChancePart(list, "decrease", num, levelDecrease);
				break;
			}
			return string.Join("\n", list);
		}

		private static double RoundChance(double value)
		{
			return Math.Round(value, 2, MidpointRounding.AwayFromZero);
		}

		private static string FormatPercent(double value)
		{
			return value.ToString("0.00", CultureInfo.InvariantCulture);
		}

		private static void AppendFailureChancePart(List<string> parts, string label, double value, int levelDecrease = 0)
		{
			double num = RoundChance(value);
			if (!(num <= 0.0))
			{
				string text = ResolveFailureOutcomeLabel(label);
				if (label == "decrease" && levelDecrease > 0)
				{
					text = $"{text} -{levelDecrease}";
				}
				parts.Add(FormatPercent(num) + "% (" + text + ")");
			}
		}

		private static string ResolveFailureOutcomeLabel(string label)
		{
			return label switch
			{
				"stay" => "$enchantment_preview_stay".Localize(), 
				"decrease" => "$enchantment_preview_decrease".Localize(), 
				"break" => "$enchantment_preview_break".Localize(), 
				_ => label, 
			};
		}
	}
	public sealed class EnchantmentResult
	{
		public Enchantment_Core.Enchanted Enchantment;

		public Player Player;

		public string ItemPrefabName = string.Empty;

		public string Message = string.Empty;

		public int PreviousLevel;

		public int CurrentLevel;

		public float SkillExpGranted;

		public bool Success;

		public bool Destroyed;

		public bool ConsumedRequirement;

		public bool LevelChanged;

		public Notifications_UI.NotificationItemResult? NotificationType;
	}
	internal enum EnchantmentOutcome
	{
		Success,
		LevelDecrease,
		Destroyed,
		NoChange
	}
	internal readonly struct EnchantmentDecision
	{
		public readonly EnchantmentOutcome Outcome;

		public readonly int NewLevel;

		public readonly Notifications_UI.NotificationItemResult NotificationType;

		public EnchantmentDecision(EnchantmentOutcome outcome, int newLevel, Notifications_UI.NotificationItemResult notificationType)
		{
			Outcome = outcome;
			NewLevel = newLevel;
			NotificationType = notificationType;
		}
	}
	internal readonly struct EnchantmentRulePreview
	{
		public readonly double BaseChance;

		public readonly double SkillBonus;

		public readonly double BlessBonus;

		public readonly double FinalChance;

		public readonly double DestroyChance;

		public readonly bool CanBreak;

		public readonly bool BlessPreventsBreak;

		public readonly SyncedData.ItemDesctructionTypeEnum FailureType;

		public EnchantmentRulePreview(double baseChance, double skillBonus, double blessBonus, double finalChance, double destroyChance, bool canBreak, bool blessPreventsBreak, SyncedData.ItemDesctructionTypeEnum failureType)
		{
			BaseChance = baseChance;
			SkillBonus = skillBonus;
			BlessBonus = blessBonus;
			FinalChance = finalChance;
			DestroyChance = destroyChance;
			CanBreak = canBreak;
			BlessPreventsBreak = blessPreventsBreak;
			FailureType = failureType;
		}
	}
	public static class EnchantmentService
	{
		public static EnchantmentResult Execute(Enchantment_Core.Enchanted enchantment, Player player, bool useBlessedScroll, bool blessedScrollPreventsBreak)
		{
			EnchantmentResult enchantmentResult = CreateResult(enchantment, player);
			if (enchantment?.Item == null || (Object)(object)player == (Object)null)
			{
				enchantmentResult.Message = "$enchantment_cannotbe".Localize();
				return enchantmentResult;
			}
			ItemData item = enchantment.Item;
			if (!IntegrationRegistry.CanEnchant(item, out string message))
			{
				enchantmentResult.Message = (string.IsNullOrWhiteSpace(message) ? "$enchantment_cannotbe".Localize() : message);
				return enchantmentResult;
			}
			if (!EnchantmentDomainHelper.CanEnchant(item, enchantment.level, enchantmentResult.ItemPrefabName))
			{
				enchantmentResult.Message = "$enchantment_cannotbe".Localize();
				return enchantmentResult;
			}
			if (!TryResolveRequirement(item, enchantmentResult.ItemPrefabName, useBlessedScroll, out SyncedData.EnchantmentReqs reqs, out GameObject requirementPrefab))
			{
				enchantmentResult.Message = "$enchantment_nomaterials".Localize();
				return enchantmentResult;
			}
			if (!TryConsumeRequirement(((Object)requirementPrefab).name))
			{
				enchantmentResult.Message = "$enchantment_nomaterials".Localize();
				return enchantmentResult;
			}
			enchantmentResult.ConsumedRequirement = true;
			float skillExp = GetSkillExp(reqs);
			EnchantmentDecision decision = EnchantmentRules.Decide(enchantment, player, useBlessedScroll, blessedScrollPreventsBreak);
			ApplyDecision(enchantment, player, decision, enchantmentResult);
			enchantmentResult.SkillExpGranted = GetGrantedSkillExp(skillExp, enchantmentResult.Success);
			enchantmentResult.Message = BuildMessage(decision.Outcome, item.m_shared.m_name.Localize(), enchantmentResult.PreviousLevel, enchantmentResult.CurrentLevel);
			return enchantmentResult;
		}

		private static EnchantmentResult CreateResult(Enchantment_Core.Enchanted enchantment, Player player)
		{
			int num = enchantment?.level ?? 0;
			return new EnchantmentResult
			{
				Enchantment = enchantment,
				Player = player,
				ItemPrefabName = EnchantmentDomainHelper.ResolveItemPrefabName(enchantment?.Item),
				PreviousLevel = num,
				CurrentLevel = num
			};
		}

		private static bool TryResolveRequirement(ItemData item, string itemPrefabName, bool useBlessedScroll, out SyncedData.EnchantmentReqs reqs, out GameObject requirementPrefab)
		{
			reqs = null;
			requirementPrefab = null;
			if (item == null || string.IsNullOrWhiteSpace(itemPrefabName))
			{
				return false;
			}
			reqs = SyncedData.GetReqs(itemPrefabName);
			if (reqs == null)
			{
				return false;
			}
			SyncedData.SingleReq singleReq = (useBlessedScroll ? reqs.blessed_enchant_prefab : reqs.enchant_prefab);
			if (singleReq == null || !singleReq.IsValid())
			{
				return false;
			}
			ZNetScene instance = ZNetScene.instance;
			requirementPrefab = ((instance != null) ? instance.GetPrefab(singleReq.prefab) : null);
			return (Object)(object)requirementPrefab != (Object)null;
		}

		private static bool TryConsumeRequirement(string requirementPrefabName)
		{
			if (string.IsNullOrWhiteSpace(requirementPrefabName))
			{
				return false;
			}
			if (Utils.CustomCountItemsNoLevel(requirementPrefabName) < 1)
			{
				return false;
			}
			Utils.CustomRemoveItemsNoLevel(requirementPrefabName, 1);
			return true;
		}

		private static float GetSkillExp(SyncedData.EnchantmentReqs reqs)
		{
			if (reqs?.enchant_prefab == null || !reqs.enchant_prefab.IsValid())
			{
				return 0f;
			}
			return EnchantmentTierCatalog.GetEnchantSkillExp(reqs.enchant_prefab.prefab);
		}

		private static float GetGrantedSkillExp(float successfulAttemptSkillExp, bool success)
		{
			if (successfulAttemptSkillExp <= 0f)
			{
				return 0f;
			}
			if (success)
			{
				return successfulAttemptSkillExp;
			}
			float num = Mathf.Clamp(SyncedData.FailedEnchantSkillExpMultiplier.Value, 0f, 2f);
			return successfulAttemptSkillExp * num;
		}

		private static void ApplyDecision(Enchantment_Core.Enchanted enchantment, Player player, EnchantmentDecision decision, EnchantmentResult result)
		{
			result.Success = decision.Outcome == EnchantmentOutcome.Success;
			result.Destroyed = decision.Outcome == EnchantmentOutcome.Destroyed;
			result.NotificationType = decision.NotificationType;
			if (decision.Outcome == EnchantmentOutcome.Destroyed)
			{
				if ((Object)(object)player != (Object)null)
				{
					((Humanoid)player).UnequipItem(enchantment.Item, true);
					((Humanoid)player).m_inventory.RemoveItem(enchantment.Item);
				}
				result.CurrentLevel = result.PreviousLevel;
			}
			else
			{
				enchantment.level = decision.NewLevel;
				enchantment.Save();
				result.CurrentLevel = enchantment.level;
				result.LevelChanged = result.CurrentLevel != result.PreviousLevel;
			}
		}

		private static string BuildMessage(EnchantmentOutcome outcome, string itemName, int previousLevel, int currentLevel)
		{
			return outcome switch
			{
				EnchantmentOutcome.Success => "$enchantment_success".Localize(itemName, previousLevel.ToString(), currentLevel.ToString()), 
				EnchantmentOutcome.LevelDecrease => "$enchantment_fail_leveldown".Localize(itemName, previousLevel.ToString(), currentLevel.ToString()), 
				EnchantmentOutcome.Destroyed => "$enchantment_fail_destroyed".Localize(itemName), 
				_ => "$enchantment_fail_nochange".Localize(itemName, currentLevel.ToString()), 
			};
		}
	}
	internal static class EnchantmentRules
	{
		public static EnchantmentRulePreview BuildPreview(ItemData item, string itemPrefabName, int currentLevel, Player player, bool useBlessedScroll, bool blessedScrollPreventsBreak)
		{
			SyncedData.ItemDesctructionTypeEnum value = SyncedData.ItemFailureType.Value;
			if (item == null || string.IsNullOrWhiteSpace(itemPrefabName))
			{
				return new EnchantmentRulePreview(0.0, 0.0, 0.0, 0.0, 0.0, canBreak: false, blessPreventsBreak: false, value);
			}
			SyncedData.Chance_Data enchantmentChance = SyncedData.GetEnchantmentChance(itemPrefabName, currentLevel, item.IsWeapon());
			double num = enchantmentChance.success;
			double num2 = EnchantmentSkillBonusService.GetAdditionalEnchantmentChance(player);
			double num3 = ((useBlessedScroll && !blessedScrollPreventsBreak) ? ((double)SyncedData.BlessedScrollsAdditionalChance.Value) : 0.0);
			double finalChance = NormalizePercentChance(num + num2 + num3);
			bool flag = useBlessedScroll && blessedScrollPreventsBreak && SyncedData.SafetyLevel.Value <= currentLevel;
			bool flag2 = SyncedData.SafetyLevel.Value <= currentLevel && !flag;
			double destroyChance = (flag2 ? NormalizePercentChance(ResolveDestroyChance(enchantmentChance, useBlessedScroll, value)) : 0.0);
			return new EnchantmentRulePreview(num, num2, num3, finalChance, destroyChance, flag2, flag, value);
		}

		public static EnchantmentDecision Decide(Enchantment_Core.Enchanted enchantment, Player player, bool useBlessedScroll, bool blessedScrollPreventsBreak)
		{
			int level = enchantment.level;
			EnchantmentRulePreview enchantmentRulePreview = BuildPreview(enchantment.Item, EnchantmentDomainHelper.ResolveItemPrefabName(enchantment.Item), level, player, useBlessedScroll, blessedScrollPreventsBreak);
			bool flag = RollPercent(enchantmentRulePreview.DestroyChance);
			if (RollPercent(enchantmentRulePreview.FinalChance))
			{
				return new EnchantmentDecision(EnchantmentOutcome.Success, level + 1, Notifications_UI.NotificationItemResult.Success);
			}
			if (!enchantmentRulePreview.CanBreak)
			{
				return new EnchantmentDecision(EnchantmentOutcome.NoChange, level, Notifications_UI.NotificationItemResult.LevelDecrease);
			}
			return enchantmentRulePreview.FailureType switch
			{
				SyncedData.ItemDesctructionTypeEnum.Destroy => new EnchantmentDecision(EnchantmentOutcome.Destroyed, level, Notifications_UI.NotificationItemResult.Destroyed), 
				SyncedData.ItemDesctructionTypeEnum.Combined => flag ? new EnchantmentDecision(EnchantmentOutcome.Destroyed, level, Notifications_UI.NotificationItemResult.Destroyed) : CreateLevelDecreaseDecision(level), 
				SyncedData.ItemDesctructionTypeEnum.CombinedEasy => flag ? CreateLevelDecreaseDecision(level) : new EnchantmentDecision(EnchantmentOutcome.NoChange, level, Notifications_UI.NotificationItemResult.LevelDecrease), 
				_ => CreateLevelDecreaseDecision(level), 
			};
		}

		private static EnchantmentDecision CreateLevelDecreaseDecision(int currentLevel)
		{
			int num = Mathf.Clamp(SyncedData.FailedEnchantLevelDecrease.Value, 1, 100);
			return new EnchantmentDecision(EnchantmentOutcome.LevelDecrease, Mathf.Max(0, currentLevel - num), Notifications_UI.NotificationItemResult.LevelDecrease);
		}

		private static double ResolveDestroyChance(SyncedData.Chance_Data chanceData, bool useBlessedScroll, SyncedData.ItemDesctructionTypeEnum failureType)
		{
			return failureType switch
			{
				SyncedData.ItemDesctructionTypeEnum.Destroy => 100.0, 
				SyncedData.ItemDesctructionTypeEnum.Combined => Math.Min(100.0, Math.Max(0.0, chanceData.destroy - (float)(useBlessedScroll ? SyncedData.BlessedScrollsAdditionalChance.Value : 0))), 
				SyncedData.ItemDesctructionTypeEnum.CombinedEasy => Math.Min(100.0, Math.Max(0.0, chanceData.destroy - (float)(useBlessedScroll ? SyncedData.BlessedScrollsAdditionalChance.Value : 0))), 
				_ => 0.0, 
			};
		}

		private static double NormalizePercentChance(double chance)
		{
			return Math.Round(Math.Min(100.0, Math.Max(0.0, chance)), 2, MidpointRounding.AwayFromZero);
		}

		private static bool RollPercent(double chance)
		{
			double num = NormalizePercentChance(chance);
			if (num <= 0.0)
			{
				return false;
			}
			if (num >= 100.0)
			{
				return true;
			}
			return (double)Random.Range(0f, 100f) < num;
		}
	}
	public static class EnchantmentSideEffects
	{
		public static void ApplyAttemptResult(EnchantmentResult result)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			if (result == null)
			{
				return;
			}
			Enchantment_VFX.UpdateGrid();
			if (result.LevelChanged && !result.Destroyed)
			{
				IntegrationRegistry.ApplyEnchantState(result.Enchantment);
				if ((Object)(object)ValheimEnchantmentSystem._thistype != (Object)null && result.Enchantment?.Item != null)
				{
					((MonoBehaviour)ValheimEnchantmentSystem._thistype).StartCoroutine(Enchantment_Core.FrameSkipEquip(result.Enchantment.Item));
				}
			}
			if (result.SkillExpGranted > 0f)
			{
				Utils.IncreaseSkillEXP(Enchantment_Skill.SkillType_Enchantment, result.SkillExpGranted);
			}
			if (result.NotificationType.HasValue && SyncedData.EnchantmentEnableNotifications.Value && SyncedData.EnchantmentNotificationMinLevel.Value <= result.CurrentLevel)
			{
				string playerName = (((Object)(object)result.Player != (Object)null) ? result.Player.GetPlayerName() : "No Name");
				Notifications_UI.AddNotification(playerName, result.ItemPrefabName, (int)result.NotificationType.Value, result.PreviousLevel, result.CurrentLevel);
			}
		}

		public static void HandleUpgrade(Enchantment_Core.Enchanted enchantment)
		{
			Enchantment_Core.Enchanted enchantment2 = enchantment;
			if ((Object)(object)ValheimEnchantmentSystem._thistype == (Object)null || enchantment2 == null)
			{
				return;
			}
			((MonoBehaviour)(object)ValheimEnchantmentSystem._thistype).DelayedInvoke(delegate
			{
				if (SyncedData.DropEnchantmentOnUpgrade.Value)
				{
					enchantment2.Item?.Data().Remove<Enchantment_Core.Enchanted>();
					Enchantment_VFX.UpdateGrid();
				}
				else
				{
					IntegrationRegistry.ApplyEnchantUpgradedState(enchantment2);
					Enchantment_VFX.UpdateGrid();
				}
			}, 1);
		}

		public static void ApplyStateChanged(Enchantment_Core.Enchanted enchantment, bool refreshEquipment)
		{
			if (enchantment != null)
			{
				IntegrationRegistry.ApplyEnchantState(enchantment);
				Enchantment_VFX.UpdateGrid();
				if (refreshEquipment && (Object)(object)ValheimEnchantmentSystem._thistype != (Object)null && enchantment.Item != null)
				{
					((MonoBehaviour)ValheimEnchantmentSystem._thistype).StartCoroutine(Enchantment_Core.FrameSkipEquip(enchantment.Item));
				}
			}
		}
	}
	public static class EnchantmentSkillBonusService
	{
		public static float GetAdditionalEnchantmentChance(Player player = null)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			Player val = (Player)(Object.op_Implicit((Object)(object)player) ? ((object)player) : ((object)Player.m_localPlayer));
			if (!Object.op_Implicit((Object)(object)val))
			{
				return 0f;
			}
			float skillLevel = ((Character)val).GetSkillLevel(Enchantment_Skill.SkillType_Enchantment);
			return skillLevel * SyncedData.AdditionalEnchantmentChancePerLevel.Value;
		}
	}
	internal static class EngineEvents
	{
		[HarmonyPatch(typeof(Inventory), "Changed")]
		[ClientOnlyPatch]
		private static class Inventory_Changed_Patch
		{
			[UsedImplicitly]
			private static void Postfix(Inventory __instance)
			{
				EngineEvents.InventoryChanged?.Invoke(__instance);
			}
		}

		[HarmonyPatch]
		[ClientOnlyPatch]
		private static class Humanoid_EquipState_Patch
		{
			[CompilerGenerated]
			private sealed class <TargetMethods>d__0 : IEnumerable<MethodInfo>, IEnumerable, IEnumerator<MethodInfo>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private MethodInfo <>2__current;

				private int <>l__initialThreadId;

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

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

				[DebuggerHidden]
				public <TargetMethods>d__0(int <>1__state)
				{
					this.<>1__state = <>1__state;
					<>l__initialThreadId = Environment.CurrentManagedThreadId;
				}

				[DebuggerHidden]
				void IDisposable.Dispose()
				{
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(Humanoid), "EquipItem", (Type[])null, (Type[])null);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(Humanoid), "UnequipItem", (Type[])null, (Type[])null);
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						return false;
					}
				}

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

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

				[DebuggerHidden]
				IEnumerator<MethodInfo> IEnumerable<MethodInfo>.GetEnumerator()
				{
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						return this;
					}
					return new <TargetMethods>d__0(0);
				}

				[DebuggerHidden]
				IEnumerator IEnumerable.GetEnumerator()
				{
					return ((IEnumerable<MethodInfo>)this).GetEnumerator();
				}
			}

			[IteratorStateMachine(typeof(<TargetMethods>d__0))]
			[UsedImplicitly]
			private static IEnumerable<MethodInfo> TargetMethods()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <TargetMethods>d__0(-2);
			}

			[UsedImplicitly]
			private static void Postfix(Humanoid __instance)
			{
				Player val = (Player)(object)((__instance is Player) ? __instance : null);
				if (val != null)
				{
					EngineEvents.EquipmentChanged?.Invoke(val);
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Show")]
		[ClientOnlyPatch]
		private static class InventoryGui_Show_Patch
		{
			[UsedImplicitly]
			private static void Postfix()
			{
				EngineEvents.InventoryGuiShown?.Invoke();
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "Awake")]
		[ClientOnlyPatch]
		private static class FejdStartup_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix(FejdStartup __instance)
			{
				EngineEvents.MainMenuAwake?.Invoke(__instance);
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		[ClientOnlyPatch]
		private static class ZNetScene_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix()
			{
				EngineEvents.WorldAwake?.Invoke();
			}
		}

		public static event Action<Inventory>? InventoryChanged;

		public static event Action<Player>? EquipmentChanged;

		public static event Action? InventoryGuiShown;

		public static event Action<FejdStartup>? MainMenuAwake;

		public static event Action? WorldAwake;
	}
	internal static class EquipmentWorldVfx
	{
		[HarmonyPatch(typeof(Humanoid), "SetupVisEquipment")]
		[ClientOnlyPatch]
		[HarmonyPriority(-10000)]
		private static class Humanoid_SetupVisEquipment_Patch
		{
			[UsedImplicitly]
			[HarmonyPriority(-6000)]
			private static void Postfix(Humanoid __instance, VisEquipment visEq, bool isRagdoll)
			{
				Player val = (Player)(Object.op_Implicit((Object)(object)ZNetScene.instance) ? ((object)Player.m_localPlayer) : ((object)((__instance is Player) ? __instance : null)));
				if (!((Object)(object)__instance != (Object)(object)val || isRagdoll) && Object.op_Implicit((Object)(object)ZNetScene.instance) && Object.op_Implicit((Object)(object)((Character)val).m_nview) && ((Character)val).m_nview.IsValid() && ((Character)val).m_nview.IsOwner())
				{
					Enchantment_VFX.InsertColor(((Character)val).m_nview.m_zdo, "VES_leftitemColor", Enchantment_VFX.GetItemEnchantmentColor(((Humanoid)val).m_leftItem, out var variant), variant);
					Enchantment_VFX.InsertColor(((Character)val).m_nview.m_zdo, "VES_rightitemColor", Enchantment_VFX.GetItemEnchantmentColor(((Humanoid)val).m_rightItem, out var variant2), variant2);
					Enchantment_VFX.InsertColor(((Character)val).m_nview.m_zdo, "VES_leftbackitemColor", Enchantment_VFX.GetItemEnchantmentColor(((Humanoid)val).m_hiddenLeftItem, out var variant3), variant3);
					Enchantment_VFX.InsertColor(((Character)val).m_nview.m_zdo, "VES_rightbackitemColor", Enchantment_VFX.GetItemEnchantmentColor(((Humanoid)val).m_hiddenRightItem, out var variant4), variant4);
					Enchantment_VFX.InsertColor(((Character)val).m_nview.m_zdo, "VES_chestitemColor", Enchantment_VFX.GetItemEnchantmentColor(((Humanoid)val).m_chestItem, out var variant5), variant5);
					Enchantment_VFX.InsertColor(((Character)val).m_nview.m_zdo, "VES_legsitemColor", Enchantment_VFX.GetItemEnchantmentColor(((Humanoid)val).m_legItem, out var variant6), variant6);
					Enchantment_VFX.InsertColor(((Character)val).m_nview.m_zdo, "VES_helmetitemColor", Enchantment_VFX.GetItemEnchantmentColor(((Humanoid)val).m_helmetItem, out var variant7), variant7);
					Enchantment_VFX.InsertColor(((Character)val).m_nview.m_zdo, "VES_shoulderitemColor", Enchantment_VFX.GetItemEnchantmentColor(((Humanoid)val).m_shoulderItem, out var variant8), variant8);
				}
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetLeftHandEquipped")]
		[ClientOnlyPatch]
		private static class VisEquipment_SetLeftHandEquipped_Patch
		{
			private static readonly HashSet<int> PendingInstances = new HashSet<int>();

			[UsedImplicitly]
			private static void Prefix(VisEquipment __instance, int hash)
			{
				if (__instance.m_currentLeftItemHash != hash)
				{
					PendingInstances.Add(((Object)__instance).GetInstanceID());
				}
			}

			[UsedImplicitly]
			private static void Postfix(VisEquipment __instance)
			{
				if (PendingInstances.Remove(((Object)__instance).GetInstanceID()) && Object.op_Implicit((Object)(object)__instance.m_nview) && __instance.m_nview.m_zdo != null)
				{
					ScheduleVisEquipmentRefresh(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetRightHandEquipped")]
		[ClientOnlyPatch]
		private static class VisEquipment_SetRightHandEquipped_Patch
		{
			private static readonly HashSet<int> PendingInstances = new HashSet<int>();

			[UsedImplicitly]
			private static void Prefix(VisEquipment __instance, int hash)
			{
				if (__instance.m_currentRightItemHash != hash)
				{
					PendingInstances.Add(((Object)__instance).GetInstanceID());
				}
			}

			[UsedImplicitly]
			private static void Postfix(VisEquipment __instance)
			{
				if (PendingInstances.Remove(((Object)__instance).GetInstanceID()) && Object.op_Implicit((Object)(object)__instance.m_nview) && __instance.m_nview.m_zdo != null)
				{
					ScheduleVisEquipmentRefresh(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetBackEquipped")]
		[ClientOnlyPatch]
		private static class VisEquipment_SetBackEquipped_Patch
		{
			private static readonly HashSet<int> PendingInstances = new HashSet<int>();

			[UsedImplicitly]
			private static void Prefix(VisEquipment __instance, int leftItem, int rightItem, int leftVariant)
			{
				if (__instance.m_currentLeftBackItemHash != leftItem || __instance.m_currentRightBackItemHash != rightItem)
				{
					PendingInstances.Add(((Object)__instance).GetInstanceID());
				}
			}

			[UsedImplicitly]
			private static void Postfix(VisEquipment __instance)
			{
				if (PendingInstances.Remove(((Object)__instance).GetInstanceID()) && Object.op_Implicit((Object)(object)__instance.m_nview) && __instance.m_nview.m_zdo != null)
				{
					ScheduleVisEquipmentRefresh(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetChestEquipped")]
		[ClientOnlyPatch]
		private static class VisEquipment_SetChestEquipped_Patch
		{
			private static readonly HashSet<int> PendingInstances = new HashSet<int>();

			[UsedImplicitly]
			private static void Prefix(VisEquipment __instance, int hash)
			{
				if (__instance.m_currentChestItemHash != hash && Enchantment_VFX.IsArmorVfxEnabled())
				{
					PendingInstances.Add(((Object)__instance).GetInstanceID());
				}
			}

			[UsedImplicitly]
			private static void Postfix(VisEquipment __instance)
			{
				if (PendingInstances.Remove(((Object)__instance).GetInstanceID()) && Object.op_Implicit((Object)(object)__instance.m_nview) && __instance.m_nview.m_zdo != null)
				{
					ScheduleVisEquipmentRefresh(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetLegEquipped")]
		[ClientOnlyPatch]
		private static class VisEquipment_SetLegEquipped_Patch
		{
			private static readonly HashSet<int> PendingInstances = new HashSet<int>();

			[UsedImplicitly]
			private static void Prefix(VisEquipment __instance, int hash)
			{
				if (__instance.m_currentLegItemHash != hash && Enchantment_VFX.IsArmorVfxEnabled())
				{
					PendingInstances.Add(((Object)__instance).GetInstanceID());
				}
			}

			[UsedImplicitly]
			private static void Postfix(VisEquipment __instance)
			{
				if (PendingInstances.Remove(((Object)__instance).GetInstanceID()) && Object.op_Implicit((Object)(object)__instance.m_nview) && __instance.m_nview.m_zdo != null)
				{
					ScheduleVisEquipmentRefresh(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetShoulderEquipped")]
		[ClientOnlyPatch]
		private static class VisEquipment_SetShoulderEquipped_Patch
		{
			private static readonly HashSet<int> PendingInstances = new HashSet<int>();

			[UsedImplicitly]
			private static void Prefix(VisEquipment __instance, int hash)
			{
				if (__instance.m_currentShoulderItemHash != hash && Enchantment_VFX.IsArmorVfxEnabled())
				{
					PendingInstances.Add(((Object)__instance).GetInstanceID());
				}
			}

			[UsedImplicitly]
			private static void Postfix(VisEquipment __instance)
			{
				if (PendingInstances.Remove(((Object)__instance).GetInstanceID()) && Object.op_Implicit((Object)(object)__instance.m_nview) && __instance.m_nview.m_zdo != null)
				{
					ScheduleVisEquipmentRefresh(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetHelmetEquipped")]
		[ClientOnlyPatch]
		private static class VisEquipment_SetHelmetEquipped_Patch
		{
			private static readonly HashSet<int> PendingInstances = new HashSet<int>();

			[UsedImplicitly]
			private static void Prefix(VisEquipment __instance, int hash)
			{
				if (__instance.m_currentHelmetItemHash != hash && Enchantment_VFX.IsArmorVfxEnabled())
				{
					PendingInstances.Add(((Object)__instance).GetInstanceID());
				}
			}

			[UsedImplicitly]
			private static void Postfix(VisEquipment __instance)
			{
				if (PendingInstances.Remove(((Object)__instance).GetInstanceID()) && Object.op_Implicit((Object)(object)__instance.m_nview) && __instance.m_nview.m_zdo != null)
				{
					ScheduleVisEquipmentRefresh(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(ItemDrop), "Start")]
		[ClientOnlyPatch]
		private static class ItemDrop_Start_Patch
		{
			[UsedImplicitly]
			private static void Postfix(ItemDrop __instance)
			{
				RefreshItemDropVisual(__instance);
			}
		}

		[HarmonyPatch(typeof(ItemStand), "SetVisualItem")]
		[ClientOnlyPatch]
		private static class ItemStand_SetVisualItem_Patch
		{
			[UsedImplicitly]
			private static void Prefix(ItemStand __instance, out bool __state, string itemName, int variant)
			{
				__state = __instance.m_visualName != itemName || __instance.m_visualVariant != variant;
			}

			[UsedImplicitly]
			private static void Postfix(ItemStand __instance, bool __state)
			{
				if (__state)
				{
					RefreshItemStandVisual(__instance);
				}
			}
		}

		private static readonly HashSet<int> ScheduledVisEquipmentRefreshes = new HashSet<int>();

		private static void RefreshEquipmentInstance(GameObject itemInstance, ZDO zdo, string colorKey, bool isArmor)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)itemInstance))
			{
				string text = ((zdo != null) ? zdo.GetString(colorKey, "") : null) ?? string.Empty;
				int variant = ((zdo != null) ? zdo.GetInt(colorKey + "_variant", 0) : 0);
				if (!Enchantment_VFX.IsEffectEnabledForClass(isArmor) || string.IsNullOrEmpty(text))
				{
					Enchantment_VFX.DisableMeshEffect(itemInstance, isArmor);
				}
				else
				{
					Enchantment_VFX.AttachMeshEffect(itemInstance, text.ToColorAlpha(), variant, isArmor);
				}
			}
		}

		private static void RefreshEquipmentInstances(IEnumerable<GameObject> itemInstances, ZDO zdo, string colorKey, bool isArmor)
		{
			if (itemInstances == null)
			{
				return;
			}
			foreach (GameObject itemInstance in itemInstances)
			{
				RefreshEquipmentInstance(itemInstance, zdo, colorKey, isArmor);
			}
		}

		private static void ScheduleVisEquipmentRefresh(VisEquipment visEquipment)
		{
			VisEquipment visEquipment2 = visEquipment;
			if (!Object.op_Implicit((Object)(object)visEquipment2))
			{
				return;
			}
			if ((Object)(object)ValheimEnchantmentSystem._thistype == (Object)null)
			{
				RefreshVisEquipment(visEquipment2);
				return;
			}
			int instanceId = ((Object)visEquipment2).GetInstanceID();
			if (!ScheduledVisEquipmentRefreshes.Add(instanceId))
			{
				return;
			}
			((MonoBehaviour)(object)ValheimEnchantmentSystem._thistype).DelayedInvoke(delegate
			{
				ScheduledVisEquipmentRefreshes.Remove(instanceId);
				if (Object.op_Implicit((Object)(object)visEquipment2))
				{
					RefreshVisEquipment(visEquipment2);
				}
			}, 1);
		}

		internal static void RefreshVisEquipment(VisEquipment visEquipment)
		{
			if (Object.op_Implicit((Object)(object)visEquipment))
			{
				ZDO zdo = visEquipment.m_nview?.m_zdo;
				RefreshEquipmentInstance(visEquipment.m_leftItemInstance, zdo, "VES_leftitemColor", isArmor: false);
				RefreshEquipmentInstance(visEquipment.m_rightItemInstance, zdo, "VES_rightitemColor", isArmor: false);
				RefreshEquipmentInstance(visEquipment.m_leftBackItemInstance, zdo, "VES_leftbackitemColor", isArmor: false);
				RefreshEquipmentInstance(visEquipment.m_rightBackItemInstance, zdo, "VES_rightbackitemColor", isArmor: false);
				RefreshEquipmentInstances(visEquipment.m_chestItemInstances, zdo, "VES_chestitemColor", isArmor: true);
				RefreshEquipmentInstances(visEquipment.m_legItemInstances, zdo, "VES_legsitemColor", isArmor: true);
				RefreshEquipmentInstances(visEquipment.m_shoulderItemInstances, zdo, "VES_shoulderitemColor", isArmor: true);
				RefreshEquipmentInstance(visEquipment.m_helmetItemInstance, zdo, "VES_helmetitemColor", isArmor: true);
			}
		}

		public static void RefreshItemDropVisual(ItemDrop itemDrop)
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)itemDrop == (Object)null)
			{
				return;
			}
			Enchantment_Core.Enchanted enchanted = itemDrop.m_itemData?.Data()?.Get<Enchantment_Core.Enchanted>();
			if (enchanted == null || enchanted.level <= 0)
			{
				Enchantment_VFX.DisableMeshEffect(((Component)itemDrop).gameObject, Enchantment_VFX.IsArmorVisual(itemDrop.m_itemData));
				return;
			}
			bool isArmor = Enchantment_VFX.IsArmorVisual(itemDrop.m_itemData);
			if (!Enchantment_VFX.IsEffectEnabledForClass(isArmor))
			{
				Enchantment_VFX.DisableMeshEffect(((Component)itemDrop).gameObject, isArmor);
				return;
			}
			string prefabName = Utils.GetPrefabName(((Component)itemDrop).gameObject);
			int variant;
			string color = SyncedData.GetColor(prefabName, enchanted.level, out variant, trimApha: false);
			Enchantment_VFX.AttachMeshEffect(((Component)itemDrop).gameObject, color.ToColorAlpha(), variant, isArmor);
		}

		public static void RefreshItemStandVisual(ItemStand itemStand)
		{
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)itemStand == (Object)null)
			{
				return;
			}
			if ((Object)(object)itemStand.m_nview == (Object)null || !itemStand.m_nview.IsValid() || !Object.op_Implicit((Object)(object)itemStand.m_visualItem))
			{
				if (Object.op_Implicit((Object)(object)itemStand.m_visualItem))
				{
					Enchantment_VFX.DisableMeshEffect(itemStand.m_visualItem);
				}
				return;
			}
			ZDO zDO = itemStand.m_nview.GetZDO();
			if (zDO == null)
			{
				Enchantment_VFX.DisableMeshEffect(itemStand.m_visualItem);
				return;
			}
			string @string = zDO.GetString(ZDOVars.s_item, "");
			if (string.IsNullOrEmpty(@string))
			{
				Enchantment_VFX.DisableMeshEffect(itemStand.m_visualItem);
				return;
			}
			GameObject val = (Object.op_Implicit((Object)(object)ObjectDB.instance) ? ObjectDB.instance.GetItemPrefab(@string) : null);
			if (!Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)ZNetScene.instance))
			{
				val = ZNetScene.instance.GetPrefab(@string);
			}
			if (!Object.op_Implicit((Object)(object)val))
			{
				Enchantment_VFX.DisableMeshEffect(itemStand.m_visualItem);
				return;
			}
			ItemDrop component = val.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null)
			{
				Enchantment_VFX.DisableMeshEffect(itemStand.m_visualItem);
				return;
			}
			ItemData val2 = component.m_itemData.Clone();
			ItemDrop.LoadFromZDO(val2, zDO);
			Enchantment_Core.Enchanted enchanted = val2.Data()?.Get<Enchantment_Core.Enchanted>();
			if (enchanted == null || enchanted.level <= 0)
			{
				Enchantment_VFX.DisableMeshEffect(itemStand.m_visualItem, Enchantment_VFX.IsArmorVisual(val2));
				return;
			}
			bool isArmor = Enchantment_VFX.IsArmorVisual(val2);
			if (!Enchantment_VFX.IsEffectEnabledForClass(isArmor))
			{
				Enchantment_VFX.DisableMeshEffect(itemStand.m_visualItem, isArmor);
				return;
			}
			int variant;
			string color = SyncedData.GetColor(@string, enchanted.level, out variant, trimApha: false);
			Enchantment_VFX.AttachMeshEffect(itemStand.m_visualItem, color.ToColorAlpha(), variant, isArmor);
		}

		public static void RefreshEquipmentVisuals()
		{
			if (ValheimEnchantmentSystem.NoGraphics)
			{
				return;
			}
			foreach (VisEquipment item in VfxInstanceRegistry.EnumerateVisEquipments())
			{
				if (!((Object)(object)((Component)item).GetComponentInParent<ArmorStand>() != (Object)null))
				{
					RefreshVisEquipment(item);
				}
			}
		}

		public static void RefreshWorldItemVisuals()
		{
			if (ValheimEnchantmentSystem.NoGraphics)
			{
				return;
			}
			foreach (ItemDrop item in VfxInstanceRegistry.EnumerateItemDrops())
			{
				RefreshItemDropVisual(item);
			}
			foreach (ItemStand item2 in VfxInstanceRegistry.EnumerateItemStands())
			{
				RefreshItemStandVisual(item2);
			}
		}
	}
	[VES_Autoload(VES_Autoload.Priority.Normal, "OnInit", new Type[] { typeof(SyncedData) })]
	internal static class EquippedEnchantmentSnapshotService
	{
		internal sealed class Snapshot
		{
			public int MaxHealthBonus;

			public int MaxStaminaBonus;

			public float MovementModifier;

			public float HealthRegen;

			public float StaminaRegen;

			public readonly List<DamageModPair> ResistancePairs = new List<DamageModPair>();

			public void Reset()
			{
				MaxHealthBonus = 0;
				MaxStaminaBonus = 0;
				MovementModifier = 0f;
				HealthRegen = 0f;
				StaminaRegen = 0f;
				ResistancePairs.Clear();
			}
		}

		private sealed class CacheEntry
		{
			public readonly WeakReference<Player> PlayerRef;

			public readonly Snapshot Snapshot = new Snapshot();

			public Inventory? Inventory;

			public bool Dirty = true;

			public int Revision = -1;

			public CacheEntry(Player player)
			{
				PlayerRef = new WeakReference<Player>(player);
				Inventory = ((Humanoid)player).m_inventory;
			}
		}

		private sealed class ReferenceComparer<T> : IEqualityComparer<T> where T : class
		{
			public static readonly ReferenceComparer<T> Instance = new ReferenceComparer<T>();

			public bool Equals(T? x, T? y)
			{
				return x == y;
			}

			public int GetHashCode(T obj)
			{
				return RuntimeHelpers.GetHashCode(obj);
			}
		}

		[HarmonyPatch(typeof(Player), "OnDestroy")]
		[ClientOnlyPatch]
		private static class Player_OnDestroy_Patch
		{
			[UsedImplicitly]
			private static void Prefix(Player __instance)
			{
				Unregister(__instance);
			}
		}

		private static readonly Snapshot EmptySnapshot = new Snapshot();

		private static readonly Dictionary<int, CacheEntry> EntriesByPlayerId = new Dictionary<int, CacheEntry>();

		private static readonly Dictionary<Inventory, HashSet<int>> PlayerIdsByInventory = new Dictionary<Inventory, HashSet<int>>(ReferenceComparer<Inventory>.Instance);

		private static int _globalRevision;

		private static bool _initialized;

		private static void OnInit()
		{
			if (!_initialized)
			{
				_initialized = true;
				SyncedData.Synced_EnchantmentStats_Weapons.ValueChanged += InvalidateAll;
				SyncedData.Synced_EnchantmentStats_Armor.ValueChanged += InvalidateAll;
				SyncedData.Overrides_EnchantmentStats.ValueChanged += InvalidateAll;
				EngineEvents.InventoryChanged += MarkDirty;
				EngineEvents.EquipmentChanged += MarkDirty;
				EngineEvents.MainMenuAwake += OnMainMenuAwake;
			}
		}

		internal static Snapshot GetSnapshot(Player? player)
		{
			if ((Object)(object)player == (Object)null || !Object.op_Implicit((Object)(object)player) || ((Humanoid)player).m_inventory == null)
			{
				return EmptySnapshot;
			}
			CacheEntry orCreateEntry = GetOrCreateEntry(player);
			if (orCreateEntry.Dirty || orCreateEntry.Revision != _globalRevision)
			{
				RebuildSnapshot(player, orCreateEntry);
			}
			return orCreateEntry.Snapshot;
		}

		internal static void MarkDirty(Player? player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				CacheEntry orCreateEntry = GetOrCreateEntry(player);
				orCreateEntry.Dirty = true;
			}
		}

		internal static void MarkDirty(Inventory? inventory)
		{
			if (inventory == null || !PlayerIdsByInventory.TryGetValue(inventory, out HashSet<int> value))
			{
				return;
			}
			int[] array = value.ToArray();
			foreach (int num in array)
			{
				Player player;
				if (!EntriesByPlayerId.TryGetValue(num, out CacheEntry value2))
				{
					value.Remove(num);
				}
				else if (!TryGetAlivePlayer(value2, out player))
				{
					RemoveEntry(num, value2);
					value.Remove(num);
				}
				else
				{
					value2.Dirty = true;
				}
			}
			if (value.Count == 0)
			{
				PlayerIdsByInventory.Remove(inventory);
			}
		}

		internal static void InvalidateAll()
		{
			_globalRevision++;
			PruneDeadEntries();
		}

		internal static void Unregister(Player? player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				int instanceID = ((Object)player).GetInstanceID();
				if (EntriesByPlayerId.TryGetValue(instanceID, out CacheEntry value))
				{
					RemoveEntry(instanceID, value);
				}
			}
		}

		private static CacheEntry GetOrCreateEntry(Player player)
		{
			int instanceID = ((Object)player).GetInstanceID();
			if (!EntriesByPlayerId.TryGetValue(instanceID, out CacheEntry value))
			{
				value = new CacheEntry(player);
				EntriesByPlayerId[instanceID] = value;
				BindInventory(instanceID, ((Humanoid)player).m_inventory);
				return value;
			}
			Inventory inventory = ((Humanoid)player).m_inventory;
			if (value.Inventory != inventory)
			{
				UnbindInventory(instanceID, value.Inventory);
				value.Inventory = inventory;
				BindInventory(instanceID, inventory);
				value.Dirty = true;
			}
			return value;
		}

		private static void RebuildSnapshot(Player player, CacheEntry entry)
		{
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			Snapshot snapshot = entry.Snapshot;
			snapshot.Reset();
			foreach (ItemData equippedItem in ((Humanoid)player).m_inventory.GetEquippedItems())
			{
				Enchantment_Core.Enchanted enchanted = equippedItem?.Data().Get<Enchantment_Core.Enchanted>();
				if (enchanted == null || enchanted.level <= 0)
				{
					continue;
				}
				SyncedData.Stat_Data stats = enchanted.Stats;
				if (stats == null)
				{
					continue;
				}
				snapshot.MaxHealthBonus += stats.max_hp;
				snapshot.MaxStaminaBonus += stats.max_stamina;
				snapshot.MovementModifier += (float)stats.movement_speed / 100f;
				snapshot.HealthRegen += stats.hp_regen;
				snapshot.StaminaRegen += stats.stamina_regen;
				foreach (DamageModPair resistancePair in stats.GetResistancePairs())
				{
					snapshot.ResistancePairs.Add(new DamageModPair
					{
						m_type = resistancePair.m_type,
						m_modifier = resistancePair.m_modifier
					});
				}
			}
			entry.Dirty = false;
			entry.Revision = _globalRevision;
		}

		private static void BindInventory(int playerId, Inventory? inventory)
		{
			if (inventory != null)
			{
				if (!PlayerIdsByInventory.TryGetValue(inventory, out HashSet<int> value))
				{
					value = new HashSet<int>();
					PlayerIdsByInventory[inventory] = value;
				}
				value.Add(playerId);
			}
		}

		private static void UnbindInventory(int playerId, Inventory? inventory)
		{
			if (inventory != null && PlayerIdsByInventory.TryGetValue(inventory, out HashSet<int> value))
			{
				value.Remove(playerId);
				if (value.Count == 0)
				{
					PlayerIdsByInventory.Remove(inventory);
				}
			}
		}

		private static bool TryGetAlivePlayer(CacheEntry entry, out Player? player)
		{
			if (!entry.PlayerRef.TryGetTarget(out player) || !Object.op_Implicit((Object)(object)player))
			{
				player = null;
				return false;
			}
			return true;
		}

		private static void PruneDeadEntries()
		{
			KeyValuePair<int, CacheEntry>[] array = EntriesByPlayerId.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				KeyValuePair<int, CacheEntry> keyValuePair = array[i];
				if (!TryGetAlivePlayer(keyValuePair.Value, out Player _))
				{
					RemoveEntry(keyValuePair.Key, keyValuePair.Value);
				}
			}
		}

		private static void RemoveEntry(int playerId, CacheEntry entry)
		{
			UnbindInventory(playerId, entry.Inventory);
			EntriesByPlayerId.Remove(playerId);
		}

		private static void ClearAll()
		{
			EntriesByPlayerId.Clear();
			PlayerIdsByInventory.Clear();
		}

		private static void OnMainMenuAwake(FejdStartup _)
		{
			ClearAll();
		}
	}
	[VES_Autoload(VES_Autoload.Priority.Normal, "OnInit", new Type[] { })]
	internal static class VfxInstanceRegistry
	{
		[HarmonyPatch(typeof(VisEquipment), "Awake")]
		[ClientOnlyPatch]
		private static class VisEquipment_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix(VisEquipment __instance)
			{
				Register(__instance);
			}
		}

		[HarmonyPatch(typeof(ItemStand), "Awake")]
		[ClientOnlyPatch]
		private static class ItemStand_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix(ItemStand __instance)
			{
				Register(__instance);
			}
		}

		[HarmonyPatch(typeof(ItemDrop), "Start")]
		[ClientOnlyPatch]
		private static class ItemDrop_Start_Patch
		{
			[UsedImplicitly]
			private static void Postfix(ItemDrop __instance)
			{
				Register(__instance);
			}
		}

		[HarmonyPatch(typeof(ArmorStand), "Awake")]
		[ClientOnlyPatch]
		private static class ArmorStand_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix(ArmorStand __instance)
			{
				Register(__instance);
			}
		}

		[HarmonyPatch]
		[ClientOnlyPatch]
		private static class VisEquipment_Unregister_Patch
		{
			private static readonly MethodBase? LifecycleMethod = FindUnregisterLifecycleMethod(typeof(VisEquipment));

			[UsedImplicitly]
			private static MethodBase? TargetMethod()
			{
				return LifecycleMethod;
			}

			[UsedImplicitly]
			private static bool Prepare()
			{
				return LifecycleMethod != null;
			}

			[UsedImplicitly]
			private static void Prefix(VisEquipment __instance)
			{
				Unregister(__instance);
			}
		}

		[HarmonyPatch]
		[ClientOnlyPatch]
		private static class ItemDrop_Unregister_Patch
		{
			private static readonly MethodBase? LifecycleMethod = FindUnregisterLifecycleMethod(typeof(ItemDrop));

			[UsedImplicitly]
			private static MethodBase? TargetMethod()
			{
				return LifecycleMethod;
			}

			[UsedImplicitly]
			private static bool Prepare()
			{
				return LifecycleMethod != null;
			}

			[UsedImplicitly]
			private static void Prefix(ItemDrop __instance)
			{
				Unregister(__instance);
			}
		}

		[HarmonyPatch]
		[ClientOnlyPatch]
		private static class ItemStand_Unregister_Patch
		{
			private static readonly MethodBase? LifecycleMethod = FindUnregisterLifecycleMethod(typeof(ItemStand));

			[UsedImplicitly]
			private static MethodBase? TargetMethod()
			{
				return LifecycleMethod;
			}

			[UsedImplicitly]
			private static bool Prepare()
			{
				return LifecycleMethod != null;
			}

			[UsedImplicitly]
			private static void Prefix(ItemStand __instance)
			{
				Unregister(__instance);
			}
		}

		[HarmonyPatch]
		[ClientOnlyPatch]
		private static class ArmorStand_Unregister_Patch
		{
			private static readonly MethodBase? LifecycleMethod = FindUnregisterLifecycleMethod(typeof(ArmorStand));

			[UsedImplicitly]
			private static MethodBase? TargetMethod()
			{
				return LifecycleMethod;
			}

			[UsedImplicitly]
			private static bool Prepare()
			{
				return LifecycleMethod != null;
			}

			[UsedImplicitly]
			private static void Prefix(ArmorStand __instance)
			{
				Unregister(__instance);
			}
		}

		[CompilerGenerated]
		private sealed class <EnumerateLiveInstances>d__21<T> : IEnumerable<T>, IEnumerable, IEnumerator<T>, IDisposable, IEnumerator where T : notnull, Component
		{
			private int <>1__state;

			private T <>2__current;

			private int <>l__initialThreadId;

			private Dictionary<int, T> instances;

			public Dictionary<int, T> <>3__instances;

			private KeyValuePair<int, T>[] <>7__wrap1;

			private int <>7__wrap2;

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

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

			[DebuggerHidden]
			public <EnumerateLiveInstances>d__21(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_0099;
				}
				<>1__state = -1;
				<>7__wrap1 = instances.ToArray();
				<>7__wrap2 = 0;
				goto IL_00a7;
				IL_0099:
				<>7__wrap2++;
				goto IL_00a7;
				IL_00a7:
				if (<>7__wrap2 < <>7__wrap1.Length)
				{
					KeyValuePair<int, T> keyValuePair = <>7__wrap1[<>7__wrap2];
					T value = keyValuePair.Value;
					if (!Object.op_Implicit((Object)(object)value))
					{
						instances.Remove(keyValuePair.Key);
					}
					else if (((Component)value).gameObject.activeInHierarchy)
					{
						<>2__current = value;
						<>1__state = 1;
						return true;
					}
					goto IL_0099;
				}
				<>7__wrap1 = null;
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<T> IEnumerable<T>.GetEnumerator()
			{
				<EnumerateLiveInstances>d__21<T> <EnumerateLiveInstances>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<EnumerateLiveInstances>d__ = this;
				}
				else
				{
					<EnumerateLiveInstances>d__ = new <EnumerateLiveInstances>d__21<T>(0);
				}
				<EnumerateLiveInstances>d__.instances = <>3__instances;
				return <EnumerateLiveInstances>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<T>)this).GetEnumerator();
			}
		}

		private static readonly Dictionary<int, VisEquipment> VisEquipments = new Dictionary<int, VisEquipment>();

		private static readonly Dictionary<int, ItemDrop> ItemDrops = new Dictionary<int, ItemDrop>();

		private static readonly Dictionary<int, ItemStand> ItemStands = new Dictionary<int, ItemStand>();

		private static readonly Dictionary<int, ArmorStand> ArmorStands = new Dictionary<int, ArmorStand>();

		private static bool _initialized;

		private static void OnInit()
		{
			if (!_initialized)
			{
				_initialized = true;
				EngineEvents.MainMenuAwake += OnMainMenuAwake;
				EngineEvents.WorldAwake += ClearAll;
			}
		}

		public static void Register(VisEquipment? visEquipment)
		{
			RegisterInstance<VisEquipment>(VisEquipments, visEquipment);
		}

		public static void Register(ItemDrop? itemDrop)
		{
			RegisterInstance<ItemDrop>(ItemDrops, itemDrop);
		}

		public static void Register(ItemStand? itemStand)
		{
			RegisterInstance<ItemStand>(ItemStands, itemStand);
		}

		public static void Register(ArmorStand? armorStand)
		{
			RegisterInstance<ArmorStand>(ArmorStands, armorStand);
		}

		public static void Unregister(VisEquipment? visEquipment)
		{
			UnregisterInstance<VisEquipment>(VisEquipments, visEquipment);
		}

		public static void Unregister(ItemDrop? itemDrop)
		{
			UnregisterInstance<ItemDrop>(ItemDrops, itemDrop);
		}

		public static void Unregister(ItemStand? itemStand)
		{
			UnregisterInstance<ItemStand>(ItemStands, itemStand);
		}

		public static void Unregister(ArmorStand? armorStand)
		{
			UnregisterInstance<ArmorStand>(ArmorStands, armorStand);
		}

		public static IEnumerable<VisEquipment> EnumerateVisEquipments()
		{
			return EnumerateLiveInstances<VisEquipment>(VisEquipments);
		}

		public static IEnumerable<ItemDrop> EnumerateItemDrops()
		{
			return EnumerateLiveInstances<ItemDrop>(ItemDrops);
		}

		public static IEnumerable<ItemStand> EnumerateItemStands()
		{
			return EnumerateLiveInstances<ItemStand>(ItemStands);
		}

		public static IEnumerable<ArmorStand> EnumerateArmorStands()
		{
			return EnumerateLiveInstances<ArmorStand>(ArmorStands);
		}

		public static void ClearAll()
		{
			VisEquipments.Clear();
			ItemDrops.Clear();
			ItemStands.Clear();
			ArmorStands.Clear();
		}

		private static void RegisterInstance<T>(Dictionary<int, T> instances, T? instance) where T : Component
		{
			if (Object.op_Implicit((Object)(object)instance))
			{
				instances[((Object)(object)instance).GetInstanceID()] = instance;
			}
		}

		private static void UnregisterInstance<T>(Dictionary<int, T> instances, T? instance) where T : Component
		{
			if (Object.op_Implicit((Object)(object)instance))
			{
				instances.Remove(((Object)(object)instance).GetInstanceID());
			}
		}

		[IteratorStateMachine(typeof(<EnumerateLiveInstances>d__21<>))]
		private static IEnumerable<T> EnumerateLiveInstances<T>(Dictionary<int, T> instances) where T : Component
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnumerateLiveInstances>d__21<T>(-2)
			{
				<>3__instances = instances
			};
		}

		private static void OnMainMenuAwake(FejdStartup _)
		{
			ClearAll();
		}

		private static MethodInfo? FindDeclaredLifecycleMethod(Type componentType, string methodName)
		{
			return componentType.GetMethod(methodName, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
		}

		private static MethodBase? FindUnregisterLifecycleMethod(Type componentType)
		{
			return FindDeclaredLifecycleMethod(componentType, "OnDestroy") ?? FindDeclaredLifecycleMethod(componentType, "OnDisable");
		}
	}
	internal static class PatchRegistry
	{
		private sealed class PatchDescriptor
		{
			public readonly string Name;

			public readonly Type RootType;

			public readonly IReadOnlyList<Type> PatchTypes;

			public readonly string[] RequiredPlugins;

			public PatchDescriptor(Type rootType, IReadOnlyList<Type> patchTypes, string[] requiredPlugins)
			{
				RootType = rootType;
				PatchTypes = patchTypes;
				RequiredPlugins = requiredPlugins ?? Array.Empty<string>();
				Name = rootType.FullName ?? rootType.Name;
			}
		}

		[CompilerGenerated]
		private sealed class <DiscoverPatchDescriptors>d__2 : IEnumerable<PatchDescriptor>, IEnumerable, IEnumerator<PatchDescriptor>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private PatchDescriptor <>2__current;

			private int <>l__initialThreadId;

			private IEnumerator<Type> <>7__wrap1;

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

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

			[DebuggerHidden]
			public <DiscoverPatchDescriptors>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						IEnumerable<Type> enumerable = ValheimEnchantmentSystem.GetAssemblyTypes().Select(ValheimEnchantmentSystem.GetTopLevelDeclaringType).Distinct()
							.OrderBy<Type, string>((Type rootType) => rootType.FullName, StringComparer.Ordinal);
						<>7__wrap1 = enumerable.GetEnumerator();
						<>1__state = -3;
						break;
					}
					case 1:
						<>1__state = -3;
						break;
					}
					while (<>7__wrap1.MoveNext())
					{
						Type current = <>7__wrap1.Current;
						List<Type> list = (from type in EnumerateTypeTree(current)
							where type.GetCustomAttributes(typeof(HarmonyPatch), inherit: false).Length != 0
							select type).OrderBy<Type, string>((Type type) => type.FullName, StringComparer.Ordinal).ToList();
						if (list.Count != 0)
						{
							string[] requiredPlugins = (from VES_RequiresPlugin attribute in current.GetCustomAttributes(typeof(VES_RequiresPlugin), inherit: false)
								select attribute.PluginGuid into pluginGuid
								where !string.IsNullOrWhiteSpace(pluginGuid)
								select pluginGuid).Distinct<string>(StringComparer.Ordinal).ToArray();
							<>2__current = new PatchDescriptor(current, list, requiredPlugins);
							<>1__state = 1;
							return true;
						}
					}
					<>m__Finally1();
					<>7__wrap1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<PatchDescriptor> IEnumerable<PatchDescriptor>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <DiscoverPatchDescriptors>d__2(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<PatchDescriptor>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <EnumerateTypeTree>d__3 : IEnumerable<Type>, IEnumerable, IEnumerator<Type>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private Type <>2__current;

			private int <>l__initialThreadId;

			private Type type;

			public Type <>3__type;

			private Type[] <>7__wrap1;

			private int <>7__wrap2;

			private IEnumerator<Type> <>7__wrap3;

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

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

			[DebuggerHidden]
			public <EnumerateTypeTree>d__3(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = null;
				<>7__wrap3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = this.type;
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<>7__wrap1 = this.type.GetNestedTypes(BindingFlags.Public | BindingFlags.NonPublic);
						<>7__wrap2 = 0;
						goto IL_00db;
					case 2:
						{
							<>1__state = -3;
							goto IL_00b3;
						}
						IL_00db:
						if (<>7__wrap2 < <>7__wrap1.Length)
						{
							Type type = <>7__wrap1[<>7__wrap2];
							<>7__wrap3 = EnumerateTypeTree(type).GetEnumerator();
							<>1__state = -3;
							goto IL_00b3;
						}
						<>7__wrap1 = null;
						return false;
						IL_00b3:
						if (<>7__wrap3.MoveNext())
						{
							Type current = <>7__wrap3.Current;
							<>2__current = current;
							<>1__state = 2;
							return true;
						}
						<>m__Finally1();
						<>7__wrap3 = null;
						<>7__wrap2++;
						goto IL_00db;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap3 != null)
				{
					<>7__wrap3.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<Type> IEnumerable<Type>.GetEnumerator()
			{
				<EnumerateTypeTree>d__3 <EnumerateTypeTree>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<EnumerateTypeTree>d__ = this;
				}
				else
				{
					<EnumerateTypeTree>d__ = new <EnumerateTypeTree>d__3(0);
				}
				<EnumerateTypeTree>d__.type = <>3__type;
				return <EnumerateTypeTree>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<Type>)this).GetEnumerator();
			}
		}

		public static void Apply(Harmony harmony, ManualLogSource logger, bool isServerRuntime, ISet<Type> failedAutoloadTypes)
		{
			HashSet<Type> hashSet = new HashSet<Type>();
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			foreach (PatchDescriptor item in DiscoverPatchDescriptors())
			{
				if (ValheimEnchantmentSystem.IsTypeBlockedByAutoloadFailure(item.RootType, failedAutoloadTypes))
				{
					num2 += item.PatchTypes.Count;
					continue;
				}
				string[] array = item.RequiredPlugins.Where((string pluginGuid) => !Chainloader.PluginInfos.ContainsKey(pluginGuid)).ToArray();
				if (array.Length != 0)
				{
					num2 += item.PatchTypes.Count;
					logger.LogDebug((object)("Skipped Harmony patch root '" + item.Name + "': missing plugin(s) " + string.Join(", ", array)));
					continue;
				}
				foreach (Type patchType in item.PatchTypes)
				{
					if (!hashSet.Add(patchType))
					{
						continue;
					}
					if (isServerRuntime && patchType.GetCustomAttribute<ClientOnlyPatch>() != null)
					{
						num2++;
						continue;
					}
					if (!isServerRuntime && patchType.GetCustomAttribute<ServerOnlyPatch>() != null)
					{
						num2++;
						continue;
					}
					try
					{
						harmony.CreateClassProcessor(patchType).Patch();
						num++;
					}
					catch (Exception ex)
					{
						num3++;
						logger.LogWarning((object)("Skipped Harmony patch '" + patchType.FullName + "' in root '" + item.Name + "': " + ex.Message));
						logger.LogDebug((object)ex);
					}
				}
			}
			logger.LogInfo((object)$"Harmony patch discovery applied. patched={num}, skipped={num2}, failed={num3}");
		}

		[IteratorStateMachine(typeof(<DiscoverPatchDescriptors>d__2))]
		private static IEnumerable<PatchDescriptor> DiscoverPatchDescriptors()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DiscoverPatchDescriptors>d__2(-2);
		}

		[IteratorStateMachine(typeof(<EnumerateTypeTree>d__3))]
		private static IEnumerable<Type> EnumerateTypeTree(Type type)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnumerateTypeTree>d__3(-2)
			{
				<>3__type = type
			};
		}
	}
	[VES_Autoload(VES_Autoload.Priority.Normal, "OnInit", new Type[] { typeof(SyncedData) })]
	internal static class InventoryOverlayVfx
	{
		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public int? Order;
		}

		[HarmonyPatch(typeof(InventoryGrid), "Awake")]
		[ClientOnlyPatch]
		private static class InventoryGrid_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix(InventoryGrid __instance)
			{
				EnsureOverlayTemplate(__instance.m_elementPrefab);
				BindScrollVisibilityUpdates(__instance);
			}
		}

		[HarmonyPatch(typeof(Hud), "Awake")]
		[ClientOnlyPatch]
		private static class Hud_Awake_Patch
		{
			internal static HotkeyBar? BarRef;

			[UsedImplicitly]
			private static void Postfix(Hud __instance)
			{
				Transform obj = __instance.m_rootObject.transform.Find("HotKeyBar");
				BarRef = ((obj != null) ? ((Component)obj).GetComponent<HotkeyBar>() : null);
				if (!((Object)(object)BarRef == (Object)null))
				{
					EnsureOverlayTemplate(BarRef.m_elementPrefab);
				}
			}
		}

		[HarmonyPatch(typeof(HotkeyBar), "UpdateIcons")]
		[ClientOnlyPatch]
		private static class HotkeyBar_UpdateIcons_Patch
		{
			internal static int _needUpdateFrame = -1;

			[UsedImplicitly]
			private static void Postfix(HotkeyBar __instance)
			{
				//IL_012c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: Unknown result type (might be due to invalid IL or missing references)
				//IL_0177: Unknown result type (might be due to invalid IL or missing references)
				//IL_0190: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance != (Object)(object)Hud_Awake_Patch.BarRef || !Object.op_Implicit((Object)(object)Player.m_localPlayer) || ((Character)Player.m_localPlayer).IsDead() || _needUpdateFrame != Time.frameCount)
				{
					return;
				}
				foreach (ElementData item in __instance.m_elements.Where((ElementData element) => !element.m_used))
				{
					((Component)item.m_go.transform.Find("VES_Level")).gameObject.SetActive(false);
				}
				foreach (ItemData item2 in __instance.m_items)
				{
					ElementData val = __instance.m_elements[item2.m_gridPos.x];
					Transform val2 = val.m_go.transform.Find("VES_Level");
					Enchantment_Core.Enchanted enchanted = item2.Data().Get<Enchantment_Core.Enchanted>();
					if ((bool)enchanted && enchanted.level > 0)
					{
						((Component)val2).gameObject.SetActive(true);
						int variant;
						Color color = SyncedData.GetColor(enchanted, out variant, trimApha: true).ToColorAlpha().IncreaseColorLight();
						((Component)((Component)val2).transform.GetChild(0)).GetComponent<TMP_Text>().text = "+" + enchanted.level;
						((Graphic)((Component)((Component)val2).transform.GetChild(0)).GetComponent<TMP_Text>()).color = color;
						((Graphic)((Component)((Component)val2).transform.GetChild(1)).GetComponent<Image>()).color = color;
						((Component)((Component)val2).transform.GetChild(1)).gameObject.SetActive(IsInventoryVisualEnabled());
					}
					else
					{
						((Component)val2).gameObject.SetActive(false);
					}
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGrid), "UpdateGui")]
		[ClientOnlyPatch]
		private static class InventoryGrid_UpdateGui_Patch
		{
			internal static int _needUpdateFrame = -1;

			[UsedImplicitly]
			private static void Postfix(InventoryGrid __instance)
			{
				if (_needUpdateFrame == Time.frameCount)
				{
					ApplyInventoryGridVisuals(__instance, updateContent: true);
				}
			}
		}

		private const int EnableInventoryVisualOrder = 104;

		private static readonly HashSet<GameObject> InitializedElementPrefabs = new HashSet<GameObject>();

		private static readonly HashSet<int> BoundScrollGrids = new HashSet<int>();

		private static GameObject? _hotbarPartPrefab;

		private static ConfigEntry<bool>? _enableInventoryVisual;

		private static bool _menuFontConfigured;

		private static ConfigDescription OrderedDescription(string description, int order)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			return new ConfigDescription(description, (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = order
				}
			});
		}

		[UsedImplicitly]
		private static void OnInit()
		{
			if (!ValheimEnchantmentSystem.NoGraphics)
			{
				_hotbarPartPrefab = ValheimEnchantmentSystem._asset.LoadAsset<GameObject>("Enchantment_HotbarPart");
				_enableInventoryVisual = ValheimEnchantmentSystem.ClientConfig("", "EnableInventoryVisual", value: true, OrderedDescription("Enable inventory and hotbar enchant visuals.", 104));
				_enableInventoryVisual.SettingChanged += delegate
				{
					UpdateGrid();
				};
				EngineEvents.InventoryChanged += OnInventoryChanged;
				EngineEvents.EquipmentChanged += OnEquipmentChanged;
				EngineEvents.InventoryGuiShown += UpdateGrid;
				EngineEvents.MainMenuAwake += OnMainMenuAwake;
			}
		}

		private static bool IsInventoryVisualEnabled()
		{
			return _enableInventoryVisual?.Value ?? true;
		}

		private static RectTransform? GetInventoryViewport(InventoryGrid grid)
		{
			if (!Object.op_Implicit((Object)(object)grid))
			{
				return null;
			}
			ScrollRect componentInParent = ((Component)grid).GetComponentInParent<ScrollRect>();
			if (!Object.op_Implicit((Object)(object)componentInParent))
			{
				return null;
			}
			if (!Object.op_Implicit((Object)(object)componentInParent.viewport))
			{
				return ((Component)componentInParent).GetComponent<RectTransform>();
			}
			return componentInParent.viewport;
		}

		private static bool IsGridElementVisible(Element element, RectTransform? viewport)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)viewport == (Object)null || (Object)(object)element.m_go == (Object)null)
			{
				return true;
			}
			RectTransform component = element.m_go.GetComponent<RectTransform>();
			if (!Object.op_Implicit((Object)(object)component) || !element.m_go.activeInHierarchy)
			{
				return false;
			}
			Bounds val = RectTransformUtility.CalculateRelativeRectTransformBounds((Transform)(object)viewport, (Transform)(object)component);
			Rect rect = viewport.rect;
			if (((Bounds)(ref val)).max.x > ((Rect)(ref rect)).xMin && ((Bounds)(ref val)).min.x < ((Rect)(ref rect)).xMax && ((Bounds)(ref val)).max.y > ((Rect)(ref rect)).yMin)
			{
				return ((Bounds)(ref val)).min.y < ((Rect)(ref rect)).yMax;
			}
			return false;
		}

		private static void EnsureOverlayTemplate(GameObject? elementPrefab)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)elementPrefab == (Object)null) && !((Object)(object)_hotbarPartPrefab == (Object)null) && !InitializedElementPrefabs.Contains(elementPrefab))
			{
				InitializedElementPrefabs.Add(elementPrefab);
				Transform transform = elementPrefab.transform;
				GameObject val = Object.Instantiate<GameObject>(_hotbarPartPrefab);
				val.transform.SetParent(transform, false);
				((Object)val).name = "VES_Level";
				val.GetComponent<RectTransform>().anchoredPosition = Vector2.zero;
				val.SetActive(false);
			}
		}

		private static void BindScrollVisibilityUpdates(InventoryGrid grid)
		{
			InventoryGrid grid2 = grid;
			if (!Object.op_Implicit((Object)(object)grid2))
			{
				return;
			}
			int instanceID = ((Object)grid2).GetInstanceID();
			if (!BoundScrollGrids.Add(instanceID))
			{
				return;
			}
			ScrollRect componentInParent = ((Component)grid2).GetComponentInParent<ScrollRect>();
			if (Object.op_Implicit((Object)(object)componentInParent))
			{
				((UnityEvent<Vector2>)(object)componentInParent.onValueChanged).AddListener((UnityAction<Vector2>)delegate
				{
					ApplyInventoryGridVisuals(grid2, updateContent: false);
				});
			}
		}

		private static void ApplyInventoryGridVisuals(InventoryGrid grid, bool updateContent)
		{
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)grid) || grid.m_inventory == null || grid.m_elements == null)
			{
				return;
			}
			RectTransform inventoryViewport = GetInventoryViewport(grid);
			int width = grid.m_inventory.GetWidth();
			foreach (Element element2 in grid.m_elements)
			{
				if (!((Object)(object)element2?.m_go == (Object)null))
				{
					Transform val = element2.m_go.transform.Find("VES_Level");
					if (!((Object)(object)val == (Object)null) && (!element2.m_used || !IsGridElementVisible(element2, inventoryViewport)))
					{
						((Component)val).gameObject.SetActive(false);
					}
				}
			}
			foreach (ItemData allItem in grid.m_inventory.GetAllItems())
			{
				Element element = grid.GetElement(allItem.m_gridPos.x, allItem.m_gridPos.y, width);
				if ((Object)(object)element?.m_go == (Object)null)
				{
					continue;
				}
				Transform val2 = element.m_go.transform.Find("VES_Level");
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				Enchantment_Core.Enchanted enchanted = allItem.Data().Get<Enchantment_Core.Enchanted>();
				bool flag = IsGridElementVisible(element, inventoryViewport);
				if (!enchanted || enchanted.level <= 0 || !flag)
				{
					((Component)val2).gameObject.SetActive(false);
					continue;
				}
				((Component)val2).gameObject.SetActive(true);
				if (updateContent)
				{
					int variant;
					Color color = SyncedData.GetColor(enchanted, out variant, trimApha: true).ToColorAlpha().IncreaseColorLight();
					((Component)((Component)val2).transform.GetChild(0)).GetComponent<TMP_Text>().text = "+" + enchanted.level;
					((Graphic)((Component)((Component)val2).transform.GetChild(0)).GetComponent<TMP_Text>()).color = color;
					((Graphic)((Component)((Component)val2).transform.GetChild(1)).GetComponent<Image>()).color = color;
				}
				((Component)((Component)val2).transform.GetChild(1)).gameObject.SetActive(IsInventoryVisualEnabled());
			}
		}

		public static void UpdateGrid()
		{
			if (!ValheimEnchantmentSystem.NoGraphics)
			{
				HotkeyBar_UpdateIcons_Patch._needUpdateFrame = Time.frameCount + 1;
				InventoryGrid_UpdateGui_Patch._needUpdateFrame = Time.frameCount + 1;
			}
		}

		private static void OnInventoryChanged(Inventory inventory)
		{
			if (inventory == ((Humanoid)(Player.m_localPlayer?)).m_inventory)
			{
				UpdateGrid();
			}
		}

		private static void OnEquipmentChanged(Player player)
		{
			if (!((Object)(object)player != (Object)(object)Player.m_localPlayer))
			{
				UpdateGrid();
			}
		}

		private static void OnMainMenuAwake(FejdStartup startup)
		{
			if (!_menuFontConfigured && !((Object)(object)_hotbarPartPrefab == (Object)null))
			{
				_menuFontConfigured = true;
				Transform obj = ((Component)startup).transform.Find("StartGame/Panel/JoinPanel/serverCount");
				TextMeshProUGUI val = ((obj != null) ? ((Component)obj).GetComponent<TextMeshProUGUI>() : null);
				if (val != null)
				{
					TextMeshProUGUI component = ((Component)_hotbarPartPrefab.transform.GetChild(0)).GetComponent<TextMeshProUGUI>();
					((TMP_Text)component).font = ((TMP_Text)val).font;
					AccessTools.Field(typeof(TextMeshProUGUI), "m_canvasRenderer").SetValue(component, ((Component)component).GetComponent<CanvasRenderer>());
					((TMP_Text)component).outlineWidth = 0.15f;
				}
			}
		}
	}
	public static class TerminalCommands
	{
		[HarmonyPatch(typeof(Terminal), "InitTerminal")]
		private static class Terminal_InitTerminal_ConfigReload_Patch
		{
			[Serializable]
			[CompilerGenerated]
			private sealed class <>c
			{
				public static readonly <>c <>9 = new <>c();

				public static ConsoleEvent <>9__0_0;

				internal void <Postfix>b__0_0(ConsoleEventArgs args)
				{
					string target = ((args.Length > 1) ? args[1] : "all");
					string message;
					bool flag = ConfigHotReloadRegistrar.TryReload(target, out message);
					ConfigReloadPoller.ResetSnapshots();
					WriteCommandMessage(flag ? message : ("Reload request completed with issues: " + message));
				}
			}

			[UsedImplicitly]
			private static void Postfix(Terminal __instance)
			{
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Expected O, but got Unknown
				string usage = ConfigHotReloadRegistrar.Usage;
				object obj = <>c.<>9__0_0;
				if (obj == null)
				{
					ConsoleEvent val = delegate(ConsoleEventArgs args)
					{
						string target = ((args.Length > 1) ? args[1] : "all");
						string message;
						bool flag = ConfigHotReloadRegistrar.TryReload(target, out message);
						ConfigReloadPoller.ResetSnapshots();
						WriteCommandMessage(flag ? message : ("Reload request completed with issues: " + message));
					};
					<>c.<>9__0_0 = val;
					obj = (object)val;
				}
				new ConsoleCommand("ves_reloadconfig", usage, (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			}
		}

		[HarmonyPatch(typeof(Terminal), "InitTerminal")]
		[ClientOnlyPatch]
		private static class Terminal_InitTerminal_Patch
		{
			[Serializable]
			[CompilerGenerated]
			private sealed class <>c
			{
				public static readonly <>c <>9 = new <>c();

				public static ConsoleEvent <>9__0_0;

				public static Func<ItemData, bool> <>9__0_2;

				public static ConsoleEvent <>9__0_1;

				internal void <Postfix>b__0_0(ConsoleEventArgs args)
				{
					if (Utils.IsDebug_Strict)
					{
						int level = int.Parse(args[1]);
						ItemData currentWeapon = ((Humanoid)Player.m_localPlayer).GetCurrentWeapon();
						if (currentWeapon != null && Object.op_Implicit((Object)(object)currentWeapon.m_dropPrefab))
						{
							Enchantment_Core.Enchanted orCreate = currentWeapon.Data().GetOrCreate<Enchantment_Core.Enchanted>();
							orCreate.level = level;
							orCreate.Save();
							EnchantmentSideEffects.ApplyStateChanged(orCreate, refreshEquipment: true);
							WriteCommandMessage("Enchantment level set to " + level);
						}
					}
				}

				internal void <Postfix>b__0_1(ConsoleEventArgs args)
				{
					if (!Utils.IsDebug_Strict)
					{
						return;
					}
					int level = int.Parse(args[1]);
					foreach (ItemData item in ((Humanoid)Player.m_localPlayer).m_inventory.m_inventory.Where(delegate(ItemData x)
					{
						GameObject dropPrefab = x.m_dropPrefab;
						return SyncedData.GetReqs((dropPrefab != null) ? ((Object)dropPrefab).name : null) != null;
					}))
					{
						Enchantment_Core.Enchanted orCreate = item.Data().GetOrCreate<Enchantment_Core.Enchanted>();
						orCreate.level = level;
						orCreate.Save();
					}
					Enchantment_VFX.UpdateGrid();
				}

				internal bool <Postfix>b__0_2(ItemData x)
				{
					GameObject dropPrefab = x.m_dropPrefab;
					return SyncedData.GetReqs((dropPrefab != null) ? ((Object)dropPrefab).name : null) != null;
				}
			}

			[UsedImplicitly]
			private static void Postfix(Terminal __instance)
			{
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Expected O, but got Unknown
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Expected O, but got Unknown
				object obj = <>c.<>9__0_0;
				if (obj == null)
				{
					ConsoleEvent val = delegate(ConsoleEventArgs args)
					{
						if (Utils.IsDebug_Strict)
						{
							int level2 = int.Parse(args[1]);
							ItemData currentWeapon = ((Humanoid)Player.m_localPlayer).GetCurrentWeapon();
							if (currentWeapon != null && Object.op_Implicit((Object)(object)currentWeapon.m_dropPrefab))
							{
								Enchantment_Core.Enchanted orCreate2 = currentWeapon.Data().GetOrCreate<Enchantment_Core.Enchanted>();
								orCreate2.level = level2;
								orCreate2.Save();
								EnchantmentSideEffects.ApplyStateChanged(orCreate2, refreshEquipment: true);
								WriteCommandMessage("Enchantment level set to " + level2);
							}
						}
					};
					<>c.<>9__0_0 = val;
					obj = (object)val;
				}
				new ConsoleCommand("setenchant", "", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
				object obj2 = <>c.<>9__0_1;
				if (obj2 == null)
				{
					ConsoleEvent val2 = delegate(ConsoleEventArgs args)
					{
						if (Utils.IsDebug_Strict)
						{
							int level = int.Parse(args[1]);
							foreach (ItemData item in ((Humanoid)Player.m_localPlayer).m_inventory.m_inventory.Where(delegate(ItemData x)
							{
								GameObject dropPrefab = x.m_dropPrefab;
								return SyncedData.GetReqs((dropPrefab != null) ? ((Object)dropPrefab).name : null) != null;
							}))
							{
								Enchantment_Core.Enchanted orCreate = item.Data().GetOrCreate<Enchantment_Core.Enchanted>();
								orCreate.level = level;
								orCreate.Save();
							}
							Enchantment_VFX.UpdateGrid();
						}
					};
					<>c.<>9__0_1 = val2;
					obj2 = (object)val2;
				}
				new ConsoleCommand("setenchantall", "", (ConsoleEvent)obj2, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			}
		}

		private static void WriteCommandMessage(string message)
		{
			Utils.print(message);
			if (Object.op_Implicit((Object)(object)Chat.instance))
			{
				Chat.instance.m_hideTimer = 0f;
				((Terminal)Chat.instance).AddString(message);
			}
		}
	}
	public static class Utils
	{
		[CompilerGenerated]
		private sealed class <DelayedAction>d__21 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public int skipFrames;

			public Action invoke;

			private int <i>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<i>5__2 = 0;
					break;
				case 1:
					<>1__state = -1;
					<i>5__2++;
					break;
				}
				if (<i>5__2 < skipFrames)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				invoke();
				return false;
			}

			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 static bool IsDebug_VES
		{
			get
			{
				if (!Player.m_debugMode)
				{
					return ZNet.IsSinglePlayer;
				}
				return true;
			}
		}

		public static bool IsDebug_Strict => Player.m_debugMode;

		public static void print(object obj, ConsoleColor color = ConsoleColor.DarkGreen)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			if ((int)Application.platform == 2)
			{
				ConsoleManager.SetConsoleColor(color);
				ConsoleManager.StandardOutStream.WriteLine($"[{DateTime.Now}] [kg.ValheimEnchantmentSystem] {obj}");
				ConsoleManager.SetConsoleColor(ConsoleColor.White);
				{
					foreach (ILogListener listener in Logger.Listeners)
					{
						DiskLogListener val = (DiskLogListener)(object)((listener is DiskLogListener) ? listener : null);
						if (val != null && val.LogWriter != null)
						{
							val.LogWriter.WriteLine($"[{DateTime.Now}] [kg.ValheimEnchantmentSystem] {obj}");
						}
					}
					return;
				}
			}
			MonoBehaviour.print((object)($"[{DateTime.Now}] [kg.ValheimEnchantmentSystem] " + obj));
		}

		public static void arr_print(IEnumerable arr, ConsoleColor color = ConsoleColor.DarkGreen)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			if ((int)Application.platform == 2)
			{
				ConsoleManager.SetConsoleColor(color);
				ConsoleManager.StandardOutStream.WriteLine($"[ValheimEnchantmentSystem] printing array: {arr}");
				int num = 0;
				foreach (object item in arr)
				{
					ConsoleManager.StandardOutStream.WriteLine($"[{num++}] {item}");
					foreach (ILogListener listener in Logger.Listeners)
					{
						DiskLogListener val = (DiskLogListener)(object)((listener is DiskLogListener) ? listener : null);
						if (val != null && val.LogWriter != null)
						{
							val.LogWriter.WriteLine($"[{num++}] {item}");
						}
					}
				}
				ConsoleManager.SetConsoleColor(ConsoleColor.White);
				return;
			}
			MonoBehaviour.print((object)("[ValheimEnchantmentSystem] " + arr));
			int num2 = 0;
			foreach (object item2 in arr)
			{
				MonoBehaviour.print((object)$"[{num2++}] {item2}");
			}
		}

		public static void WriteFile(this string path, string data)
		{
			File.WriteAllText(path, data);
		}

		public static string ReadFile(this string path)
		{
			return File.ReadAllText(path);
		}

		public static string Localize(this string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return string.Empty;
			}
			try
			{
				Localization instance = Localization.instance;
				return ((instance != null) ? instance.Localize(text) : null) ?? text;
			}
			catch
			{
				return text;
			}
		}

		public static string Localize(this string text, params string[] args)
		{
			if (string.IsNullOrEmpty(text))
			{
				return string.Empty;
			}
			try
			{
				Localization instance = Localization.instance;
				return ((instance != null) ? instance.Localize(text, args) : null) ?? text;
			}
			catch
			{
				return text;
			}
		}

		public static bool StlocIndex(this object obj, int index)
		{
			if (obj is LocalBuilder localBuilder)
			{
				return localBuilder.LocalIndex == index;
			}
			return false;
		}

		public static Color ToColorAlpha(this string colorString)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			if (colorString[0] == '#')
			{
				colorString = colorString.Substring(1);
			}
			if (!uint.TryParse(colorString, NumberStyles.HexNumber, null, out var result))
			{
				return Color.white;
			}
			switch (colorString.Length)
			{
			case 8:
			{
				float num4 = (float)((result >> 24) & 0xFFu) / 255f;
				float num5 = (float)((result >> 16) & 0xFFu) / 255f;
				float num6 = (float)((result >> 8) & 0xFFu) / 255f;
				float num7 = (float)(result & 0xFFu) / 255f;
				Color result3 = default(Color);
				((Color)(ref result3))..ctor(num4, num5, num6, num7);
				return result3;
			}
			case 6:
			{
				float num = (float)((result >> 16) & 0xFFu) / 255f;
				float num2 = (float)((result >> 8) & 0xFFu) / 255f;
				float num3 = (float)(result & 0xFFu) / 255f;
				Color result2 = default(Color);
				((Color)(ref result2))..ctor(num, num2, num3, 1f);
				return result2;
			}
			default:
				return Color.white;
			}
		}

		public static int CustomCountItemsNoLevel(string prefab)
		{
			int num = 0;
			foreach (ItemData item in ((Humanoid)Player.m_localPlayer).m_inventory.m_inventory)
			{
				if (((Object)item.m_dropPrefab).name == prefab)
				{
					num += item.m_stack;
				}
			}
			return num;
		}

		public static void CustomRemoveItemsNoLevel(string prefab, int amount)
		{
			foreach (ItemData item in ((Humanoid)Player.m_localPlayer).m_inventory.m_inventory)
			{
				if (((Object)item.m_dropPrefab).name == prefab)
				{
					int num = Mathf.Min(item.m_stack, amount);
					item.m_stack -= num;
					amount -= num;
					if (amount <= 0)
					{
						break;
					}
				}
			}
			((Humanoid)Player.m_localPlayer).m_inventory.m_inventory.RemoveAll((ItemData x) => x.m_stack <= 0);
			((Humanoid)Player.m_localPlayer).m_inventory.Changed();
		}

		public static string IncreaseColorLight(this string color)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			Color val = default(Color);
			if (!ColorUtility.TryParseHtmlString(color, ref val))
			{
				return color;
			}
			float num = default(float);
			float num2 = default(float);
			float num3 = default(float);
			Color.RGBToHSV(val, ref num, ref num2, ref num3);
			num3 = 1f;
			val = Color.HSVToRGB(num, num2, num3);
			return "#" + ColorUtility.ToHtmlStringRGB(val);
		}

		public static Color IncreaseColorLight(this Color c)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			float num = default(float);
			float num2 = default(float);
			float num3 = default(float);
			Color.RGBToHSV(c, ref num, ref num2, ref num3);
			num3 = 1f;
			c = Color.HSVToRGB(num, num2, num3);
			return c;
		}

		public static string GetPrefabNameByItemName(string itemname)
		{
			string itemname2 = itemname;
			GameObject val = ((IEnumerable<GameObject>)ObjectDB.instance.m_items).FirstOrDefault((Func<GameObject, bool>)((GameObject x) => x.GetComponent<ItemDrop>().m_itemData.m_shared.m_name == itemname2));
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			return ((Object)val).name;
		}

		public static bool TryDeserializeYAML<T>(string text, out T obj, out string error)
		{
			obj = default(T);
			error = string.Empty;
			try
			{
				if (string.IsNullOrWhiteSpace(text))
				{
					error = "content is empty";
					return false;
				}
				T val = new DeserializerBuilder().Build().Deserialize<T>(text);
				if (val == null)
				{
					error = "deserialized to null";
					return false;
				}
				obj = val;
				return true;
			}
			catch (Exception ex)
			{
				error = ex.ToString();
				return false;
			}
		}

		public static bool TryFromYAML<T>(this string path, out T obj, out string error)
		{
			obj = default(T);
			try
			{
				if (!File.Exists(path))
				{
					error = "file does not exist";
					return false;
				}
				string text = File.ReadAllText(path);
				return TryDeserializeYAML<T>(text, out obj, out error);
			}
			catch (Exception ex)
			{
				error = ex.ToString();
				return false;
			}
		}

		public static T FromYAML<T>(this string path)
		{
			if (path.TryFromYAML<T>(out T obj, out string error))
			{
				return obj;
			}
			throw new InvalidOperationException("Error while deserializing " + path + ": " + error);
		}

		public static IEnumerable<Enchantment_Core.Enchanted> EquippedEnchantments(this Player p)
		{
			return from x in ((Humanoid)p).m_inventory.GetEquippedItems()
				select x.Data().Get<Enchantment_Core.Enchanted>() into x
				where x != null && x.level > 0
				select x;
		}

		[IteratorStateMachine(typeof(<DelayedAction>d__21))]
		private static IEnumerator DelayedAction(Action invoke, int skipFrames)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedAction>d__21(0)
			{
				invoke = invoke,
				skipFrames = skipFrames
			};
		}

		public static void DelayedInvoke(this MonoBehaviour mb, Action invoke, int skipFrames)
		{
			mb.StartCoroutine(DelayedAction(invoke, skipFrames));
		}

		public static double RoundOne(this float f)
		{
			return Math.Round(f, 1);
		}

		public static void IncreaseSkillEXP(SkillType skillType, float expToAdd)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || expToAdd <= 0f)
			{
				return;
			}
			Skill skill = localPlayer.m_skills.GetSkill(skillType);
			if (skill == null)
			{
				return;
			}
			float num = Mathf.Max(0f, skill.m_info?.m_increseStep ?? 1f);
			expToAdd *= num;
			while (expToAdd > 0f)
			{
				float nextLevelRequirement = skill.GetNextLevelRequirement();
				if (skill.m_accumulator + expToAdd >= nextLevelRequirement)
				{
					expToAdd -= nextLevelRequirement - skill.m_accumulator;
					skill.m_accumulator = 0f;
					skill.m_level += 1f;
					skill.m_level = Mathf.Clamp(skill.m_level, 0f, 100f);
				}
				else
				{
					skill.m_accumulator += expToAdd;
					expToAdd = 0f;
				}
			}
		}

		public static Transform FindChild(Transform aParent, string aName)
		{
			Stack<Transform> stack = new Stack<Transform>();
			Transform val = aParent;
			do
			{
				for (int num = val.childCount - 1; num >= 0; num--)
				{
					stack.Push(val.GetChild(num));
				}
				if (stack.Count <= 0)
				{
					return null;
				}
				val = stack.Pop();
			}
			while (((Object)val).name != aName);
			return val;
		}

		public static bool IsEnemy(this Character c)
		{
			if ((Object)(object)c == (Object)(object)Player.m_localPlayer)
			{
				return false;
			}
			if (c.IsPlayer())
			{
				if (((Character)Player.m_localPlayer).IsPVPEnabled())
				{
					return c.IsPVPEnabled();
				}
				return false;
			}
			if (Object.op_Implicit((Object)(object)c.m_baseAI))
			{
				return c.m_baseAI.IsEnemy((Character)(object)Player.m_localPlayer);
			}
			return true;
		}

		public static void InstantiateItem(GameObject prefab, int count, int level, Inventory overrideInventory = null)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (!Object.op_Implicit((Object)(object)localPlayer) || !Object.op_Implicit((Object)(object)prefab) || count == 0)
			{
				return;
			}
			Inventory val = overrideInventory ?? ((Humanoid)localPlayer).m_inventory;
			ItemDrop component = prefab.GetComponent<ItemDrop>();
			if (component == null)
			{
				return;
			}
			if (component.m_itemData.m_shared.m_maxStackSize > 1)
			{
				GameObject val2 = Object.Instantiate<GameObject>(prefab, ((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward * 1.5f + Vector3.up * 1.5f, Quaternion.identity);
				ItemDrop component2 = val2.GetComponent<ItemDrop>();
				component2.m_itemData.m_quality = level;
				component2.m_itemData.m_stack = count;
				component2.m_itemData.m_durability = component2.m_itemData.GetMaxDurability();
				component2.Save();
				val2.SetActive(true);
				if (val.CanAddItem(val2, -1))
				{
					val.AddItem(component2.m_itemData);
					ZNetScene.instance.Destroy(val2);
				}
				return;
			}
			for (int i = 0; i < count; i++)
			{
				GameObject val3 = Object.Instantiate<GameObject>(prefab, ((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward * 1.5f + Vector3.up * 1.5f, Quaternion.identity);
				ItemDrop component3 = val3.GetComponent<ItemDrop>();
				component3.m_itemData.m_quality = level;
				component3.m_itemData.m_durability = component3.m_itemData.GetMaxDurability();
				component3.Save();
				val3.SetActive(true);
				if (val.CanAddItem(val3, -1))
				{
					val.AddItem(component3.m_itemData);
					ZNetScene.instance.Destroy(val3);
				}
			}
		}
	}
	[BepInPlugin("kg.ValheimEnchantmentSystem", "ValheimEnchantmentSystem", "1.9.9")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class ValheimEnchantmentSystem : BaseUnityPlugin
	{
		private enum Toggle
		{
			On = 1,
			Off = 0
		}

		private readonly struct AutoloadFailure
		{
			public readonly Type ModuleType;

			public readonly string Reason;

			public AutoloadFailure(Type moduleType, string reason)
			{
				ModuleType = moduleType;
				Reason = reason;
			}
		}

		private const string GUID = "kg.ValheimEnchantmentSystem";

		private const string PLUGIN_NAME = "ValheimEnchantmentSystem";

		private const string PLUGIN_VERSION = "1.9.9";

		private const string GeneralConfigSection = "General";

		private const string ClientConfigSection = "Client";

		private static readonly string ConfigFileName = "kg.ValheimEnchantmentSystem.cfg";

		private static readonly string ConfigFileFullPath = Path.Combine(Paths.ConfigPath, ConfigFileName);

		public static ValheimEnchantmentSystem _thistype;

		public static AssetBundle _asset;

		public static readonly Harmony Harmony = new Harmony("kg.ValheimEnchantmentSystem");

		public static readonly ConfigSync ConfigSync = new ConfigSync("kg.ValheimEnchantmentSystem")
		{
			DisplayName = "ValheimEnchantmentSystem",
			ModRequired = true,
			MinimumRequiredVersion = "1.9.9",
			CurrentVersion = "1.9.9"
		};

		public static string ConfigFolder;

		private static ConfigEntry<Toggle> _serverConfigLocked = null;

		public static bool NoGraphics;

		internal static IEnumerable<Type> GetAssemblyTypes()
		{
			try
			{
				return Assembly.GetExecutingAssembly().GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				foreach (Exception item in ex.LoaderExceptions.Where((Exception e) => e != null))
				{
					Utils.print($"Autoload type scan loader exception: {item}", ConsoleColor.Red);
				}
				return ex.Types.Where((Type type) => type != null);
			}
		}

		private static bool TryResolveAutoloadMethod(Type moduleType, VES_Autoload autoload, out MethodInfo method, out string reason)
		{
			method = null;
			string text = (string.IsNullOrWhiteSpace(autoload.InitMethod) ? "OnInit" : autoload.InitMethod);
			MethodInfo method2 = moduleType.GetMethod(text, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (method2 == null)
			{
				reason = "method '" + text + "' not found";
				return false;
			}
			if (!method2.IsStatic)
			{
				reason = "method '" + text + "' must be static";
				return false;
			}
			if (method2.GetParameters().Length != 0)
			{
				reason = "method '" + text + "' must not have parameters";
				return false;
			}
			if (method2.ReturnType != typeof(void))
			{
				reason = "method '" + text + "' must return void";
				return false;
			}
			method = method2;
			reason = string.Empty;
			return true;
		}

		private static HashSet<Type> RunAutoload()
		{
			List<KeyValuePair<VES_Autoload, Type>> list = (from t in GetAssemblyTypes()
				where t.GetCustomAttribute<VES_Autoload>() != null
				select t into x
				select new KeyValuePair<VES_Autoload, Type>(x.GetCustomAttribute<VES_Autoload>(), x) into x
				orderby x.Key.priority
				select x).ThenBy<KeyValuePair<VES_Autoload, Type>, string>((KeyValuePair<VES_Autoload, Type> x) => x.Value.FullName, StringComparer.Ordinal).ToList();
			HashSet<Type> knownAutoloadModules = list.Select((KeyValuePair<VES_Autoload, Type> entry) => GetTopLevelDeclaringType(entry.Value)).ToHashSet();
			HashSet<Type> hashSet = new HashSet<Type>();
			List<AutoloadFailure> list2 = new List<AutoloadFailure>();
			int num = 0;
			foreach (KeyValuePair<VES_Autoload, Type> item in list)
			{
				Type value = item.Value;
				Type topLevelDeclaringType = GetTopLevelDeclaringType(value);
				Type[] source = (item.Key.DependsOn ?? Array.Empty<Type>()).Select(GetTopLevelDeclaringType).Distinct().ToArray();
				Type[] array = source.Where((Type dependency) => !knownAutoloadModules.Contains(dependency)).ToArray();
				if (array.Length != 0)
				{
					string text = "unknown dependency: " + string.Join(", ", array.Select((Type type) => type.FullName ?? type.Name));
					hashSet.Add(topLevelDeclaringType);
					list2.Add(new AutoloadFailure(value, text));
					Utils.print("Autoload dependency validation failed for " + value.FullName + ": " + text, ConsoleColor.Red);
					continue;
				}
				Type[] array2 = source.Where(hashSet.Contains).ToArray();
				if (array2.Length != 0)
				{
					string text2 = "dependency failed: " + string.Join(", ", array2.Select((Type type) => type.FullName ?? type.Name));
					hashSet.Add(topLevelDeclaringType);
					list2.Add(new AutoloadFailure(value, text2));
					Utils.print("Autoload skipped " + value.FullName + ": " + text2, ConsoleColor.Yellow);
					continue;
				}
				if (!TryResolveAutoloadMethod(value, item.Key, out MethodInfo method, out string reason))
				{
					hashSet.Add(topLevelDeclaringType);
					list2.Add(new AutoloadFailure(value, reason));
					Utils.print("Autoload validation failed for " + value.FullName + ": " + reason, ConsoleColor.Red);
					continue;
				}
				try
				{
					method.Invoke(null, null);
					num++;
				}
				catch (Exception ex)
				{
					Exception ex3 = ((ex is TargetInvocationException ex2 && ex.InnerException != null) ? ex2.InnerException : ex);
					hashSet.Add(topLevelDeclaringType);
					list2.Add(new AutoloadFailure(value, ex3.Message));
					Utils.print($"Autoload exception on method {method}. Class {value}\n:{ex3}", ConsoleColor.Red);
				}
			}
			if (list2.Count > 0)
			{
				string arg = string.Join(", ", list2.Select((AutoloadFailure failure) => failure.ModuleType.Name + " (" + failure.Reason + ")"));
				Utils.print($"Autoload completed with failures. success={num}, failed={list2.Count}. Failed modules: {arg}", ConsoleColor.Yellow);
			}
			return hashSet;
		}

		internal static Type GetTopLevelDeclaringType(Type type)
		{
			Type type2 = type;
			while (type2.DeclaringType != null)
			{
				type2 = type2.DeclaringType;
			}
			return type2;
		}

		internal static bool IsTypeBlockedByAutoloadFailure(Type type, ISet<Type> failedAutoloadTypes)
		{
			if (failedAutoloadTypes.Count == 0)
			{
				return false;
			}
			Type topLevelDeclaringType = GetTopLevelDeclaringType(type);
			return failedAutoloadTypes.Contains(topLevelDeclaringType);
		}

		private void Awake()
		{
			bool saveOnSet = BeginBootstrap();
			try
			{
				InitializeRuntimeState();
				InitializeSharedInfrastructure();
				InitializeConfigInfrastructure();
				InitializeAssets();
				HashSet<Type> failedAutoloadTypes = RunAutoload();
				ApplyRegisteredPatches(failedAutoloadTypes);
				InitializeConfigReloadInfrastructure();
			}
			finally
			{
				EndBootstrap(saveOnSet);
			}
		}

		private void Update()
		{
			ConfigReloadPoller.Update();
			if (!NoGraphics)
			{
				VES_UI.Update();
				Info_UI.Update();
				Notifications_UI.Update();
			}
		}

		private void Start()
		{
		}

		private void OnDestroy()
		{
			((BaseUnityPlugin)this).Config.Save();
			ConfigReloadPoller.Shutdown();
		}

		private static AssetBundle GetAssetBundle(string filename)
		{
			string filename2 = filename;
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string name = executingAssembly.GetManifestResourceNames().Single((string str) => str.EndsWith(filename2));
			using Stream stream = executingAssembly.GetManifestResourceStream(name);
			return AssetBundle.LoadFromStream(stream);
		}

		private bool BeginBootstrap()
		{
			bool saveOnConfigSet = ((BaseUnityPlugin)this).Config.SaveOnConfigSet;
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = false;
			return saveOnConfigSet;
		}

		private void InitializeRuntimeState()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			NoGraphics = (int)SystemInfo.graphicsDeviceType == 4;
			_thistype = this;
		}

		private static void InitializeSharedInfrastructure()
		{
			JSON.Parameters = new JSONParameters
			{
				UseExtensions = false,
				SerializeNullValues = false,
				DateTimeMilliseconds = false,
				UseUTCDateTime = true,
				UseOptimizedDatasetSchema = true,
				UseValuesOfEnums = true
			};
			LocalizationBootstrap.Initialize();
		}

		private void InitializeConfigInfrastructure()
		{
			ConfigFolder = Path.Combine(Paths.ConfigPath, "ValheimEnchantmentSystem");
			if (!Directory.Exists(ConfigFolder))
			{
				Directory.CreateDirectory(ConfigFolder);
			}
			_serverConfigLocked = config("General", "Lock Configuration", Toggle.On, "If on, synced configuration can be changed by server admins only.");
			ConfigSync.AddLockingConfigEntry<Toggle>(_serverConfigLocked);
		}

		private void InitializeAssets()
		{
			_asset = GetAssetBundle("kg_enchantment");
		}

		private void ApplyRegisteredPatches(HashSet<Type> failedAutoloadTypes)
		{
			PatchRegistry.Apply(Harmony, ((BaseUnityPlugin)this).Logger, NoGraphics, failedAutoloadTypes);
		}

		private void EndBootstrap(bool saveOnSet)
		{
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = saveOnSet;
			((BaseUnityPlugin)this).Config.Save();
		}

		private static string WithSyncTag(string description, bool synchronizedSetting)
		{
			if (description.Contains("[Synced with Server]") || description.Contains("[Not Synced with Server]"))
			{
				return description;
			}
			string text = (synchronizedSetting ? "[Synced with Server]" : "[Not Synced with Server]");
			if (!string.IsNullOrWhiteSpace(description))
			{
				return description + " " + text;
			}
			return text;
		}

		private void InitializeConfigReloadInfrastructure()
		{
			ConfigHotReloadRegistrar.Initialize(ConfigFileFullPath, TryReloadMainConfig);
			ConfigReloadPoller.Initialize();
		}

		private bool TryReloadMainConfig()
		{
			if (!File.Exists(ConfigFileFullPath))
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)(ConfigFileName + " does not exist; skipping config reload."));
				return false;
			}
			try
			{
				((BaseUnityPlugin)this).Config.Reload();
				return true;
			}
			catch
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Could not load " + ConfigFileName + ". Check config format and values."));
				return false;
			}
		}

		public static ConfigEntry<T> config<T>(string group, string name, T value, ConfigDescription description, bool synchronizedSetting = true)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			object[] array = description.Tags ?? Array.Empty<object>();
			ConfigDescription val = new ConfigDescription(WithSyncTag(description.Description, synchronizedSetting), description.AcceptableValues, array);
			ConfigEntry<T> val2 = ((BaseUnityPlugin)_thistype).Config.Bind<T>(group, name, value, val);
			SyncedConfigEntry<T> syncedConfigEntry = ConfigSync.AddConfigEntry<T>(val2);
			syncedConfigEntry.SynchronizedConfig = synchronizedSetting;
			return val2;
		}

		public static ConfigEntry<T> config<T>(string group, string name, T value, string description, bool synchronizedSetting = true)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting);
		}

		public static ConfigEntry<T> ClientConfig<T>(string group, string name, T value, ConfigDescription description)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			string text = (string.IsNullOrEmpty(group) ? name : (group + " - " + name));
			object[] array = description.Tags ?? Array.Empty<object>();
			ConfigDescription val = new ConfigDescription(WithSyncTag(description.Description, synchronizedSetting: false), description.AcceptableValues, array);
			return ((BaseUnityPlugin)_thistype).Config.Bind<T>("Client", text, value, val);
		}

		public static ConfigEntry<T> ClientConfig<T>(string group, string name, T value, string description)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			return ClientConfig(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()));
		}
	}
}
namespace kg.ValheimEnchantmentSystem.UI
{
	public static class EnchantmentStatFormatter
	{
		private static readonly List<FieldInfo> CachedValueFields = (from field in AccessTools.GetDeclaredFields(typeof(SyncedData.Stat_Data))
			where field.FieldType.IsValueType
			select field).ToList();

		private static readonly (Func<SyncedData.Stat_Data, int> Getter, string Label, bool Percent)[] IntTransitions = new(Func<SyncedData.Stat_Data, int>, string, bool)[20]
		{
			((SyncedData.Stat_Data stats) => stats.damage_percentage, "$enchantment_bonusespercentdamage", true),
			((SyncedData.Stat_Data stats) => stats.attack_speed, "$enchantment_attackspeed", true),
			((SyncedData.Stat_Data stats) => stats.movement_speed, "$enchantment_movementspeed", true),
			((SyncedData.Stat_Data stats) => stats.durability_percentage, "$item_durability", true),
			((SyncedData.Stat_Data stats) => stats.durability, "$item_durability", false),
			((SyncedData.Stat_Data stats) => stats.damage_true, "$enchantment_truedamage", false),
			((SyncedData.Stat_Data stats) => stats.damage_fire, "$inventory_fire", false),
			((SyncedData.Stat_Data stats) => stats.damage_blunt, "$inventory_blunt", false),
			((SyncedData.Stat_Data stats) => stats.damage_slash, "$inventory_slash", false),
			((SyncedData.Stat_Data stats) => stats.damage_pierce, "$inventory_pierce", false),
			((SyncedData.Stat_Data stats) => stats.damage_chop, "$enchantment_chopdamage", false),
			((SyncedData.Stat_Data stats) => stats.damage_pickaxe, "$enchantment_pickaxedamage", false),
			((SyncedData.Stat_Data stats) => stats.damage_frost, "$inventory_frost", false),
			((SyncedData.Stat_Data stats) => stats.damage_lightning, "$inventory_lightning", false),
			((SyncedData.Stat_Data stats) => stats.damage_poison, "$inventory_poison", false),
			((SyncedData.Stat_Data stats) => stats.damage_spirit, "$inventory_spirit", false),
			((SyncedData.Stat_Data stats) => stats.max_hp, "$se_health", false),
			((SyncedData.Stat_Data stats) => stats.max_stamina, "$se_stamina", false),
			((SyncedData.Stat_Data stats) => stats.API_backpacks_additionalrow_x, "$enchantment_backpacks_additionalrow_x", false),
			((SyncedData.Stat_Data stats) => stats.API_backpacks_additionalrow_y, "$enchantment_backpacks_additionalrow_y", false)
		};

		private static readonly (Func<SyncedData.Stat_Data, float> Getter, string Label, bool Percent, string Suffix)[] FloatTransitions = new(Func<SyncedData.Stat_Data, float>, string, bool, string)[4]
		{
			((SyncedData.Stat_Data stats) => stats.armor_percentage, "$enchantment_bonusespercentarmor", true, string.Empty),
			((SyncedData.Stat_Data stats) => stats.armor, "$item_armor", false, string.Empty),
			((SyncedData.Stat_Data stats) => stats.hp_regen, "$se_healthregen", false, "/10s"),
			((SyncedData.Stat_Data stats) => stats.stamina_regen, "$se_staminaregen", false, "/s")
		};

		private static readonly (Func<SyncedData.Stat_Data, DamageModifier> Getter, string Label)[] ResistanceTransitions = new(Func<SyncedData.Stat_Data, DamageModifier>, string)[10]
		{
			((SyncedData.Stat_Data stats) => stats.resistance_blunt, "$inventory_blunt"),
			((SyncedData.Stat_Data stats) => stats.resistance_slash, "$inventory_slash"),
			((SyncedData.Stat_Data stats) => stats.resistance_pierce, "$inventory_pierce"),
			((SyncedData.Stat_Data stats) => stats.resistance_chop, "$enchantment_chopdamage"),
			((SyncedData.Stat_Data stats) => stats.resistance_pickaxe, "$enchantment_pickaxedamage"),
			((SyncedData.Stat_Data stats) => stats.resistance_fire, "$inventory_fire"),
			((SyncedData.Stat_Data stats) => stats.resistance_frost, "$inventory_frost"),
			((SyncedData.Stat_Data stats) => stats.resistance_lightning, "$inventory_lightning"),
			((SyncedData.Stat_Data stats) => stats.resistance_poison, "$inventory_poison"),
			((SyncedData.Stat_Data stats) => stats.resistance_spirit, "$inventory_spirit")
		};

		public static string BuildAdditionalStats(SyncedData.Stat_Data stats, string color)
		{
			if (stats == null || !ShouldShow(stats))
			{
				return "\n";
			}
			StringBuilder stringBuilder = new StringBuilder();
			if (stats.attack_speed > 0)
			{
				stringBuilder.Append($"\n<color={color}>•</color> $enchantment_attackspeed: <color=#DF745D>+{stats.attack_speed}%</color>");
			}
			if (stats.movement_speed > 0)
			{
				stringBuilder.Append($"\n<color={color}>•</color> $enchantment_movementspeed: <color=#DF745D>+{stats.movement_speed}%</color>");
			}
			if (stats.durability_percentage > 0)
			{
				stringBuilder.Append($"\n<color={color}>•</color> $item_durability: <color=#DF745D>+{stats.durability_percentage}%</color>");
			}
			if (stats.durability > 0)
			{
				stringBuilder.Append($"\n<color={color}>•</color> $item_durability: <color=#DF745D>+{stats.durability}</color>");
			}
			if (stats.damage_true > 0)
			{
				stringBuilder.Append($"\n<color={color}>•</color> $enchantment_truedamage: +{stats.damage_true}");
			}
			if (stats.damage_fire > 0)
			{
				stringBuilder.Append($"\n<color={color}>•</color> $inventory_fire: <color=#FFA500>+{stats.damage_fire}</color>");
			}
			if (stats.damage_blunt > 0)
			{
				stringBuilder.Append($"\n<color={color}>•</color> $inventory_blunt: <color=#FFFF00>+{stats.damage_blunt}</color>");
			}
			if (stats.damage_slash > 0)
			{
				stringBuilder.Append($"\n<color={color}>•</color> $inventory_slash: <color=#7F00FF>+{stats.damage_slash}</color>");
			}
			if (stats.damage_pierce > 0)
			{
				stringBuilder.Append($"\n<color={color}>•</color> $inventory_pierce: <color=#D499B9>+{stats.damage_pierce}</color>");
			}
			if (stats.damage_chop > 0)
			{
				stringBuilder.Append($"\n<color={color}>•</color> $enchantment_chopdamage: <color=#FFAF00>+{stats.damage_chop}</color>");
			}
			if (stats.damage_pickaxe > 0)
			{
				stringBuilder.Append($"\n<color={color}>•</color> $enchantment_pickaxedamage: <color=#FF00FF>+{stats.damage_pickaxe}</color>");
			}
			if (stats.damage_frost > 0)
			{
				stringBuilder.Append($"\n<color={color}>•</color> $inventory_frost: <color=#00FFFF>+{stats.damage_frost}</color>");
			}
			if (stats.damage_lightning > 0)
			{
				stringBuilder.Append($"\n<color={color}>•</color> $inventory_lightning: <color=#0000FF>+{stats.damage_lightning}</color>");
			}
			if (stats.damage_poison > 0)
			{
				stringBuilder.Append($"\n<color={color}>•</color> $inventory_poison: <color=#00FF00>+{stats.damage_poison}</color>");
			}
			if (stats.damage_spirit > 0)
			{
				stringBuilder.Append($"\n<color={color}>•</color> $inventory_spirit: <color=#FFFFA0>+{stats.damage_spirit}</color>");
			}
			if (stats.max_hp > 0)
			{
				stringBuilder.Append($"\n<color={color}>•</color> $se_health: <color=#DD3333>+{stats.max_hp}</color>");
			}
			if (stats.hp_regen > 0f)
			{
				stringBuilder.Append($"\n<color={color}>•</color> $se_healthregen: <color=#DD3333>+{stats.hp_regen}/10s</color>");
			}
			if (stats.armor > 0f)
			{
				stringBuilder.Append($"\n<color={color}>•</color> $item_armor: <color=#009FAF>+{stats.armor}</color>");
			}
			if (stats.max_stamina > 0)
			{
				stringBuilder.Append($"\n<color={color}>•</color> $se_stamina: <color=#EEEE11>+{stats.max_stamina}</color>");
			}
			if (stats.stamina_regen > 0f)
			{
				stringBuilder.Append($"\n<color={color}>•</color> $se_staminaregen: <color=#EEEE11>+{stats.stamina_regen}/s</color>");
			}
			if (stats.API_backpacks_additionalrow_x > 0)
			{
				stringBuilder.Append($"\n<color={color}>•</color> $enchantment_backpacks_additionalrow_x: <color=#7393B3>{stats.API_backpacks_additionalrow_x}</color>");
			}
			if (stats.API_backpacks_additionalrow_y > 0)
			{
				stringBuilder.Append($"\n<color={color}>•</color> $enchantment_backpacks_additionalrow_y: <color=#7393B3>{stats.API_backpacks_additionalrow_y}</color>");
			}
			stringBuilder.Append(SE_Stats.GetDamageModifiersTooltipString(stats.GetResistancePairs()).Replace("\n", "\n<color=" + color + ">•</color> "));
			stringBuilder.Append("\n");
			return stringBuilder.ToString();
		}

		public static string BuildInfoDescription(SyncedData.Stat_Data stats)
		{
			if (stats == null)
			{
				return string.Empty;
			}
			string text = string.Empty;
			if (stats.damage_percentage > 0)
			{
				text += $"\n• $enchantment_bonusespercentdamage: <color=#AF009F>+{stats.damage_percentage}%</color>";
			}
			if (stats.armor_percentage > 0f)
			{
				text += $"\n• $enchantment_bonusespercentarmor: <color=#009FAF>+{stats.armor_percentage}%</color>";
			}
			return text + BuildAdditionalStats(stats, "#FFFFFF");
		}

		public static string BuildTransitionDescription(SyncedData.Stat_Data? current, SyncedData.Stat_Data? next)
		{
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			if (next == null)
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder();
			(Func<SyncedData.Stat_Data, int>, string, bool)[] intTransitions = IntTransitions;
			for (int i = 0; i < intTransitions.Length; i++)
			{
				(Func<SyncedData.Stat_Data, int>, string, bool) tuple = intTransitions[i];
				Func<SyncedData.Stat_Data, int> item = tuple.Item1;
				string item2 = tuple.Item2;
				bool item3 = tuple.Item3;
				int currentValue = ((current != null) ? item(current) : 0);
				int nextValue = item(next);
				AppendTransitionLine(stringBuilder, item2, currentValue, nextValue, item3, string.Empty);
			}
			(Func<SyncedData.Stat_Data, float>, string, bool, string)[] floatTransitions = FloatTransitions;
			for (int j = 0; j < floatTransitions.Length; j++)
			{
				(Func<SyncedData.Stat_Data, float>, string, bool, string) tuple2 = floatTransitions[j];
				Func<SyncedData.Stat_Data, float> item4 = tuple2.Item1;
				string item5 = tuple2.Item2;
				bool item6 = tuple2.Item3;
				string item7 = tuple2.Item4;
				float currentValue2 = ((current != null) ? item4(current) : 0f);
				float nextValue2 = item4(next);
				AppendTransitionLine(stringBuilder, item5, currentValue2, nextValue2, item6, item7);
			}
			(Func<SyncedData.Stat_Data, DamageModifier>, string)[] resistanceTransitions = ResistanceTransitions;
			for (int k = 0; k < resistanceTransitions.Length; k++)
			{
				(Func<SyncedData.Stat_Data, DamageModifier>, string) tuple3 = resistanceTransitions[k];
				Func<SyncedData.Stat_Data, DamageModifier> item8 = tuple3.Item1;
				string item9 = tuple3.Item2;
				DamageModifier currentValue3 = (DamageModifier)((current != null) ? ((int)item8(current)) : 0);
				DamageModifier nextValue3 = item8(next);
				AppendResistanceTransitionLine(stringBuilder, item9, currentValue3, nextValue3);
			}
			return stringBuilder.ToString().Trim();
		}

		private static bool ShouldShow(SyncedData.Stat_Data stats)
		{
			SyncedData.Stat_Data stats2 = stats;
			return CachedValueFields.Any((FieldInfo field) => !field.GetValue(stats2).Equals(Activator.CreateInstance(field.FieldType)));
		}

		private static void AppendTransitionLine(StringBuilder builder, string label, int currentValue, int nextValue, bool percent, string suffix)
		{
			if (currentValue != nextValue || nextValue != 0)
			{
				string formattedCurrent = FormatValue(currentValue, percent, suffix);
				string formattedNext = FormatValue(nextValue, percent, suffix);
				AppendTransitionLine(builder, label, currentValue != 0, formattedCurrent, formattedNext);
			}
		}

		private static void AppendTransitionLine(StringBuilder builder, string label, float currentValue, float nextValue, bool percent, string suffix)
		{
			if (!(Math.Abs(currentValue - nextValue) < 0.001f) || !(Math.Abs(nextValue) < 0.001f))
			{
				string formattedCurrent = FormatValue(currentValue, percent, suffix);
				string formattedNext = FormatValue(nextValue, percent, suffix);
				AppendTransitionLine(builder, label, Math.Abs(currentValue) >= 0.001f, formattedCurrent, formattedNext);
			}
		}

		private static void AppendTransitionLine(StringBuilder builder, string label, bool hasCurrentValue, string formattedCurrent, string formattedNext)
		{
			if (!(string.Equals(formattedCurrent, formattedNext, StringComparison.Ordinal) && hasCurrentValue))
			{
				if (builder.Length > 0)
				{
					builder.Append('\n');
				}
				builder.Append("• ").Append(label).Append(": ");
				if (hasCurrentValue)
				{
					builder.Append(formattedCurrent).Append(" > ").Append(formattedNext);
				}
				else
				{
					builder.Append(formattedNext);
				}
			}
		}

		private static void AppendResistanceTransitionLine(StringBuilder builder, string label, DamageModifier currentValue, DamageModifier nextValue)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if ((currentValue != nextValue || (int)nextValue != 0) && currentValue != nextValue)
			{
				if (builder.Length > 0)
				{
					builder.Append('\n');
				}
				builder.Append("• ").Append(label).Append(": ");
				if ((int)currentValue != 0)
				{
					builder.Append(FormatDamageModifier(currentValue)).Append(" > ").Append(FormatDamageModifier(nextValue));
				}
				else
				{
					builder.Append(FormatDamageModifier(nextValue));
				}
			}
		}

		private static string FormatValue(int value, bool percent, string suffix)
		{
			if (!percent)
			{
				return $"+{value}{suffix}";
			}
			return $"+{value}%{suffix}";
		}

		private static string FormatValue(float value, bool percent, string suffix)
		{
			string text = value.ToString("0.#", CultureInfo.InvariantCulture);
			if (!percent)
			{
				return "+" + text + suffix;
			}
			return "+" + text + "%" + suffix;
		}

		private static string FormatDamageModifier(DamageModifier modifier)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected I4, but got Unknown
			return (modifier - 1) switch
			{
				0 => "$enchantment_modifier_resistant".Localize(), 
				1 => "$enchantment_modifier_weak".Localize(), 
				2 => "$enchantment_modifier_immune".Localize(), 
				3 => "$enchantment_modifier_ignore".Localize(), 
				4 => "$enchantment_modifier_veryresistant".Localize(), 
				5 => "$enchantment_modifier_veryweak".Localize(), 
				_ => "$enchantment_modifier_normal".Localize(), 
			};
		}
	}
	internal sealed class InfoEntryView : MonoBehaviour
	{
		private Transform _itemsRoot;

		private GameObject _iconTemplate;

		private Text _additionalLabel;

		private Text _infoText;

		private Button _toggleButton;

		private GameObject _openIcon;

		private GameObject _closeIcon;

		public bool IsExpanded { get; private set; }

		public static InfoEntryView Attach(GameObject root)
		{
			InfoEntryView orAddComponent = UIBindingHelper.GetOrAddComponent<InfoEntryView>(root);
			orAddComponent.Bind();
			return orAddComponent;
		}

		public void Apply(InfoPanelEntryModel model, GameObject? tooltipPrefab)
		{
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			ClearIcons();
			_infoText.text = model.BodyText;
			bool flag = !string.IsNullOrWhiteSpace(model.AdditionalText);
			((Component)_additionalLabel).gameObject.SetActive(flag);
			if (flag)
			{
				_additionalLabel.text = model.AdditionalText;
			}
			((Component)_itemsRoot).gameObject.SetActive(model.Icons.Count > 0);
			foreach (InfoPanelIconModel icon in model.Icons)
			{
				GameObject val = Object.Instantiate<GameObject>(_iconTemplate, _itemsRoot);
				val.SetActive(true);
				UIBindingHelper.GetRequired<Image>(val.transform, "Icon").sprite = icon.Icon;
				((Graphic)UIBindingHelper.GetRequired<Image>(val.transform, "border")).color = (icon.Highlight ? Color.green : Color.white);
				UITooltip component = val.GetComponent<UITooltip>();
				if (component != null)
				{
					component.m_topic = icon.TooltipTopic;
					component.m_text = icon.TooltipText;
					if ((Object)(object)tooltipPrefab != (Object)null)
					{
						component.m_tooltipPrefab = tooltipPrefab;
					}
				}
			}
			SetExpanded(model.StartExpanded);
		}

		public void BindToggle(Action onToggle)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			Action onToggle2 = onToggle;
			((UnityEventBase)_toggleButton.onClick).RemoveAllListeners();
			((UnityEvent)_toggleButton.onClick).AddListener((UnityAction)delegate
			{
				onToggle2();
			});
		}

		public void SetExpanded(bool expanded)
		{
			IsExpanded = expanded;
			((Component)_infoText).gameObject.SetActive(expanded);
			_openIcon.SetActive(!expanded);
			_closeIcon.SetActive(expanded);
		}

		private void Bind()
		{
			Transform transform = ((Component)this).transform;
			_itemsRoot = UIBindingHelper.FindRequired(transform, "Items");
			_iconTemplate = ((Component)UIBindingHelper.FindRequired(_itemsRoot, "Icon")).gameObject;
			_iconTemplate.SetActive(false);
			_additionalLabel = UIBindingHelper.GetRequired<Text>(transform, "ANY");
			_infoText = UIBindingHelper.GetRequired<Text>(transform, "Info");
			_toggleButton = ((Component)UIBindingHelper.FindRequired(transform, "Open")).GetComponent<Button>();
			_openIcon = ((Component)UIBindingHelper.FindRequired(transform, "Open/open")).gameObject;
			_closeIcon = ((Component)UIBindingHelper.FindRequired(transform, "Open/close")).gameObject;
		}

		private void ClearIcons()
		{
			for (int num = _itemsRoot.childCount - 1; num >= 0; num--)
			{
				Transform child = _itemsRoot.GetChild(num);
				if (!((Object)(object)((Component)child).gameObject == (Object)(object)_iconTemplate))
				{
					Object.Destroy((Object)(object)((Component)child).gameObject);
				}
			}
		}
	}
	internal sealed class InfoPanelController
	{
		private readonly InfoPanelView _view;

		private readonly GameObject _elementPrefab;

		private readonly InfoPanelQueryService _queryService;

		private readonly Action _playClick;

		private bool _suppressRender;

		private GameObject? _tooltipPrefab;

		private InfoPanelCategory _currentCategory;

		public bool IsVisible
		{
			get
			{
				if ((Object)(object)_view != (Object)null)
				{
					return ((Component)_view).gameObject.activeSelf;
				}
				return false;
			}
		}

		public InfoPanelController(InfoPanelView view, GameObject elementPrefab, InfoPanelQueryService queryService, Action playClick)
		{
			_view = view;
			_elementPrefab = elementPrefab;
			_queryService = queryService;
			_playClick = playClick;
			((UnityEventBase)_view.Search.onValueChanged).RemoveAllListeners();
			((UnityEvent<string>)(object)_view.Search.onValueChanged).AddListener((UnityAction<string>)delegate
			{
				OnSearchChanged();
			});
			BindCategoryButton(InfoPanelCategory.Reqs);
			BindCategoryButton(InfoPanelCategory.Stats);
			BindCategoryButton(InfoPanelCategory.Chances);
			ResetState();
		}

		public void ConfigureTooltipPrefab(GameObject? tooltipPrefab)
		{
			_tooltipPrefab = tooltipPrefab;
		}

		public void Show(InfoPanelCategory initialCategory = InfoPanelCategory.Reqs, string? initialSearchText = null)
		{
			ResetState(initialCategory, initialSearchText);
			_view.LocalizeRoot();
			((Component)_view).gameObject.SetActive(true);
			Render();
		}

		public void Hide()
		{
			((Component)_view).gameObject.SetActive(false);
			ResetState();
		}

		public void Update()
		{
			if (IsVisible)
			{
				if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					Hide();
				}
				else if (Input.GetKeyDown((KeyCode)27))
				{
					Hide();
				}
			}
		}

		private void BindCategoryButton(InfoPanelCategory category)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			Button categoryButton = _view.GetCategoryButton(category);
			((UnityEventBase)categoryButton.onClick).RemoveAllListeners();
			((UnityEvent)categoryButton.onClick).AddListener((UnityAction)delegate
			{
				_playClick();
				SelectCategory(category);
				Render();
			});
		}

		private void OnSearchChanged()
		{
			if (!_suppressRender)
			{
				Render();
			}
		}

		private void ResetState(InfoPanelCategory initialCategory = InfoPanelCategory.Reqs, string? initialSearchText = null)
		{
			_view.ClearContent();
			SelectCategory(initialCategory);
			_suppressRender = true;
			_view.Search.text = initialSearchText ?? string.Empty;
			_suppressRender = false;
		}

		private void SelectCategory(InfoPanelCategory category)
		{
			_currentCategory = category;
			_view.SetCategorySelected(category);
		}

		private void Render()
		{
			_view.ClearContent();
			if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return;
			}
			List<InfoPanelEntryModel> entries = _queryService.GetEntries(_currentCategory, _view.Search.text);
			foreach (InfoPanelEntryModel item in entries)
			{
				InfoEntryView entryView = InfoEntryView.Attach(Object.Instantiate<GameObject>(_elementPrefab, _view.Content));
				entryView.Apply(item, _tooltipPrefab);
				entryView.BindToggle(delegate
				{
					_playClick();
					entryView.SetExpanded(!entryView.IsExpanded);
					_view.ForceCanvasLayout();
				});
			}
			_view.ForceCanvasLayout();
		}
	}
	internal enum InfoPanelCategory
	{
		Reqs,
		Stats,
		Chances
	}
	internal sealed class InfoPanelIconModel
	{
		public Sprite Icon;

		public string TooltipTopic = string.Empty;

		public string TooltipText = string.Empty;

		public bool Highlight;
	}
	internal sealed class InfoPanelEntryModel
	{
		public readonly List<InfoPanelIconModel> Icons = new List<InfoPanelIconModel>();

		public string BodyText = string.Empty;

		public string? AdditionalText;

		public bool StartExpanded;
	}
	internal sealed class InfoPanelQueryService
	{
		[CompilerGenerated]
		private sealed class <BuildIcons>d__7 : IEnumerable<InfoPanelIconModel>, IEnumerable, IEnumerator<InfoPanelIconModel>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private InfoPanelIconModel <>2__current;

			private int <>l__initialThreadId;

			private IEnumerable<string> prefabs;

			public IEnumerable<string> <>3__prefabs;

			private string found;

			public string <>3__found;

			private IEnumerator<string> <>7__wrap1;

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

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

			[DebuggerHidden]
			public <BuildIcons>d__7(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = prefabs.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					while (<>7__wrap1.MoveNext())
					{
						string current = <>7__wrap1.Current;
						ZNetScene instance = ZNetScene.instance;
						GameObject val = ((instance != null) ? instance.GetPrefab(current) : null);
						ItemDrop val2 = ((val != null) ? val.GetComponent<ItemDrop>() : null);
						if (val2 != null)
						{
							string name = val2.m_itemData.m_shared.m_name;
							if (Player.m_localPlayer.m_knownRecipes.Contains(name) || Player.m_localPlayer.m_knownMaterial.Contains(name))
							{
								<>2__current = new InfoPanelIconModel
								{
									Icon = val2.m_itemData.GetIcon(),
									TooltipTopic = name.Localize(),
									TooltipText = val2.m_itemData.GetTooltip(-1),
									Highlight = string.Equals(found, current, StringComparison.OrdinalIgnoreCase)
								};
								<>1__state = 1;
								return true;
							}
						}
					}
					<>m__Finally1();
					<>7__wrap1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<InfoPanelIconModel> IEnumerable<InfoPanelIconModel>.GetEnumerator()
			{
				<BuildIcons>d__7 <BuildIcons>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<BuildIcons>d__ = this;
				}
				else
				{
					<BuildIcons>d__ = new <BuildIcons>d__7(0);
				}
				<BuildIcons>d__.prefabs = <>3__prefabs;
				<BuildIcons>d__.found = <>3__found;
				return <BuildIcons>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<InfoPanelIconModel>)this).GetEnumerator();
			}
		}

		public List<InfoPanelEntryModel> GetEntries(InfoPanelCategory category, string? searchText)
		{
			if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return new List<InfoPanelEntryModel>();
			}
			return category switch
			{
				InfoPanelCategory.Reqs => GetRequirementEntries(searchText), 
				InfoPanelCategory.Stats => GetStatEntries(searchText), 
				InfoPanelCategory.Chances => GetChanceEntries(searchText), 
				_ => new List<InfoPanelEntryModel>(), 
			};
		}

		private List<InfoPanelEntryModel> GetRequirementEntries(string? searchText)
		{
			List<InfoPanelEntryModel> list = new List<InfoPanelEntryModel>();
			if (string.IsNullOrWhiteSpace(searchText))
			{
				list.Add(CreateGuideEntry());
			}
			foreach (SyncedData.EnchantmentReqs item in SyncedData.Synced_EnchantmentReqs.Value)
			{
				string found = null;
				if (string.IsNullOrWhiteSpace(searchText) || HasAny(item.Items, searchText, out found))
				{
					InfoPanelEntryModel infoPanelEntryModel = CreateEntry(item.Items, GenerateReqsText(item), found, null);
					if (infoPanelEntryModel != null)
					{
						list.Add(infoPanelEntryModel);
					}
				}
			}
			return list;
		}

		private List<InfoPanelEntryModel> GetStatEntries(string? searchText)
		{
			List<InfoPanelEntryModel> list = new List<InfoPanelEntryModel>();
			if (string.IsNullOrWhiteSpace(searchText))
			{
				AddIfNotNull(list, CreateEntry(null, GenerateStatsText(SyncedData.Synced_EnchantmentStats_Weapons.Value), null, "$enchantment_defaultstats_weapon".Localize()));
				AddIfNotNull(list, CreateEntry(null, GenerateStatsText(SyncedData.Synced_EnchantmentStats_Armor.Value), null, "$enchantment_defaultstats_armor".Localize()));
			}
			foreach (SyncedData.OverrideStats item in SyncedData.Overrides_EnchantmentStats.Value)
			{
				string found = null;
				if (string.IsNullOrWhiteSpace(searchText) || HasAny(item.Items, searchText, out found))
				{
					string text = GenerateStatsText(item.Stats);
					if (!string.IsNullOrEmpty(text))
					{
						AddIfNotNull(list, CreateEntry(item.Items, text, found, null));
					}
				}
			}
			return list;
		}

		private List<InfoPanelEntryModel> GetChanceEntries(string? searchText)
		{
			List<InfoPanelEntryModel> list = new List<InfoPanelEntryModel>();
			if (string.IsNullOrWhiteSpace(searchText))
			{
				AddIfNotNull(list, CreateEntry(null, GenerateChancesText(SyncedData.Synced_EnchantmentChances_Weapons.Value), null, "$enchantment_defaultchances_weapon".Localize()));
				AddIfNotNull(list, CreateEntry(null, GenerateChancesText(SyncedData.Synced_EnchantmentChances_Armor.Value), null, "$enchantment_defaultchances_armor".Localize()));
			}
			foreach (SyncedData.OverrideChances item in SyncedData.Overrides_EnchantmentChances.Value)
			{
				string found = null;
				if (string.IsNullOrWhiteSpace(searchText) || HasAny(item.Items, searchText, out found))
				{
					string text = GenerateChancesText(item.Chances);
					if (!string.IsNullOrEmpty(text))
					{
						AddIfNotNull(list, CreateEntry(item.Items, text, found, null));
					}
				}
			}
			return list;
		}

		private static void AddIfNotNull(List<InfoPanelEntryModel> entries, InfoPanelEntryModel? entry)
		{
			if (entry != null)
			{
				entries.Add(entry);
			}
		}

		private static InfoPanelEntryModel CreateGuideEntry()
		{
			InfoPanelEntryModel infoPanelEntryModel = new InfoPanelEntryModel();
			infoPanelEntryModel.AdditionalText = "$enchantment_info_guide".Localize();
			infoPanelEntryModel.BodyText = string.Join("\n", "• $enchantment_info_guide_search".Localize(), "• $enchantment_info_guide_tabs".Localize(), "• " + ScrollCombineService.GetCombineInstructionText());
			infoPanelEntryModel.StartExpanded = true;
			return infoPanelEntryModel;
		}

		private InfoPanelEntryModel? CreateEntry(IEnumerable<string>? prefabs, string text, string? found, string? additionalText)
		{
			InfoPanelEntryModel infoPanelEntryModel = new InfoPanelEntryModel
			{
				BodyText = text,
				AdditionalText = additionalText
			};
			if (prefabs != null)
			{
				infoPanelEntryModel.Icons.AddRange(BuildIcons(prefabs, found));
			}
			if (infoPanelEntryModel.Icons.Count == 0 && string.IsNullOrWhiteSpace(infoPanelEntryModel.AdditionalText))
			{
				return null;
			}
			return infoPanelEntryModel;
		}

		[IteratorStateMachine(typeof(<BuildIcons>d__7))]
		private IEnumerable<InfoPanelIconModel> BuildIcons(IEnumerable<string> prefabs, string? found)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <BuildIcons>d__7(-2)
			{
				<>3__prefabs = prefabs,
				<>3__found = found
			};
		}

		private static bool HasAny(IEnumerable<string> list, string search, out string? found)
		{
			string value = NormalizeSearch(search);
			foreach (string item in list)
			{
				if (NormalizeSearch(item).Contains(value))
				{
					found = item;
					return true;
				}
				ZNetScene instance = ZNetScene.instance;
				GameObject val = ((instance != null) ? instance.GetPrefab(item) : null);
				ItemDrop val2 = ((val != null) ? val.GetComponent<ItemDrop>() : null);
				if (val2 != null && NormalizeSearch(val2.m_itemData.m_shared.m_name.Localize()).Contains(value))
				{
					found = item;
					return true;
				}
			}
			found = null;
			return false;
		}

		private static string NormalizeSearch(string value)
		{
			return (value ?? string.Empty).ToLowerInvariant().Replace(" ", string.Empty);
		}

		private static string GenerateReqsText(SyncedData.EnchantmentReqs reqs)
		{
			string text = "• $enchantment_canbeenchantedwith:";
			if (reqs.enchant_prefab.IsValid())
			{
				ZNetScene instance = ZNetScene.instance;
				object obj;
				if (instance == null)
				{
					obj = null;
				}
				else
				{
					GameObject prefab = instance.GetPrefab(reqs.enchant_prefab.prefab);
					obj = ((prefab != null) ? prefab.GetComponent<ItemDrop>() : null);
				}
				ItemDrop val = (ItemDrop)obj;
				if (val != null)
				{
					text = text + "\n<color=yellow>• " + val.m_itemData.m_shared.m_name + "</color>";
				}
			}
			if (reqs.blessed_enchant_prefab.IsValid())
			{
				ZNetScene instance2 = ZNetScene.instance;
				object obj2;
				if (instance2 == null)
				{
					obj2 = null;
				}
				else
				{
					GameObject prefab2 = instance2.GetPrefab(reqs.blessed_enchant_prefab.prefab);
					obj2 = ((prefab2 != null) ? prefab2.GetComponent<ItemDrop>() : null);
				}
				ItemDrop val2 = (ItemDrop)obj2;
				if (val2 != null)
				{
					text = text + "\n<color=yellow>• " + val2.m_itemData.m_shared.m_name + "</color>";
				}
			}
			return text.Localize();
		}

		private static string GenerateStatsText(Dictionary<int, SyncedData.Stat_Data> stats)
		{
			string text = string.Empty;
			foreach (KeyValuePair<int, SyncedData.Stat_Data> item in stats.OrderBy<KeyValuePair<int, SyncedData.Stat_Data>, int>((KeyValuePair<int, SyncedData.Stat_Data> x) => x.Key))
			{
				text += $"<color=yellow>• lvl{item.Key}:</color>";
				text += EnchantmentStatFormatter.BuildInfoDescription(item.Value);
			}
			return text.Localize().Trim();
		}

		private static string GenerateChancesText(Dictionary<int, SyncedData.Chance_Data> chances)
		{
			string text = string.Empty;
			foreach (KeyValuePair<int, SyncedData.Chance_Data> item in chances.OrderBy<KeyValuePair<int, SyncedData.Chance_Data>, int>((KeyValuePair<int, SyncedData.Chance_Data> x) => x.Key))
			{
				if (!(item.Value.success < 0f) && !(item.Value.destroy < 0f))
				{
					string arg = FormatChance(item.Value.success);
					string arg2 = ((item.Value.destroy > 0f) ? (", $enchantment_destroychance: " + FormatChance(item.Value.destroy) + "%").Localize() : string.Empty);
					text += $"<color=yellow>• lvl{item.Key}:</color> {arg}%{arg2}\n";
				}
			}
			return text.Trim();
		}

		private static string FormatChance(float chance)
		{
			return Math.Round(chance, 2, MidpointRounding.AwayFromZero).ToString("0.00", CultureInfo.InvariantCulture);
		}
	}
	internal sealed class InfoPanelView : MonoBehaviour
	{
		public InputField Search;

		public Transform Content;

		private readonly Dictionary<InfoPanelCategory, GameObject> _categoryRoots = new Dictionary<InfoPanelCategory, GameObject>();

		private readonly Dictionary<InfoPanelCategory, Text> _categoryLabels = new Dictionary<InfoPanelCategory, Text>();

		public static InfoPanelView Attach(GameObject root)
		{
			InfoPanelView orAddComponent = UIBindingHelper.GetOrAddComponent<InfoPanelView>(root);
			orAddComponent.Bind();
			return orAddComponent;
		}

		public Button GetCategoryButton(InfoPanelCategory category)
		{
			return _categoryRoots[category].GetComponent<Button>();
		}

		public void SetCategorySelected(InfoPanelCategory category)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<InfoPanelCategory, Text> categoryLabel in _categoryLabels)
			{
				((Graphic)categoryLabel.Value).color = ((categoryLabel.Key == category) ? Color.yellow : Color.white);
			}
		}

		public void ClearContent()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			foreach (Transform item in Content)
			{
				Transform val = item;
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
		}

		public void ForceCanvasLayout()
		{
			List<ContentSizeFitter> list = ((Component)this).gameObject.GetComponentsInChildren<ContentSizeFitter>(true).ToList();
			Canvas.ForceUpdateCanvases();
			list.ForEach(delegate(ContentSizeFitter fitter)
			{
				((Behaviour)fitter).enabled = false;
			});
			list.ForEach(delegate(ContentSizeFitter fitter)
			{
				((Behaviour)fitter).enabled = true;
			});
		}

		public void LocalizeRoot()
		{
			if (Localization.instance != null)
			{
				Localization.instance.Localize(((Component)this).transform);
			}
		}

		private void Bind()
		{
			Transform transform = ((Component)this).transform;
			Search = UIBindingHelper.GetRequired<InputField>(transform, "Canvas/Background/Search");
			Content = UIBindingHelper.FindRequired(transform, "Canvas/Background/Scroll View/Viewport/Content");
			BindCategory(transform, InfoPanelCategory.Reqs, "Canvas/Background/Categories/Reqs");
			BindCategory(transform, InfoPanelCategory.Stats, "Canvas/Background/Categories/Stats");
			BindCategory(transform, InfoPanelCategory.Chances, "Canvas/Background/Categories/Chances");
		}

		private void BindCategory(Transform root, InfoPanelCategory category, string path)
		{
			Transform val = UIBindingHelper.FindRequired(root, path);
			_categoryRoots[category] = ((Component)val).gameObject;
			_categoryLabels[category] = UIBindingHelper.GetRequired<Text>(val, "Text");
		}
	}
	[VES_Autoload(VES_Autoload.Priority.Normal, "OnInit", new Type[]
	{
		typeof(SyncedData),
		typeof(VES_UI)
	})]
	public static class Info_UI
	{
		private static InfoPanelView? _view;

		private static InfoPanelController? _controller;

		public static bool IsVisible()
		{
			return _controller?.IsVisible ?? false;
		}

		[UsedImplicitly]
		private static void OnInit()
		{
			if (!ValheimEnchantmentSystem.NoGraphics)
			{
				GameObject val = Object.Instantiate<GameObject>(ValheimEnchantmentSystem._asset.LoadAsset<GameObject>("kg_EnchantmentUI_Info"));
				GameObject elementPrefab = ValheimEnchantmentSystem._asset.LoadAsset<GameObject>("kg_EnchantmentUI_Info_Element");
				val.SetActive(false);
				Object.DontDestroyOnLoad((Object)(object)val);
				_view = InfoPanelView.Attach(val);
				_controller = new InfoPanelController(_view, elementPrefab, new InfoPanelQueryService(), VES_UI.PlayClick);
				OverlayUiHost.Register(new OverlayUiHost.PanelRegistration("InfoPanel", IsVisible, null, delegate(GameObject tooltipPrefab)
				{
					_controller?.ConfigureTooltipPrefab(tooltipPrefab);
				}));
			}
		}

		internal static void Show(InfoPanelCategory category = InfoPanelCategory.Reqs, string? searchText = null)
		{
			_controller?.Show(category, searchText);
		}

		public static void Update()
		{
			_controller?.Update();
		}

		private static void Hide()
		{
			_controller?.Hide();
		}
	}
	internal sealed class MainEnchantmentController
	{
		private static readonly Color VfxDefaultBless = new Color(0.6313726f, 0.6156863f, 0f, 1f);

		private static readonly int Speed = Shader.PropertyToID("_Speed");

		private static readonly Color DefaultTrailColor = new Color(1f, 1f, 1f, 0.8f);

		private readonly MainEnchantmentView _view;

		private readonly Sprite _defaultQuestionMark;

		private readonly GameObject _completionVfxPrefab;

		private readonly AudioClip _oneSecondClip;

		private readonly AudioClip _threeSecondClip;

		private readonly AudioClip _sixSecondClip;

		private readonly AudioClip _successSound;

		private readonly AudioClip _failSound;

		private readonly Func<AudioSource?> _audioSourceProvider;

		private readonly Func<int> _animationDurationProvider;

		private readonly Action _playClick;

		private readonly Action<InfoPanelCategory, string?> _showInfo;

		private readonly Func<bool> _isInfoVisible;

		private readonly Func<bool> _showChanceHud;

		private readonly float _itemStartX;

		private readonly float _scrollStartX;

		private readonly float _startY;

		private bool _useBless;

		private ItemData? _currentItem;

		private bool _enchantProcessing;

		private float _enchantTimer;

		private float _timerMax;

		private bool _shouldReselect;

		public bool IsVisible
		{
			get
			{
				if ((Object)(object)_view != (Object)null)
				{
					return ((Component)_view).gameObject.activeSelf;
				}
				return false;
			}
		}

		public MainEnchantmentController(MainEnchantmentView view, Sprite defaultQuestionMark, GameObject completionVfxPrefab, AudioClip oneSecondClip, AudioClip threeSecondClip, AudioClip sixSecondClip, AudioClip successSound, AudioClip failSound, Func<AudioSource?> audioSourceProvider, Func<int> animationDurationProvider, Action playClick, Action<InfoPanelCategory, string?> showInfo, Func<bool> isInfoVisible, Func<bool> showChanceHud)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Expected O, but got Unknown
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Expected O, but got Unknown
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Expected O, but got Unknown
			_view = view;
			_defaultQuestionMark = defaultQuestionMark;
			_completionVfxPrefab = completionVfxPrefab;
			_oneSecondClip = oneSecondClip;
			_threeSecondClip = threeSecondClip;
			_sixSecondClip = sixSecondClip;
			_successSound = successSound;
			_failSound = failSound;
			_audioSourceProvider = audioSourceProvider;
			_animationDurationProvider = animationDurationProvider;
			_playClick = playClick;
			_showInfo = showInfo;
			_isInfoVisible = isInfoVisible;
			_showChanceHud = showChanceHud;
			_itemStartX = _view.ItemRect.anchoredPosition.x;
			_scrollStartX = _view.ScrollRect.anchoredPosition.x;
			_startY = _view.ScrollRect.anchoredPosition.y;
			((UnityEventBase)_view.UseBlessButton.onClick).RemoveAllListeners();
			((UnityEvent)_view.UseBlessButton.onClick).AddListener((UnityAction)delegate
			{
				_playClick();
				ToggleBless();
			});
			((UnityEventBase)_view.StartButton.onClick).RemoveAllListeners();
			((UnityEvent)_view.StartButton.onClick).AddListener((UnityAction)delegate
			{
				_playClick();
				HandleStartButton();
			});
			((UnityEventBase)_view.InfoButton.onClick).RemoveAllListeners();
			((UnityEvent)_view.InfoButton.onClick).AddListener((UnityAction)delegate
			{
				_playClick();
				_showInfo(InfoPanelCategory.Reqs, ResolveInfoSearchText());
			});
			ResetState();
		}

		public void ConfigureTooltipPrefab(GameObject? tooltipPrefab)
		{
			_view.ItemTooltip.m_tooltipPrefab = tooltipPrefab;
			_view.ChanceTooltip.m_tooltipPrefab = tooltipPrefab;
			EnchantmentPreview preview = EnchantmentPreviewService.GetPreview(_currentItem, _useBless);
			UpdateItemTooltip(preview);
			UpdateChanceTooltip(preview);
		}

		public void Show()
		{
			ResetState();
			if (!InventoryGui.IsVisible())
			{
				InventoryGui.instance.Show((Container)null, 1);
			}
			if (Localization.instance != null)
			{
				_view.LocalizeStaticText();
			}
			((Component)_view).gameObject.SetActive(true);
		}

		public void Hide()
		{
			((Component)_view).gameObject.SetActive(false);
			ResetState();
		}

		public void Update()
		{
			if (!IsVisible)
			{
				return;
			}
			if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				Hide();
			}
			else if (Input.GetKeyDown((KeyCode)27) && !_isInfoVisible())
			{
				((MonoBehaviour)(object)ValheimEnchantmentSystem._thistype).DelayedInvoke(Hide, 1);
			}
			else if (Input.GetKeyDown((KeyCode)9) && !_enchantProcessing && !_shouldReselect && !_isInfoVisible())
			{
				_playClick();
				ToggleBless();
			}
			else if ((Input.GetKeyDown((KeyCode)32) || Input.GetKeyDown((KeyCode)13)) && !_isInfoVisible())
			{
				HandleStartButton();
			}
			else
			{
				if (!_enchantProcessing)
				{
					return;
				}
				if (_currentItem == null || !((Humanoid)Player.m_localPlayer).m_inventory.ContainsItem(_currentItem))
				{
					Hide();
					return;
				}
				_enchantTimer -= Time.deltaTime;
				if (_enchantTimer <= 0f)
				{
					FinishEnchantment();
				}
				else
				{
					UpdateAnimation();
				}
			}
		}

		public void HandleDraggedItem(ItemData item)
		{
			SelectItem(item);
		}

		private void HandleStartButton()
		{
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			if (_currentItem == null || !Object.op_Implicit((Object)(object)Player.m_localPlayer) || !((Humanoid)Player.m_localPlayer).m_inventory.ContainsItem(_currentItem))
			{
				ResetState();
				return;
			}
			if (_shouldReselect)
			{
				ReselectCurrentItemPreservingBless();
				_playClick();
				return;
			}
			if (_enchantProcessing)
			{
				_enchantProcessing = false;
				_enchantTimer = 0f;
				ReselectCurrentItemPreservingBless();
				StopAudio();
				return;
			}
			EnchantmentPreview preview = EnchantmentPreviewService.GetPreview(_currentItem, _useBless);
			if (!preview.CanSelect)
			{
				ResetState();
				return;
			}
			ApplyPreview(preview);
			if (preview.CanAttempt)
			{
				_enchantProcessing = true;
				_timerMax = _animationDurationProvider();
				_enchantTimer = _timerMax;
				_view.StartText.text = "$enchantment_cancel".Localize();
				((Component)_view.ProgressRoot).gameObject.SetActive(true);
				_view.ProgressFill.fillAmount = 0f;
				_view.ProgressVfxRect.anchoredPosition = Vector2.zero;
				MainModule main = _view.ProgressVfx.main;
				((MainModule)(ref main)).startColor = MinMaxGradient.op_Implicit(_useBless ? VfxDefaultBless : Color.white);
				((Graphic)_view.ProgressAccent).color = (_useBless ? Color.yellow : Color.white);
				((Graphic)_view.ItemVisual).color = Color.clear;
				((Graphic)_view.ScrollVisual).color = Color.clear;
				SetChanceHudVisible(visible: false);
				((Component)_view.UseBlessRoot).gameObject.SetActive(false);
				_view.ItemText.text = string.Empty;
				_view.ScrollText.text = string.Empty;
				SetTrailSpeed(_view.ItemTrail, 1f);
				SetTrailSpeed(_view.ScrollTrail, 1f);
				PlayAnimationClip();
			}
		}

		private void ToggleBless()
		{
			if (_currentItem != null)
			{
				_useBless = !_useBless;
				EnchantmentPreview preview = EnchantmentPreviewService.GetPreview(_currentItem, _useBless);
				if (!preview.CanSelect)
				{
					ResetState();
				}
				else
				{
					ApplyPreview(preview);
				}
			}
		}

		private void SelectItem(ItemData? item)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			if (!IsVisible || _enchantProcessing || item == null)
			{
				return;
			}
			ResetState();
			InventoryGui.instance.SetupDragItem((ItemData)null, (Inventory)null, 1);
			if (!((Humanoid)Player.m_localPlayer).m_inventory.ContainsItem(item))
			{
				return;
			}
			EnchantmentPreview preview = EnchantmentPreviewService.GetPreview(item, useBlessedScroll: false);
			if (!preview.CanSelect)
			{
				if (!string.IsNullOrWhiteSpace(preview.BlockedMessage))
				{
					_view.ItemText.text = preview.BlockedMessage;
					((Graphic)_view.ItemText).color = Color.red;
				}
				return;
			}
			_currentItem = item;
			_view.ItemRect.anchoredPosition = new Vector2(_itemStartX, _startY);
			((Component)_view.ItemRoot).gameObject.SetActive(true);
			_view.ItemRoot.localScale = Vector3.one;
			((Component)_view.ItemTrail).gameObject.SetActive(true);
			SetChanceHudVisible(visible: true);
			((Component)_view.UseBlessRoot).gameObject.SetActive(true);
			_view.ScrollRect.anchoredPosition = new Vector2(_scrollStartX, _startY);
			((Component)_view.ScrollRoot).gameObject.SetActive(true);
			ApplyPreview(preview);
		}

		private void ApplyPreview(EnchantmentPreview? preview)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			if (preview?.Item == null)
			{
				return;
			}
			_useBless = preview.UseBlessedScroll;
			((Component)_view.UseBlessIcon).gameObject.SetActive(_useBless);
			_view.ItemText.text = preview.ItemLabel;
			_view.ItemIcon.sprite = preview.Item.GetIcon();
			((Graphic)_view.ItemTrail).color = preview.TrailColor;
			if (preview.IsMaxedOut)
			{
				_view.ItemRect.anchoredPosition = new Vector2(0f, _startY);
				_view.ItemRoot.localScale = Vector3.one;
				_view.ChanceText.text = string.Empty;
				SetChanceHudVisible(visible: false);
				((Component)_view.UseBlessRoot).gameObject.SetActive(false);
				((Component)_view.ScrollRoot).gameObject.SetActive(false);
				((Component)_view.StartRoot).gameObject.SetActive(true);
				((Selectable)_view.StartButton).interactable = false;
				_view.StartText.text = "$enchantment_maxedout_short".Localize();
				UpdateItemTooltip(preview);
				UpdateChanceTooltip(preview);
				return;
			}
			_view.ChanceText.text = BuildChanceDisplayText(preview);
			SetChanceHudVisible(visible: true);
			((Component)_view.StartRoot).gameObject.SetActive(true);
			((Selectable)_view.StartButton).interactable = preview.CanAttempt;
			_view.StartText.text = "$enchantment_enchant".Localize();
			UpdateItemTooltip(preview);
			UpdateChanceTooltip(preview);
			if (preview.HasRequirementDefinition)
			{
				_view.ScrollText.text = preview.RequirementStatusText;
				((Graphic)_view.ScrollText).color = (preview.HasRequiredItems ? Color.white : Color.red);
				_view.ScrollIcon.sprite = preview.RequirementIcon;
				((Component)_view.ScrollTrail).gameObject.SetActive(true);
				((Graphic)_view.ScrollTrail).color = (Color)(_useBless ? new Color(1f, 1f, 0f, 0.8f) : DefaultTrailColor);
			}
			else
			{
				_view.ScrollText.text = preview.RequirementStatusText;
				((Graphic)_view.ScrollText).color = Color.red;
				_view.ScrollIcon.sprite = _defaultQuestionMark;
				((Component)_view.ScrollTrail).gameObject.SetActive(false);
				((Graphic)_view.ScrollTrail).color = DefaultTrailColor;
			}
		}

		private void ResetState()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Unknown result type (might be due to invalid IL or missing references)
			StopAudio();
			_currentItem = null;
			_enchantProcessing = false;
			_enchantTimer = 0f;
			_timerMax = 0f;
			_shouldReselect = false;
			_useBless = false;
			_view.ItemRect.anchoredPosition = Vector2.zero;
			((Component)_view.ItemRoot).gameObject.SetActive(true);
			_view.ItemRoot.localScale = new Vector3(1.4f, 1.4f, 1f);
			_view.ItemText.text = "$enchantment_selectanitem".Localize();
			((Graphic)_view.ItemText).color = Color.white;
			_view.ItemIcon.sprite = _defaultQuestionMark;
			((Graphic)_view.ItemVisual).color = Color.clear;
			((Component)_view.ItemTrail).gameObject.SetActive(false);
			((Graphic)_view.ItemTrail).color = DefaultTrailColor;
			((Behaviour)_view.ItemTooltip).enabled = false;
			_view.ItemTooltip.m_text = string.Empty;
			_view.ItemTooltip.m_topic = string.Empty;
			((Behaviour)_view.ChanceTooltip).enabled = false;
			_view.ChanceTooltip.m_text = string.Empty;
			_view.ChanceTooltip.m_topic = string.Empty;
			SetTrailSpeed(_view.ItemTrail, 0.5f);
			_view.ScrollRect.anchoredPosition = new Vector2(_scrollStartX, _startY);
			((Component)_view.ScrollRoot).gameObject.SetActive(false);
			_view.ScrollRoot.localScale = Vector3.one;
			_view.ScrollText.text = "$enchantment_noenchantitems".Localize();
			((Graphic)_view.ScrollText).color = Color.red;
			_view.ScrollIcon.sprite = _defaultQuestionMark;
			((Graphic)_view.ScrollVisual).color = Color.clear;
			((Component)_view.ScrollTrail).gameObject.SetActive(false);
			((Graphic)_view.ScrollTrail).color = DefaultTrailColor;
			SetTrailSpeed(_view.ScrollTrail, 0.5f);
			((Component)_view.UseBlessRoot).gameObject.SetActive(false);
			((Component)_view.UseBlessIcon).gameObject.SetActive(false);
			((Component)_view.StartRoot).gameObject.SetActive(false);
			((Selectable)_view.StartButton).interactable = false;
			_view.StartText.text = "$enchantment_enchant".Localize();
			((Component)_view.ProgressRoot).gameObject.SetActive(false);
			_view.ProgressVfxRect.anchoredPosition = Vector2.zero;
			_view.ProgressFill.fillAmount = 0f;
			((Graphic)_view.ProgressAccent).color = Color.clear;
			MainModule main = _view.ProgressVfx.main;
			((MainModule)(ref main)).startColor = MinMaxGradient.op_Implicit(Color.clear);
			SetChanceHudVisible(visible: false);
			_view.ChanceText.text = string.Empty;
		}

		private string BuildChanceDisplayText(EnchantmentPreview preview)
		{
			return $"{preview.AttemptSummary.FinalChancePercent:0.00}%";
		}

		private void SetChanceHudVisible(bool visible)
		{
			((Component)_view.ChanceRoot).gameObject.SetActive(visible && _showChanceHud());
		}

		private void UpdateItemTooltip(EnchantmentPreview? preview)
		{
			if (!((Object)(object)_view.ItemTooltip == (Object)null))
			{
				if (preview?.Item == null || string.IsNullOrWhiteSpace(preview.NextStatsTooltipText))
				{
					((Behaviour)_view.ItemTooltip).enabled = false;
					_view.ItemTooltip.m_topic = string.Empty;
					_view.ItemTooltip.m_text = string.Empty;
				}
				else
				{
					_view.ItemTooltip.m_topic = preview.ItemDisplayName;
					_view.ItemTooltip.m_text = preview.NextStatsTooltipText;
					((Behaviour)_view.ItemTooltip).enabled = true;
				}
			}
		}

		private void UpdateChanceTooltip(EnchantmentPreview? preview)
		{
			if ((Object)(object)_view.ChanceTooltip == (Object)null)
			{
				return;
			}
			if (!_showChanceHud() || preview?.Item == null)
			{
				((Behaviour)_view.ChanceTooltip).enabled = false;
				_view.ChanceTooltip.m_topic = string.Empty;
				_view.ChanceTooltip.m_text = string.Empty;
				return;
			}
			List<string> list = new List<string>();
			if (!string.IsNullOrWhiteSpace(preview.AttemptSummary.ChanceBreakdownText))
			{
				list.Add(preview.AttemptSummary.ChanceBreakdownText);
			}
			if (!string.IsNullOrWhiteSpace(preview.AttemptSummary.FailureBreakdownText))
			{
				list.Add(preview.AttemptSummary.FailureBreakdownText);
			}
			if (list.Count == 0)
			{
				((Behaviour)_view.ChanceTooltip).enabled = false;
				_view.ChanceTooltip.m_topic = string.Empty;
				_view.ChanceTooltip.m_text = string.Empty;
			}
			else
			{
				_view.ChanceTooltip.m_topic = "$enchantment_chance".Localize();
				_view.ChanceTooltip.m_text = string.Join("\n", list);
				((Behaviour)_view.ChanceTooltip).enabled = true;
			}
		}

		private void ReselectCurrentItemPreservingBless()
		{
			if (_currentItem == null)
			{
				ResetState();
				return;
			}
			bool useBless = _useBless;
			SelectItem(_currentItem);
			if (_useBless != useBless)
			{
				ToggleBless();
			}
		}

		private void UpdateAnimation()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			float num = 1f - _enchantTimer / _timerMax;
			_view.ProgressFill.fillAmount = num;
			_view.ProgressVfxRect.anchoredPosition = new Vector2(300f * num, 0f);
			Color color = (_useBless ? new Color(1f, 1f, 0f, num) : new Color(1f, 1f, 1f, num));
			((Graphic)_view.ItemVisual).color = color;
			((Graphic)_view.ScrollVisual).color = color;
			_view.ItemRect.anchoredPosition = new Vector2(Mathf.Lerp(_itemStartX, 0f, num), Mathf.Lerp(_startY, 0f, num));
			_view.ScrollRect.anchoredPosition = new Vector2(Mathf.Lerp(_scrollStartX, 0f, num), Mathf.Lerp(_startY, 0f, num));
			_view.ItemRoot.localScale = new Vector3(1f + num * 0.4f, 1f + num * 0.4f, 1f);
			_view.ScrollRoot.localScale = new Vector3(1f + num * 0.4f, 1f + num * 0.4f, 1f);
		}

		private void FinishEnchantment()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			_view.ItemRect.anchoredPosition = Vector2.zero;
			_view.ItemRoot.localScale = new Vector3(1.4f, 1.4f, 1f);
			_enchantProcessing = false;
			_enchantTimer = 0f;
			((Component)_view.ScrollRoot).gameObject.SetActive(false);
			((Component)_view.ProgressRoot).gameObject.SetActive(false);
			Enchantment_Core.Enchanted orCreate = _currentItem.Data().GetOrCreate<Enchantment_Core.Enchanted>();
			EnchantmentResult enchantmentResult = orCreate.Enchant(Player.m_localPlayer, _useBless, SyncedData.BlessedScrollsPreventBreak.Value);
			EnchantmentSideEffects.ApplyAttemptResult(enchantmentResult);
			_view.ItemText.text = enchantmentResult.Message;
			((Graphic)_view.ItemText).color = (enchantmentResult.Success ? Color.green : Color.red);
			((Graphic)_view.ItemVisual).color = (enchantmentResult.Success ? Color.green : Color.red);
			((Graphic)_view.ItemTrail).color = SyncedData.GetColor(orCreate, out var _, trimApha: true).IncreaseColorLight().ToColorAlpha();
			GameObject val = Object.Instantiate<GameObject>(_completionVfxPrefab, _view.ItemRoot);
			MainModule main = val.GetComponent<ParticleSystem>().main;
			((MainModule)(ref main)).startColor = MinMaxGradient.op_Implicit(enchantmentResult.Success ? Color.green : Color.red);
			PlayOneShot(enchantmentResult.Success ? _successSound : _failSound);
			SetTrailSpeed(_view.ItemTrail, 0.5f);
			SetTrailSpeed(_view.ScrollTrail, 0.5f);
			_shouldReselect = true;
			((Component)_view.StartRoot).gameObject.SetActive(true);
			((Selectable)_view.StartButton).interactable = true;
			_view.StartText.text = "$enchantment_ok".Localize();
		}

		private void PlayAnimationClip()
		{
			AudioSource val = _audioSourceProvider();
			if (!((Object)(object)val == (Object)null))
			{
				val.Stop();
				val.clip = ((_timerMax <= 1f) ? _oneSecondClip : ((_timerMax <= 3f) ? _threeSecondClip : _sixSecondClip));
				val.Play();
			}
		}

		private void PlayOneShot(AudioClip clip)
		{
			AudioSource val = _audioSourceProvider();
			if (!((Object)(object)val == (Object)null) && !((Object)(object)clip == (Object)null))
			{
				val.PlayOneShot(clip);
			}
		}

		private void StopAudio()
		{
			AudioSource obj = _audioSourceProvider();
			if (obj != null)
			{
				obj.Stop();
			}
		}

		private static void SetTrailSpeed(Image trailImage, float speed)
		{
			if (!((Object)(object)((trailImage != null) ? ((Graphic)trailImage).material : null) == (Object)null))
			{
				((Graphic)trailImage).material.SetFloat(Speed, speed);
			}
		}

		private string? ResolveInfoSearchText()
		{
			return _currentItem?.m_shared?.m_name?.Localize();
		}
	}
	internal sealed class MainEnchantmentView : MonoBehaviour
	{
		public Text HeaderText;

		public Transform ItemRoot;

		public RectTransform ItemRect;

		public Text ItemText;

		public Image ItemIcon;

		public Image ItemVisual;

		public Image ItemTrail;

		public UITooltip ItemTooltip;

		public Transform ScrollRoot;

		public RectTransform ScrollRect;

		public Text ScrollText;

		public Image ScrollIcon;

		public Image ScrollVisual;

		public Image ScrollTrail;

		public Transform UseBlessRoot;

		public Text UseBlessText;

		public Button UseBlessButton;

		public Image UseBlessIcon;

		public Transform StartRoot;

		public Button StartButton;

		public Text StartText;

		public Transform ProgressRoot;

		public RectTransform ProgressVfxRect;

		public ParticleSystem ProgressVfx;

		public Image ProgressFill;

		public Image ProgressAccent;

		public Transform ChanceRoot;

		public Text ChanceText;

		public UITooltip ChanceTooltip;

		public Button InfoButton;

		public static MainEnchantmentView Attach(GameObject root)
		{
			MainEnchantmentView orAddComponent = UIBindingHelper.GetOrAddComponent<MainEnchantmentView>(root);
			orAddComponent.Bind();
			return orAddComponent;
		}

		public void LocalizeStaticText()
		{
			HeaderText.text = "$enchantment_header".Localize();
			UseBlessText.text = "$enchantment_usebless".Localize();
		}

		private void Bind()
		{
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)this).transform;
			HeaderText = UIBindingHelper.GetRequired<Text>(transform, "Canvas/Header/Text");
			ItemRoot = UIBindingHelper.FindRequired(transform, "Canvas/Background/Item");
			ItemRect = ((Component)ItemRoot).GetComponent<RectTransform>();
			ItemText = UIBindingHelper.GetRequired<Text>(ItemRoot, "Text");
			ItemIcon = UIBindingHelper.GetRequired<Image>(ItemRoot, "Icon");
			ItemVisual = UIBindingHelper.GetRequired<Image>(ItemRoot, "Visual");
			ItemTrail = UIBindingHelper.GetRequired<Image>(ItemRoot, "Trail");
			ItemTooltip = UIBindingHelper.GetOrAddComponent<UITooltip>(((Component)ItemRoot).gameObject);
			((Behaviour)ItemTooltip).enabled = false;
			ScrollRoot = UIBindingHelper.FindRequired(transform, "Canvas/Background/Scroll");
			ScrollRect = ((Component)ScrollRoot).GetComponent<RectTransform>();
			ScrollText = UIBindingHelper.GetRequired<Text>(ScrollRoot, "Text");
			ScrollIcon = UIBindingHelper.GetRequired<Image>(ScrollRoot, "Icon");
			ScrollVisual = UIBindingHelper.GetRequired<Image>(ScrollRoot, "Visual");
			ScrollTrail = UIBindingHelper.GetRequired<Image>(ScrollRoot, "Trail");
			UseBlessRoot = UIBindingHelper.FindRequired(transform, "Canvas/Background/UseBless");
			UseBlessText = UIBindingHelper.GetRequired<Text>(UseBlessRoot, "Text");
			UseBlessButton = ((Component)UseBlessRoot).GetComponent<Button>();
			UseBlessIcon = UIBindingHelper.GetRequired<Image>(UseBlessRoot, "Icon");
			((Graphic)UseBlessText).color = Color.yellow;
			StartRoot = UIBindingHelper.FindRequired(transform, "Canvas/Background/Start");
			StartButton = ((Component)StartRoot).GetComponent<Button>();
			StartText = UIBindingHelper.GetRequired<Text>(StartRoot, "Text");
			ProgressRoot = UIBindingHelper.FindRequired(transform, "Canvas/Background/Progress");
			ProgressVfxRect = ((Component)UIBindingHelper.FindRequired(ProgressRoot, "VFX")).GetComponent<RectTransform>();
			ProgressVfx = ((Component)ProgressVfxRect).GetComponent<ParticleSystem>();
			ProgressFill = UIBindingHelper.GetRequired<Image>(ProgressRoot, "Fill");
			ProgressAccent = ((Component)((Component)ProgressFill).transform.GetChild(0)).GetComponent<Image>();
			ChanceRoot = UIBindingHelper.FindRequired(transform, "Canvas/Background/Chance");
			ChanceText = UIBindingHelper.GetRequired<Text>(ChanceRoot, "Text");
			ChanceText.supportRichText = true;
			Image orAddComponent = UIBindingHelper.GetOrAddComponent<Image>(((Component)ChanceRoot).gameObject);
			((Graphic)orAddComponent).color = Color.clear;
			((Graphic)orAddComponent).raycastTarget = true;
			ChanceTooltip = UIBindingHelper.GetOrAddComponent<UITooltip>(((Component)ChanceRoot).gameObject);
			((Behaviour)ChanceTooltip).enabled = false;
			InfoButton = ((Component)UIBindingHelper.FindRequired(transform, "Canvas/Background/Info")).GetComponent<Button>();
		}
	}
	[VES_Autoload(VES_Autoload.Priority.Normal, "OnInit", new Type[] { typeof(SyncedData) })]
	public static class VES_UI
	{
		private enum GamepadShortcutButton
		{
			Disabled,
			JoyButtonA,
			JoyButtonB,
			JoyButtonX,
			JoyButtonY,
			JoyLBumper,
			JoyRBumper,
			JoyLTrigger,
			JoyRTrigger,
			JoyLStick,
			JoyRStick,
			JoyBack,
			JoyStart,
			JoyDPadUp,
			JoyDPadDown,
			JoyDPadLeft,
			JoyDPadRight
		}

		[HarmonyPatch(typeof(AudioMan), "Awake")]
		[ClientOnlyPatch]
		private static class AudioMan_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix(AudioMan __instance)
			{
				AudioMixerGroup val = __instance.m_masterMixer.FindMatchingGroups("SFX")[0];
				EnsureAudioSource(val);
				GameObject[] array = ValheimEnchantmentSystem._asset.LoadAllAssets<GameObject>();
				foreach (GameObject val2 in array)
				{
					AudioSource[] componentsInChildren = val2.GetComponentsInChildren<AudioSource>(true);
					foreach (AudioSource val3 in componentsInChildren)
					{
						val3.outputAudioMixerGroup = val;
					}
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "SetupDragItem")]
		[ClientOnlyPatch]
		private static class InventoryGui_SetupDragItem_Patch
		{
			[UsedImplicitly]
			private static void Postfix(InventoryGui __instance)
			{
				if (Object.op_Implicit((Object)(object)__instance.m_dragGo) && __instance.m_dragItem != null)
				{
					_controller?.HandleDraggedItem(__instance.m_dragItem);
				}
			}
		}

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

			public static EventHandler <>9__18_0;

			public static Func<AudioSource?> <>9__18_1;

			public static Func<int> <>9__18_2;

			public static Func<bool> <>9__18_3;

			public static Action<GameObject> <>9__18_4;

			public static UnityAction <>9__22_0;

			internal void <OnInit>b__18_0(object _, EventArgs _)
			{
				ApplyEnchantmentGamepadShortcut();
			}

			internal AudioSource? <OnInit>b__18_1()
			{
				return AUsrc;
			}

			internal int <OnInit>b__18_2()
			{
				return Mathf.Clamp(_enchantmentAnimationDuration.Value, 1, 5);
			}

			internal bool <OnInit>b__18_3()
			{
				return true;
			}

			internal void <OnInit>b__18_4(GameObject tooltipPrefab)
			{
				_controller?.ConfigureTooltipPrefab(tooltipPrefab);
			}

			internal void <HandleInventoryGuiAwake>b__22_0()
			{
				if (IsVisible())
				{
					Hide();
				}
				else
				{
					Show();
				}
				PlayClick();
			}
		}

		private static AudioSource? AUsrc;

		private static AudioClip _oneSecondClip;

		private static AudioClip _threeSecondClip;

		private static AudioClip _sixSecondClip;

		private static AudioClip _click;

		private static AudioClip _successSound;

		private static AudioClip _failSound;

		private static GameObject _completionVfxPrefab;

		private static Sprite _defaultQuestionMark;

		private static MainEnchantmentView? _view;

		private static MainEnchantmentController? _controller;

		private static Button? _enchantmentButton;

		private static GameObject? _enchantmentBackground;

		private static GameObject? _enchantmentButtonGamepadHint;

		public static ConfigEntry<int> _enchantmentAnimationDuration;

		private static ConfigEntry<GamepadShortcutButton> _gamepadShortcut;

		public static bool IsVisible()
		{
			return _controller?.IsVisible ?? false;
		}

		[UsedImplicitly]
		private static void OnInit()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			if (!ValheimEnchantmentSystem.NoGraphics)
			{
				_enchantmentAnimationDuration = ValheimEnchantmentSystem.ClientConfig(string.Empty, "EnchantmentAnimationDuration", 1, new ConfigDescription("Duration of the enchantment animation in seconds. Values outside 1-5 are clamped at runtime.", (AcceptableValueBase)null, Array.Empty<object>()));
				_gamepadShortcut = ValheimEnchantmentSystem.ClientConfig("UI", "GamepadShortcut", GamepadShortcutButton.JoyButtonX, new ConfigDescription("Controller shortcut assigned to the enchantment inventory button. Change this if it conflicts with repair; set to Disabled to remove the shortcut.", (AcceptableValueBase)null, Array.Empty<object>()));
				_gamepadShortcut.SettingChanged += delegate
				{
					ApplyEnchantmentGamepadShortcut();
				};
				_oneSecondClip = ValheimEnchantmentSystem._asset.LoadAsset<AudioClip>("kg_EnchantmentSound_Main_1");
				_threeSecondClip = ValheimEnchantmentSystem._asset.LoadAsset<AudioClip>("kg_EnchantmentSound_Main_3");
				_sixSecondClip = ValheimEnchantmentSystem._asset.LoadAsset<AudioClip>("kg_EnchantmentSound_Main_6");
				_completionVfxPrefab = ValheimEnchantmentSystem._asset.LoadAsset<GameObject>("kg_EnchantmentUI_VFX1");
				_defaultQuestionMark = ValheimEnchantmentSystem._asset.LoadAsset<Sprite>("kg_EnchantmentQuestion");
				_click = ValheimEnchantmentSystem._asset.LoadAsset<AudioClip>("kg_EnchantmentClick");
				_successSound = ValheimEnchantmentSystem._asset.LoadAsset<AudioClip>("kg_EnchantmentSound_Success");
				_failSound = ValheimEnchantmentSystem._asset.LoadAsset<AudioClip>("kg_EnchantmentSound_Fail");
				GameObject val = Object.Instantiate<GameObject>(ValheimEnchantmentSystem._asset.LoadAsset<GameObject>("kg_EnchantmentUI"));
				val.SetActive(false);
				Object.DontDestroyOnLoad((Object)(object)val);
				_view = MainEnchantmentView.Attach(val);
				_controller = new MainEnchantmentController(_view, _defaultQuestionMark, _completionVfxPrefab, _oneSecondClip, _threeSecondClip, _sixSecondClip, _successSound, _failSound, () => AUsrc, () => Mathf.Clamp(_enchantmentAnimationDuration.Value, 1, 5), PlayClick, Info_UI.Show, Info_UI.IsVisible, () => true);
				OverlayUiHost.Register(new OverlayUiHost.PanelRegistration("Enchantment", IsVisible, IsVisible, delegate(GameObject tooltipPrefab)
				{
					_controller?.ConfigureTooltipPrefab(tooltipPrefab);
				}, HandleInventoryGuiAwake, HandleInventoryGuiShow));
			}
		}

		public static void Update()
		{
			_controller?.Update();
		}

		private static void Show()
		{
			_controller?.Show();
		}

		private static void Hide()
		{
			_controller?.Hide();
		}

		private static void HandleInventoryGuiAwake(InventoryGui inventoryGui)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			if ((Object)(object)_enchantmentButton != (Object)null)
			{
				return;
			}
			if ((Object)(object)((Component)inventoryGui.m_repairPanel).gameObject != (Object)(object)((Component)inventoryGui.m_repairButton).gameObject)
			{
				_enchantmentBackground = Object.Instantiate<GameObject>(((Component)inventoryGui.m_repairPanel).gameObject);
				_enchantmentBackground.transform.SetParent(((Component)inventoryGui.m_repairPanel).transform.parent, false);
				RectTransform component = _enchantmentBackground.GetComponent<RectTransform>();
				component.anchoredPosition += new Vector2(0f, 74f);
				_enchantmentBackground.transform.SetAsFirstSibling();
			}
			else
			{
				_enchantmentBackground = new GameObject("enchantment_menu_background");
			}
			_enchantmentButton = Object.Instantiate<GameObject>(((Component)inventoryGui.m_repairButton).gameObject).GetComponent<Button>();
			((Component)_enchantmentButton).transform.SetParent(((Component)inventoryGui.m_repairButton).transform.parent, false);
			((Object)_enchantmentButton).name = "enchantment_menu";
			((UnityEventBase)_enchantmentButton.onClick).RemoveAllListeners();
			ButtonClickedEvent onClick = _enchantmentButton.onClick;
			object obj = <>c.<>9__22_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					if (IsVisible())
					{
						Hide();
					}
					else
					{
						Show();
					}
					PlayClick();
				};
				<>c.<>9__22_0 = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			RectTransform component2 = ((Component)_enchantmentButton).GetComponent<RectTransform>();
			component2.anchoredPosition += new Vector2(0f, 74f);
			Transform? obj2 = UIBindingHelper.FindOptional(((Component)_enchantmentButton).transform, "Glow");
			if (obj2 != null)
			{
				((Component)obj2).gameObject.SetActive(false);
			}
			((Component)_enchantmentButton).gameObject.SetActive(true);
			UIBindingHelper.GetRequired<Image>(((Component)_enchantmentButton).transform, "Image").sprite = ValheimEnchantmentSystem._asset.LoadAsset<Sprite>("kg_Enchantment_Icon");
			ApplyEnchantmentGamepadShortcut();
		}

		private static void HandleInventoryGuiShow()
		{
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				if (Localization.instance != null && (Object)(object)_enchantmentButton != (Object)null)
				{
					((Component)_enchantmentButton).GetComponent<UITooltip>().m_text = "$enchantment_menu".Localize();
				}
				GameObject? enchantmentBackground = _enchantmentBackground;
				if (enchantmentBackground != null)
				{
					enchantmentBackground.SetActive(true);
				}
				Button? enchantmentButton = _enchantmentButton;
				if (enchantmentButton != null)
				{
					((Component)enchantmentButton).gameObject.SetActive(true);
				}
				ApplyEnchantmentGamepadShortcut();
			}
		}

		private static void ApplyEnchantmentGamepadShortcut()
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_enchantmentButton == (Object)null || _gamepadShortcut == null)
			{
				return;
			}
			UIGamePad component = ((Component)_enchantmentButton).GetComponent<UIGamePad>();
			if (!((Object)(object)component == (Object)null))
			{
				if ((Object)(object)_enchantmentButtonGamepadHint == (Object)null && (Object)(object)component.m_hint != (Object)null)
				{
					_enchantmentButtonGamepadHint = component.m_hint;
				}
				string text = (component.m_zinputKey = ToZInputKey(_gamepadShortcut.Value));
				component.m_keyCode = (KeyCode)0;
				component.m_hint = (string.IsNullOrEmpty(text) ? null : _enchantmentButtonGamepadHint);
				UpdateGamepadHint(component.m_hint, text);
			}
		}

		private static string ToZInputKey(GamepadShortcutButton button)
		{
			if (button != 0)
			{
				return button.ToString();
			}
			return string.Empty;
		}

		private static void UpdateGamepadHint(GameObject? hint, string zinputKey)
		{
			if ((Object)(object)hint == (Object)null)
			{
				return;
			}
			if (string.IsNullOrEmpty(zinputKey))
			{
				hint.SetActive(false);
				return;
			}
			string text = ResolveGamepadShortcutLabel(zinputKey);
			Text[] componentsInChildren = hint.GetComponentsInChildren<Text>(true);
			foreach (Text val in componentsInChildren)
			{
				val.text = text;
			}
			TMP_Text[] componentsInChildren2 = hint.GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text val2 in componentsInChildren2)
			{
				val2.text = text;
			}
		}

		private static string ResolveGamepadShortcutLabel(string zinputKey)
		{
			try
			{
				string boundKeyString = ZInput.instance.GetBoundKeyString(zinputKey, true);
				return string.IsNullOrWhiteSpace(boundKeyString) ? zinputKey : boundKeyString;
			}
			catch
			{
				return zinputKey;
			}
		}

		public static void PlayClick()
		{
			if ((Object)(object)AUsrc != (Object)null && (Object)(object)_click != (Object)null)
			{
				AUsrc.PlayOneShot(_click);
			}
		}

		private static AudioSource EnsureAudioSource(AudioMixerGroup sfxGroup)
		{
			if ((Object)(object)AUsrc == (Object)null)
			{
				AUsrc = Chainloader.ManagerObject.GetComponent<AudioSource>();
				if ((Object)(object)AUsrc == (Object)null)
				{
					AUsrc = Chainloader.ManagerObject.AddComponent<AudioSource>();
				}
			}
			AUsrc.reverbZoneMix = 0f;
			AUsrc.spatialBlend = 0f;
			AUsrc.bypassListenerEffects = true;
			AUsrc.bypassEffects = true;
			AUsrc.volume = 1f;
			AUsrc.outputAudioMixerGroup = sfxGroup;
			return AUsrc;
		}
	}
	[VES_Autoload(VES_Autoload.Priority.Last, "OnInit", new Type[] { })]
	public static class Notifications_UI
	{
		private class Notification
		{
			public string PlayerName;

			public string ItemPrefab;

			public int Type;

			public int PrevLevel;

			public int Level;
		}

		[Flags]
		public enum Filter
		{
			None = 0,
			Success = 1,
			Fail = 2
		}

		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public int? Order;
		}

		public enum NotificationItemResult
		{
			Success,
			LevelDecrease,
			Destroyed
		}

		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		[ClientOnlyPatch]
		private static class ZNetScene_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix(ZNetScene __instance)
			{
				ResetTransientState();
				ZRoutedRpc.instance.Register<string, string, int, int, int>("kg_Enchantment_GlobalNotification", (Method<string, string, int, int, int>)delegate(long sender, string playerName, string itemPrefab, int type, int prevLevel, int level)
				{
					if (IsServerSender(sender))
					{
						switch ((NotificationItemResult)type)
						{
						case NotificationItemResult.Success:
							if (!_filterConfig.Value.HasFlagFast(Filter.Success))
							{
								return;
							}
							break;
						case NotificationItemResult.LevelDecrease:
						case NotificationItemResult.Destroyed:
							if (!_filterConfig.Value.HasFlagFast(Filter.Fail))
							{
								return;
							}
							break;
						}
						_notifications.Enqueue(new Notification
						{
							PlayerName = playerName,
							ItemPrefab = itemPrefab,
							Type = type,
							Level = level,
							PrevLevel = prevLevel
						});
					}
				});
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		private static class ZNetScene_Awake_Server_Patch
		{
			[UsedImplicitly]
			private static void Postfix(ZNetScene __instance)
			{
				ResetTransientState();
				ZRoutedRpc.instance.Register<string, int, int, int>("kg_Enchantment_GlobalNotification_Request", (Method<string, int, int, int>)delegate(long sender, string itemPrefab, int type, int prevLevel, int level)
				{
					if (Object.op_Implicit((Object)(object)ZNet.instance) && ZNet.instance.IsServer() && IsAllowedByCooldown(sender) && TryResolveSenderPlayerName(sender, out string playerName))
					{
						ServerPublishNotification(playerName, itemPrefab ?? "No Prefab", type, prevLevel, level);
					}
				});
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "Awake")]
		[ClientOnlyPatch]
		private static class FejdStartup_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix()
			{
				ResetTransientState();
			}
		}

		[CompilerGenerated]
		private sealed class <GetWebhookTargets>d__42 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private NotificationItemResult type;

			public NotificationItemResult <>3__type;

			private ConfigEntry<string>[] <>7__wrap1;

			private int <>7__wrap2;

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

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

			[DebuggerHidden]
			public <GetWebhookTargets>d__42(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_0081;
				}
				<>1__state = -1;
				ConfigEntry<string>[] array = ((type == NotificationItemResult.Success) ? _successWebhooks : _failWebhooks);
				<>7__wrap1 = array;
				<>7__wrap2 = 0;
				goto IL_008f;
				IL_0081:
				<>7__wrap2++;
				goto IL_008f;
				IL_008f:
				if (<>7__wrap2 < <>7__wrap1.Length)
				{
					ConfigEntry<string> val = <>7__wrap1[<>7__wrap2];
					if (val != null)
					{
						string text = (val.Value ?? "").Trim();
						if (text.Length != 0)
						{
							<>2__current = text;
							<>1__state = 1;
							return true;
						}
					}
					goto IL_0081;
				}
				<>7__wrap1 = null;
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				<GetWebhookTargets>d__42 <GetWebhookTargets>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetWebhookTargets>d__ = this;
				}
				else
				{
					<GetWebhookTargets>d__ = new <GetWebhookTargets>d__42(0);
				}
				<GetWebhookTargets>d__.type = <>3__type;
				return <GetWebhookTargets>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<string>)this).GetEnumerator();
			}
		}

		private const int SuccessWebhook1Order = 600;

		private const int SuccessWebhook2Order = 599;

		private const int SuccessWebhook3Order = 598;

		private const int FailWebhook1Order = 500;

		private const int FailWebhook2Order = 499;

		private const int FailWebhook3Order = 498;

		public static readonly ConfigEntry<string>[] _successWebhooks = new ConfigEntry<string>[3];

		public static readonly ConfigEntry<string>[] _failWebhooks = new ConfigEntry<string>[3];

		public static ConfigEntry<int> _duration;

		private const float FadeDuration = 0.25f;

		private static readonly Queue<Notification> _notifications = new Queue<Notification>();

		private static GameObject UI;

		private static readonly List<Image> _colorGroup = new List<Image>();

		private static readonly Color SuccessColor = Color.green;

		private static readonly Color FailColor = Color.red;

		private static Image ItemIcon;

		private static Text ResultText;

		private static Text ItemNameText;

		private static Transform Scaler;

		private static Image Outline;

		public static ConfigEntry<Filter> _filterConfig;

		private const float NotificationRequestCooldown = 0.35f;

		private static readonly Dictionary<long, float> _requestCooldownUntil = new Dictionary<long, float>();

		private static readonly Vector3 OriginalScale = new Vector3(1.25f, 1.25f, 1f);

		private static float _timer;

		private static float _dequeueTimer = 1f;

		private static bool IsVisible()
		{
			if (Object.op_Implicit((Object)(object)UI))
			{
				return UI.activeSelf;
			}
			return false;
		}

		public static bool HasFlagFast(this Filter value, Filter flag)
		{
			return (value & flag) == flag;
		}

		private static ConfigDescription OrderedDescription(string description, int order)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			return new ConfigDescription(description, (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = order
				}
			});
		}

		[UsedImplicitly]
		private static void OnInit()
		{
			_successWebhooks[0] = ValheimEnchantmentSystem.config("Notifications", "SuccessWebhook1", "", OrderedDescription("Discord webhook #1 for success notifications", 600), synchronizedSetting: false);
			_successWebhooks[1] = ValheimEnchantmentSystem.config("Notifications", "SuccessWebhook2", "", OrderedDescription("Discord webhook #2 for success notifications", 599), synchronizedSetting: false);
			_successWebhooks[2] = ValheimEnchantmentSystem.config("Notifications", "SuccessWebhook3", "", OrderedDescription("Discord webhook #3 for success notifications", 598), synchronizedSetting: false);
			_failWebhooks[0] = ValheimEnchantmentSystem.config("Notifications", "FailWebhook1", "", OrderedDescription("Discord webhook #1 for fail notifications", 500), synchronizedSetting: false);
			_failWebhooks[1] = ValheimEnchantmentSystem.config("Notifications", "FailWebhook2", "", OrderedDescription("Discord webhook #2 for fail notifications", 499), synchronizedSetting: false);
			_failWebhooks[2] = ValheimEnchantmentSystem.config("Notifications", "FailWebhook3", "", OrderedDescription("Discord webhook #3 for fail notifications", 498), synchronizedSetting: false);
			if (!ValheimEnchantmentSystem.NoGraphics)
			{
				_filterConfig = ValheimEnchantmentSystem.ClientConfig("Notifications", "Filter", Filter.Success, "Filter notifications by type");
				_duration = ValheimEnchantmentSystem.ClientConfig("Notifications", "Duration", 5, "Duration of notification");
				UI = Object.Instantiate<GameObject>(ValheimEnchantmentSystem._asset.LoadAsset<GameObject>("kg_EnchantmentUI_Notification"));
				((Object)UI).name = "kg_EnchantmentUI_Notification";
				UI.SetActive(false);
				Object.DontDestroyOnLoad((Object)(object)UI);
				Scaler = UI.transform.Find("Canvas/Scaler");
				ItemIcon = ((Component)UI.transform.Find("Canvas/Scaler/NotificationItem/bg/Icon")).GetComponent<Image>();
				ResultText = ((Component)UI.transform.Find("Canvas/Scaler/NotificationText/Result")).GetComponent<Text>();
				ItemNameText = ((Component)UI.transform.Find("Canvas/Scaler/NotificationText/Text")).GetComponent<Text>();
				Outline = ((Component)UI.transform.Find("Canvas/Scaler/NotificationItem/outline")).GetComponent<Image>();
				_colorGroup.AddRange(from t in UI.GetComponentsInChildren<Image>(true)
					where ((Object)t).name == "colorcontrol"
					select t into x
					select ((Component)x).GetComponent<Image>());
			}
		}

		public static void Update()
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			_dequeueTimer -= Time.deltaTime;
			if (_dequeueTimer <= 0f)
			{
				_dequeueTimer = 1f;
				if (_notifications.Count > 0 && !IsVisible() && Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					Notification not = _notifications.Dequeue();
					ShowNotification(not);
				}
			}
			if (IsVisible())
			{
				_timer += Time.deltaTime;
				int value = _duration.Value;
				if (_timer >= (float)value)
				{
					Hide();
				}
				else if (_timer <= 0.25f)
				{
					Scaler.localScale = OriginalScale * (_timer / 0.25f);
				}
				else if (_timer >= (float)value - 0.25f)
				{
					Scaler.localScale = OriginalScale * (((float)value - _timer) / 0.25f);
				}
				else
				{
					Scaler.localScale = OriginalScale;
				}
			}
		}

		internal static void ResetTransientState()
		{
			_notifications.Clear();
			_requestCooldownUntil.Clear();
			_dequeueTimer = 1f;
			Hide();
		}

		private static void Hide()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			_timer = 0f;
			if ((Object)(object)Scaler != (Object)null)
			{
				Scaler.localScale = Vector3.zero;
			}
			if ((Object)(object)UI != (Object)null)
			{
				UI.SetActive(false);
			}
		}

		private static void ShowNotification(Notification not)
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			NotificationItemResult type = (NotificationItemResult)not.Type;
			switch (type)
			{
			case NotificationItemResult.Success:
				if (!_filterConfig.Value.HasFlagFast(Filter.Success))
				{
					_dequeueTimer = 0f;
					return;
				}
				break;
			case NotificationItemResult.LevelDecrease:
			case NotificationItemResult.Destroyed:
				if (!_filterConfig.Value.HasFlagFast(Filter.Fail))
				{
					_dequeueTimer = 0f;
					return;
				}
				break;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab(not.ItemPrefab);
			if (!Object.op_Implicit((Object)(object)prefab))
			{
				return;
			}
			ItemDrop component = prefab.GetComponent<ItemDrop>();
			if (component == null)
			{
				return;
			}
			string text = component.m_itemData.m_shared.m_name.Localize();
			_timer = 0f;
			Scaler.localScale = OriginalScale;
			Text resultText = ResultText;
			string text2;
			switch (type)
			{
			case NotificationItemResult.Success:
				text2 = "$enchantment_notification_success_topic".Localize();
				break;
			case NotificationItemResult.LevelDecrease:
			case NotificationItemResult.Destroyed:
				text2 = "$enchantment_notification_fail_topic".Localize();
				break;
			default:
				text2 = "";
				break;
			}
			resultText.text = text2;
			((Graphic)ResultText).color = ((type == NotificationItemResult.Success) ? SuccessColor : FailColor);
			ItemIcon.sprite = component.m_itemData.GetIcon();
			foreach (Image item in _colorGroup)
			{
				((Graphic)item).color = ((type == NotificationItemResult.Success) ? SuccessColor : FailColor);
			}
			string text3 = type switch
			{
				NotificationItemResult.Success => "$enchantment_notification_success".Localize(not.PlayerName, text, not.PrevLevel.ToString(), not.Level.ToString()), 
				NotificationItemResult.LevelDecrease => "$enchantment_notification_fail".Localize(not.PlayerName, text, not.PrevLevel.ToString(), not.Level.ToString()), 
				NotificationItemResult.Destroyed => "$enchantment_notification_fail_destroyed".Localize(not.PlayerName, text, not.PrevLevel.ToString()), 
				_ => "", 
			};
			ItemNameText.text = text3;
			((Graphic)ItemNameText).color = ((type == NotificationItemResult.Success) ? SuccessColor : FailColor);
			((Graphic)Outline).color = SyncedData.GetColor(not.ItemPrefab, not.Level, out var _, trimApha: true, (type == NotificationItemResult.Success) ? "#00FF00" : "#FF0000").IncreaseColorLight().ToColorAlpha();
			UI.SetActive(true);
		}

		private static bool IsServerSender(long sender)
		{
			if (ZRoutedRpc.instance == null)
			{
				return false;
			}
			return sender == ZRoutedRpc.instance.GetServerPeerID();
		}

		private static bool IsValidNotification(int type, int prevLevel, int level, string itemPrefab)
		{
			if (!Enum.IsDefined(typeof(NotificationItemResult), type))
			{
				return false;
			}
			if (prevLevel < 0 || level < 0 || prevLevel > 500 || level > 500)
			{
				return false;
			}
			if (string.IsNullOrWhiteSpace(itemPrefab) || !Object.op_Implicit((Object)(object)ZNetScene.instance))
			{
				return false;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab(itemPrefab);
			return ((prefab != null) ? prefab.GetComponent<ItemDrop>() : null) != null;
		}

		private static bool TryResolveSenderPlayerName(long sender, out string playerName)
		{
			playerName = "";
			if (ZRoutedRpc.instance == null)
			{
				return false;
			}
			object peer = ZRoutedRpc.instance.GetPeer(sender);
			if (peer == null)
			{
				return false;
			}
			if (AccessTools.Field(peer.GetType(), "m_playerName")?.GetValue(peer) is string text && !string.IsNullOrWhiteSpace(text))
			{
				playerName = text;
				return true;
			}
			if (AccessTools.Property(peer.GetType(), "m_playerName")?.GetValue(peer) is string text2 && !string.IsNullOrWhiteSpace(text2))
			{
				playerName = text2;
				return true;
			}
			return false;
		}

		private static bool IsAllowedByCooldown(long sender)
		{
			float time = Time.time;
			if (_requestCooldownUntil.TryGetValue(sender, out var value) && time < value)
			{
				return false;
			}
			_requestCooldownUntil[sender] = time + 0.35f;
			return true;
		}

		[IteratorStateMachine(typeof(<GetWebhookTargets>d__42))]
		private static IEnumerable<string> GetWebhookTargets(NotificationItemResult type)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetWebhookTargets>d__42(-2)
			{
				<>3__type = type
			};
		}

		private static void TrySendDiscordNotification(string playerName, string itemPrefab, NotificationItemResult type, int prevLevel, int level)
		{
			string text = itemPrefab;
			GameObject prefab = ZNetScene.instance.GetPrefab(itemPrefab);
			ItemDrop val = ((prefab != null) ? prefab.GetComponent<ItemDrop>() : null);
			if (val != null)
			{
				text = val.m_itemData.m_shared.m_name.Localize();
			}
			string msg = type switch
			{
				NotificationItemResult.Success => "$enchantment_notification_success".Localize(playerName, text, prevLevel.ToString(), level.ToString()), 
				NotificationItemResult.LevelDecrease => "$enchantment_notification_fail".Localize(playerName, text, prevLevel.ToString(), level.ToString()), 
				NotificationItemResult.Destroyed => "$enchantment_notification_fail_destroyed".Localize(playerName, text, prevLevel.ToString()), 
				_ => "", 
			};
			foreach (string item in GetWebhookTargets(type).Distinct<string>(StringComparer.OrdinalIgnoreCase))
			{
				DiscordWebhook.TrySend(item, msg);
			}
		}

		private static void ServerPublishNotification(string playerName, string itemPrefab, int type, int prevLevel, int level)
		{
			if (Object.op_Implicit((Object)(object)ZNet.instance) && ZNet.instance.IsServer() && IsValidNotification(type, prevLevel, level, itemPrefab))
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "kg_Enchantment_GlobalNotification", new object[5]
				{
					playerName ?? "No Name",
					itemPrefab,
					type,
					prevLevel,
					level
				});
				TrySendDiscordNotification(playerName ?? "No Name", itemPrefab, (NotificationItemResult)type, prevLevel, level);
			}
		}

		public static void AddNotification(string playerName, string itemPrefab, int type, int prevLevel, int level)
		{
			if (ZRoutedRpc.instance != null)
			{
				if (Object.op_Implicit((Object)(object)ZNet.instance) && ZNet.instance.IsServer())
				{
					ServerPublishNotification(playerName ?? "No Name", itemPrefab ?? "No Prefab", type, prevLevel, level);
					return;
				}
				ZRoutedRpc.instance.InvokeRoutedRPC("kg_Enchantment_GlobalNotification_Request", new object[4]
				{
					itemPrefab ?? "No Prefab",
					type,
					prevLevel,
					level
				});
			}
		}
	}
	internal static class OverlayUiHost
	{
		internal sealed class PanelRegistration
		{
			public readonly string Key;

			public readonly Func<bool> IsVisible;

			public readonly Func<bool>? BlocksInventoryHide;

			public readonly Action<GameObject>? ConfigureTooltipPrefab;

			public readonly Action<InventoryGui>? OnInventoryGuiAwake;

			public readonly Action? OnInventoryGuiShow;

			public PanelRegistration(string key, Func<bool> isVisible, Func<bool>? blocksInventoryHide = null, Action<GameObject>? configureTooltipPrefab = null, Action<InventoryGui>? onInventoryGuiAwake = null, Action? onInventoryGuiShow = null)
			{
				Key = key;
				IsVisible = isVisible ?? throw new ArgumentNullException("isVisible");
				BlocksInventoryHide = blocksInventoryHide;
				ConfigureTooltipPrefab = configureTooltipPrefab;
				OnInventoryGuiAwake = onInventoryGuiAwake;
				OnInventoryGuiShow = onInventoryGuiShow;
			}
		}

		[HarmonyPatch(typeof(TextInput), "IsVisible")]
		[ClientOnlyPatch]
		private static class TextInput_IsVisible_Patch
		{
			[UsedImplicitly]
			private static void Postfix(ref bool __result)
			{
				__result |= AnyVisible();
			}
		}

		[HarmonyPatch(typeof(StoreGui), "IsVisible")]
		[ClientOnlyPatch]
		private static class StoreGui_IsVisible_Patch
		{
			[UsedImplicitly]
			private static void Postfix(ref bool __result)
			{
				__result |= AnyVisible();
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Awake")]
		[ClientOnlyPatch]
		private static class InventoryGui_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix(InventoryGui __instance)
			{
				NotifyInventoryGuiAwake(__instance);
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Show")]
		[ClientOnlyPatch]
		private static class InventoryGui_Show_Patch
		{
			[UsedImplicitly]
			private static void Postfix()
			{
				NotifyInventoryGuiShow();
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Hide")]
		[ClientOnlyPatch]
		private static class InventoryGui_Hide_Patch
		{
			[UsedImplicitly]
			private static bool Prefix()
			{
				return !BlocksInventoryHide();
			}
		}

		private static readonly Dictionary<string, PanelRegistration> Panels = new Dictionary<string, PanelRegistration>(StringComparer.Ordinal);

		public static void Register(PanelRegistration registration)
		{
			if (registration != null && !string.IsNullOrWhiteSpace(registration.Key))
			{
				Panels[registration.Key] = registration;
			}
		}

		public static bool AnyVisible()
		{
			return Panels.Values.Any((PanelRegistration panel) => SafeInvoke(panel.Key, panel.IsVisible));
		}

		public static bool BlocksInventoryHide()
		{
			return Panels.Values.Any((PanelRegistration panel) => panel.BlocksInventoryHide != null && SafeInvoke(panel.Key, panel.BlocksInventoryHide));
		}

		public static void NotifyInventoryGuiAwake(InventoryGui inventoryGui)
		{
			InventoryGui inventoryGui2 = inventoryGui;
			if ((Object)(object)inventoryGui2 == (Object)null)
			{
				return;
			}
			InventoryGrid playerGrid = inventoryGui2.m_playerGrid;
			object obj;
			if (playerGrid == null)
			{
				obj = null;
			}
			else
			{
				GameObject elementPrefab = playerGrid.m_elementPrefab;
				obj = ((elementPrefab == null) ? null : elementPrefab.GetComponent<UITooltip>()?.m_tooltipPrefab);
			}
			GameObject tooltipPrefab = (GameObject)obj;
			if ((Object)(object)tooltipPrefab != (Object)null)
			{
				foreach (PanelRegistration panel2 in Panels.Values)
				{
					SafeInvoke(panel2.Key, delegate
					{
						panel2.ConfigureTooltipPrefab?.Invoke(tooltipPrefab);
					});
				}
			}
			foreach (PanelRegistration panel in Panels.Values)
			{
				SafeInvoke(panel.Key, delegate
				{
					panel.OnInventoryGuiAwake?.Invoke(inventoryGui2);
				});
			}
		}

		public static void NotifyInventoryGuiShow()
		{
			foreach (PanelRegistration panel in Panels.Values)
			{
				SafeInvoke(panel.Key, delegate
				{
					panel.OnInventoryGuiShow?.Invoke();
				});
			}
		}

		private static bool SafeInvoke(string key, Func<bool> callback)
		{
			try
			{
				return callback();
			}
			catch (Exception ex)
			{
				Debug.LogWarning((object)("[kg.ValheimEnchantmentSystem] Overlay host callback failed for '" + key + "': " + ex.Message));
				return false;
			}
		}

		private static void SafeInvoke(string key, Action callback)
		{
			try
			{
				callback();
			}
			catch (Exception ex)
			{
				Debug.LogWarning((object)("[kg.ValheimEnchantmentSystem] Overlay host callback failed for '" + key + "': " + ex.Message));
			}
		}
	}
	internal static class UIBindingHelper
	{
		public static Transform FindRequired(Transform root, string path)
		{
			Transform val = root.Find(path);
			if ((Object)(object)val == (Object)null)
			{
				throw new InvalidOperationException("UI binding path not found: " + path);
			}
			return val;
		}

		public static Transform? FindOptional(Transform root, string path)
		{
			return root.Find(path);
		}

		public static T GetRequired<T>(Transform root, string path) where T : Component
		{
			T component = ((Component)FindRequired(root, path)).GetComponent<T>();
			if ((Object)(object)component == (Object)null)
			{
				throw new InvalidOperationException("UI component not found at path: " + path + " (" + typeof(T).Name + ")");
			}
			return component;
		}

		public static T GetOrAddComponent<T>(GameObject gameObject) where T : Component
		{
			return gameObject.GetComponent<T>() ?? gameObject.AddComponent<T>();
		}
	}
}
namespace kg.ValheimEnchantmentSystem.Platform
{
	internal static class ContentFixupRegistry
	{
		internal enum SceneFixupKind
		{
			CraftingStationFeedbackFromDonor
		}

		internal readonly struct SceneFixupDefinition
		{
			public readonly string FixupName;

			public readonly SceneFixupKind Kind;

			public readonly string DonorPrefabName;

			public SceneFixupDefinition(string fixupName, SceneFixupKind kind, string donorPrefabName)
			{
				FixupName = fixupName;
				Kind = kind;
				DonorPrefabName = donorPrefabName;
			}
		}

		private sealed class RegisteredFixup
		{
			public readonly string OwnerName;

			public readonly GameObject Prefab;

			public readonly SceneFixupDefinition Definition;

			public RegisteredFixup(string ownerName, GameObject prefab, SceneFixupDefinition definition)
			{
				OwnerName = ownerName;
				Prefab = prefab;
				Definition = definition;
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		private static class ZNetScene_Awake_ContentFixup_Patch
		{
			[UsedImplicitly]
			[HarmonyPriority(200)]
			private static void Postfix(ZNetScene __instance)
			{
				ApplySceneFixups(__instance);
			}
		}

		private static readonly List<RegisteredFixup> SceneFixups = new List<RegisteredFixup>();

		private static readonly HashSet<string> FixupKeys = new HashSet<string>(StringComparer.Ordinal);

		public static void RegisterSceneFixup(PieceRegistrationService.RegisteredPiece piece, SceneFixupDefinition definition)
		{
			if (piece != null)
			{
				RegisterSceneFixup(piece.PrefabName, piece.Prefab, definition);
			}
		}

		private static void RegisterSceneFixup(string ownerName, GameObject prefab, SceneFixupDefinition definition)
		{
			if (!((Object)(object)prefab == (Object)null) && !string.IsNullOrWhiteSpace(ownerName) && !string.IsNullOrWhiteSpace(definition.FixupName))
			{
				string item = ownerName + ":" + definition.FixupName;
				if (FixupKeys.Add(item))
				{
					SceneFixups.Add(new RegisteredFixup(ownerName, prefab, definition));
				}
			}
		}

		internal static void ApplySceneFixups(ZNetScene? scene)
		{
			if ((Object)(object)scene == (Object)null)
			{
				return;
			}
			foreach (RegisteredFixup sceneFixup in SceneFixups)
			{
				try
				{
					ApplySceneFixup(scene, sceneFixup);
				}
				catch (Exception ex)
				{
					Debug.LogWarning((object)("[kg.ValheimEnchantmentSystem] Content fixup '" + sceneFixup.Definition.FixupName + "' failed for '" + sceneFixup.OwnerName + "': " + ex.Message));
				}
			}
			ContentValidationService.ValidateRegisteredContent(scene);
		}

		private static void ApplySceneFixup(ZNetScene scene, RegisteredFixup fixup)
		{
			if (fixup.Definition.Kind == SceneFixupKind.CraftingStationFeedbackFromDonor)
			{
				ApplyCraftingStationFeedbackFromDonor(scene, fixup.Prefab, fixup.Definition.DonorPrefabName);
			}
			else
			{
				Debug.LogWarning((object)$"[kg.ValheimEnchantmentSystem] Unsupported content fixup kind '{fixup.Definition.Kind}' for '{fixup.OwnerName}'.");
			}
		}

		private static void ApplyCraftingStationFeedbackFromDonor(ZNetScene scene, GameObject stationPrefab, string donorPrefabName)
		{
			if ((Object)(object)scene == (Object)null || (Object)(object)stationPrefab == (Object)null || string.IsNullOrWhiteSpace(donorPrefabName))
			{
				return;
			}
			GameObject prefab = scene.GetPrefab(donorPrefabName);
			if (!Object.op_Implicit((Object)(object)prefab))
			{
				return;
			}
			Piece component = prefab.GetComponent<Piece>();
			Piece component2 = stationPrefab.GetComponent<Piece>();
			CraftingStation component3 = prefab.GetComponent<CraftingStation>();
			CraftingStation component4 = stationPrefab.GetComponent<CraftingStation>();
			if (!((Object)(object)component == (Object)null) && !((Object)(object)component2 == (Object)null) && !((Object)(object)component3 == (Object)null) && !((Object)(object)component4 == (Object)null))
			{
				if (component4.m_useAnimation == 0 && component3.m_useAnimation != 0)
				{
					component4.m_useAnimation = component3.m_useAnimation;
				}
				if (IsEffectListEmpty(component4.m_craftItemEffects) && !IsEffectListEmpty(component3.m_craftItemEffects))
				{
					component4.m_craftItemEffects = component3.m_craftItemEffects;
				}
				if (IsEffectListEmpty(component4.m_craftItemDoneEffects) && !IsEffectListEmpty(component3.m_craftItemDoneEffects))
				{
					component4.m_craftItemDoneEffects = component3.m_craftItemDoneEffects;
				}
				if (IsEffectListEmpty(component4.m_repairItemDoneEffects) && !IsEffectListEmpty(component3.m_repairItemDoneEffects))
				{
					component4.m_repairItemDoneEffects = component3.m_repairItemDoneEffects;
				}
			}
		}

		private static bool IsEffectListEmpty(EffectList? effectList)
		{
			if (effectList != null && effectList.m_effectPrefabs != null)
			{
				return effectList.m_effectPrefabs.Length == 0;
			}
			return true;
		}
	}
	internal static class ContentValidationService
	{
		private static readonly Dictionary<string, PieceRegistrationService.RegisteredPiece> CraftingPieces = new Dictionary<string, PieceRegistrationService.RegisteredPiece>(StringComparer.Ordinal);

		private static readonly Dictionary<string, ItemRegistrationService.RegisteredItem> RegisteredItems = new Dictionary<string, ItemRegistrationService.RegisteredItem>(StringComparer.Ordinal);

		private static readonly HashSet<string> WarningCache = new HashSet<string>(StringComparer.Ordinal);

		public static void RegisterCraftingPiece(PieceRegistrationService.RegisteredPiece piece)
		{
			if (piece != null && !((Object)(object)piece.Prefab == (Object)null))
			{
				CraftingPieces[piece.PrefabName] = piece;
			}
		}

		public static void RegisterRecipeItem(ItemRegistrationService.RegisteredItem item)
		{
			if (item != null && !((Object)(object)item.Prefab == (Object)null))
			{
				RegisteredItems[item.PrefabName] = item;
			}
		}

		internal static void ValidateRegisteredContent(ZNetScene? scene)
		{
			if ((Object)(object)scene == (Object)null)
			{
				return;
			}
			foreach (PieceRegistrationService.RegisteredPiece value in CraftingPieces.Values)
			{
				ValidateCraftingPiece(value, scene);
			}
			foreach (ItemRegistrationService.RegisteredItem value2 in RegisteredItems.Values)
			{
				ValidateRegisteredItem(value2, scene);
			}
		}

		private static void ValidateCraftingPiece(PieceRegistrationService.RegisteredPiece registration, ZNetScene scene)
		{
			GameObject prefab = registration.Prefab;
			if ((Object)(object)prefab == (Object)null)
			{
				WarnOnce("Missing registered crafting piece prefab for '" + registration.PrefabName + "'.");
				return;
			}
			Piece val = registration.TryGetComponent<Piece>();
			if ((Object)(object)val == (Object)null)
			{
				WarnOnce("Registered crafting piece '" + registration.PrefabName + "' is missing a Piece component.");
				return;
			}
			if (string.IsNullOrWhiteSpace(val.m_name))
			{
				WarnOnce("Registered crafting piece '" + registration.PrefabName + "' is missing a localized name token.");
			}
			if (string.IsNullOrWhiteSpace(val.m_description))
			{
				WarnOnce("Registered crafting piece '" + registration.PrefabName + "' is missing a localized description token.");
			}
			if (!string.IsNullOrWhiteSpace(registration.CraftingStationName))
			{
				GameObject prefab2 = scene.GetPrefab(registration.CraftingStationName);
				if ((Object)(object)((prefab2 != null) ? prefab2.GetComponent<CraftingStation>() : null) == (Object)null)
				{
					WarnOnce("Registered crafting piece '" + registration.PrefabName + "' references unknown crafting station '" + registration.CraftingStationName + "'.");
				}
			}
			CraftingStation val2 = registration.TryGetComponent<CraftingStation>();
			if (val2 != null)
			{
				if (registration.RequirePlaceEffect && IsEffectListEmpty(val.m_placeEffect))
				{
					WarnOnce("Crafting station piece '" + registration.PrefabName + "' has no place effect.");
				}
				if (val2.m_useAnimation == 0)
				{
					WarnOnce("Crafting station piece '" + registration.PrefabName + "' has no use animation configured.");
				}
				if (IsEffectListEmpty(val2.m_craftItemEffects))
				{
					WarnOnce("Crafting station piece '" + registration.PrefabName + "' has no craft item effects.");
				}
				if (IsEffectListEmpty(val2.m_craftItemDoneEffects))
				{
					WarnOnce("Crafting station piece '" + registration.PrefabName + "' has no craft completion effects.");
				}
				if (IsEffectListEmpty(val2.m_repairItemDoneEffects))
				{
					WarnOnce("Crafting station piece '" + registration.PrefabName + "' has no repair completion effects.");
				}
			}
		}

		private static void ValidateRegisteredItem(ItemRegistrationService.RegisteredItem registration, ZNetScene scene)
		{
			if ((Object)(object)registration.Prefab == (Object)null)
			{
				WarnOnce("Missing registered item prefab for '" + registration.PrefabName + "'.");
				return;
			}
			foreach (string craftingStationName in registration.CraftingStationNames)
			{
				GameObject prefab = scene.GetPrefab(craftingStationName);
				if ((Object)(object)((prefab != null) ? prefab.GetComponent<CraftingStation>() : null) == (Object)null)
				{
					WarnOnce("Registered item '" + registration.PrefabName + "' references unknown crafting station '" + craftingStationName + "'.");
				}
			}
		}

		private static bool IsEffectListEmpty(EffectList? effectList)
		{
			if (effectList != null && effectList.m_effectPrefabs != null)
			{
				return effectList.m_effectPrefabs.Length == 0;
			}
			return true;
		}

		private static void WarnOnce(string message)
		{
			if (WarningCache.Add(message))
			{
				Debug.LogWarning((object)("[kg.ValheimEnchantmentSystem] " + message));
			}
		}
	}
	internal static class ItemRegistrationService
	{
		internal sealed class RegisteredItem
		{
			private readonly ThinItemManager.RegisteredItemData _item;

			public GameObject Prefab => _item.Prefab;

			public string PrefabName => ((Object)Prefab).name;

			internal IEnumerable<string> CraftingStationNames => (from recipe in _item.Recipes
				select recipe.CraftingStationName into name
				where !string.IsNullOrWhiteSpace(name)
				select name).Distinct<string>(StringComparer.OrdinalIgnoreCase);

			public RegisteredItem(ThinItemManager.RegisteredItemData item)
			{
				_item = item;
			}

			public T? TryGetComponent<T>() where T : Component
			{
				return Prefab.GetComponent<T>();
			}

			internal void ApplyRecipe(ScrollRecipeCatalog.RecipeData recipe, string craftingStation, int level)
			{
				_item.SetRecipe(new ThinItemManager.RecipeDefinition(string.Empty, recipe.Amount, craftingStation, level, ParseRequirements(recipe.Requirements)));
			}

			internal void ConfigureConversion(string recipeKey, int craftAmount, string requiredItemName, int requiredItemAmount, string craftingStation, int level)
			{
				_item.SetRecipe(new ThinItemManager.RecipeDefinition(recipeKey, craftAmount, craftingStation, level, new ThinItemManager.RequirementDefinition[1]
				{
					new ThinItemManager.RequirementDefinition(requiredItemName, requiredItemAmount)
				}));
			}
		}

		public static RegisteredItem CreateRecipeItem(GameObject prefab, string sharedName, string descriptionKey)
		{
			RegisteredItem registeredItem = new RegisteredItem(ThinItemManager.RegisterRecipeItem(prefab, sharedName, descriptionKey));
			ContentValidationService.RegisterRecipeItem(registeredItem);
			return registeredItem;
		}

		public static void ApplyRecipe(RegisteredItem item, ScrollRecipeCatalog.RecipeData recipe, string craftingStation, int level = 1)
		{
			item.ApplyRecipe(recipe, craftingStation, level);
		}

		public static void ConfigureConversion(RegisteredItem item, string recipeKey, int craftAmount, string requiredItemName, int requiredItemAmount, string craftingStation, int level = 1)
		{
			item.ConfigureConversion(recipeKey, craftAmount, requiredItemName, requiredItemAmount, craftingStation, level);
		}

		private static ThinItemManager.RequirementDefinition[] ParseRequirements(IEnumerable<string> requirements)
		{
			return requirements.Select(delegate(string requirement)
			{
				string[] array = requirement.Split(new char[1] { ',' });
				string itemName = array[0];
				int result;
				int amount = ((array.Length <= 1 || !int.TryParse(array[1], out result)) ? 1 : result);
				int result2;
				int quality = ((array.Length > 2 && int.TryParse(array[2], out result2)) ? result2 : 0);
				return new ThinItemManager.RequirementDefinition(itemName, amount, quality);
			}).ToArray();
		}
	}
	internal static class LocalizationBootstrap
	{
		public static void Initialize()
		{
			Localizer.Load();
		}
	}
	internal static class PieceRegistrationService
	{
		internal sealed class RegisteredPiece
		{
			private readonly BuildPiece _buildPiece;

			public GameObject Prefab => _buildPiece.Prefab;

			public string PrefabName => ((Object)Prefab).name;

			internal string CraftingStationName { get; }

			internal bool RequirePlaceEffect { get; }

			public RegisteredPiece(BuildPiece buildPiece, string craftingStationName, bool requirePlaceEffect)
			{
				_buildPiece = buildPiece;
				CraftingStationName = craftingStationName;
				RequirePlaceEffect = requirePlaceEffect;
			}

			public T? TryGetComponent<T>() where T : Component
			{
				return Prefab.GetComponent<T>();
			}

			public T? GetComponent<T>() where T : Component
			{
				return TryGetComponent<T>();
			}
		}

		internal readonly struct CraftingPieceDefinition
		{
			public readonly string PrefabName;

			public readonly string NameKey;

			public readonly string DescriptionKey;

			public readonly string ToolName;

			public readonly string CraftingStationName;

			public readonly Requirement[] Requirements;

			public readonly ContentFixupRegistry.SceneFixupDefinition[] SceneFixups;

			public readonly bool RequirePlaceEffect;

			public CraftingPieceDefinition(string prefabName, string nameKey, string descriptionKey, string toolName, string craftingStationName, Requirement[] requirements, ContentFixupRegistry.SceneFixupDefinition[]? sceneFixups = null, bool requirePlaceEffect = true)
			{
				PrefabName = prefabName;
				NameKey = nameKey;
				DescriptionKey = descriptionKey;
				ToolName = toolName;
				CraftingStationName = craftingStationName;
				Requirements = requirements ?? Array.Empty<Requirement>();
				SceneFixups = sceneFixups ?? Array.Empty<ContentFixupRegistry.SceneFixupDefinition>();
				RequirePlaceEffect = requirePlaceEffect;
			}
		}

		internal readonly struct Requirement
		{
			public readonly string ItemName;

			public readonly int Amount;

			public readonly bool Recover;

			public Requirement(string itemName, int amount, bool recover)
			{
				ItemName = itemName;
				Amount = amount;
				Recover = recover;
			}
		}

		public static RegisteredPiece RegisterCraftingPiece(CraftingPieceDefinition definition)
		{
			BuildPiece buildPiece = new BuildPiece(ValheimEnchantmentSystem._asset, definition.PrefabName);
			Piece component = buildPiece.Prefab.GetComponent<Piece>();
			component.m_name = definition.NameKey;
			component.m_description = definition.DescriptionKey;
			buildPiece.Category.Set(BuildPieceCategory.Crafting);
			buildPiece.Tool.Add(definition.ToolName);
			if (string.Equals(definition.CraftingStationName, "piece_workbench", StringComparison.OrdinalIgnoreCase))
			{
				buildPiece.Crafting.Set(CraftingTable.Workbench);
			}
			else
			{
				buildPiece.Crafting.Set(definition.CraftingStationName);
			}
			Requirement[] requirements = definition.Requirements;
			for (int i = 0; i < requirements.Length; i++)
			{
				Requirement requirement = requirements[i];
				buildPiece.RequiredItems.Add(requirement.ItemName, requirement.Amount, requirement.Recover);
			}
			RegisteredPiece registeredPiece = new RegisteredPiece(buildPiece, definition.CraftingStationName, definition.RequirePlaceEffect);
			ContentValidationService.RegisterCraftingPiece(registeredPiece);
			ContentFixupRegistry.SceneFixupDefinition[] sceneFixups = definition.SceneFixups;
			foreach (ContentFixupRegistry.SceneFixupDefinition definition2 in sceneFixups)
			{
				ContentFixupRegistry.RegisterSceneFixup(registeredPiece, definition2);
			}
			return registeredPiece;
		}
	}
	internal static class SkillRegistrationService
	{
		public static SkillType RegisterConfigurableSkill(string englishName, string iconResourceName)
		{
			new Skill(englishName, iconResourceName).Configurable = true;
			return (SkillType)Mathf.Abs(StringExtensionMethods.GetStableHashCode(englishName));
		}
	}
	internal static class ThinItemManager
	{
		private sealed class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public int? Order;
		}

		private sealed class ItemConfig
		{
			public readonly Dictionary<string, RecipeConfig> Recipes = new Dictionary<string, RecipeConfig>(StringComparer.Ordinal);
		}

		private sealed class RecipeConfig
		{
			public ConfigEntry<string>? CraftingCosts;
		}

		internal sealed class RegisteredItemData
		{
			private readonly Dictionary<string, RecipeDefinition> _recipes = new Dictionary<string, RecipeDefinition>(StringComparer.Ordinal);

			public readonly GameObject Prefab;

			public readonly string SharedName;

			public readonly string DescriptionKey;

			public IEnumerable<RecipeDefinition> Recipes => _recipes.Values;

			public RegisteredItemData(GameObject prefab, string sharedName, string descriptionKey)
			{
				Prefab = prefab;
				SharedName = sharedName;
				DescriptionKey = descriptionKey;
			}

			public void SetRecipe(RecipeDefinition recipe)
			{
				_recipes[recipe.Key] = recipe;
				EnsureConfigBindings(this);
			}
		}

		internal readonly struct RequirementDefinition
		{
			public readonly string ItemName;

			public readonly int Amount;

			public readonly int Quality;

			public RequirementDefinition(string itemName, int amount, int quality = 0)
			{
				ItemName = itemName;
				Amount = amount;
				Quality = quality;
			}
		}

		internal readonly struct RecipeDefinition
		{
			public readonly string Key;

			public readonly int CraftAmount;

			public readonly string CraftingStationName;

			public readonly int MinStationLevel;

			public readonly RequirementDefinition[] Requirements;

			public RecipeDefinition(string key, int craftAmount, string craftingStationName, int minStationLevel, RequirementDefinition[] requirements)
			{
				Key = key;
				CraftAmount = craftAmount;
				CraftingStationName = craftingStationName;
				MinStationLevel = minStationLevel;
				Requirements = requirements ?? Array.Empty<RequirementDefinition>();
			}
		}

		private static class SerializedRequirements
		{
			internal readonly struct SerializedRecipe
			{
				public readonly RequirementDefinition[] Requirements;

				public readonly int CraftAmount;

				public SerializedRecipe(IEnumerable<RequirementDefinition> requirements, int craftAmount)
				{
					Requirements = requirements?.ToArray() ?? Array.Empty<RequirementDefinition>();
					CraftAmount = craftAmount;
				}
			}

			public static string Serialize(IEnumerable<RequirementDefinition> requirements, int craftAmount)
			{
				List<string> list = (from requirement in requirements
					where !string.IsNullOrWhiteSpace(requirement.ItemName)
					select (requirement.Quality <= 0) ? $"{requirement.ItemName}:{requirement.Amount}" : $"{requirement.ItemName}:{requirement.Amount}:{requirement.Quality}").ToList();
				list.Add($"amount={Mathf.Clamp(craftAmount, 0, 24)}");
				return string.Join(",", list);
			}

			public static SerializedRecipe Deserialize(string serialized, int defaultCraftAmount)
			{
				if (string.IsNullOrWhiteSpace(serialized))
				{
					return new SerializedRecipe(Array.Empty<RequirementDefinition>(), defaultCraftAmount);
				}
				List<RequirementDefinition> list = new List<RequirementDefinition>();
				int craftAmount = defaultCraftAmount;
				string[] array = serialized.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
				foreach (string text in array)
				{
					string text2 = text.Trim();
					if (text2.Length == 0)
					{
						continue;
					}
					if (text2.StartsWith("amount=", StringComparison.OrdinalIgnoreCase))
					{
						string s = text2.Substring("amount=".Length).Trim();
						if (int.TryParse(s, out var result))
						{
							craftAmount = result;
						}
						continue;
					}
					string[] array2 = text2.Split(new char[1] { ':' });
					string text3 = array2[0].Trim();
					if (!string.IsNullOrWhiteSpace(text3))
					{
						int result2;
						int amount = ((array2.Length <= 1 || !int.TryParse(array2[1], out result2)) ? 1 : result2);
						int result3;
						int quality = ((array2.Length > 2 && int.TryParse(array2[2], out result3)) ? result3 : 0);
						list.Add(new RequirementDefinition(text3, amount, quality));
					}
				}
				return new SerializedRecipe(list, craftAmount);
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		private static class ZNetScene_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix(ZNetScene __instance)
			{
				ApplySceneRegistration(__instance);
			}
		}

		[HarmonyPatch(typeof(ObjectDB), "Awake")]
		private static class ObjectDB_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix(ObjectDB __instance)
			{
				ApplyObjectDbRegistration(__instance);
			}
		}

		[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
		private static class ObjectDB_CopyOtherDb_Patch
		{
			[UsedImplicitly]
			private static void Postfix(ObjectDB __instance)
			{
				ApplyObjectDbRegistration(__instance);
			}
		}

		private static readonly string[] ObjectDbReadinessSentinels = new string[2] { "Hammer", "TrophyFader" };

		private const string FixedScrollCraftingStationName = "kg_EnchantmentScrollStation";

		private const string ScrollRecipeConfigSection = "Scroll Recipes";

		private static readonly Dictionary<string, RegisteredItemData> RegisteredItems = new Dictionary<string, RegisteredItemData>(StringComparer.Ordinal);

		private static readonly Dictionary<string, ItemConfig> ItemConfigs = new Dictionary<string, ItemConfig>(StringComparer.Ordinal);

		public static RegisteredItemData RegisterRecipeItem(GameObject prefab, string sharedName, string descriptionKey)
		{
			if ((Object)(object)prefab == (Object)null)
			{
				throw new ArgumentNullException("prefab");
			}
			ItemDrop component = prefab.GetComponent<ItemDrop>();
			if (component == null)
			{
				throw new InvalidOperationException("Item prefab '" + ((Object)prefab).name + "' is missing ItemDrop.");
			}
			component.m_itemData.m_shared.m_name = sharedName;
			component.m_itemData.m_shared.m_description = descriptionKey;
			RegisteredItemData registeredItemData = new RegisteredItemData(prefab, sharedName, descriptionKey);
			RegisteredItems[((Object)prefab).name] = registeredItemData;
			return registeredItemData;
		}

		private static void ApplySceneRegistration(ZNetScene scene)
		{
			foreach (RegisteredItemData value in RegisteredItems.Values)
			{
				if (!scene.m_prefabs.Contains(value.Prefab))
				{
					scene.m_prefabs.Add(value.Prefab);
				}
				int stableHashCode = StringExtensionMethods.GetStableHashCode(((Object)value.Prefab).name);
				if (!scene.m_namedPrefabs.ContainsKey(stableHashCode))
				{
					scene.m_namedPrefabs.Add(stableHashCode, value.Prefab);
				}
			}
		}

		private static void ApplyObjectDbRegistration(ObjectDB objectDb)
		{
			if ((Object)(object)objectDb == (Object)null || objectDb.m_items == null || objectDb.m_recipes == null)
			{
				return;
			}
			EnsureConfigBindings();
			if (!IsObjectDbReady(objectDb))
			{
				return;
			}
			bool flag = false;
			foreach (RegisteredItemData value in RegisteredItems.Values)
			{
				flag |= EnsureItemRegistered(objectDb, value);
				flag |= RebuildRecipes(objectDb, value);
			}
			if (flag)
			{
				objectDb.UpdateRegisters();
				ZenUiCompatibility.InvalidateCraftingRecipeCache();
			}
		}

		private static bool IsObjectDbReady(ObjectDB objectDb)
		{
			if ((Object)(object)objectDb == (Object)null)
			{
				return false;
			}
			string[] objectDbReadinessSentinels = ObjectDbReadinessSentinels;
			foreach (string text in objectDbReadinessSentinels)
			{
				if ((Object)(object)objectDb.GetItemPrefab(text) == (Object)null)
				{
					return false;
				}
			}
			return true;
		}

		private static bool EnsureItemRegistered(ObjectDB objectDb, RegisteredItemData item)
		{
			bool result = false;
			if (!objectDb.m_items.Contains(item.Prefab))
			{
				objectDb.m_items.Add(item.Prefab);
				result = true;
			}
			if (objectDb.m_itemByHash == null)
			{
				objectDb.m_itemByHash = new Dictionary<int, GameObject>();
			}
			int stableHashCode = StringExtensionMethods.GetStableHashCode(((Object)item.Prefab).name);
			if (!objectDb.m_itemByHash.ContainsKey(stableHashCode))
			{
				objectDb.m_itemByHash.Add(stableHashCode, item.Prefab);
				result = true;
			}
			return result;
		}

		private static bool RebuildRecipes(ObjectDB objectDb, RegisteredItemData item)
		{
			ObjectDB objectDb2 = objectDb;
			RegisteredItemData item2 = item;
			ItemDrop itemDrop = item2.Prefab.GetComponent<ItemDrop>();
			if (itemDrop == null)
			{
				return false;
			}
			string recipePrefix = BuildRecipeNamePrefix(((Object)item2.Prefab).name);
			int num = objectDb2.m_recipes.RemoveAll((Recipe recipe) => (Object)(object)recipe != (Object)null && (Object)(object)recipe.m_item == (Object)(object)itemDrop && ((Object)recipe).name != null && ((Object)recipe).name.StartsWith(recipePrefix, StringComparison.Ordinal));
			List<Recipe> list = (from recipe in item2.Recipes
				select BuildRecipe(objectDb2, item2, GetEffectiveRecipe(item2, recipe)) into recipe
				where (Object)(object)recipe != (Object)null
				select recipe).ToList();
			if (list.Count == 0 && num == 0)
			{
				return false;
			}
			objectDb2.m_recipes.AddRange(list);
			if (num <= 0)
			{
				return list.Count > 0;
			}
			return true;
		}

		private static Recipe? BuildRecipe(ObjectDB objectDb, RegisteredItemData item, RecipeDefinition recipe)
		{
			ItemDrop component = item.Prefab.GetComponent<ItemDrop>();
			if (component == null)
			{
				return null;
			}
			Recipe val = ScriptableObject.CreateInstance<Recipe>();
			((Object)val).name = BuildRecipeName(((Object)item.Prefab).name, recipe);
			val.m_item = component;
			val.m_amount = Math.Max(1, recipe.CraftAmount);
			val.m_enabled = recipe.CraftAmount > 0;
			val.m_resources = ToPieceRequirements(objectDb, recipe.Requirements);
			val.m_craftingStation = ResolveCraftingStation(recipe.CraftingStationName);
			val.m_minStationLevel = Math.Max(0, recipe.MinStationLevel);
			val.m_requireOnlyOneIngredient = false;
			val.m_qualityResultAmountMultiplier = 1f;
			return val;
		}

		private static CraftingStation? ResolveCraftingStation(string craftingStationName)
		{
			if (string.IsNullOrWhiteSpace(craftingStationName) || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return null;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab(craftingStationName);
			if (prefab == null)
			{
				return null;
			}
			return prefab.GetComponent<CraftingStation>();
		}

		private static void EnsureConfigBindings()
		{
			foreach (RegisteredItemData value in RegisteredItems.Values)
			{
				EnsureConfigBindings(value);
			}
		}

		private static void EnsureConfigBindings(RegisteredItemData item)
		{
			RegisteredItemData item2 = item;
			if (item2 == null || (Object)(object)item2.Prefab == (Object)null)
			{
				return;
			}
			if (!ItemConfigs.TryGetValue(((Object)item2.Prefab).name, out ItemConfig value))
			{
				value = new ItemConfig();
				ItemConfigs[((Object)item2.Prefab).name] = value;
			}
			string configGroup = GetConfigGroup(item2);
			string displayName = GetDisplayName(item2);
			RecipeDefinition[] array = item2.Recipes.OrderBy(GetRecipeSortIndex).ThenBy<RecipeDefinition, string>((RecipeDefinition recipe) => GetRecipeConfigKey(recipe), StringComparer.Ordinal).ToArray();
			int num = array.Length * 10;
			RecipeDefinition[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				RecipeDefinition recipe2 = array2[i];
				string recipeConfigKey = GetRecipeConfigKey(recipe2);
				if (value.Recipes.ContainsKey(recipeConfigKey))
				{
					num -= 10;
					continue;
				}
				string recipeConfigSuffix = GetRecipeConfigSuffix(recipe2);
				string text = (string.IsNullOrWhiteSpace(recipeConfigSuffix) ? displayName : (displayName + recipeConfigSuffix));
				RecipeConfig recipeConfig = new RecipeConfig();
				recipeConfig.CraftingCosts = Config(configGroup, displayName + " - Crafting Costs" + recipeConfigSuffix, SerializedRequirements.Serialize(recipe2.Requirements, recipe2.CraftAmount), OrderedDescription("Item costs to craft " + text + ". Use item:amount entries and append amount=N. Set amount=0 to disable the recipe.", num));
				recipeConfig.CraftingCosts.SettingChanged += delegate
				{
					ReapplyRuntimeConfiguration(item2);
				};
				value.Recipes[recipeConfigKey] = recipeConfig;
				num -= 10;
			}
		}

		private static void ReapplyRuntimeConfiguration(RegisteredItemData item)
		{
			if (!((Object)(object)ObjectDB.instance == (Object)null) && IsObjectDbReady(ObjectDB.instance))
			{
				bool flag = EnsureItemRegistered(ObjectDB.instance, item);
				if (flag | RebuildRecipes(ObjectDB.instance, item))
				{
					ObjectDB.instance.UpdateRegisters();
					ZenUiCompatibility.InvalidateCraftingRecipeCache();
				}
			}
		}

		private static RecipeDefinition GetEffectiveRecipe(RegisteredItemData item, RecipeDefinition recipe)
		{
			if (!ItemConfigs.TryGetValue(((Object)item.Prefab).name, out ItemConfig value) || !value.Recipes.TryGetValue(GetRecipeConfigKey(recipe), out RecipeConfig value2))
			{
				return recipe;
			}
			ConfigEntry<string> craftingCosts = value2.CraftingCosts;
			SerializedRequirements.SerializedRecipe serializedRecipe = ((craftingCosts != null) ? SerializedRequirements.Deserialize(craftingCosts.Value, recipe.CraftAmount) : new SerializedRequirements.SerializedRecipe(recipe.Requirements, recipe.CraftAmount));
			return new RecipeDefinition(recipe.Key, Mathf.Clamp(serializedRecipe.CraftAmount, 0, 24), "kg_EnchantmentScrollStation", recipe.MinStationLevel, serializedRecipe.Requirements);
		}

		private static Requirement[] ToPieceRequirements(ObjectDB objectDb, IEnumerable<RequirementDefinition> requirements)
		{
			ObjectDB objectDb2 = objectDb;
			return (from requirement in requirements.Where((RequirementDefinition requirement) => !string.IsNullOrWhiteSpace(requirement.ItemName)).Select((Func<RequirementDefinition, Requirement>)delegate(RequirementDefinition requirement)
				{
					//IL_0043: Unknown result type (might be due to invalid IL or missing references)
					//IL_0048: Unknown result type (might be due to invalid IL or missing references)
					//IL_004f: Unknown result type (might be due to invalid IL or missing references)
					//IL_005c: Expected O, but got Unknown
					GameObject itemPrefab = objectDb2.GetItemPrefab(requirement.ItemName);
					ItemDrop val = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
					if (!((Object)(object)val == (Object)null))
					{
						return new Requirement
						{
							m_resItem = val,
							m_amount = requirement.Amount
						};
					}
					Debug.LogWarning((object)("[kg.ValheimEnchantmentSystem] The required item '" + requirement.ItemName + "' does not exist."));
					return null;
				})
				where requirement != null
				select requirement).ToArray();
		}

		private static string GetConfigGroup(RegisteredItemData item)
		{
			return "Scroll Recipes";
		}

		private static string GetDisplayName(RegisteredItemData item)
		{
			if (string.IsNullOrWhiteSpace(item.SharedName))
			{
				return ((Object)item.Prefab).name;
			}
			string text = SharedLocalizationCache.LocalizeForConfig(item.SharedName).Trim();
			if (!string.IsNullOrWhiteSpace(text) && !string.Equals(text, item.SharedName, StringComparison.Ordinal))
			{
				return text;
			}
			return ((Object)item.Prefab).name;
		}

		private static string GetRecipeConfigKey(RecipeDefinition recipe)
		{
			if (!string.IsNullOrWhiteSpace(recipe.Key))
			{
				return recipe.Key;
			}
			return "Default";
		}

		private static int GetRecipeSortIndex(RecipeDefinition recipe)
		{
			return (!string.IsNullOrWhiteSpace(recipe.Key)) ? 1 : 0;
		}

		private static string GetRecipeConfigSuffix(RecipeDefinition recipe)
		{
			if (string.IsNullOrWhiteSpace(recipe.Key))
			{
				return string.Empty;
			}
			string text = (string.Equals(recipe.Key, "ConvertNormal", StringComparison.Ordinal) ? "Alt" : recipe.Key);
			return " (" + text + ")";
		}

		private static string BuildRecipeNamePrefix(string prefabName)
		{
			return prefabName + "_Recipe_";
		}

		private static string BuildRecipeName(string prefabName, RecipeDefinition recipe)
		{
			string text = (string.IsNullOrWhiteSpace(recipe.Key) ? "Default" : recipe.Key);
			return prefabName + "_Recipe_" + text;
		}

		private static ConfigEntry<T> Config<T>(string group, string name, T value, ConfigDescription description)
		{
			return ValheimEnchantmentSystem.config(group, name, value, description);
		}

		private static ConfigDescription OrderedDescription(string description, int order, AcceptableValueBase? acceptableValues = null)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			return new ConfigDescription(description, acceptableValues, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = order
				}
			});
		}
	}
}
namespace kg.ValheimEnchantmentSystem.Misc
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false)]
	public class VES_Autoload : Attribute
	{
		public enum Priority
		{
			Init,
			First,
			Normal,
			Last
		}

		public readonly Priority priority;

		public readonly string InitMethod;

		public readonly Type[] DependsOn;

		public VES_Autoload(Priority priority = Priority.Last, string InitMethod = "OnInit", params Type[] dependsOn)
		{
			this.priority = priority;
			this.InitMethod = InitMethod;
			DependsOn = dependsOn ?? Array.Empty<Type>();
		}
	}
	[AttributeUsage(AttributeTargets.Class, Inherited = false)]
	public class ClientOnlyPatch : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class, Inherited = false)]
	public class ServerOnlyPatch : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = true)]
	public class VES_RequiresPlugin : Attribute
	{
		public readonly string PluginGuid;

		public VES_RequiresPlugin(string pluginGuid)
		{
			PluginGuid = pluginGuid ?? string.Empty;
		}
	}
	public static class DiscordWebhook
	{
		private static readonly Regex HtmlTagRegex = new Regex("<.*?>", RegexOptions.Compiled);

		public static void TrySend(string link, string msg)
		{
			string msg2 = msg;
			string link2 = link;
			msg2 = HtmlTagRegex.Replace(msg2 ?? string.Empty, "**");
			if (!Uri.TryCreate(link2, UriKind.Absolute, out Uri _))
			{
				return;
			}
			Task.Run(async delegate
			{
				_ = 2;
				try
				{
					string json = JSON.ToJSON(new Dictionary<string, string> { { "content", msg2 } });
					HttpWebRequest request = (HttpWebRequest)WebRequest.Create(link2);
					request.ContentType = "application/json";
					request.Method = "POST";
					using (StreamWriter streamWriter = new StreamWriter(await request.GetRequestStreamAsync()))
					{
						await streamWriter.WriteAsync(json);
					}
					using (await request.GetResponseAsync())
					{
					}
				}
				catch (Exception ex)
				{
					Utils.print("Discord webhook send failed: " + ex.Message, ConsoleColor.Red);
				}
			});
		}
	}
	[VES_Autoload(VES_Autoload.Priority.Init, "OnInit", new Type[] { })]
	public static class External_AsmLoad
	{
		[UsedImplicitly]
		private static void OnInit()
		{
			LoadAsm("VES_Scripts");
		}

		private static void LoadAsm(string name)
		{
			string name2 = name;
			string[] manifestResourceNames = Assembly.GetExecutingAssembly().GetManifestResourceNames();
			if (manifestResourceNames.Length == 0)
			{
				Utils.print("No resources found", ConsoleColor.Red);
				return;
			}
			string name3 = manifestResourceNames.Single((string str) => str.EndsWith(name2 + ".dll"));
			using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(name3);
			byte[] array = new byte[stream.Length];
			stream.Read(array, 0, array.Length);
			try
			{
				Assembly.Load(array);
				stream.Dispose();
			}
			catch (Exception arg)
			{
				Utils.print($"Error loading {name2} assembly\n:{arg}", ConsoleColor.Red);
			}
		}
	}
}
namespace kg.ValheimEnchantmentSystem.Items_Structures
{
	internal static class ScrollCombineService
	{
		private enum RequiredShape
		{
			[Description("three in a row")]
			Row3,
			[Description("five in a cross")]
			Cross5
		}

		private sealed class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public int? Order;
		}

		private sealed class OverlayRefs
		{
			public readonly int ElementInstanceId;

			public readonly GameObject? Root;

			public readonly GameObject? Row3;

			public readonly GameObject? Cross5;

			public OverlayRefs(int elementInstanceId, GameObject? root, GameObject? row3, GameObject? cross5)
			{
				ElementInstanceId = elementInstanceId;
				Root = root;
				Row3 = row3;
				Cross5 = cross5;
			}
		}

		private sealed class GridState
		{
			public readonly int GridInstanceId;

			public InventoryGrid? Grid;

			public Inventory? Inventory;

			public OverlayRefs[] Overlays = Array.Empty<OverlayRefs>();

			public bool Dirty = true;

			public int RefreshAfterFrame;

			public GridState(int gridInstanceId, InventoryGrid grid)
			{
				GridInstanceId = gridInstanceId;
				Grid = grid;
			}
		}

		private sealed class ReferenceComparer<T> : IEqualityComparer<T> where T : class
		{
			public static readonly ReferenceComparer<T> Instance = new ReferenceComparer<T>();

			public bool Equals(T? x, T? y)
			{
				return x == y;
			}

			public int GetHashCode(T obj)
			{
				return RuntimeHelpers.GetHashCode(obj);
			}
		}

		private const int AllowCombineOrder = 1000;

		private const int RequiredShapeOrder = 999;

		private static ConfigEntry<bool> _allowScrollCombine = null;

		private static ConfigEntry<RequiredShape> _requiredShape = null;

		private static GameObject _combineOutline = null;

		private static readonly HashSet<GameObject> InitializedElementPrefabs = new HashSet<GameObject>();

		private static readonly Dictionary<int, GridState> GridStates = new Dictionary<int, GridState>();

		private static readonly Dictionary<Inventory, HashSet<int>> GridIdsByInventory = new Dictionary<Inventory, HashSet<int>>(ReferenceComparer<Inventory>.Instance);

		private static bool _initialized;

		public static void Initialize()
		{
			if (!_initialized)
			{
				_initialized = true;
				_allowScrollCombine = ValheimEnchantmentSystem.config("Scrolls", "Allow Combine", value: true, OrderedDescription("Allow combining scrolls by arranging those in a certain shape and right-clicking the center.", 1000));
				_requiredShape = ValheimEnchantmentSystem.config("Scrolls", "Required Shape", RequiredShape.Cross5, OrderedDescription("what shape of the same items is required to combine", 999));
				_combineOutline = ValheimEnchantmentSystem._asset.LoadAsset<GameObject>("Enchantment_CombinePart");
				_allowScrollCombine.SettingChanged += delegate
				{
					RequestRefreshAll();
				};
				_requiredShape.SettingChanged += delegate
				{
					RequestRefreshAll();
				};
			}
		}

		public static void AttachCombineOutline(InventoryGrid inventoryGrid)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)inventoryGrid?.m_elementPrefab == (Object)null) && !((Object)(object)_combineOutline == (Object)null))
			{
				if (InitializedElementPrefabs.Add(inventoryGrid.m_elementPrefab))
				{
					GameObject val = Object.Instantiate<GameObject>(_combineOutline);
					val.transform.SetParent(inventoryGrid.m_elementPrefab.transform, false);
					((Object)val).name = "VES_Combine";
					val.GetComponent<RectTransform>().anchoredPosition = Vector2.zero;
					val.SetActive(false);
				}
				GetOrCreateGridState(inventoryGrid);
			}
		}

		public static void BindInventoryGrid(InventoryGrid inventoryGrid, Inventory? inventory)
		{
			if ((Object)(object)inventoryGrid == (Object)null)
			{
				return;
			}
			GridState orCreateGridState = GetOrCreateGridState(inventoryGrid);
			if (orCreateGridState.Inventory == inventory)
			{
				return;
			}
			UnbindInventory(orCreateGridState);
			orCreateGridState.Inventory = inventory;
			if (inventory != null)
			{
				if (!GridIdsByInventory.TryGetValue(inventory, out HashSet<int> value))
				{
					value = new HashSet<int>();
					GridIdsByInventory[inventory] = value;
				}
				value.Add(orCreateGridState.GridInstanceId);
			}
			RequestRefresh(inventoryGrid, nextFrame: false);
		}

		public static void RequestRefresh(InventoryGrid? inventoryGrid, bool nextFrame = true)
		{
			if (!((Object)(object)inventoryGrid == (Object)null))
			{
				GridState orCreateGridState = GetOrCreateGridState(inventoryGrid);
				orCreateGridState.Dirty = true;
				int num = Time.frameCount + (nextFrame ? 1 : 0);
				orCreateGridState.RefreshAfterFrame = (nextFrame ? Math.Max(orCreateGridState.RefreshAfterFrame, num) : num);
			}
		}

		public static void RequestRefresh(Inventory? inventory, bool nextFrame = true)
		{
			if (inventory == null || !GridIdsByInventory.TryGetValue(inventory, out HashSet<int> value))
			{
				return;
			}
			int[] array = value.ToArray();
			foreach (int num in array)
			{
				if (!GridStates.TryGetValue(num, out GridState value2) || (Object)(object)value2.Grid == (Object)null)
				{
					value.Remove(num);
				}
				else
				{
					RequestRefresh(value2.Grid, nextFrame);
				}
			}
			if (value.Count == 0)
			{
				GridIdsByInventory.Remove(inventory);
			}
		}

		public static void RequestRefreshAll(bool nextFrame = true)
		{
			KeyValuePair<int, GridState>[] array = GridStates.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				KeyValuePair<int, GridState> keyValuePair = array[i];
				if ((Object)(object)keyValuePair.Value.Grid == (Object)null)
				{
					RemoveGridState(keyValuePair.Key);
				}
				else
				{
					RequestRefresh(keyValuePair.Value.Grid, nextFrame);
				}
			}
		}

		public static void TryFlushDirtyRefresh(InventoryGrid inventoryGrid)
		{
			if (!((Object)(object)inventoryGrid == (Object)null))
			{
				GridState orCreateGridState = GetOrCreateGridState(inventoryGrid);
				if (orCreateGridState.Inventory != inventoryGrid.m_inventory)
				{
					BindInventoryGrid(inventoryGrid, inventoryGrid.m_inventory);
					orCreateGridState = GetOrCreateGridState(inventoryGrid);
				}
				if (orCreateGridState.Dirty && Time.frameCount >= orCreateGridState.RefreshAfterFrame && RefreshCombineIndicators(orCreateGridState))
				{
					orCreateGridState.Dirty = false;
					orCreateGridState.RefreshAfterFrame = 0;
				}
			}
		}

		private static bool RefreshCombineIndicators(GridState state)
		{
			InventoryGrid grid = state.Grid;
			Inventory val = grid?.m_inventory ?? state.Inventory;
			if ((Object)(object)grid == (Object)null || val == null || grid.m_elements == null)
			{
				return false;
			}
			EnsureOverlayCache(state);
			OverlayRefs[] overlays = state.Overlays;
			foreach (OverlayRefs overlayRefs in overlays)
			{
				GameObject? root = overlayRefs.Root;
				if (root != null)
				{
					root.SetActive(false);
				}
			}
			if (!_allowScrollCombine.Value)
			{
				return true;
			}
			bool active = _requiredShape.Value == RequiredShape.Row3;
			bool active2 = _requiredShape.Value == RequiredShape.Cross5;
			foreach (ItemData allItem in val.GetAllItems())
			{
				if (!ScrollRegistry.IsUpgradeableScroll(allItem) || !CanCombine(allItem, val, out var _))
				{
					continue;
				}
				int num = allItem.m_gridPos.y * val.m_width + allItem.m_gridPos.x;
				if (num < 0 || num >= state.Overlays.Length)
				{
					continue;
				}
				OverlayRefs overlayRefs2 = state.Overlays[num];
				if (!((Object)(object)overlayRefs2.Root == (Object)null))
				{
					overlayRefs2.Root.SetActive(true);
					GameObject? row = overlayRefs2.Row3;
					if (row != null)
					{
						row.SetActive(active);
					}
					GameObject? cross = overlayRefs2.Cross5;
					if (cross != null)
					{
						cross.SetActive(active2);
					}
				}
			}
			return true;
		}

		private static void EnsureOverlayCache(GridState state)
		{
			InventoryGrid grid = state.Grid;
			if (grid?.m_elements == null)
			{
				state.Overlays = Array.Empty<OverlayRefs>();
				return;
			}
			bool flag = state.Overlays.Length != grid.m_elements.Count;
			if (!flag)
			{
				for (int i = 0; i < grid.m_elements.Count; i++)
				{
					GameObject val = grid.m_elements[i]?.m_go;
					OverlayRefs overlayRefs = state.Overlays[i];
					if ((Object)(object)val == (Object)null || (Object)(object)overlayRefs.Root == (Object)null || overlayRefs.ElementInstanceId != ((Object)val).GetInstanceID())
					{
						flag = true;
						break;
					}
				}
			}
			if (flag)
			{
				OverlayRefs[] array = new OverlayRefs[grid.m_elements.Count];
				for (int j = 0; j < grid.m_elements.Count; j++)
				{
					GameObject val2 = grid.m_elements[j]?.m_go;
					Transform val3 = (((Object)(object)val2 != (Object)null) ? val2.transform.Find("VES_Combine") : null);
					array[j] = new OverlayRefs(Object.op_Implicit((Object)(object)val2) ? ((Object)val2).GetInstanceID() : 0, (val3 != null) ? ((Component)val3).gameObject : null, ((Object)(object)val3 != (Object)null && val3.childCount > 1) ? ((Component)val3.GetChild(1)).gameObject : null, ((Object)(object)val3 != (Object)null && val3.childCount > 2) ? ((Component)val3.GetChild(2)).gameObject : null);
				}
				state.Overlays = array;
			}
		}

		private static GridState GetOrCreateGridState(InventoryGrid inventoryGrid)
		{
			int instanceID = ((Object)inventoryGrid).GetInstanceID();
			if (!GridStates.TryGetValue(instanceID, out GridState value))
			{
				value = new GridState(instanceID, inventoryGrid);
				GridStates[instanceID] = value;
			}
			value.Grid = inventoryGrid;
			return value;
		}

		private static void UnbindInventory(GridState state)
		{
			if (state.Inventory == null)
			{
				return;
			}
			if (GridIdsByInventory.TryGetValue(state.Inventory, out HashSet<int> value))
			{
				value.Remove(state.GridInstanceId);
				if (value.Count == 0)
				{
					GridIdsByInventory.Remove(state.Inventory);
				}
			}
			state.Inventory = null;
		}

		private static void RemoveGridState(int gridInstanceId)
		{
			if (GridStates.TryGetValue(gridInstanceId, out GridState value))
			{
				UnbindInventory(value);
				GridStates.Remove(gridInstanceId);
			}
		}

		public static void TryCombineAt(InventoryGrid inventoryGrid, UIInputHandler element)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (!_allowScrollCombine.Value || (Object)(object)inventoryGrid == (Object)null || (Object)(object)element == (Object)null)
			{
				return;
			}
			Vector2i buttonPos = inventoryGrid.GetButtonPos(((Component)element).gameObject);
			ItemData itemAt = inventoryGrid.m_inventory.GetItemAt(buttonPos.x, buttonPos.y);
			if (ScrollRegistry.IsUpgradeableScroll(itemAt) && TryConsumePattern(itemAt, inventoryGrid.m_inventory, out var toInstantiate))
			{
				string name = ((Object)itemAt.m_dropPrefab).name;
				if (ScrollRegistry.TryGetUpgradePrefabName(name, out string upgradedPrefabName))
				{
					Utils.InstantiateItem(ZNetScene.instance.GetPrefab(upgradedPrefabName), toInstantiate, 1, inventoryGrid.m_inventory);
					RequestRefresh(inventoryGrid.m_inventory);
					VES_UI.PlayClick();
				}
			}
		}

		public static void AppendCombineTooltip(ItemData item, bool crafting, ref string tooltip)
		{
			if (_allowScrollCombine.Value && ScrollRegistry.IsUpgradeableScroll(item))
			{
				tooltip = tooltip + "\n\n" + GetCombineInstructionText();
			}
		}

		public static string GetCombineInstructionText()
		{
			return "$enchantment_putinlinetocombine".Localize(GetRequiredShapeMarkup());
		}

		private static ConfigDescription OrderedDescription(string description, int order)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			return new ConfigDescription(description, (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Order = order
				}
			});
		}

		private static string GetRequiredShapeMarkup()
		{
			if (!_initialized || _requiredShape.Value != 0)
			{
				return "<color=yellow><b>+</b></color>";
			}
			return "<color=yellow><b>-</b></color>";
		}

		private static bool CanCombine(ItemData item, Inventory grid, out int toInstantiate)
		{
			return _requiredShape.Value switch
			{
				RequiredShape.Row3 => HaveSurrounds3(item, grid, out toInstantiate), 
				RequiredShape.Cross5 => HaveSurrounds5(item, grid, out toInstantiate), 
				_ => ReturnFalse(out toInstantiate), 
			};
		}

		private static bool TryConsumePattern(ItemData item, Inventory grid, out int toInstantiate)
		{
			return _requiredShape.Value switch
			{
				RequiredShape.Row3 => HaveSurrounds3(item, grid, out toInstantiate, removeIfTrue: true), 
				RequiredShape.Cross5 => HaveSurrounds5(item, grid, out toInstantiate, removeIfTrue: true), 
				_ => ReturnFalse(out toInstantiate), 
			};
		}

		private static bool ReturnFalse(out int value)
		{
			value = 0;
			return false;
		}

		private static bool HaveSurrounds3(ItemData item, Inventory grid, out int toInstantiate, bool removeIfTrue = false)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			toInstantiate = 0;
			Vector2i gridPos = item.m_gridPos;
			int num = gridPos.x - 1;
			int num2 = gridPos.x + 1;
			int num3 = gridPos.x - 2;
			int num4 = gridPos.x + 2;
			if (num < 0 || num2 >= grid.m_width)
			{
				return false;
			}
			ItemData itemAt = grid.GetItemAt(num, gridPos.y);
			ItemData itemAt2 = grid.GetItemAt(num2, gridPos.y);
			if (!MatchesSamePrefab(item, itemAt, itemAt2))
			{
				return false;
			}
			if (num3 >= 0)
			{
				ItemData itemAt3 = grid.GetItemAt(num3, gridPos.y);
				if (itemAt3 != null && ((Object)itemAt3.m_dropPrefab).name == ((Object)item.m_dropPrefab).name)
				{
					return false;
				}
			}
			if (num4 < grid.m_width)
			{
				ItemData itemAt4 = grid.GetItemAt(num4, gridPos.y);
				if (itemAt4 != null && ((Object)itemAt4.m_dropPrefab).name == ((Object)item.m_dropPrefab).name)
				{
					return false;
				}
			}
			toInstantiate = Mathf.Min(new int[3] { item.m_stack, itemAt.m_stack, itemAt2.m_stack });
			if (removeIfTrue)
			{
				grid.RemoveItem(item, toInstantiate);
				grid.RemoveItem(itemAt, toInstantiate);
				grid.RemoveItem(itemAt2, toInstantiate);
			}
			return true;
		}

		private static bool HaveSurrounds5(ItemData item, Inventory grid, out int toInstantiate, bool removeIfTrue = false)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			toInstantiate = 0;
			Vector2i gridPos = item.m_gridPos;
			int reservedTopRows = IntegrationRegistry.GetReservedTopRows();
			if (reservedTopRows > 0 && gridPos.y < reservedTopRows)
			{
				return false;
			}
			int num = gridPos.x - 1;
			int num2 = gridPos.x + 1;
			int num3 = gridPos.y - 1;
			int num4 = gridPos.y + 1;
			if (num < 0 || num2 >= grid.m_width || num3 < 0 || num4 >= grid.m_height)
			{
				return false;
			}
			ItemData itemAt = grid.GetItemAt(num, gridPos.y);
			ItemData itemAt2 = grid.GetItemAt(num2, gridPos.y);
			ItemData itemAt3 = grid.GetItemAt(gridPos.x, num3);
			ItemData itemAt4 = grid.GetItemAt(gridPos.x, num4);
			if (!MatchesSamePrefab(item, itemAt, itemAt2, itemAt3, itemAt4))
			{
				return false;
			}
			if (HasAdjacentDuplicate(grid, ((Object)item.m_dropPrefab).name, gridPos.x - 2, gridPos.y) || HasAdjacentDuplicate(grid, ((Object)item.m_dropPrefab).name, gridPos.x + 2, gridPos.y) || HasAdjacentDuplicate(grid, ((Object)item.m_dropPrefab).name, gridPos.x, gridPos.y - 2) || HasAdjacentDuplicate(grid, ((Object)item.m_dropPrefab).name, gridPos.x, gridPos.y + 2))
			{
				return false;
			}
			toInstantiate = Mathf.Min(new int[5] { item.m_stack, itemAt.m_stack, itemAt2.m_stack, itemAt3.m_stack, itemAt4.m_stack });
			if (removeIfTrue)
			{
				grid.RemoveItem(item, toInstantiate);
				grid.RemoveItem(itemAt, toInstantiate);
				grid.RemoveItem(itemAt2, toInstantiate);
				grid.RemoveItem(itemAt3, toInstantiate);
				grid.RemoveItem(itemAt4, toInstantiate);
			}
			return true;
		}

		private static bool MatchesSamePrefab(ItemData centerItem, params ItemData[] surroundingItems)
		{
			if ((Object)(object)centerItem?.m_dropPrefab == (Object)null)
			{
				return false;
			}
			foreach (ItemData val in surroundingItems)
			{
				if ((Object)(object)val?.m_dropPrefab == (Object)null || ((Object)val.m_dropPrefab).name != ((Object)centerItem.m_dropPrefab).name)
				{
					return false;
				}
			}
			return true;
		}

		private static bool HasAdjacentDuplicate(Inventory inventory, string prefabName, int x, int y)
		{
			if (x < 0 || y < 0 || x >= inventory.m_width || y >= inventory.m_height)
			{
				return false;
			}
			ItemData itemAt = inventory.GetItemAt(x, y);
			if (itemAt != null && (Object)(object)itemAt.m_dropPrefab != (Object)null)
			{
				return ((Object)itemAt.m_dropPrefab).name == prefabName;
			}
			return false;
		}
	}
	internal static class ScrollContentBootstrap
	{
		private static bool _initialized;

		public static void Initialize()
		{
			if (_initialized)
			{
				return;
			}
			_initialized = true;
			foreach (char allTier in EnchantmentTierCatalog.AllTiers)
			{
				RegisterTierContent(allTier);
			}
		}

		private static void RegisterTierContent(char tier)
		{
			GameObject val = ScrollPrefabFactory.LoadTierPrefab("kg_EnchantScroll_Weapon", tier);
			GameObject val2 = ScrollPrefabFactory.LoadTierPrefab("kg_EnchantScroll_Weapon_Blessed", tier);
			GameObject val3 = ScrollPrefabFactory.LoadTierPrefab("kg_EnchantScroll_Armor", tier);
			GameObject val4 = ScrollPrefabFactory.LoadTierPrefab("kg_EnchantScroll_Armor_Blessed", tier);
			GameObject val5 = ScrollPrefabFactory.LoadTierPrefab("kg_EnchantSkillScroll", tier);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val2 == (Object)null) && !((Object)(object)val3 == (Object)null) && !((Object)(object)val4 == (Object)null) && !((Object)(object)val5 == (Object)null))
			{
				ItemRegistrationService.RegisteredItem registeredItem = ConfigureCraftableScroll(val, tier, blessed: false, isArmor: false, $"$kg_enchantscroll_{tier}_weapon", "$kg_enchantscroll_weapon_description");
				ItemRegistrationService.RegisteredItem registeredItem2 = ConfigureCraftableScroll(val2, tier, blessed: true, isArmor: false, $"$kg_enchantscroll_{tier}_weapon_blessed", "$kg_enchantscroll_weapon_blessed_description");
				ConfigureBlessedConvertRecipe(registeredItem2, ((Object)registeredItem.Prefab).name, tier);
				ItemRegistrationService.RegisteredItem registeredItem3 = ConfigureCraftableScroll(val3, tier, blessed: false, isArmor: true, $"$kg_enchantscroll_{tier}_armor", "$kg_enchantscroll_armor_description");
				ItemRegistrationService.RegisteredItem registeredItem4 = ConfigureCraftableScroll(val4, tier, blessed: true, isArmor: true, $"$kg_enchantscroll_{tier}_armor_blessed", "$kg_enchantscroll_armor_blessed_description");
				ConfigureBlessedConvertRecipe(registeredItem4, ((Object)registeredItem3.Prefab).name, tier);
				ConfigureSkillScroll(val5, tier);
				if (tier != 'S')
				{
					ScrollRegistry.RegisterUpgradeablePrefab(registeredItem.Prefab);
					ScrollRegistry.RegisterUpgradeablePrefab(registeredItem2.Prefab);
					ScrollRegistry.RegisterUpgradeablePrefab(registeredItem3.Prefab);
					ScrollRegistry.RegisterUpgradeablePrefab(registeredItem4.Prefab);
				}
			}
		}

		private static ItemRegistrationService.RegisteredItem ConfigureCraftableScroll(GameObject prefab, char tier, bool blessed, bool isArmor, string sharedName, string descriptionKey)
		{
			ItemRegistrationService.RegisteredItem registeredItem = ItemRegistrationService.CreateRecipeItem(prefab, sharedName, descriptionKey);
			ItemRegistrationService.ApplyRecipe(registeredItem, ScrollRecipeCatalog.GetRecipe(tier, blessed, isArmor), "kg_EnchantmentScrollStation");
			ScrollRegistry.RegisterLocalizedPrefab(sharedName, registeredItem.Prefab);
			return registeredItem;
		}

		private static void ConfigureBlessedConvertRecipe(ItemRegistrationService.RegisteredItem blessedItem, string normalPrefabName, char tier)
		{
			ItemRegistrationService.ConfigureConversion(blessedItem, "ConvertNormal", ScrollRecipeCatalog.GetBlessedConvertAmount(tier), normalPrefabName, ScrollRecipeCatalog.GetBlessedConvertRequirement(), "kg_EnchantmentScrollStation");
		}

		private static void ConfigureSkillScroll(GameObject skillScrollPrefab, char tier)
		{
			string text = $"$kg_enchantskillscroll_{tier}";
			ItemDrop component = skillScrollPrefab.GetComponent<ItemDrop>();
			if (component != null)
			{
				component.m_itemData.m_shared.m_name = text;
			}
			ScrollRegistry.RegisterLocalizedPrefab(text, skillScrollPrefab);
			SkillScrollService.RegisterSkillScrollPrefab(skillScrollPrefab);
		}
	}
	internal static class ScrollPrefabFactory
	{
		private static GameObject? _prefabRoot;

		public static GameObject? LoadTierPrefab(string assetPrefix, char tier)
		{
			if (tier == 'E')
			{
				return ClonePrefab(ValheimEnchantmentSystem._asset.LoadAsset<GameObject>(assetPrefix + "_S"), assetPrefix + "_E");
			}
			return ValheimEnchantmentSystem._asset.LoadAsset<GameObject>($"{assetPrefix}_{tier}");
		}

		private static GameObject? ClonePrefab(GameObject prefab, string newName)
		{
			if ((Object)(object)prefab == (Object)null)
			{
				return null;
			}
			bool activeSelf = prefab.activeSelf;
			prefab.SetActive(false);
			GameObject val = Object.Instantiate<GameObject>(prefab);
			prefab.SetActive(activeSelf);
			((Object)val).name = newName;
			ItemDrop component = val.GetComponent<ItemDrop>();
			if (component != null)
			{
				component.m_itemData.m_dropPrefab = val;
			}
			Object.DontDestroyOnLoad((Object)(object)val);
			EnsurePrefabRoot();
			val.transform.SetParent(_prefabRoot.transform, false);
			val.SetActive(activeSelf);
			return val;
		}

		private static void EnsurePrefabRoot()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			if (!((Object)(object)_prefabRoot != (Object)null))
			{
				_prefabRoot = new GameObject("VES_PrefabRoot");
				_prefabRoot.SetActive(false);
				Object.DontDestroyOnLoad((Object)(object)_prefabRoot);
			}
		}
	}
	internal static class ScrollRecipeCatalog
	{
		internal readonly struct RecipeData
		{
			public readonly int Amount;

			public readonly string[] Requirements;

			public RecipeData(int amount, params string[] requirements)
			{
				Amount = amount;
				Requirements = requirements;
			}
		}

		private static readonly Dictionary<char, RecipeData> DefaultRecipesWeapon = new Dictionary<char, RecipeData>
		{
			{
				'F',
				new RecipeData(6, "TrophyNeck,1", "Dandelion,6", "Wood,24", "Stone,12")
			},
			{
				'E',
				new RecipeData(3, "TrophyDraugr,1", "Entrails,3", "ElderBark,12", "Guck,6")
			},
			{
				'D',
				new RecipeData(3, "TrophyWolf,1", "WolfPelt,3", "Crystal,6", "Obsidian,9")
			},
			{
				'C',
				new RecipeData(6, "TrophyDeathsquito,1", "Needle,6", "FineWood,24", "Tar,12")
			},
			{
				'B',
				new RecipeData(6, "TrophySeeker,1", "Carapace,12", "YggdrasilWood,18", "BlackMarble,24")
			},
			{
				'A',
				new RecipeData(3, "TrophyVolture,1", "ProustitePowder,6", "Blackwood,12", "Grausten,24")
			},
			{
				'S',
				new RecipeData(1, "TrophyFader,1")
			}
		};

		private static readonly Dictionary<char, RecipeData> DefaultRecipesWeaponBlessed = new Dictionary<char, RecipeData>
		{
			{
				'F',
				new RecipeData(2, "TrophyBjorn,1", "BjornPaw,4", "BoneFragments,12", "Bronze,8")
			},
			{
				'E',
				new RecipeData(2, "TrophyDraugrElite,1", "Bloodbag,4", "Chain,2", "Iron,8")
			},
			{
				'D',
				new RecipeData(4, "TrophyFenring,1", "WolfFang,8", "JuteRed,4", "Silver,16")
			},
			{
				'C',
				new RecipeData(4, "TrophyBjornUndead,1", "UndeadBjornRibcage,8", "LinenThread,24", "BlackMetal,16")
			},
			{
				'B',
				new RecipeData(1, "TrophyGjall,1", "Bilebag,2", "BlackCore,1", "Eitr,4")
			},
			{
				'A',
				new RecipeData(4, "TrophyFallenValkyrie,1", "CelestialFeather,12", "BonemawSerpentTooth,6", "FlametalNew,16")
			},
			{
				'S',
				new RecipeData(1, "TrophyFader,1")
			}
		};

		private static readonly Dictionary<char, RecipeData> DefaultRecipesArmor = new Dictionary<char, RecipeData>
		{
			{
				'F',
				new RecipeData(2, "TrophyBoar,1", "LeatherScraps,2", "Resin,6", "Flint,4")
			},
			{
				'E',
				new RecipeData(3, "TrophyBlob,1", "Ooze,6", "ElderBark,12", "Guck,6")
			},
			{
				'D',
				new RecipeData(3, "TrophyHatchling,1", "FreezeGland,3", "Crystal,6", "Obsidian,9")
			},
			{
				'C',
				new RecipeData(3, "TrophyGoblin,1", "Coins,30", "FineWood,12", "Tar,6")
			},
			{
				'B',
				new RecipeData(6, "TrophyTick,1", "GiantBloodSack,6", "YggdrasilWood,18", "BlackMarble,24")
			},
			{
				'A',
				new RecipeData(3, "TrophyAsksvin,1", "SulfurStone,3", "Blackwood,12", "Grausten,24")
			},
			{
				'S',
				new RecipeData(1, "TrophyFader,1")
			}
		};

		private static readonly Dictionary<char, RecipeData> DefaultRecipesArmorBlessed = new Dictionary<char, RecipeData>
		{
			{
				'F',
				new RecipeData(1, "TrophyFrostTroll,1", "TrollHide,5", "Ectoplasm,1", "Bronze,4")
			},
			{
				'E',
				new RecipeData(1, "TrophyAbomination,1", "Root,5", "Chitin,2", "Iron,4")
			},
			{
				'D',
				new RecipeData(4, "TrophySGolem,1", "WolfClaw,2", "WolfHairBundle,8", "Silver,16")
			},
			{
				'C',
				new RecipeData(2, "TrophyLox,1", "LoxPelt,6", "BarleyFlour,12", "BlackMetal,8")
			},
			{
				'B',
				new RecipeData(4, "TrophySeekerBrute,1", "Mandible,4", "JuteBlue,6", "Eitr,16")
			},
			{
				'A',
				new RecipeData(4, "TrophyMorgen,1", "MorgenHeart,4", "CharredBone,24", "FlametalNew,16")
			},
			{
				'S',
				new RecipeData(1, "TrophyFader,1")
			}
		};

		public static int GetBlessedConvertAmount(char tier)
		{
			return 1;
		}

		public static int GetBlessedConvertRequirement()
		{
			return 12;
		}

		public static RecipeData GetRecipe(char tier, bool blessed, bool isArmor)
		{
			Dictionary<char, RecipeData> dictionary = ((!isArmor) ? (blessed ? DefaultRecipesWeaponBlessed : DefaultRecipesWeapon) : (blessed ? DefaultRecipesArmorBlessed : DefaultRecipesArmor));
			return dictionary[tier];
		}
	}
	internal static class ScrollRegistry
	{
		private static readonly HashSet<string> UpgradeableScrollPrefabs = new HashSet<string>(StringComparer.Ordinal);

		private static readonly Dictionary<string, GameObject> NameToPrefab = new Dictionary<string, GameObject>(StringComparer.Ordinal);

		private static readonly Dictionary<char, char> UpgradeMapper = new Dictionary<char, char>
		{
			{ 'F', 'E' },
			{ 'E', 'D' },
			{ 'D', 'C' },
			{ 'C', 'B' },
			{ 'B', 'A' },
			{ 'A', 'S' }
		};

		public static void RegisterLocalizedPrefab(string sharedName, GameObject prefab)
		{
			if (!string.IsNullOrWhiteSpace(sharedName) && !((Object)(object)prefab == (Object)null))
			{
				NameToPrefab[sharedName] = prefab;
			}
		}

		public static void RegisterUpgradeablePrefab(GameObject prefab)
		{
			if ((Object)(object)prefab != (Object)null)
			{
				UpgradeableScrollPrefabs.Add(((Object)prefab).name);
			}
		}

		public static void FixDropPrefab(ItemData item)
		{
			if (item != null && !Object.op_Implicit((Object)(object)item.m_dropPrefab) && item.m_shared?.m_name != null && NameToPrefab.TryGetValue(item.m_shared.m_name, out GameObject value))
			{
				item.m_dropPrefab = value;
			}
		}

		public static bool IsUpgradeableScroll(ItemData item)
		{
			FixDropPrefab(item);
			if ((Object)(object)item?.m_dropPrefab != (Object)null)
			{
				return UpgradeableScrollPrefabs.Contains(((Object)item.m_dropPrefab).name);
			}
			return false;
		}

		public static bool TryGetUpgradePrefabName(string currentPrefabName, out string upgradedPrefabName)
		{
			upgradedPrefabName = string.Empty;
			if (string.IsNullOrWhiteSpace(currentPrefabName))
			{
				return false;
			}
			char key = currentPrefabName[currentPrefabName.Length - 1];
			if (!UpgradeMapper.TryGetValue(key, out var value))
			{
				return false;
			}
			upgradedPrefabName = currentPrefabName.Substring(0, currentPrefabName.Length - 1) + value;
			return true;
		}

		public static void FixInventoryPrefabs(Inventory inventory)
		{
			if (inventory == null)
			{
				return;
			}
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				FixDropPrefab(allItem);
			}
		}
	}
	internal static class ScrollStationBootstrap
	{
		private const string StationPrefabName = "kg_EnchantmentScrollStation";

		private const string FeedbackDonorPrefabName = "piece_workbench";

		private static readonly PieceRegistrationService.CraftingPieceDefinition StationDefinition = new PieceRegistrationService.CraftingPieceDefinition("kg_EnchantmentScrollStation", "$kg_enchantment_scrollstation", "$kg_enchantment_scrollstation_description", "Hammer", "piece_workbench", new PieceRegistrationService.Requirement[4]
		{
			new PieceRegistrationService.Requirement("SurtlingCore", 1, recover: true),
			new PieceRegistrationService.Requirement("BoneFragments", 5, recover: true),
			new PieceRegistrationService.Requirement("Flint", 10, recover: true),
			new PieceRegistrationService.Requirement("Stone", 20, recover: true)
		}, new ContentFixupRegistry.SceneFixupDefinition[1]
		{
			new ContentFixupRegistry.SceneFixupDefinition("WorkbenchFeedback", ContentFixupRegistry.SceneFixupKind.CraftingStationFeedbackFromDonor, "piece_workbench")
		}, requirePlaceEffect: false);

		private static bool _initialized;

		public static void Initialize()
		{
			if (!_initialized)
			{
				_initialized = true;
				PieceRegistrationService.RegisterCraftingPiece(StationDefinition);
			}
		}
	}
	[VES_Autoload(VES_Autoload.Priority.Last, "OnInit", new Type[]
	{
		typeof(VES_UI),
		typeof(Enchantment_Skill)
	})]
	public static class ScrollItems
	{
		[HarmonyPatch(typeof(InventoryGrid), "Awake")]
		[ClientOnlyPatch]
		public static class InventoryGrid_Awake_Patch
		{
			[UsedImplicitly]
			public static void Postfix(InventoryGrid __instance)
			{
				ScrollCombineService.AttachCombineOutline(__instance);
			}
		}

		[HarmonyPatch(typeof(InventoryGrid), "UpdateInventory")]
		[ClientOnlyPatch]
		private static class InventoryGrid_UpdateInventory_Patch
		{
			[UsedImplicitly]
			public static void Postfix(InventoryGrid __instance, Inventory inventory)
			{
				ScrollCombineService.BindInventoryGrid(__instance, inventory);
			}
		}

		[HarmonyPatch(typeof(InventoryGrid), "UpdateGui")]
		[ClientOnlyPatch]
		private static class InventoryGrid_UpdateGui_Patch
		{
			[UsedImplicitly]
			public static void Postfix(InventoryGrid __instance)
			{
				ScrollCombineService.TryFlushDirtyRefresh(__instance);
			}
		}

		[HarmonyPatch(typeof(InventoryGrid), "OnRightClick")]
		[ClientOnlyPatch]
		private static class InventoryGrid_OnRightClick_Patch
		{
			[UsedImplicitly]
			private static void Postfix(InventoryGrid __instance, UIInputHandler element)
			{
				ScrollCombineService.TryCombineAt(__instance, element);
			}
		}

		[HarmonyPatch(typeof(ItemData), "GetTooltip", new Type[]
		{
			typeof(ItemData),
			typeof(int),
			typeof(bool),
			typeof(float),
			typeof(int)
		})]
		[ClientOnlyPatch]
		public static class TooltipPatch
		{
			[UsedImplicitly]
			public static void Postfix(ItemData item, bool crafting, ref string __result)
			{
				ScrollCombineService.AppendCombineTooltip(item, crafting, ref __result);
			}
		}

		[HarmonyPatch(typeof(ItemDrop), "DropItem", new Type[]
		{
			typeof(ItemData),
			typeof(int),
			typeof(Vector3),
			typeof(Quaternion)
		})]
		private static class ItemDrop_DropItem_Patch
		{
			[UsedImplicitly]
			private static void Prefix(ItemData item)
			{
				ScrollRegistry.FixDropPrefab(item);
			}

			[UsedImplicitly]
			private static void Postfix(ItemDrop __result)
			{
				if ((Object)(object)__result != (Object)null && !((Component)__result).gameObject.activeSelf)
				{
					((Component)__result).gameObject.SetActive(true);
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "Save")]
		private static class Inventory_Save_Patch
		{
			[UsedImplicitly]
			private static void Prefix(Inventory __instance)
			{
				ScrollRegistry.FixInventoryPrefabs(__instance);
			}
		}

		[UsedImplicitly]
		private static void OnInit()
		{
			ScrollStationBootstrap.Initialize();
			ScrollCombineService.Initialize();
			ScrollContentBootstrap.Initialize();
			EngineEvents.InventoryChanged += delegate(Inventory inventory)
			{
				ScrollCombineService.RequestRefresh(inventory);
			};
		}
	}
	[VES_Autoload(VES_Autoload.Priority.Normal, "OnInit", new Type[] { typeof(IntegrationRegistry) })]
	public static class BiomeTierResolver
	{
		[HarmonyPatch(typeof(ZoneSystem), "Start")]
		private static class ZoneSystem_Start_Patch
		{
			[UsedImplicitly]
			private static void Postfix()
			{
				RefreshCustomBiomeConfigs();
			}
		}

		private sealed class DeclaredCustomBiomeYamlEntry
		{
			public string biome { get; set; } = string.Empty;

		}

		[CompilerGenerated]
		private sealed class <EnumerateBiomeTierMappings>d__24 : IEnumerable<KeyValuePair<Biome, ConfigEntry<string>>>, IEnumerable, IEnumerator<KeyValuePair<Biome, ConfigEntry<string>>>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private KeyValuePair<Biome, ConfigEntry<string>> <>2__current;

			private int <>l__initialThreadId;

			private Dictionary<Biome, ConfigEntry<string>>.Enumerator <>7__wrap1;

			KeyValuePair<Biome, ConfigEntry<string>> IEnumerator<KeyValuePair<Biome, ConfigEntry<string>>>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

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

			[DebuggerHidden]
			public <EnumerateBiomeTierMappings>d__24(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				switch (<>1__state)
				{
				case -3:
				case 1:
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
					break;
				case -4:
				case 2:
					try
					{
					}
					finally
					{
						<>m__Finally2();
					}
					break;
				}
				<>7__wrap1 = default(Dictionary<Biome, ConfigEntry<string>>.Enumerator);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = BuiltInBiomeTiers.GetEnumerator();
						<>1__state = -3;
						goto IL_006a;
					case 1:
						<>1__state = -3;
						goto IL_006a;
					case 2:
						{
							<>1__state = -4;
							break;
						}
						IL_006a:
						if (<>7__wrap1.MoveNext())
						{
							KeyValuePair<Biome, ConfigEntry<string>> current = <>7__wrap1.Current;
							<>2__current = current;
							<>1__state = 1;
							return true;
						}
						<>m__Finally1();
						<>7__wrap1 = default(Dictionary<Biome, ConfigEntry<string>>.Enumerator);
						<>7__wrap1 = ResolvedCustomBiomeTiers.GetEnumerator();
						<>1__state = -4;
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						KeyValuePair<Biome, ConfigEntry<string>> current2 = <>7__wrap1.Current;
						<>2__current = current2;
						<>1__state = 2;
						return true;
					}
					<>m__Finally2();
					<>7__wrap1 = default(Dictionary<Biome, ConfigEntry<string>>.Enumerator);
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>7__wrap1).Dispose();
			}

			private void <>m__Finally2()
			{
				<>1__state = -1;
				((IDisposable)<>7__wrap1).Dispose();
			}

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

			[DebuggerHidden]
			IEnumerator<KeyValuePair<Biome, ConfigEntry<string>>> IEnumerable<KeyValuePair<Biome, ConfigEntry<string>>>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <EnumerateBiomeTierMappings>d__24(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<KeyValuePair<Biome, ConfigEntry<string>>>)this).GetEnumerator();
			}
		}

		private const string ExpandWorldBiomeDirectoryName = "expand_world";

		private const string ExpandWorldBiomeFilePattern = "expand_biomes*.yaml";

		private static readonly Dictionary<Biome, ConfigEntry<string>> BuiltInBiomeTiers = new Dictionary<Biome, ConfigEntry<string>>();

		private static readonly Dictionary<Biome, ConfigEntry<string>> ResolvedCustomBiomeTiers = new Dictionary<Biome, ConfigEntry<string>>();

		private static readonly Dictionary<string, ConfigEntry<string>> CustomBiomeTierByIdentifier = new Dictionary<string, ConfigEntry<string>>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, Biome> LoggedResolvedCustomBiomeNumbersByIdentifier = new Dictionary<string, Biome>(StringComparer.OrdinalIgnoreCase);

		private static bool _initialized;

		[UsedImplicitly]
		private static void OnInit()
		{
			Initialize();
		}

		public static void Initialize()
		{
			if (!_initialized)
			{
				_initialized = true;
				RegisterBuiltInBiomeConfigs();
				IntegrationRegistry.BiomesChanged += RefreshCustomBiomeConfigs;
				RefreshCustomBiomeConfigs();
			}
		}

		public static bool TryResolveTier(Character character, out char tier)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			tier = '\0';
			if ((Object)(object)character == (Object)null)
			{
				return false;
			}
			return TryResolveTier(ResolveBiome(((Component)character).transform.position), out tier);
		}

		public static bool TryResolveTier(Biome biome, out char tier)
		{
			//IL_0008: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected I4, but got Unknown
			tier = '\0';
			if (BuiltInBiomeTiers.TryGetValue(biome, out ConfigEntry<string> value))
			{
				return EnchantmentTierCatalog.TryParse(value.Value, out tier);
			}
			if (ResolvedCustomBiomeTiers.TryGetValue(biome, out ConfigEntry<string> value2))
			{
				return EnchantmentTierCatalog.TryParse(value2.Value, out tier);
			}
			int num = int.MinValue;
			foreach (KeyValuePair<Biome, ConfigEntry<string>> item in EnumerateBiomeTierMappings())
			{
				if ((biome & item.Key) != 0)
				{
					int num2 = (int)item.Key;
					if (num2 > num && EnchantmentTierCatalog.TryParse(item.Value.Value, out var tier2))
					{
						num = num2;
						tier = tier2;
					}
				}
			}
			return num != int.MinValue;
		}

		private static Biome ResolveBiome(Vector3 position)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (WorldGenerator.instance != null)
			{
				Biome biome = WorldGenerator.instance.GetBiome(position);
				if ((int)biome != 0)
				{
					return biome;
				}
			}
			if (!((Object)(object)EnvMan.instance != (Object)null))
			{
				return (Biome)0;
			}
			return EnvMan.instance.m_currentBiome;
		}

		private static void RegisterBuiltInBiomeConfigs()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<Biome, char> builtInBiomeTier in EnchantmentTierCatalog.BuiltInBiomeTiers)
			{
				RegisterBuiltInBiomeConfig(builtInBiomeTier.Key, builtInBiomeTier.Value);
			}
		}

		private static void RegisterBuiltInBiomeConfig(Biome biome, char defaultTier)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (!BuiltInBiomeTiers.ContainsKey(biome))
			{
				string builtInBiomeConfigName = GetBuiltInBiomeConfigName(biome);
				string description = $"Tier of scrolls {biome} (F E D C B A S)";
				BuiltInBiomeTiers[biome] = ValheimEnchantmentSystem.config("Scrolls", builtInBiomeConfigName, defaultTier.ToString(), description);
			}
		}

		private static string GetBuiltInBiomeConfigName(Biome biome)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Invalid comparison between Unknown and I4
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected I4, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Invalid comparison between Unknown and I4
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Invalid comparison between Unknown and I4
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			if ((int)biome <= 16)
			{
				switch (biome - 1)
				{
				default:
					if ((int)biome != 8)
					{
						if ((int)biome != 16)
						{
							break;
						}
						return "6 - Plains Tier";
					}
					return "2 - BlackForest Tier";
				case 0:
					return "1 - Meadows Tier";
				case 1:
					return "3 - Swamp Tier";
				case 3:
					return "5 - Mountain Tier";
				case 2:
					break;
				}
			}
			else if ((int)biome <= 64)
			{
				if ((int)biome == 32)
				{
					return "8 - Ashlands Tier";
				}
				if ((int)biome == 64)
				{
					return "9 - DeepNorth Tier";
				}
			}
			else
			{
				if ((int)biome == 256)
				{
					return "4 - Ocean Tier";
				}
				if ((int)biome == 512)
				{
					return "7 - Mistlands Tier";
				}
			}
			return $"{biome} Tier";
		}

		private static void RefreshCustomBiomeConfigs()
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			bool flag = RegisterDeclaredCustomBiomeConfigsFromYaml();
			if (!IntegrationRegistry.TryGetCustomBiomes(out List<CustomBiomeDefinition> customBiomes))
			{
				if (flag)
				{
					((BaseUnityPlugin)ValheimEnchantmentSystem._thistype).Config.Save();
				}
				return;
			}
			ResolvedCustomBiomeTiers.Clear();
			foreach (CustomBiomeDefinition item in customBiomes.OrderBy((CustomBiomeDefinition entry) => (int)entry.Biome))
			{
				if ((int)item.Biome != 0 && TryNormalizeCustomBiomeIdentifier(item.Identifier, out string normalizedIdentifier))
				{
					ConfigEntry<string> configEntry;
					bool flag2 = TryGetOrCreateCustomBiomeConfig(normalizedIdentifier, item.Identifier, out configEntry);
					flag = flag || flag2;
					ResolvedCustomBiomeTiers[item.Biome] = configEntry;
					LogResolvedCustomBiomeNumberIfChanged(normalizedIdentifier, item.Identifier, item.Biome);
				}
			}
			if (flag)
			{
				((BaseUnityPlugin)ValheimEnchantmentSystem._thistype).Config.Save();
			}
		}

		private static bool RegisterDeclaredCustomBiomeConfigsFromYaml()
		{
			if (!ExpandWorldDataIntegration.Instance.IsAvailable())
			{
				return false;
			}
			if (!TryGetDeclaredCustomBiomeIdentifiers(out List<string> identifiers))
			{
				return false;
			}
			bool result = false;
			foreach (string item in identifiers)
			{
				if (TryGetOrCreateCustomBiomeConfig(item, item, out ConfigEntry<string> _))
				{
					Utils.print("Registered custom biome scroll tier config slot: " + item);
					result = true;
				}
			}
			return result;
		}

		private static bool TryGetDeclaredCustomBiomeIdentifiers(out List<string> identifiers)
		{
			identifiers = new List<string>();
			string path = Path.Combine(Paths.ConfigPath, "expand_world");
			if (!Directory.Exists(path))
			{
				return false;
			}
			string[] array;
			try
			{
				array = Directory.GetFiles(path, "expand_biomes*.yaml").OrderByDescending<string, string>(Path.GetFileName, StringComparer.OrdinalIgnoreCase).ToArray();
			}
			catch (Exception ex)
			{
				Utils.print("Failed to enumerate Expand World Data biome yaml files: " + ex.Message, ConsoleColor.Yellow);
				return false;
			}
			if (array.Length == 0)
			{
				return false;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			string[] array2 = array;
			foreach (string path2 in array2)
			{
				if (!TryReadDeclaredBiomeYaml(path2, out List<DeclaredCustomBiomeYamlEntry> yamlEntries, out string error))
				{
					Utils.print("Failed to parse Expand World Data biome yaml '" + Path.GetFileName(path2) + "': " + error, ConsoleColor.Yellow);
					continue;
				}
				foreach (DeclaredCustomBiomeYamlEntry item in yamlEntries)
				{
					if (TryNormalizeCustomBiomeIdentifier(item.biome, out string normalizedIdentifier) && !IsBuiltInBiomeIdentifier(normalizedIdentifier) && hashSet.Add(normalizedIdentifier))
					{
						identifiers.Add(normalizedIdentifier);
					}
				}
			}
			return identifiers.Count > 0;
		}

		private static bool TryReadDeclaredBiomeYaml(string path, out List<DeclaredCustomBiomeYamlEntry> yamlEntries, out string error)
		{
			yamlEntries = new List<DeclaredCustomBiomeYamlEntry>();
			error = string.Empty;
			try
			{
				if (!File.Exists(path))
				{
					error = "file does not exist";
					return false;
				}
				string text = File.ReadAllText(path);
				if (string.IsNullOrWhiteSpace(text))
				{
					error = "content is empty";
					return false;
				}
				List<DeclaredCustomBiomeYamlEntry> list = new DeserializerBuilder().IgnoreUnmatchedProperties().Build().Deserialize<List<DeclaredCustomBiomeYamlEntry>>(text);
				if (list == null)
				{
					error = "deserialized to null";
					return false;
				}
				yamlEntries = list;
				return true;
			}
			catch (Exception ex)
			{
				error = ex.ToString();
				return false;
			}
		}

		private static bool TryGetOrCreateCustomBiomeConfig(string normalizedIdentifier, string rawIdentifier, out ConfigEntry<string> configEntry)
		{
			configEntry = null;
			if (!TryNormalizeCustomBiomeIdentifier(normalizedIdentifier, out string normalizedIdentifier2))
			{
				return false;
			}
			if (CustomBiomeTierByIdentifier.TryGetValue(normalizedIdentifier2, out configEntry))
			{
				return false;
			}
			string name = "Custom - " + normalizedIdentifier2 + " Tier";
			string description = "Tier of scrolls " + rawIdentifier + " (ExpandWorldData custom biome identifier, use F E D C B A S)";
			configEntry = ValheimEnchantmentSystem.config("Scrolls", name, string.Empty, description);
			CustomBiomeTierByIdentifier[normalizedIdentifier2] = configEntry;
			return true;
		}

		private static void LogResolvedCustomBiomeNumberIfChanged(string normalizedIdentifier, string rawIdentifier, Biome biome)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected I4, but got Unknown
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (!LoggedResolvedCustomBiomeNumbersByIdentifier.TryGetValue(normalizedIdentifier, out var value) || value != biome)
			{
				LoggedResolvedCustomBiomeNumbersByIdentifier[normalizedIdentifier] = biome;
				Utils.print($"Resolved custom biome scroll tier config: {rawIdentifier} [{(int)biome}]");
			}
		}

		private static bool TryNormalizeCustomBiomeIdentifier(string identifier, out string normalizedIdentifier)
		{
			normalizedIdentifier = NormalizeCustomBiomeIdentifier(identifier);
			if (normalizedIdentifier.Length > 0)
			{
				return !string.Equals(normalizedIdentifier, "none", StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}

		private static string NormalizeCustomBiomeIdentifier(string identifier)
		{
			return identifier.Replace('\r', ' ').Replace('\n', ' ').Trim()
				.ToLowerInvariant();
		}

		private static bool IsBuiltInBiomeIdentifier(string identifier)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (Enum.TryParse<Biome>(identifier, ignoreCase: true, out Biome result))
			{
				return EnchantmentTierCatalog.IsBuiltInBiome(result);
			}
			return false;
		}

		[IteratorStateMachine(typeof(<EnumerateBiomeTierMappings>d__24))]
		private static IEnumerable<KeyValuePair<Biome, ConfigEntry<string>>> EnumerateBiomeTierMappings()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnumerateBiomeTierMappings>d__24(-2);
		}
	}
	[VES_Autoload(VES_Autoload.Priority.Normal, "OnInit", new Type[] { typeof(BiomeTierResolver) })]
	public static class ScrollDropService
	{
		[HarmonyPatch(typeof(Character), "OnDeath")]
		private static class Tome_SpawnLoot_Patch
		{
			[UsedImplicitly]
			private static void Prefix(Character __instance)
			{
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				if (MonsterDroppingScrolls.Value && IsOwnerDropContext(__instance) && HasPlayerLastHit(__instance))
				{
					string prefabName = Utils.GetPrefabName(((Component)__instance).gameObject);
					if (!ExcludedDropPrefabs.Contains(prefabName) && BiomeTierResolver.TryResolveTier(__instance, out var tier))
					{
						Vector3 position = ((Component)__instance).transform.position;
						TryDropDefault(tier, __instance.IsBoss(), position);
						TryDropBlessed(tier, __instance.IsBoss(), position);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Character), "OnDeath")]
		private static class Tome_SpawnLootSkill_Patch
		{
			[UsedImplicitly]
			private static void Prefix(Character __instance)
			{
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				if (MonsterDroppingSkillScrolls.Value && IsOwnerDropContext(__instance) && HasPlayerLastHit(__instance))
				{
					string prefabName = Utils.GetPrefabName(((Component)__instance).gameObject);
					if (!ExcludedDropPrefabs.Contains(prefabName) && BiomeTierResolver.TryResolveTier(__instance, out var tier))
					{
						TryDropSkillScroll(tier, __instance.IsBoss(), ((Component)__instance).transform.position);
					}
				}
			}
		}

		private static ConfigEntry<float> DropChance = null;

		private static ConfigEntry<float> DropChanceBosses = null;

		private static ConfigEntry<float> DropChanceBlessed = null;

		private static ConfigEntry<float> DropChanceBlessedBosses = null;

		private static ConfigEntry<float> DropChanceSkill = null;

		private static ConfigEntry<float> DropChanceSkillBosses = null;

		private static ConfigEntry<bool> MonsterDroppingScrolls = null;

		private static ConfigEntry<bool> MonsterDroppingSkillScrolls = null;

		private static ConfigEntry<string> ExcludePrefabsFromDrop = null;

		private static readonly HashSet<string> ExcludedDropPrefabs = new HashSet<string>();

		private static bool _initialized;

		[UsedImplicitly]
		private static void OnInit()
		{
			Initialize();
		}

		public static void Initialize()
		{
			if (!_initialized)
			{
				_initialized = true;
				MonsterDroppingScrolls = ValheimEnchantmentSystem.config("Scrolls", "Drop From Monsters", value: true, "Allow monsters to drop scrolls.");
				MonsterDroppingSkillScrolls = ValheimEnchantmentSystem.config("Skill Scrolls", "Drop From Monsters (Skill exp)", value: true, "Allow monsters to drop enchant skill exp scrolls.");
				DropChance = ValheimEnchantmentSystem.config("Scrolls", "Drop Chance", 7f, "Chance to drop from enemies.");
				DropChanceBosses = ValheimEnchantmentSystem.config("Scrolls", "Drop Chance (Bosses)", 100f, "Chance to drop from bosses.");
				DropChanceBlessed = ValheimEnchantmentSystem.config("Scrolls", "Blessed Drop Chance", 0.5f, "Chance to drop from enemies.");
				DropChanceBlessedBosses = ValheimEnchantmentSystem.config("Scrolls", "Blessed Drop Chance (Bosses)", 40f, "Chance to drop from bosses.");
				DropChanceSkill = ValheimEnchantmentSystem.config("Skill Scrolls", "Drop Chance (Skill exp)", 1f, "Chance to drop from enemies.");
				DropChanceSkillBosses = ValheimEnchantmentSystem.config("Skill Scrolls", "Drop Chance (Skill exp) (Bosses)", 100f, "Chance to drop from bosses.");
				ExcludePrefabsFromDrop = ValheimEnchantmentSystem.config("Scrolls", "Exclude Prefabs From Drop", "TentaRoot", "Comma separated list of prefabs to exclude from dropping scrolls.");
				ExcludePrefabsFromDrop.SettingChanged += FillExclude;
				FillExclude();
			}
		}

		private static void FillExclude(object? sender = null, EventArgs? e = null)
		{
			ExcludedDropPrefabs.Clear();
			if (string.IsNullOrWhiteSpace(ExcludePrefabsFromDrop.Value))
			{
				return;
			}
			string[] array = ExcludePrefabsFromDrop.Value.Replace(" ", string.Empty).Split(new char[1] { ',' });
			foreach (string text in array)
			{
				if (!string.IsNullOrWhiteSpace(text))
				{
					ExcludedDropPrefabs.Add(text);
				}
			}
		}

		private static bool IsOwnerDropContext(Character character)
		{
			if ((Object)(object)character == (Object)null || character.IsPlayer() || character.IsTamed())
			{
				return false;
			}
			if ((Object)(object)character.m_nview == (Object)null || !character.m_nview.IsValid() || !character.m_nview.IsOwner())
			{
				return false;
			}
			return (Object)(object)ZNetScene.instance != (Object)null;
		}

		private static bool HasPlayerLastHit(Character character)
		{
			object obj;
			if (character == null)
			{
				obj = null;
			}
			else
			{
				HitData lastHit = character.m_lastHit;
				obj = ((lastHit != null) ? lastHit.GetAttacker() : null);
			}
			return obj is Player;
		}

		private static void DropItem(GameObject prefab, Vector3 centerPos, float dropArea)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)prefab == (Object)null)
			{
				return;
			}
			Quaternion val = Quaternion.Euler(0f, (float)Random.Range(0, 360), 0f);
			Vector3 val2 = Random.insideUnitSphere * dropArea;
			GameObject val3 = Object.Instantiate<GameObject>(prefab, centerPos + val2, val);
			val3.SetActive(true);
			Rigidbody component = val3.GetComponent<Rigidbody>();
			if (component != null)
			{
				Vector3 insideUnitSphere = Random.insideUnitSphere;
				if (insideUnitSphere.y < 0f)
				{
					insideUnitSphere.y = 0f - insideUnitSphere.y;
				}
				component.AddForce(insideUnitSphere * 5f, (ForceMode)2);
			}
		}

		private static void TryDropDefault(char tier, bool isBoss, Vector3 position)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			float num = (isBoss ? DropChanceBosses.Value : DropChance.Value) / 100f;
			if (!(Random.value > num))
			{
				string text = ((Random.value < 0.5f) ? $"kg_EnchantScroll_Weapon_{tier}" : $"kg_EnchantScroll_Armor_{tier}");
				DropItem(ZNetScene.instance.GetPrefab(text), position + Vector3.up * 0.75f, 0.5f);
			}
		}

		private static void TryDropBlessed(char tier, bool isBoss, Vector3 position)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			float num = (isBoss ? DropChanceBlessedBosses.Value : DropChanceBlessed.Value) / 100f;
			if (!(Random.value > num))
			{
				string text = ((Random.value < 0.5f) ? $"kg_EnchantScroll_Weapon_Blessed_{tier}" : $"kg_EnchantScroll_Armor_Blessed_{tier}");
				DropItem(ZNetScene.instance.GetPrefab(text), position + Vector3.up * 0.75f, 0.5f);
			}
		}

		private static void TryDropSkillScroll(char tier, bool isBoss, Vector3 position)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			float num = (isBoss ? DropChanceSkillBosses.Value : DropChanceSkill.Value) / 100f;
			if (!(Random.value > num))
			{
				DropItem(ZNetScene.instance.GetPrefab($"kg_EnchantSkillScroll_{tier}"), position + Vector3.up * 0.75f, 0.5f);
			}
		}
	}
	[VES_Autoload(VES_Autoload.Priority.Normal, "OnInit", new Type[] { })]
	public static class SkillScrollService
	{
		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		private static class ZNetScene_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix(ZNetScene __instance)
			{
				foreach (GameObject skillScrollPrefab in SkillScrollPrefabs)
				{
					if (!((Object)(object)skillScrollPrefab == (Object)null))
					{
						if (!__instance.m_prefabs.Contains(skillScrollPrefab))
						{
							__instance.m_prefabs.Add(skillScrollPrefab);
						}
						__instance.m_namedPrefabs[StringExtensionMethods.GetStableHashCode(((Object)skillScrollPrefab).name)] = skillScrollPrefab;
					}
				}
				if (ZRoutedRpc.instance != null)
				{
					ZRoutedRpc.instance.Register<string>("VES_RequestConsumeExpScroll_Server", (Action<long, string>)RPC_RequestConsume_Server);
					ZRoutedRpc.instance.Register<int>("VES_GrantConsumeExpScroll_Client", (Action<long, int>)RPC_GrantConsume_Client);
				}
			}
		}

		public sealed class ExpScroll : MonoBehaviour, Interactable, Hoverable
		{
			private const string ZdoCreationTime = "CreationTime";

			private const int MaxDuration = 120;

			private ZNetView _znv;

			private bool _expirationInitialized;

			private int _initializationRetryCount;

			private int CreationTime
			{
				get
				{
					return _znv.GetZDO().GetInt("CreationTime", 0);
				}
				set
				{
					_znv.GetZDO().Set("CreationTime", value);
				}
			}

			private void Awake()
			{
				_znv = ((Component)this).GetComponent<ZNetView>();
				TryInitialize();
			}

			private void TryInitialize()
			{
				((MonoBehaviour)this).CancelInvoke("TryInitialize");
				if ((Object)(object)_znv == (Object)null)
				{
					_znv = ((Component)this).GetComponent<ZNetView>();
				}
				if ((Object)(object)_znv == (Object)null)
				{
					ScheduleInitializationRetry("missing ZNetView component");
				}
				else if (!_znv.IsValid())
				{
					ScheduleInitializationRetry("ZNetView is not yet valid");
				}
				else
				{
					if (_expirationInitialized || !_znv.IsOwner())
					{
						return;
					}
					_expirationInitialized = true;
					if (!TryGetCurrentSeconds(out var currentSeconds))
					{
						((MonoBehaviour)this).Invoke("ScheduleExpiration", 1f);
						return;
					}
					if (CreationTime == 0)
					{
						CreationTime = (int)Math.Floor(currentSeconds);
					}
					ScheduleExpiration();
				}
			}

			private void ScheduleInitializationRetry(string reason)
			{
				_initializationRetryCount++;
				((MonoBehaviour)this).Invoke("TryInitialize", 0.2f);
			}

			private void OnDestroy()
			{
				((MonoBehaviour)this).CancelInvoke("TryInitialize");
				((MonoBehaviour)this).CancelInvoke("ScheduleExpiration");
				((MonoBehaviour)this).CancelInvoke("ExpireIfNeeded");
			}

			private void ScheduleExpiration()
			{
				((MonoBehaviour)this).CancelInvoke("ScheduleExpiration");
				((MonoBehaviour)this).CancelInvoke("ExpireIfNeeded");
				if ((Object)(object)_znv == (Object)null || !_znv.IsValid() || !_znv.IsOwner())
				{
					return;
				}
				ZDO zDO = _znv.GetZDO();
				if (zDO == null || zDO.GetBool("VES_Consumed", false))
				{
					return;
				}
				if (!TryGetCurrentSeconds(out var currentSeconds))
				{
					((MonoBehaviour)this).Invoke("ScheduleExpiration", 1f);
					return;
				}
				double num = 120.0 - (currentSeconds - (double)CreationTime);
				if (num <= 0.0)
				{
					ExpireIfNeeded();
				}
				else
				{
					((MonoBehaviour)this).Invoke("ExpireIfNeeded", (float)num);
				}
			}

			private void ExpireIfNeeded()
			{
				if ((Object)(object)_znv == (Object)null || !_znv.IsValid() || !_znv.IsOwner())
				{
					return;
				}
				ZDO zDO = _znv.GetZDO();
				if (zDO != null && !zDO.GetBool("VES_Consumed", false))
				{
					if (!TryGetCurrentSeconds(out var currentSeconds))
					{
						((MonoBehaviour)this).Invoke("ScheduleExpiration", 1f);
					}
					else if (currentSeconds - (double)CreationTime < 120.0)
					{
						ScheduleExpiration();
					}
					else if (!((Object)(object)ZNetScene.instance == (Object)null))
					{
						_znv.ClaimOwnership();
						ZNetScene.instance.Destroy(((Component)this).gameObject);
					}
				}
			}

			private static bool TryGetCurrentSeconds(out double currentSeconds)
			{
				currentSeconds = 0.0;
				if ((Object)(object)EnvMan.instance == (Object)null)
				{
					return false;
				}
				currentSeconds = EnvMan.instance.m_totalSeconds;
				return true;
			}

			public bool Interact(Humanoid user, bool hold, bool alt)
			{
				if ((Object)(object)_znv == (Object)null || !_znv.IsValid())
				{
					TryInitialize();
				}
				if ((Object)(object)_znv == (Object)null || !_znv.IsValid())
				{
					return false;
				}
				if (hold)
				{
					return false;
				}
				if (_znv.GetZDO() == null || _znv.GetZDO().GetBool("VES_Consumed", false))
				{
					return false;
				}
				if (ZRoutedRpc.instance == null)
				{
					return false;
				}
				if (!TryGetCurrentZdoIdText(_znv, out string zdoIdText))
				{
					return false;
				}
				ZRoutedRpc.instance.InvokeRoutedRPC(0L, "VES_RequestConsumeExpScroll_Server", new object[1] { zdoIdText });
				return true;
			}

			internal static void GrantConsumeLocal(int expValue)
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				if (expValue <= 0)
				{
					return;
				}
				Utils.IncreaseSkillEXP(Enchantment_Skill.SkillType_Enchantment, expValue);
				if (ValheimEnchantmentSystem.NoGraphics || (Object)(object)ZNetScene.instance == (Object)null)
				{
					return;
				}
				Player localPlayer = Player.m_localPlayer;
				if (!((Object)(object)localPlayer == (Object)null))
				{
					GameObject prefab = ZNetScene.instance.GetPrefab("fx_Potion_frostresist");
					if ((Object)(object)prefab != (Object)null)
					{
						Object.Instantiate<GameObject>(prefab, ((Component)localPlayer).transform.position, Quaternion.identity);
					}
				}
			}

			public bool UseItem(Humanoid user, ItemData item)
			{
				return false;
			}

			public string GetHoverText()
			{
				return "<b>$enchantment_skill_scroll</b>\n\n[<color=yellow><b>$KEY_Use</b></color>] $enchantment_skill_scroll_use".Localize();
			}

			public string GetHoverName()
			{
				return string.Empty;
			}
		}

		private const float InitializationRetryDelaySeconds = 0.2f;

		private const string SkillScrollPrefabPrefix = "kg_EnchantSkillScroll_";

		private const string RoutedRequestConsume = "VES_RequestConsumeExpScroll_Server";

		private const string RoutedGrantConsume = "VES_GrantConsumeExpScroll_Client";

		private const string SkillScrollConsumedZdoKey = "VES_Consumed";

		private static readonly Dictionary<char, ConfigEntry<int>> BookXpByTier = new Dictionary<char, ConfigEntry<int>>();

		private static readonly List<GameObject> SkillScrollPrefabs = new List<GameObject>();

		private static bool _initialized;

		[UsedImplicitly]
		private static void OnInit()
		{
			Initialize();
		}

		public static void Initialize()
		{
			if (_initialized)
			{
				return;
			}
			_initialized = true;
			foreach (char allTier in EnchantmentTierCatalog.AllTiers)
			{
				BookXpByTier[allTier] = ValheimEnchantmentSystem.config("Skill Scrolls", $"Skill EXP Scroll {allTier}", EnchantmentTierCatalog.GetDefaultSkillScrollExp(allTier), $"Skill EXP Scroll {allTier}");
			}
		}

		public static void RegisterSkillScrollPrefab(GameObject skillScrollPrefab)
		{
			if (!((Object)(object)skillScrollPrefab == (Object)null))
			{
				if ((Object)(object)skillScrollPrefab.GetComponent<ExpScroll>() == (Object)null)
				{
					skillScrollPrefab.AddComponent<ExpScroll>();
				}
				if (!SkillScrollPrefabs.Contains(skillScrollPrefab))
				{
					SkillScrollPrefabs.Add(skillScrollPrefab);
				}
			}
		}

		private static bool TryGetConfiguredExpValue(GameObject item, out int expValue)
		{
			expValue = 0;
			string prefabName = Utils.GetPrefabName(item);
			if (string.IsNullOrEmpty(prefabName))
			{
				return false;
			}
			if (!EnchantmentTierCatalog.TryGetTierFromPrefabName(prefabName, out var tier))
			{
				return false;
			}
			if (!BookXpByTier.TryGetValue(tier, out ConfigEntry<int> value))
			{
				return false;
			}
			expValue = value.Value;
			if (expValue <= 0)
			{
				return false;
			}
			return true;
		}

		private static bool IsSkillScrollPrefabName(string? prefabName)
		{
			if (!string.IsNullOrWhiteSpace(prefabName))
			{
				return prefabName.StartsWith("kg_EnchantSkillScroll_", StringComparison.Ordinal);
			}
			return false;
		}

		private static bool TryGetCurrentZdoIdText(ZNetView znv, out string zdoIdText)
		{
			zdoIdText = string.Empty;
			if ((Object)(object)znv == (Object)null || !znv.IsValid())
			{
				return false;
			}
			ZDO zDO = znv.GetZDO();
			if (zDO == null)
			{
				return false;
			}
			zdoIdText = ((object)(ZDOID)(ref zDO.m_uid)).ToString();
			return !string.IsNullOrWhiteSpace(zdoIdText);
		}

		private static bool TryParseZdoId(string text, out ZDOID zdoId)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			zdoId = ZDOID.None;
			if (string.IsNullOrWhiteSpace(text))
			{
				return false;
			}
			string[] array = text.Split(new char[1] { ':' });
			if (array.Length < 2)
			{
				return false;
			}
			if (!long.TryParse(array[0], out var result))
			{
				return false;
			}
			if (!uint.TryParse(array[1], out var result2))
			{
				return false;
			}
			zdoId = new ZDOID(result, result2);
			return true;
		}

		private static bool TryResolveSkillScrollZdo(string zdoIdText, out ZDO zdo, out GameObject prefab)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			zdo = null;
			prefab = null;
			if (!TryParseZdoId(zdoIdText, out var zdoId))
			{
				return false;
			}
			if (ZDOMan.instance == null)
			{
				return false;
			}
			zdo = ZDOMan.instance.GetZDO(zdoId);
			if (zdo == null)
			{
				return false;
			}
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				return false;
			}
			int prefab2 = zdo.GetPrefab();
			if (prefab2 == 0)
			{
				return false;
			}
			prefab = ZNetScene.instance.GetPrefab(prefab2);
			if ((Object)(object)prefab == (Object)null)
			{
				return false;
			}
			if (!IsSkillScrollPrefabName(((Object)prefab).name))
			{
				return false;
			}
			return true;
		}

		private static void RPC_RequestConsume_Server(long sender, string zdoIdText)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && TryResolveSkillScrollZdo(zdoIdText, out ZDO zdo, out GameObject prefab))
			{
				TryConsumeFromServer(zdo, prefab, sender);
			}
		}

		private static void RPC_GrantConsume_Client(long sender, int expValue)
		{
			if (ZRoutedRpc.instance == null || sender == ZRoutedRpc.instance.GetServerPeerID())
			{
				ExpScroll.GrantConsumeLocal(expValue);
			}
		}

		private static void TryConsumeFromServer(ZDO zdo, GameObject prefab, long sender)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || zdo == null || zdo.GetBool("VES_Consumed", false) || !TryGetConfiguredExpValue(prefab, out var expValue))
			{
				return;
			}
			zdo.Set("VES_Consumed", true);
			zdo.SetOwner(ZDOMan.GetSessionID());
			if (ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(sender, "VES_GrantConsumeExpScroll_Client", new object[1] { expValue });
			}
			if (!((Object)(object)ZNetScene.instance == (Object)null) && ZDOMan.instance != null)
			{
				GameObject val = ZNetScene.instance.FindInstance(zdo.m_uid);
				if ((Object)(object)val != (Object)null)
				{
					ZNetScene.instance.Destroy(val);
				}
				else
				{
					ZDOMan.instance.DestroyZDO(zdo);
				}
			}
		}
	}
}
namespace kg.ValheimEnchantmentSystem.Integrations
{
	internal sealed class AugaIntegration : IOptionalIntegration, IInventoryGridCompatibility
	{
		public static readonly AugaIntegration Instance = new AugaIntegration();

		private const string AugaGuid = "Auga";

		public string Name => "Auga";

		public bool IsAvailable()
		{
			return Chainloader.PluginInfos.ContainsKey("Auga");
		}

		public void Initialize()
		{
		}

		public int GetReservedTopRows()
		{
			return 2;
		}
	}
	[VES_RequiresPlugin("expand_world_data")]
	public sealed class ExpandWorldDataIntegration : IOptionalIntegration, IBiomeCatalogSource
	{
		[HarmonyPatch]
		private static class BiomeReloadPatch
		{
			[UsedImplicitly]
			private static bool Prepare()
			{
				return Instance.GetBiomeReloadTargetMethods(logMissingHooks: true).Count > 0;
			}

			[UsedImplicitly]
			private static IEnumerable<MethodBase> TargetMethods()
			{
				return Instance.GetBiomeReloadTargetMethods(logMissingHooks: false);
			}

			[UsedImplicitly]
			private static void Postfix()
			{
				Instance.NotifyChanged();
			}
		}

		public static readonly ExpandWorldDataIntegration Instance = new ExpandWorldDataIntegration();

		private const string ExpandWorldDataGuid = "expand_world_data";

		private const string ExpandWorldBiomeManagerTypeName = "ExpandWorldData.BiomeManager";

		private const string ExpandWorldBiomeToDisplayNameFieldName = "BiomeToDisplayName";

		private static readonly string[] ExpandWorldBiomeReloadMethodNames = new string[4] { "NamesFromFile", "FromFile", "FromSetting", "SetNames" };

		public string Name => "ExpandWorldData";

		public event Action? Changed;

		public bool IsAvailable()
		{
			return Chainloader.PluginInfos.ContainsKey("expand_world_data");
		}

		public void Initialize()
		{
		}

		public bool TryGetCustomBiomes(out List<CustomBiomeDefinition> customBiomes)
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			customBiomes = new List<CustomBiomeDefinition>();
			if (!IsAvailable())
			{
				return false;
			}
			Type type = AccessTools.TypeByName("ExpandWorldData.BiomeManager");
			if (type == null)
			{
				Utils.print("ExpandWorldData biome manager type was not found while refreshing custom biome tiers.", ConsoleColor.Yellow);
				return false;
			}
			FieldInfo fieldInfo = AccessTools.Field(type, "BiomeToDisplayName");
			if (fieldInfo == null)
			{
				Utils.print("ExpandWorldData biome name map field was not found while refreshing custom biome tiers.", ConsoleColor.Yellow);
				return false;
			}
			object value;
			try
			{
				value = fieldInfo.GetValue(null);
			}
			catch (Exception ex)
			{
				Utils.print("Failed to read ExpandWorldData biome map: " + ex.Message, ConsoleColor.Yellow);
				return false;
			}
			if (!(value is IEnumerable enumerable))
			{
				return false;
			}
			foreach (object item in enumerable)
			{
				if (TryGetBiomeMapEntry(item, out Biome biome, out string identifier) && (int)biome != 0 && !string.Equals(identifier, "none", StringComparison.OrdinalIgnoreCase) && !EnchantmentTierCatalog.IsBuiltInBiome(biome))
				{
					customBiomes.Add(new CustomBiomeDefinition(biome, identifier));
				}
			}
			return true;
		}

		private void NotifyChanged()
		{
			this.Changed?.Invoke();
		}

		private static bool TryGetBiomeMapEntry(object entry, out Biome biome, out string identifier)
		{
			biome = (Biome)0;
			identifier = string.Empty;
			if (entry == null)
			{
				return false;
			}
			Type type = entry.GetType();
			PropertyInfo propertyInfo = AccessTools.Property(type, "Key");
			PropertyInfo propertyInfo2 = AccessTools.Property(type, "Value");
			if (propertyInfo == null || propertyInfo2 == null)
			{
				return false;
			}
			object value = propertyInfo.GetValue(entry);
			object value2 = propertyInfo2.GetValue(entry);
			if (value == null || !(value2 is string text))
			{
				return false;
			}
			biome = (Biome)Convert.ToInt32(value);
			identifier = text.Trim();
			return identifier.Length > 0;
		}

		private List<MethodBase> GetBiomeReloadTargetMethods(bool logMissingHooks)
		{
			List<MethodBase> list = new List<MethodBase>();
			if (!IsAvailable())
			{
				return list;
			}
			Type type = AccessTools.TypeByName("ExpandWorldData.BiomeManager");
			if (type == null)
			{
				if (logMissingHooks)
				{
					Utils.print("ExpandWorldData biome manager type was not found while preparing biome reload hooks.", ConsoleColor.Yellow);
				}
				return list;
			}
			string[] expandWorldBiomeReloadMethodNames = ExpandWorldBiomeReloadMethodNames;
			foreach (string text in expandWorldBiomeReloadMethodNames)
			{
				MethodInfo methodInfo = AccessTools.Method(type, text, (Type[])null, (Type[])null);
				if ((object)methodInfo != null && !list.Contains(methodInfo))
				{
					list.Add(methodInfo);
				}
			}
			if (list.Count == 0 && logMissingHooks)
			{
				Utils.print("ExpandWorldData is installed, but no known biome reload hook was found. Skipping biome reload patch.", ConsoleColor.Yellow);
			}
			return list;
		}
	}
	public readonly struct CustomBiomeDefinition
	{
		public readonly Biome Biome;

		public readonly string Identifier;

		public CustomBiomeDefinition(Biome biome, string identifier)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			Biome = biome;
			Identifier = identifier;
		}
	}
	internal interface IOptionalIntegration
	{
		string Name { get; }

		bool IsAvailable();

		void Initialize();
	}
	internal interface IEnchantCompatibilityRule
	{
		bool CanEnchant(ItemData item, out string message);
	}
	internal interface IEnchantmentStateIntegration
	{
		void Apply(Enchantment_Core.Enchanted enchantment);

		void ApplyUpgraded(Enchantment_Core.Enchanted enchantment);
	}
	internal interface IInventoryGridCompatibility
	{
		int GetReservedTopRows();
	}
	internal interface IBiomeCatalogSource
	{
		event Action? Changed;

		bool TryGetCustomBiomes(out List<CustomBiomeDefinition> customBiomes);
	}
	[VES_Autoload(VES_Autoload.Priority.Normal, "OnInit", new Type[] { typeof(SyncedData) })]
	public static class IntegrationRegistry
	{
		private static readonly IOptionalIntegration[] Integrations = new IOptionalIntegration[3]
		{
			AugaIntegration.Instance,
			JewelcraftingIntegration.Instance,
			ExpandWorldDataIntegration.Instance
		};

		private static readonly List<IEnchantCompatibilityRule> CompatibilityRules = new List<IEnchantCompatibilityRule>();

		private static readonly List<IEnchantmentStateIntegration> StateIntegrations = new List<IEnchantmentStateIntegration>();

		private static readonly List<IInventoryGridCompatibility> InventoryGridCompatibilities = new List<IInventoryGridCompatibility>();

		private static readonly List<IBiomeCatalogSource> BiomeCatalogSources = new List<IBiomeCatalogSource>();

		private static bool _initialized;

		public static event Action? BiomesChanged;

		[UsedImplicitly]
		private static void OnInit()
		{
			if (_initialized)
			{
				return;
			}
			_initialized = true;
			IOptionalIntegration[] integrations = Integrations;
			foreach (IOptionalIntegration optionalIntegration in integrations)
			{
				if (optionalIntegration.IsAvailable())
				{
					if (optionalIntegration is IEnchantCompatibilityRule item)
					{
						CompatibilityRules.Add(item);
					}
					if (optionalIntegration is IEnchantmentStateIntegration item2)
					{
						StateIntegrations.Add(item2);
					}
					if (optionalIntegration is IInventoryGridCompatibility item3)
					{
						InventoryGridCompatibilities.Add(item3);
					}
					if (optionalIntegration is IBiomeCatalogSource biomeCatalogSource)
					{
						BiomeCatalogSources.Add(biomeCatalogSource);
						biomeCatalogSource.Changed += NotifyBiomesChanged;
					}
					optionalIntegration.Initialize();
				}
			}
		}

		public static bool CanEnchant(ItemData item, out string message)
		{
			foreach (IEnchantCompatibilityRule compatibilityRule in CompatibilityRules)
			{
				if (!compatibilityRule.CanEnchant(item, out message))
				{
					return false;
				}
			}
			message = string.Empty;
			return true;
		}

		public static void ApplyEnchantState(Enchantment_Core.Enchanted enchantment)
		{
			foreach (IEnchantmentStateIntegration stateIntegration in StateIntegrations)
			{
				stateIntegration.Apply(enchantment);
			}
		}

		public static void ApplyEnchantUpgradedState(Enchantment_Core.Enchanted enchantment)
		{
			foreach (IEnchantmentStateIntegration stateIntegration in StateIntegrations)
			{
				stateIntegration.ApplyUpgraded(enchantment);
			}
		}

		public static int GetReservedTopRows()
		{
			int num = 0;
			foreach (IInventoryGridCompatibility inventoryGridCompatibility in InventoryGridCompatibilities)
			{
				num = Mathf.Max(num, inventoryGridCompatibility.GetReservedTopRows());
			}
			return num;
		}

		public static bool TryGetCustomBiomes(out List<CustomBiomeDefinition> customBiomes)
		{
			customBiomes = new List<CustomBiomeDefinition>();
			bool result = false;
			foreach (IBiomeCatalogSource biomeCatalogSource in BiomeCatalogSources)
			{
				if (biomeCatalogSource.TryGetCustomBiomes(out List<CustomBiomeDefinition> customBiomes2))
				{
					result = true;
					customBiomes.AddRange(customBiomes2);
				}
			}
			return result;
		}

		private static void NotifyBiomesChanged()
		{
			IntegrationRegistry.BiomesChanged?.Invoke();
		}
	}
	internal sealed class JewelcraftingIntegration : IOptionalIntegration
	{
		public static readonly JewelcraftingIntegration Instance = new JewelcraftingIntegration();

		private const string JewelcraftingGuid = "org.bepinex.plugins.jewelcrafting";

		private const string EnchantmentDataKey = "kg.ValheimEnchantmentSystem#kg.ValheimEnchantmentSystem.Enchantment_Core+Enchanted";

		public string Name => "Jewelcrafting";

		public bool IsAvailable()
		{
			return Chainloader.PluginInfos.ContainsKey("org.bepinex.plugins.jewelcrafting");
		}

		public void Initialize()
		{
			API.OnItemMirrored(OnItemMirror);
		}

		private bool OnItemMirror(ItemData item)
		{
			if (!SyncedData.AllowJewelcraftingMirrorCopyEnchant.Value)
			{
				item.m_customData.Remove("kg.ValheimEnchantmentSystem#kg.ValheimEnchantmentSystem.Enchantment_Core+Enchanted");
			}
			return true;
		}
	}
	[VES_RequiresPlugin("ZenDragon.ZenUI")]
	internal static class ZenUiCompatibility
	{
		[HarmonyPatch(typeof(InventoryGui), "UpdateRecipeList")]
		[ClientOnlyPatch]
		private static class InventoryGui_UpdateRecipeList_Patch
		{
			[UsedImplicitly]
			[HarmonyPrefix]
			[HarmonyPriority(800)]
			private static void Prefix(List<Recipe> recipes)
			{
				if (recipes == null || recipes.Count == 0 || !TryResolveHooks())
				{
					return;
				}
				if (!(_recipeToGroupsField?.GetValue(null) is IDictionary dictionary))
				{
					InvalidateCraftingRecipeCache();
					return;
				}
				foreach (Recipe recipe in recipes)
				{
					if ((Object)(object)recipe != (Object)null && !dictionary.Contains(recipe))
					{
						InvalidateCraftingRecipeCache();
						break;
					}
				}
			}
		}

		private const string ZenUiGuid = "ZenDragon.ZenUI";

		private const string CraftingPanelTypeName = "ZenUI.Section.CraftingPanel";

		private const string LastObjectDbRecipesCountFieldName = "_lastObjectDBRecipesCount";

		private const string RecipeToGroupsFieldName = "RecipeToGroups";

		private const string RecipeItemCloneCacheFieldName = "RecipeItemCloneCache";

		private static bool _hooksResolved;

		private static bool _loggedMissingHooks;

		private static FieldInfo? _lastObjectDbRecipesCountField;

		private static FieldInfo? _recipeToGroupsField;

		private static FieldInfo? _recipeItemCloneCacheField;

		public static void InvalidateCraftingRecipeCache()
		{
			if (!TryResolveHooks())
			{
				return;
			}
			try
			{
				_lastObjectDbRecipesCountField?.SetValue(null, -1);
				ClearDictionary(_recipeToGroupsField);
				ClearDictionary(_recipeItemCloneCacheField);
			}
			catch (Exception ex)
			{
				Utils.print("ZenUI crafting cache invalidation failed: " + ex.Message, ConsoleColor.Yellow);
			}
		}

		private static bool TryResolveHooks()
		{
			if (!Chainloader.PluginInfos.ContainsKey("ZenDragon.ZenUI"))
			{
				return false;
			}
			if (_hooksResolved)
			{
				if (_lastObjectDbRecipesCountField != null)
				{
					return _recipeToGroupsField != null;
				}
				return false;
			}
			_hooksResolved = true;
			Type type = AccessTools.TypeByName("ZenUI.Section.CraftingPanel");
			if (type != null)
			{
				_lastObjectDbRecipesCountField = AccessTools.Field(type, "_lastObjectDBRecipesCount");
				_recipeToGroupsField = AccessTools.Field(type, "RecipeToGroups");
				_recipeItemCloneCacheField = AccessTools.Field(type, "RecipeItemCloneCache");
			}
			if (_lastObjectDbRecipesCountField != null && _recipeToGroupsField != null)
			{
				return true;
			}
			if (!_loggedMissingHooks)
			{
				_loggedMissingHooks = true;
				Utils.print("ZenUI is installed, but crafting panel cache hooks were not found. Skipping recipe cache compatibility.", ConsoleColor.Yellow);
			}
			return false;
		}

		private static void ClearDictionary(FieldInfo? field)
		{
			if (field?.GetValue(null) is IDictionary dictionary)
			{
				dictionary.Clear();
			}
		}
	}
}
namespace kg.ValheimEnchantmentSystem.Configs
{
	internal static class ConfigHotReloadRegistrar
	{
		private const float YamlPollDebounceSeconds = 1.5f;

		private static readonly Dictionary<string, ConfigReloadDomain> Domains = new Dictionary<string, ConfigReloadDomain>(StringComparer.OrdinalIgnoreCase);

		public static string Usage => "ves_reloadconfig [all|main|chance|stat|color|reqs]";

		public static void Initialize(string mainConfigPath, Func<bool> reloadMainConfig)
		{
			Domains.Clear();
			Add(new ConfigReloadDomain("main", new string[1] { mainConfigPath }, Array.Empty<string>(), reloadMainConfig, () => true, () => !IsServerRuntime()));
			Add(new ConfigReloadDomain("chance", new string[2]
			{
				EnchantmentConfigPaths.ChancesWeaponsYaml,
				EnchantmentConfigPaths.ChancesArmorYaml
			}, new string[1] { EnchantmentConfigPaths.OverrideChancesDirectory }, ReloadChanceDomain, IsServerRuntime, null, 1.5f));
			Add(new ConfigReloadDomain("stat", new string[2]
			{
				EnchantmentConfigPaths.StatsWeaponsYaml,
				EnchantmentConfigPaths.StatsArmorYaml
			}, new string[1] { EnchantmentConfigPaths.OverrideStatsDirectory }, ReloadStatDomain, IsServerRuntime, null, 1.5f));
			Add(new ConfigReloadDomain("color", new string[1] { EnchantmentConfigPaths.ColorsYaml }, new string[1] { EnchantmentConfigPaths.OverrideColorsDirectory }, ReloadColorDomain, IsServerRuntime, null, 1.5f));
			Add(new ConfigReloadDomain("reqs", new string[1] { EnchantmentConfigPaths.RequirementsYaml }, new string[1] { EnchantmentConfigPaths.AdditionalRequirementsDirectory }, ReloadRequirementDomain, IsServerRuntime, null, 1.5f));
		}

		public static IReadOnlyCollection<ConfigReloadDomain> GetDomains()
		{
			return (IReadOnlyCollection<ConfigReloadDomain>)(object)Domains.Values.ToArray();
		}

		public static bool TryReload(string target, out string message)
		{
			string text = NormalizeTarget(target);
			if (string.IsNullOrEmpty(text) || string.Equals(text, "all", StringComparison.OrdinalIgnoreCase))
			{
				return TryReloadAll(out message);
			}
			if (!Domains.TryGetValue(text, out ConfigReloadDomain value))
			{
				message = "Unknown config domain '" + target + "'. Use: " + Usage + ".";
				return false;
			}
			return TryReloadDomain(value, out message);
		}

		private static void Add(ConfigReloadDomain domain)
		{
			Domains[domain.Name] = domain;
		}

		private static bool TryReloadAll(out string message)
		{
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			List<string> list3 = new List<string>();
			foreach (ConfigReloadDomain value in Domains.Values)
			{
				if (!CanReload(value))
				{
					list2.Add(value.Name);
				}
				else if (value.Reload())
				{
					list.Add(value.Name);
				}
				else
				{
					list3.Add(value.Name);
				}
			}
			List<string> list4 = new List<string>();
			if (list.Count > 0)
			{
				list4.Add("reloaded: " + string.Join(", ", list));
			}
			if (list2.Count > 0)
			{
				list4.Add("skipped: " + string.Join(", ", list2));
			}
			if (list3.Count > 0)
			{
				list4.Add("failed: " + string.Join(", ", list3));
			}
			message = ((list4.Count > 0) ? string.Join(" | ", list4) : "No config domains were reloaded.");
			if (list3.Count == 0)
			{
				return list.Count > 0;
			}
			return false;
		}

		private static bool TryReloadDomain(ConfigReloadDomain domain, out string message)
		{
			if (!CanReload(domain))
			{
				message = "Config domain '" + domain.Name + "' is only reloadable on the server/runtime host.";
				return false;
			}
			bool flag = domain.Reload();
			message = (flag ? ("Reloaded config domain '" + domain.Name + "'.") : ("Failed to reload config domain '" + domain.Name + "'."));
			return flag;
		}

		private static bool CanReload(ConfigReloadDomain domain)
		{
			try
			{
				return domain.CanReload();
			}
			catch (Exception arg)
			{
				Utils.print($"Config reload predicate failed for {domain.Name}: {arg}", ConsoleColor.Red);
				return false;
			}
		}

		public static bool CanPoll(ConfigReloadDomain domain)
		{
			try
			{
				return domain.CanPoll();
			}
			catch (Exception arg)
			{
				Utils.print($"Config polling predicate failed for {domain.Name}: {arg}", ConsoleColor.Red);
				return false;
			}
		}

		private static string NormalizeTarget(string target)
		{
			if (string.IsNullOrWhiteSpace(target))
			{
				return string.Empty;
			}
			return target.Trim().ToLowerInvariant() switch
			{
				"chances" => "chance", 
				"stats" => "stat", 
				"colors" => "color", 
				"requirements" => "reqs", 
				"requirement" => "reqs", 
				_ => target.Trim().ToLowerInvariant(), 
			};
		}

		private static bool ReloadChanceDomain()
		{
			bool flag = EnchantmentChanceRepository.TryReloadWeaponChances();
			bool flag2 = EnchantmentChanceRepository.TryReloadArmorChances();
			bool flag3 = EnchantmentChanceRepository.TryReloadOverrides();
			return flag && flag2 && flag3;
		}

		private static bool ReloadStatDomain()
		{
			bool flag = EnchantmentStatRepository.TryReloadWeaponStats();
			bool flag2 = EnchantmentStatRepository.TryReloadArmorStats();
			bool flag3 = EnchantmentStatRepository.TryReloadOverrides();
			return flag && flag2 && flag3;
		}

		private static bool ReloadColorDomain()
		{
			bool flag = EnchantmentColorRepository.TryReloadColors();
			bool flag2 = EnchantmentColorRepository.TryReloadOverrides();
			return flag && flag2;
		}

		private static bool ReloadRequirementDomain()
		{
			return EnchantmentRequirementRepository.TryReload(SyncedData.Synced_EnchantmentReqs);
		}

		private static bool IsServerRuntime()
		{
			if (Object.op_Implicit((Object)(object)Game.instance) && Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return ZNet.instance.IsServer();
			}
			return false;
		}
	}
	[Flags]
	internal enum ConfigRefreshScope
	{
		None = 0,
		Ui = 1,
		LocalPlayerState = 2,
		EquipmentVfx = 4
	}
	internal static class ConfigRefreshCoordinator
	{
		private static readonly MethodInfo HumanoidSetupEquipmentMethod = AccessTools.Method(typeof(Humanoid), "SetupEquipment", (Type[])null, (Type[])null);

		private static readonly MethodInfo PlayerUpdateStatsMethod = AccessTools.Method(typeof(Player), "UpdateStats", new Type[1] { typeof(float) }, (Type[])null);

		private static ConfigRefreshScope PendingRefreshScope;

		private static bool RefreshScheduled;

		private static bool IsInitialized;

		public static void Initialize()
		{
			if (!IsInitialized)
			{
				RegisterSettingRefreshHandlers();
				RegisterSyncedValueRefreshHandlers();
				IsInitialized = true;
			}
		}

		private static void RegisterSettingRefreshHandlers()
		{
			EnchantmentSettings.SafetyLevel.SettingChanged += delegate
			{
				RequestRefresh(ConfigRefreshScope.Ui);
			};
			EnchantmentSettings.DropEnchantmentOnUpgrade.SettingChanged += delegate
			{
				RequestRefresh(ConfigRefreshScope.Ui);
			};
			EnchantmentSettings.ItemFailureType.SettingChanged += delegate
			{
				RequestRefresh(ConfigRefreshScope.Ui);
			};
			EnchantmentSettings.FailedEnchantLevelDecrease.SettingChanged += delegate
			{
				RequestRefresh(ConfigRefreshScope.Ui);
			};
			EnchantmentSettings.BlessedScrollsPreventBreak.SettingChanged += delegate
			{
				RequestRefresh(ConfigRefreshScope.Ui);
			};
			EnchantmentSettings.BlessedScrollsAdditionalChance.SettingChanged += delegate
			{
				RequestRefresh(ConfigRefreshScope.Ui);
			};
			EnchantmentSettings.AllowJewelcraftingMirrorCopyEnchant.SettingChanged += delegate
			{
				RequestRefresh(ConfigRefreshScope.Ui);
			};
			EnchantmentSettings.AdditionalEnchantmentChancePerLevel.SettingChanged += delegate
			{
				RequestRefresh(ConfigRefreshScope.Ui);
			};
		}

		private static void RegisterSyncedValueRefreshHandlers()
		{
			SyncedData.Synced_EnchantmentChances_Weapons.ValueChanged += delegate
			{
				RequestRefresh(ConfigRefreshScope.Ui);
			};
			SyncedData.Synced_EnchantmentChances_Armor.ValueChanged += delegate
			{
				RequestRefresh(ConfigRefreshScope.Ui);
			};
			SyncedData.Synced_EnchantmentStats_Weapons.ValueChanged += delegate
			{
				RequestRefresh(ConfigRefreshScope.Ui | ConfigRefreshScope.LocalPlayerState);
			};
			SyncedData.Synced_EnchantmentStats_Armor.ValueChanged += delegate
			{
				RequestRefresh(ConfigRefreshScope.Ui | ConfigRefreshScope.LocalPlayerState);
			};
			SyncedData.Synced_EnchantmentColors.ValueChanged += delegate
			{
				RequestRefresh(ConfigRefreshScope.Ui | ConfigRefreshScope.EquipmentVfx);
			};
			SyncedData.Synced_EnchantmentReqs.ValueChanged += delegate
			{
				RequestRefresh(ConfigRefreshScope.Ui);
			};
			SyncedData.Overrides_EnchantmentChances.ValueChanged += delegate
			{
				RequestRefresh(ConfigRefreshScope.Ui);
			};
			SyncedData.Overrides_EnchantmentStats.ValueChanged += delegate
			{
				RequestRefresh(ConfigRefreshScope.Ui | ConfigRefreshScope.LocalPlayerState);
			};
			SyncedData.Overrides_EnchantmentColors.ValueChanged += delegate
			{
				RequestRefresh(ConfigRefreshScope.Ui | ConfigRefreshScope.EquipmentVfx);
			};
		}

		private static void RequestRefresh(ConfigRefreshScope scope)
		{
			PendingRefreshScope |= scope;
			if (!RefreshScheduled)
			{
				if ((Object)(object)ValheimEnchantmentSystem._thistype == (Object)null)
				{
					FlushRefresh();
					return;
				}
				RefreshScheduled = true;
				((MonoBehaviour)(object)ValheimEnchantmentSystem._thistype).DelayedInvoke(FlushRefresh, 1);
			}
		}

		private static void FlushRefresh()
		{
			ConfigRefreshScope pendingRefreshScope = PendingRefreshScope;
			PendingRefreshScope = ConfigRefreshScope.None;
			RefreshScheduled = false;
			if (pendingRefreshScope != 0)
			{
				if ((pendingRefreshScope & ConfigRefreshScope.LocalPlayerState) != 0)
				{
					RefreshLocalPlayerState();
				}
				if ((pendingRefreshScope & ConfigRefreshScope.Ui) != 0)
				{
					Enchantment_VFX.UpdateGrid();
				}
				if ((pendingRefreshScope & ConfigRefreshScope.EquipmentVfx) != 0)
				{
					Enchantment_VFX.RefreshSceneVisuals();
				}
				if (PendingRefreshScope != 0)
				{
					RequestRefresh(ConfigRefreshScope.None);
				}
			}
		}

		private static void RefreshLocalPlayerState()
		{
			if (ValheimEnchantmentSystem.NoGraphics || !Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return;
			}
			try
			{
				HumanoidSetupEquipmentMethod?.Invoke(Player.m_localPlayer, null);
			}
			catch (Exception ex)
			{
				Utils.print("Failed to refresh local equipment state: " + ex.Message, ConsoleColor.Yellow);
			}
			try
			{
				PlayerUpdateStatsMethod?.Invoke(Player.m_localPlayer, new object[1] { 0f });
			}
			catch (Exception ex2)
			{
				Utils.print("Failed to refresh local player stats: " + ex2.Message, ConsoleColor.Yellow);
			}
			foreach (ItemData allItem in ((Humanoid)Player.m_localPlayer).m_inventory.GetAllItems())
			{
				float maxDurability = allItem.GetMaxDurability();
				if (!(maxDurability <= 0f) && allItem.m_durability > maxDurability)
				{
					allItem.m_durability = maxDurability;
				}
			}
			((Humanoid)Player.m_localPlayer).m_inventory.Changed();
		}
	}
	internal sealed class ConfigReloadDomain
	{
		public string Name { get; }

		public IReadOnlyList<string> Files { get; }

		public IReadOnlyList<string> Directories { get; }

		public Func<bool> Reload { get; }

		public Func<bool> CanReload { get; }

		public Func<bool> CanPoll { get; }

		public float PollDebounceSeconds { get; }

		public ConfigReloadDomain(string name, IEnumerable<string> files, IEnumerable<string> directories, Func<bool> reload, Func<bool> canReload, Func<bool>? canPoll = null, float pollDebounceSeconds = 0f)
		{
			Name = name;
			Files = (files ?? Array.Empty<string>()).ToArray();
			Directories = (directories ?? Array.Empty<string>()).ToArray();
			Reload = reload;
			CanReload = canReload;
			CanPoll = canPoll ?? canReload;
			PollDebounceSeconds = Math.Max(0f, pollDebounceSeconds);
		}
	}
	internal static class ConfigReloadPoller
	{
		private sealed class PendingReload
		{
			public string Signature = string.Empty;

			public float FirstObservedAtRealtime;
		}

		private const float PollIntervalSeconds = 2f;

		private static readonly Dictionary<string, string> LastSignatures = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, PendingReload> PendingReloads = new Dictionary<string, PendingReload>(StringComparer.OrdinalIgnoreCase);

		private static bool IsInitialized;

		private static float NextPollAtRealtime;

		public static void Initialize()
		{
			LastSignatures.Clear();
			PendingReloads.Clear();
			CaptureSnapshots();
			NextPollAtRealtime = Time.realtimeSinceStartup;
			IsInitialized = true;
		}

		public static void Update()
		{
			if (IsInitialized && !(Time.realtimeSinceStartup < NextPollAtRealtime))
			{
				NextPollAtRealtime = Time.realtimeSinceStartup + 2f;
				PollDomains();
			}
		}

		public static void ResetSnapshots()
		{
			PendingReloads.Clear();
			CaptureSnapshots();
			NextPollAtRealtime = Time.realtimeSinceStartup + 2f;
		}

		public static void Shutdown()
		{
			LastSignatures.Clear();
			PendingReloads.Clear();
			NextPollAtRealtime = 0f;
			IsInitialized = false;
		}

		private static void PollDomains()
		{
			foreach (ConfigReloadDomain domain in ConfigHotReloadRegistrar.GetDomains())
			{
				if (!CanPoll(domain))
				{
					PendingReloads.Remove(domain.Name);
					continue;
				}
				string text;
				try
				{
					text = BuildSignature(domain);
				}
				catch (Exception arg)
				{
					Utils.print($"Failed to snapshot config domain {domain.Name}: {arg}", ConsoleColor.Red);
					continue;
				}
				if (!LastSignatures.TryGetValue(domain.Name, out string value))
				{
					LastSignatures[domain.Name] = text;
					PendingReloads.Remove(domain.Name);
				}
				else if (string.Equals(value, text, StringComparison.Ordinal))
				{
					PendingReloads.Remove(domain.Name);
				}
				else if (TryConsumePendingReload(domain, text))
				{
					LastSignatures[domain.Name] = text;
					if (domain.Reload())
					{
						Utils.print("Reloaded config domain '" + domain.Name + "' via polling.");
					}
				}
			}
		}

		private static void CaptureSnapshots()
		{
			foreach (ConfigReloadDomain domain in ConfigHotReloadRegistrar.GetDomains())
			{
				try
				{
					LastSignatures[domain.Name] = BuildSignature(domain);
				}
				catch (Exception arg)
				{
					Utils.print($"Failed to capture config snapshot for domain {domain.Name}: {arg}", ConsoleColor.Red);
				}
			}
		}

		private static bool CanPoll(ConfigReloadDomain domain)
		{
			if (!ConfigHotReloadRegistrar.CanPoll(domain))
			{
				return false;
			}
			try
			{
				return domain.CanReload();
			}
			catch (Exception arg)
			{
				Utils.print($"Config domain predicate failed for {domain.Name}: {arg}", ConsoleColor.Red);
				return false;
			}
		}

		private static bool TryConsumePendingReload(ConfigReloadDomain domain, string signature)
		{
			if (!PendingReloads.TryGetValue(domain.Name, out PendingReload value) || !string.Equals(value.Signature, signature, StringComparison.Ordinal))
			{
				PendingReloads[domain.Name] = new PendingReload
				{
					Signature = signature,
					FirstObservedAtRealtime = Time.realtimeSinceStartup
				};
				return false;
			}
			if (Time.realtimeSinceStartup - value.FirstObservedAtRealtime < domain.PollDebounceSeconds)
			{
				return false;
			}
			PendingReloads.Remove(domain.Name);
			return true;
		}

		private static string BuildSignature(ConfigReloadDomain domain)
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (string item in domain.Files.OrderBy<string, string>((string path) => path, StringComparer.OrdinalIgnoreCase))
			{
				AppendFileSignature(stringBuilder, item);
			}
			foreach (string item2 in domain.Directories.OrderBy<string, string>((string path) => path, StringComparer.OrdinalIgnoreCase))
			{
				AppendDirectorySignature(stringBuilder, item2);
			}
			return stringBuilder.ToString();
		}

		private static void AppendDirectorySignature(StringBuilder builder, string directory)
		{
			string value = NormalizePath(directory);
			builder.Append("D|").Append(value).Append('|');
			if (!Directory.Exists(directory))
			{
				builder.Append("missing;");
				return;
			}
			string[] array = Directory.GetFiles(directory, "*.yml", SearchOption.TopDirectoryOnly).OrderBy<string, string>((string path) => path, StringComparer.OrdinalIgnoreCase).ToArray();
			builder.Append(array.Length).Append(';');
			string[] array2 = array;
			foreach (string file in array2)
			{
				AppendFileSignature(builder, file);
			}
		}

		private static void AppendFileSignature(StringBuilder builder, string file)
		{
			string value = NormalizePath(file);
			builder.Append("F|").Append(value).Append('|');
			if (!File.Exists(file))
			{
				builder.Append("missing;");
				return;
			}
			FileInfo fileInfo = new FileInfo(file);
			builder.Append(fileInfo.Length).Append('|').Append(fileInfo.LastWriteTimeUtc.Ticks)
				.Append(';');
		}

		private static string NormalizePath(string path)
		{
			if (string.IsNullOrWhiteSpace(path))
			{
				return string.Empty;
			}
			try
			{
				return Path.GetFullPath(path).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
			}
			catch
			{
				return path;
			}
		}
	}
	public static class Defaults
	{
		private static readonly Dictionary<int, SyncedData.Stat_Data> DefaultStats_Weapons = new Dictionary<int, SyncedData.Stat_Data>
		{
			{
				1,
				new SyncedData.Stat_Data
				{
					damage_percentage = 2
				}
			},
			{
				2,
				new SyncedData.Stat_Data
				{
					damage_percentage = 4
				}
			},
			{
				3,
				new SyncedData.Stat_Data
				{
					damage_percentage = 6
				}
			},
			{
				4,
				new SyncedData.Stat_Data
				{
					damage_percentage = 8
				}
			},
			{
				5,
				new SyncedData.Stat_Data
				{
					damage_percentage = 10
				}
			},
			{
				6,
				new SyncedData.Stat_Data
				{
					damage_percentage = 13
				}
			},
			{
				7,
				new SyncedData.Stat_Data
				{
					damage_percentage = 16
				}
			},
			{
				8,
				new SyncedData.Stat_Data
				{
					damage_percentage = 19
				}
			},
			{
				9,
				new SyncedData.Stat_Data
				{
					damage_percentage = 22
				}
			},
			{
				10,
				new SyncedData.Stat_Data
				{
					damage_percentage = 25
				}
			},
			{
				11,
				new SyncedData.Stat_Data
				{
					damage_percentage = 29
				}
			},
			{
				12,
				new SyncedData.Stat_Data
				{
					damage_percentage = 33
				}
			},
			{
				13,
				new SyncedData.Stat_Data
				{
					damage_percentage = 37
				}
			},
			{
				14,
				new SyncedData.Stat_Data
				{
					damage_percentage = 41
				}
			},
			{
				15,
				new SyncedData.Stat_Data
				{
					damage_percentage = 45
				}
			},
			{
				16,
				new SyncedData.Stat_Data
				{
					damage_percentage = 50
				}
			},
			{
				17,
				new SyncedData.Stat_Data
				{
					damage_percentage = 56
				}
			},
			{
				18,
				new SyncedData.Stat_Data
				{
					damage_percentage = 63
				}
			},
			{
				19,
				new SyncedData.Stat_Data
				{
					damage_percentage = 71
				}
			},
			{
				20,
				new SyncedData.Stat_Data
				{
					damage_percentage = 80
				}
			}
		};

		private static readonly Dictionary<int, SyncedData.Stat_Data> DefaultStats_Armor = new Dictionary<int, SyncedData.Stat_Data>
		{
			{
				1,
				new SyncedData.Stat_Data
				{
					durability_percentage = 3,
					max_hp = 1,
					hp_regen = 0.2f
				}
			},
			{
				2,
				new SyncedData.Stat_Data
				{
					durability_percentage = 6,
					max_hp = 2,
					hp_regen = 0.4f
				}
			},
			{
				3,
				new SyncedData.Stat_Data
				{
					durability_percentage = 9,
					max_hp = 3,
					hp_regen = 0.6f
				}
			},
			{
				4,
				new SyncedData.Stat_Data
				{
					durability_percentage = 12,
					max_hp = 4,
					hp_regen = 0.8f
				}
			},
			{
				5,
				new SyncedData.Stat_Data
				{
					durability_percentage = 15,
					max_hp = 5,
					hp_regen = 1f
				}
			},
			{
				6,
				new SyncedData.Stat_Data
				{
					durability_percentage = 18,
					max_hp = 6,
					hp_regen = 1.2f
				}
			},
			{
				7,
				new SyncedData.Stat_Data
				{
					durability_percentage = 21,
					max_hp = 7,
					hp_regen = 1.4f
				}
			},
			{
				8,
				new SyncedData.Stat_Data
				{
					durability_percentage = 24,
					max_hp = 8,
					hp_regen = 1.6f
				}
			},
			{
				9,
				new SyncedData.Stat_Data
				{
					durability_percentage = 27,
					max_hp = 9,
					hp_regen = 1.8f
				}
			},
			{
				10,
				new SyncedData.Stat_Data
				{
					durability_percentage = 30,
					max_hp = 10,
					hp_regen = 2f
				}
			},
			{
				11,
				new SyncedData.Stat_Data
				{
					durability_percentage = 30,
					max_hp = 10,
					hp_regen = 2f,
					armor_percentage = 0.5f,
					armor = 0.5f
				}
			},
			{
				12,
				new SyncedData.Stat_Data
				{
					durability_percentage = 30,
					max_hp = 10,
					hp_regen = 2f,
					armor_percentage = 1.5f,
					armor = 1.1f
				}
			},
			{
				13,
				new SyncedData.Stat_Data
				{
					durability_percentage = 30,
					max_hp = 10,
					hp_regen = 2f,
					armor_percentage = 3f,
					armor = 1.8f
				}
			},
			{
				14,
				new SyncedData.Stat_Data
				{
					durability_percentage = 30,
					max_hp = 10,
					hp_regen = 2f,
					armor_percentage = 5f,
					armor = 2.6f
				}
			},
			{
				15,
				new SyncedData.Stat_Data
				{
					durability_percentage = 30,
					max_hp = 10,
					hp_regen = 2f,
					armor_percentage = 7.5f,
					armor = 3.5f
				}
			},
			{
				16,
				new SyncedData.Stat_Data
				{
					durability_percentage = 30,
					max_hp = 10,
					hp_regen = 2f,
					armor_percentage = 11f,
					armor = 4.6f
				}
			},
			{
				17,
				new SyncedData.Stat_Data
				{
					durability_percentage = 30,
					max_hp = 10,
					hp_regen = 2f,
					armor_percentage = 15f,
					armor = 5.8f
				}
			},
			{
				18,
				new SyncedData.Stat_Data
				{
					durability_percentage = 30,
					max_hp = 10,
					hp_regen = 2f,
					armor_percentage = 19.5f,
					armor = 7.1f
				}
			},
			{
				19,
				new SyncedData.Stat_Data
				{
					durability_percentage = 30,
					max_hp = 10,
					hp_regen = 2f,
					armor_percentage = 24.5f,
					armor = 8.5f
				}
			},
			{
				20,
				new SyncedData.Stat_Data
				{
					durability_percentage = 30,
					max_hp = 10,
					hp_regen = 2f,
					armor_percentage = 30f,
					armor = 10f
				}
			}
		};

		private static readonly Dictionary<int, SyncedData.Chance_Data> DefaultChances_Weapons = new Dictionary<int, SyncedData.Chance_Data>
		{
			{
				0,
				new SyncedData.Chance_Data
				{
					success = 90f
				}
			},
			{
				1,
				new SyncedData.Chance_Data
				{
					success = 86f
				}
			},
			{
				2,
				new SyncedData.Chance_Data
				{
					success = 82f
				}
			},
			{
				3,
				new SyncedData.Chance_Data
				{
					success = 78f
				}
			},
			{
				4,
				new SyncedData.Chance_Data
				{
					success = 74f
				}
			},
			{
				5,
				new SyncedData.Chance_Data
				{
					success = 70f
				}
			},
			{
				6,
				new SyncedData.Chance_Data
				{
					success = 65f
				}
			},
			{
				7,
				new SyncedData.Chance_Data
				{
					success = 60f
				}
			},
			{
				8,
				new SyncedData.Chance_Data
				{
					success = 55f
				}
			},
			{
				9,
				new SyncedData.Chance_Data
				{
					success = 50f
				}
			},
			{
				10,
				new SyncedData.Chance_Data
				{
					success = 45f
				}
			},
			{
				11,
				new SyncedData.Chance_Data
				{
					success = 40f
				}
			},
			{
				12,
				new SyncedData.Chance_Data
				{
					success = 35f
				}
			},
			{
				13,
				new SyncedData.Chance_Data
				{
					success = 30f
				}
			},
			{
				14,
				new SyncedData.Chance_Data
				{
					success = 25f
				}
			},
			{
				15,
				new SyncedData.Chance_Data
				{
					success = 20f
				}
			},
			{
				16,
				new SyncedData.Chance_Data
				{
					success = 15f
				}
			},
			{
				17,
				new SyncedData.Chance_Data
				{
					success = 10f
				}
			},
			{
				18,
				new SyncedData.Chance_Data
				{
					success = 5f
				}
			},
			{
				19,
				new SyncedData.Chance_Data
				{
					success = 0f
				}
			}
		};

		private static readonly Dictionary<int, SyncedData.Chance_Data> DefaultChances_Armor = new Dictionary<int, SyncedData.Chance_Data>
		{
			{
				0,
				new SyncedData.Chance_Data
				{
					success = 93f
				}
			},
			{
				1,
				new SyncedData.Chance_Data
				{
					success = 89f
				}
			},
			{
				2,
				new SyncedData.Chance_Data
				{
					success = 85f
				}
			},
			{
				3,
				new SyncedData.Chance_Data
				{
					success = 81f
				}
			},
			{
				4,
				new SyncedData.Chance_Data
				{
					success = 77f
				}
			},
			{
				5,
				new SyncedData.Chance_Data
				{
					success = 73f
				}
			},
			{
				6,
				new SyncedData.Chance_Data
				{
					success = 68f
				}
			},
			{
				7,
				new SyncedData.Chance_Data
				{
					success = 63f
				}
			},
			{
				8,
				new SyncedData.Chance_Data
				{
					success = 58f
				}
			},
			{
				9,
				new SyncedData.Chance_Data
				{
					success = 53f
				}
			},
			{
				10,
				new SyncedData.Chance_Data
				{
					success = 48f
				}
			},
			{
				11,
				new SyncedData.Chance_Data
				{
					success = 43f
				}
			},
			{
				12,
				new SyncedData.Chance_Data
				{
					success = 38f
				}
			},
			{
				13,
				new SyncedData.Chance_Data
				{
					success = 33f
				}
			},
			{
				14,
				new SyncedData.Chance_Data
				{
					success = 28f
				}
			},
			{
				15,
				new SyncedData.Chance_Data
				{
					success = 23f
				}
			},
			{
				16,
				new SyncedData.Chance_Data
				{
					success = 18f
				}
			},
			{
				17,
				new SyncedData.Chance_Data
				{
					success = 13f
				}
			},
			{
				18,
				new SyncedData.Chance_Data
				{
					success = 8f
				}
			},
			{
				19,
				new SyncedData.Chance_Data
				{
					success = 3f
				}
			}
		};

		private static readonly Dictionary<int, SyncedData.VFX_Data> DefaultColors = new Dictionary<int, SyncedData.VFX_Data>
		{
			{
				1,
				new SyncedData.VFX_Data
				{
					color = "#1E151C01",
					variant = 0
				}
			},
			{
				2,
				new SyncedData.VFX_Data
				{
					color = "#1E181F02",
					variant = 0
				}
			},
			{
				3,
				new SyncedData.VFX_Data
				{
					color = "#1E1A2A03",
					variant = 0
				}
			},
			{
				4,
				new SyncedData.VFX_Data
				{
					color = "#1E1E3AA6",
					variant = 0
				}
			},
			{
				5,
				new SyncedData.VFX_Data
				{
					color = "#1E1E4AB0",
					variant = 0
				}
			},
			{
				6,
				new SyncedData.VFX_Data
				{
					color = "#23415A9B",
					variant = 0
				}
			},
			{
				7,
				new SyncedData.VFX_Data
				{
					color = "#28577EA2",
					variant = 0
				}
			},
			{
				8,
				new SyncedData.VFX_Data
				{
					color = "#1E508EA9",
					variant = 0
				}
			},
			{
				9,
				new SyncedData.VFX_Data
				{
					color = "#14469EB0",
					variant = 0
				}
			},
			{
				10,
				new SyncedData.VFX_Data
				{
					color = "#0A3CAFB7",
					variant = 0
				}
			},
			{
				11,
				new SyncedData.VFX_Data
				{
					color = "#0038BFC0",
					variant = 0
				}
			},
			{
				12,
				new SyncedData.VFX_Data
				{
					color = "#0038BFC0",
					variant = 0
				}
			},
			{
				13,
				new SyncedData.VFX_Data
				{
					color = "#001CDBC4",
					variant = 0
				}
			},
			{
				14,
				new SyncedData.VFX_Data
				{
					color = "#001CDBDB",
					variant = 0
				}
			},
			{
				15,
				new SyncedData.VFX_Data
				{
					color = "#001CDFE2",
					variant = 0
				}
			},
			{
				16,
				new SyncedData.VFX_Data
				{
					color = "#A0140EE9",
					variant = 0
				}
			},
			{
				17,
				new SyncedData.VFX_Data
				{
					color = "#B40A0EF0",
					variant = 0
				}
			},
			{
				18,
				new SyncedData.VFX_Data
				{
					color = "#C8000EF7",
					variant = 0
				}
			},
			{
				19,
				new SyncedData.VFX_Data
				{
					color = "#D2000EFE",
					variant = 0
				}
			},
			{
				20,
				new SyncedData.VFX_Data
				{
					color = "#FF000EFF",
					variant = 0
				}
			}
		};

		private static readonly Dictionary<string, List<string>> DefaultReqs = new Dictionary<string, List<string>>
		{
			["(S)Weapon"] = new List<string> { "SwordCheat", "SledgeCheat" },
			["(S)Armor"] = new List<string> { "HelmetFishingHat" },
			["(A)Weapon"] = new List<string>
			{
				"SwordNiedhogg", "SwordNiedhoggBlood", "SwordNiedhoggLightning", "SwordNiedhoggNature", "SwordDyrnwyn", "THSwordSlayer", "THSwordSlayerBlood", "THSwordSlayerNature", "THSwordSlayerLightning", "SpearSplitner",
				"SpearSplitner_Blood", "SpearSplitner_Nature", "SpearSplitner_Lightning", "AxeBerzerkr", "AxeBerzerkrBlood", "AxeBerzerkrLightning", "AxeBerzerkrNature", "MaceEldner", "MaceEldnerBlood", "MaceEldnerLightning",
				"MaceEldnerNature", "ShieldFlametal", "ShieldFlametalTower", "BowAshlands", "BowAshlandsBlood", "BowAshlandsRoot", "BowAshlandsStorm", "CrossbowRipper", "CrossbowRipperBlood", "CrossbowRipperLightning",
				"CrossbowRipperNature", "StaffClusterbomb", "StaffGreenRoots", "StaffLightning", "StaffRedTroll"
			},
			["(A)Armor"] = new List<string>
			{
				"HelmetAshlandsMediumHood", "ArmorAshlandsMediumChest", "ArmorAshlandsMediumLegs", "HelmetMage_Ashlands", "ArmorMageChest_Ashlands", "ArmorMageLegs_Ashlands", "HelmetFlametal", "ArmorFlametalChest", "ArmorFlametalLegs", "CapeAsksvin",
				"CapeAsh"
			},
			["(B)Weapon"] = new List<string>
			{
				"AtgeirHimminAfl", "THSwordKrom", "SwordMistwalker", "AxeJotunBane", "BattleaxeSkullSplittur", "SledgeDemolisher", "SpearCarapace", "KnifeSkollAndHati", "ShieldCarapaceBuckler", "ShieldCarapace",
				"BowSpineSnap", "CrossbowArbalest", "StaffFireball", "StaffIceShards", "StaffSkeleton", "PickaxeBlackMetal"
			},
			["(B)Armor"] = new List<string> { "HelmetCarapace", "ArmorCarapaceChest", "ArmorCarapaceLegs", "HelmetMage", "ArmorMageChest", "ArmorMageLegs", "CapeFeather" },
			["(C)Weapon"] = new List<string> { "AtgeirBlackmetal", "SwordBlackmetal", "AxeBlackMetal", "BattleaxeBlackmetal", "MaceNeedle", "FistBjornUndeadClaw", "KnifeBlackMetal", "ShieldBlackmetal", "ShieldBlackmetalTower" },
			["(C)Armor"] = new List<string> { "HelmetPadded", "ArmorPaddedCuirass", "ArmorPaddedGreaves", "HelmetBerserkerUndead", "ArmorBerserkerUndeadChest", "ArmorBerserkerUndeadLegs", "CapeLinen", "CapeLox" },
			["(D)Weapon"] = new List<string> { "KnifeSilver", "SwordSilver", "MaceSilver", "SpearWolfFang", "BattleaxeCrystal", "FistFenrirClaw", "ShieldSilver", "BowDraugrFang" },
			["(D)Armor"] = new List<string> { "HelmetDrake", "ArmorWolfChest", "ArmorWolfLegs", "CapeWolf", "HelmetFenring", "ArmorFenringChest", "ArmorFenringLegs" },
			["(E)Weapon"] = new List<string>
			{
				"AtgeirIron", "AxeIron", "MaceIron", "SledgeIron", "SwordIron", "SpearElderbark", "KnifeChitin", "ShieldBanded", "ShieldIronBuckler", "ShieldIronTower",
				"ShieldSerpentscale", "BowHuntsman", "PickaxeIron"
			},
			["(E)Armor"] = new List<string> { "HelmetIron", "ArmorIronChest", "ArmorIronLegs", "HelmetRoot", "ArmorRootChest", "ArmorRootLegs" },
			["(F)Weapon"] = new List<string>
			{
				"Club", "AxeStone", "AxeFlint", "SpearFlint", "KnifeFlint", "AxeEarly", "SledgeStagbreaker", "KnifeButcher", "KnifeCopper", "AtgeirBronze",
				"AxeBronze", "MaceBronze", "SpearBronze", "SwordBronze", "FistBjornClaw", "ShieldWood", "ShieldWoodTower", "ShieldBronzeBuckler", "ShieldBoneTower", "Bow",
				"BowFineWood", "PickaxeAntler", "PickaxeBronze"
			},
			["(F)Armor"] = new List<string>
			{
				"ArmorRagsChest", "ArmorRagsLegs", "HelmetLeather", "ArmorLeatherChest", "ArmorLeatherLegs", "CapeDeerHide", "HelmetTrollLeather", "ArmorTrollLeatherChest", "ArmorTrollLeatherLegs", "CapeTrollHide",
				"HelmetBronze", "ArmorBronzeChest", "ArmorBronzeLegs", "HelmetBerserkerHood", "ArmorBerserkerChest", "ArmorBerserkerLegs"
			}
		};

		private static List<SyncedData.OverrideChances> DefaultOverrides_Chances = new List<SyncedData.OverrideChances>
		{
			new SyncedData.OverrideChances
			{
				Items = new List<string> { "SwordCheat", "SledgeCheat" },
				Chances = new Dictionary<int, SyncedData.Chance_Data>
				{
					{
						1,
						new SyncedData.Chance_Data
						{
							success = 50f
						}
					},
					{
						2,
						new SyncedData.Chance_Data
						{
							success = 45f
						}
					},
					{
						3,
						new SyncedData.Chance_Data
						{
							success = 40f
						}
					},
					{
						4,
						new SyncedData.Chance_Data
						{
							success = 30f
						}
					},
					{
						5,
						new SyncedData.Chance_Data
						{
							success = 25f
						}
					},
					{
						6,
						new SyncedData.Chance_Data
						{
							success = 20f
						}
					},
					{
						7,
						new SyncedData.Chance_Data
						{
							success = 10f
						}
					},
					{
						8,
						new SyncedData.Chance_Data
						{
							success = 5f
						}
					},
					{
						9,
						new SyncedData.Chance_Data
						{
							success = 3f
						}
					},
					{
						10,
						new SyncedData.Chance_Data
						{
							success = 0f
						}
					}
				}
			}
		};

		private static readonly List<SyncedData.OverrideColors> DefaultOverrides_Colors = new List<SyncedData.OverrideColors>
		{
			new SyncedData.OverrideColors
			{
				Items = new List<string> { "SwordCheat", "SledgeCheat" },
				Colors = new Dictionary<int, SyncedData.VFX_Data>
				{
					{
						1,
						new SyncedData.VFX_Data
						{
							color = "#00190019",
							variant = 0
						}
					},
					{
						2,
						new SyncedData.VFX_Data
						{
							color = "#00320032",
							variant = 0
						}
					},
					{
						3,
						new SyncedData.VFX_Data
						{
							color = "#004B004B",
							variant = 0
						}
					},
					{
						4,
						new SyncedData.VFX_Data
						{
							color = "#00640064",
							variant = 0
						}
					},
					{
						5,
						new SyncedData.VFX_Data
						{
							color = "#007D007D",
							variant = 0
						}
					},
					{
						6,
						new SyncedData.VFX_Data
						{
							color = "#00960096",
							variant = 0
						}
					},
					{
						7,
						new SyncedData.VFX_Data
						{
							color = "#00AF00AF",
							variant = 0
						}
					},
					{
						8,
						new SyncedData.VFX_Data
						{
							color = "#00C800C8",
							variant = 0
						}
					},
					{
						9,
						new SyncedData.VFX_Data
						{
							color = "#00E100E1",
							variant = 0
						}
					},
					{
						10,
						new SyncedData.VFX_Data
						{
							color = "#00FA00FA",
							variant = 0
						}
					}
				}
			}
		};

		private static readonly List<SyncedData.OverrideStats> DefaultOverrides_Stats = new List<SyncedData.OverrideStats>
		{
			new SyncedData.OverrideStats
			{
				Items = new List<string> { "SwordCheat", "SledgeCheat" },
				Stats = new Dictionary<int, SyncedData.Stat_Data>
				{
					{
						1,
						new SyncedData.Stat_Data
						{
							damage_percentage = 5,
							damage_fire = 10
						}
					},
					{
						2,
						new SyncedData.Stat_Data
						{
							damage_percentage = 10,
							damage_fire = 20
						}
					},
					{
						3,
						new SyncedData.Stat_Data
						{
							damage_percentage = 15,
							damage_fire = 30
						}
					},
					{
						4,
						new SyncedData.Stat_Data
						{
							damage_percentage = 20,
							damage_fire = 40
						}
					},
					{
						5,
						new SyncedData.Stat_Data
						{
							damage_percentage = 25,
							damage_fire = 50
						}
					},
					{
						6,
						new SyncedData.Stat_Data
						{
							damage_percentage = 30,
							damage_fire = 60
						}
					},
					{
						7,
						new SyncedData.Stat_Data
						{
							damage_percentage = 35,
							damage_fire = 70
						}
					},
					{
						8,
						new SyncedData.Stat_Data
						{
							damage_percentage = 40,
							damage_fire = 80
						}
					},
					{
						9,
						new SyncedData.Stat_Data
						{
							damage_percentage = 45,
							damage_fire = 90
						}
					},
					{
						10,
						new SyncedData.Stat_Data
						{
							damage_percentage = 50,
							damage_fire = 100
						}
					}
				}
			}
		};

		public static string YAML_Stats_Weapons => new SerializerBuilder().ConfigureDefaultValuesHandling(DefaultValuesHandling.OmitDefaults).Build().Serialize(DefaultStats_Weapons);

		public static string YAML_Stats_Armor => new SerializerBuilder().ConfigureDefaultValuesHandling(DefaultValuesHandling.OmitDefaults).Build().Serialize(DefaultStats_Armor);

		public static string YAML_Reqs => Regex.Replace(new SerializerBuilder().ConfigureDefaultValuesHandling(DefaultValuesHandling.OmitDefaults).Build().Serialize(DefaultReqs), "(?m)^\\s*-\\s", "  - ");

		public static string YAML_Colors => new SerializerBuilder().ConfigureDefaultValuesHandling(DefaultValuesHandling.OmitDefaults).Build().Serialize(DefaultColors);

		public static string YAML_Chances_Weapons => SerializeDefaultChances(DefaultChances_Weapons);

		public static string YAML_Chances_Armor => SerializeDefaultChances(DefaultChances_Armor);

		public static string YAML_Overrides_Chances => new SerializerBuilder().ConfigureDefaultValuesHandling(DefaultValuesHandling.OmitDefaults).Build().Serialize(DefaultOverrides_Chances);

		public static string YAML_Overrides_Colors => new SerializerBuilder().ConfigureDefaultValuesHandling(DefaultValuesHandling.OmitDefaults).Build().Serialize(DefaultOverrides_Colors);

		public static string YAML_Overrides_Stats => new SerializerBuilder().ConfigureDefaultValuesHandling(DefaultValuesHandling.OmitDefaults).Build().Serialize(DefaultOverrides_Stats);

		private static string SerializeDefaultChances(Dictionary<int, SyncedData.Chance_Data> chances)
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (KeyValuePair<int, SyncedData.Chance_Data> chance in chances)
			{
				stringBuilder.Append(chance.Key).Append(':').Append('\n');
				stringBuilder.Append("  success: ").Append(chance.Value.success.ToString("0.###", CultureInfo.InvariantCulture)).Append('\n');
				stringBuilder.Append("  destroy: ").Append(chance.Value.destroy.ToString("0.###", CultureInfo.InvariantCulture)).Append('\n');
			}
			return stringBuilder.ToString();
		}
	}
	internal static class EnchantmentChanceRepository
	{
		private static readonly Dictionary<string, Dictionary<int, SyncedData.Chance_Data>> OptimizedOverrides = new Dictionary<string, Dictionary<int, SyncedData.Chance_Data>>();

		private static bool IsInitialized;

		public static void Initialize()
		{
			EnsureSubscriptions();
			OptimizeOverridesCache();
		}

		public static void LoadAuthoritativeData()
		{
			EnchantmentYamlConfigSupport.InitializeYamlConfig(EnchantmentConfigPaths.ChancesWeaponsYaml, Defaults.YAML_Chances_Weapons, SyncedData.Synced_EnchantmentChances_Weapons, "weapon enchant chances");
			EnchantmentYamlConfigSupport.InitializeYamlConfig(EnchantmentConfigPaths.ChancesArmorYaml, Defaults.YAML_Chances_Armor, SyncedData.Synced_EnchantmentChances_Armor, "armor enchant chances");
			SyncedData.Overrides_EnchantmentChances.Value = new List<SyncedData.OverrideChances>();
			TryReloadOverrides();
			OptimizeOverridesCache();
		}

		public static bool TryReloadWeaponChances()
		{
			return EnchantmentYamlConfigSupport.TryReloadYamlConfig(EnchantmentConfigPaths.ChancesWeaponsYaml, SyncedData.Synced_EnchantmentChances_Weapons, "weapon enchant chances");
		}

		public static bool TryReloadArmorChances()
		{
			return EnchantmentYamlConfigSupport.TryReloadYamlConfig(EnchantmentConfigPaths.ChancesArmorYaml, SyncedData.Synced_EnchantmentChances_Armor, "armor enchant chances");
		}

		public static bool TryReloadOverrides()
		{
			if (!EnchantmentYamlConfigSupport.TryReadYamlListDirectory(EnchantmentConfigPaths.OverrideChancesDirectory, out List<SyncedData.OverrideChances> result, out string error))
			{
				Utils.print("Skipped reload for enchantment chance overrides: " + error, ConsoleColor.Red);
				return false;
			}
			SyncedData.Overrides_EnchantmentChances.Value = result;
			return true;
		}

		public static SyncedData.Chance_Data GetEnchantmentChance(string dropPrefab, int level, bool isWeapon)
		{
			if (TryGetDefinedEnchantmentChance(dropPrefab, level, isWeapon, out SyncedData.Chance_Data chance))
			{
				return chance;
			}
			return new SyncedData.Chance_Data
			{
				success = 0f
			};
		}

		public static bool IsLevelEnchantable(string dropPrefab, int level, bool isWeapon)
		{
			if (TryGetDefinedEnchantmentChance(dropPrefab, level, isWeapon, out SyncedData.Chance_Data chance) && chance.success >= 0f)
			{
				return chance.destroy >= 0f;
			}
			return false;
		}

		private static bool TryGetDefinedEnchantmentChance(string dropPrefab, int level, bool isWeapon, out SyncedData.Chance_Data chance)
		{
			chance = null;
			if (dropPrefab != null && OptimizedOverrides.TryGetValue(dropPrefab, out Dictionary<int, SyncedData.Chance_Data> value) && value.TryGetValue(level, out var value2))
			{
				chance = value2;
				return true;
			}
			Dictionary<int, SyncedData.Chance_Data> dictionary = (isWeapon ? SyncedData.Synced_EnchantmentChances_Weapons.Value : SyncedData.Synced_EnchantmentChances_Armor.Value);
			return dictionary.TryGetValue(level, out chance);
		}

		private static void EnsureSubscriptions()
		{
			if (!IsInitialized)
			{
				SyncedData.Overrides_EnchantmentChances.ValueChanged += OptimizeOverridesCache;
				IsInitialized = true;
			}
		}

		private static void OptimizeOverridesCache()
		{
			OptimizedOverrides.Clear();
			foreach (SyncedData.OverrideChances item in SyncedData.Overrides_EnchantmentChances.Value)
			{
				foreach (string item2 in item.Items)
				{
					OptimizedOverrides[item2] = item.Chances;
				}
			}
		}
	}
	internal static class EnchantmentColorRepository
	{
		private static readonly Dictionary<string, Dictionary<int, SyncedData.VFX_Data>> OptimizedOverrides = new Dictionary<string, Dictionary<int, SyncedData.VFX_Data>>();

		private static bool IsInitialized;

		public static void Initialize()
		{
			EnsureSubscriptions();
			OptimizeOverridesCache();
		}

		public static void LoadAuthoritativeData()
		{
			EnchantmentYamlConfigSupport.InitializeYamlConfig(EnchantmentConfigPaths.ColorsYaml, Defaults.YAML_Colors, SyncedData.Synced_EnchantmentColors, "enchantment colors");
			SyncedData.Overrides_EnchantmentColors.Value = new List<SyncedData.OverrideColors>();
			TryReloadOverrides();
			OptimizeOverridesCache();
		}

		public static bool TryReloadColors()
		{
			return EnchantmentYamlConfigSupport.TryReloadYamlConfig(EnchantmentConfigPaths.ColorsYaml, SyncedData.Synced_EnchantmentColors, "enchantment colors");
		}

		public static bool TryReloadOverrides()
		{
			if (!EnchantmentYamlConfigSupport.TryReadYamlListDirectory(EnchantmentConfigPaths.OverrideColorsDirectory, out List<SyncedData.OverrideColors> result, out string error))
			{
				Utils.print("Skipped reload for enchantment color overrides: " + error, ConsoleColor.Red);
				return false;
			}
			SyncedData.Overrides_EnchantmentColors.Value = result;
			return true;
		}

		public static string GetColor(string dropPrefab, int level, out int variant, bool trimAlpha, string defaultValue = "#00000000")
		{
			variant = 0;
			if (level == 0)
			{
				return SanitizeColor(defaultValue, defaultValue, trimAlpha);
			}
			if (dropPrefab != null && OptimizedOverrides.TryGetValue(dropPrefab, out Dictionary<int, SyncedData.VFX_Data> value) && value.TryGetValue(level, out var value2))
			{
				string result = SanitizeColor(value2.color, defaultValue, trimAlpha);
				variant = NormalizeVariantIndex(value2.variant);
				return result;
			}
			if (SyncedData.Synced_EnchantmentColors.Value.TryGetValue(level, out SyncedData.VFX_Data value3))
			{
				string result2 = SanitizeColor(value3.color, defaultValue, trimAlpha);
				variant = NormalizeVariantIndex(value3.variant);
				return result2;
			}
			return SanitizeColor(defaultValue, defaultValue, trimAlpha);
		}

		private static void EnsureSubscriptions()
		{
			if (!IsInitialized)
			{
				SyncedData.Overrides_EnchantmentColors.ValueChanged += OptimizeOverridesCache;
				IsInitialized = true;
			}
		}

		private static void OptimizeOverridesCache()
		{
			OptimizedOverrides.Clear();
			foreach (SyncedData.OverrideColors item in SyncedData.Overrides_EnchantmentColors.Value)
			{
				foreach (string item2 in item.Items)
				{
					OptimizedOverrides[item2] = item.Colors;
				}
			}
		}

		private static string SanitizeColor(string color, string defaultValue, bool trimAlpha)
		{
			string text = (string.IsNullOrWhiteSpace(defaultValue) ? "#00000000" : defaultValue);
			string text2 = (string.IsNullOrWhiteSpace(color) ? text : color.Trim());
			if (!text2.StartsWith("#", StringComparison.Ordinal))
			{
				text2 = "#" + text2;
			}
			int num = (trimAlpha ? 7 : 9);
			if (text2.Length < num)
			{
				text2 = text;
				if (!text2.StartsWith("#", StringComparison.Ordinal))
				{
					text2 = "#" + text2;
				}
				if (text2.Length < num)
				{
					text2 = (trimAlpha ? "#000000" : "#00000000");
				}
			}
			if (!trimAlpha)
			{
				return text2;
			}
			return text2.Substring(0, 7);
		}

		private static int NormalizeVariantIndex(int variant)
		{
			if (Enchantment_VFX.VFXs.Count == 0)
			{
				return 0;
			}
			int num = ((variant > 0) ? (variant - 1) : 0);
			return Mathf.Clamp(num, 0, Enchantment_VFX.VFXs.Count - 1);
		}
	}
	public static class EnchantmentConfigPaths
	{
		private static string RootDirectory = string.Empty;

		public static string ChancesWeaponsYaml { get; private set; } = string.Empty;


		public static string ChancesArmorYaml { get; private set; } = string.Empty;


		public static string StatsWeaponsYaml { get; private set; } = string.Empty;


		public static string StatsArmorYaml { get; private set; } = string.Empty;


		public static string ColorsYaml { get; private set; } = string.Empty;


		public static string RequirementsYaml { get; private set; } = string.Empty;


		public static string OverrideChancesDirectory { get; private set; } = string.Empty;


		public static string OverrideStatsDirectory { get; private set; } = string.Empty;


		public static string OverrideColorsDirectory { get; private set; } = string.Empty;


		public static string AdditionalRequirementsDirectory { get; private set; } = string.Empty;


		public static void Initialize()
		{
			string fullPath = Path.GetFullPath(ValheimEnchantmentSystem.ConfigFolder);
			if (!string.Equals(RootDirectory, fullPath, StringComparison.OrdinalIgnoreCase))
			{
				RootDirectory = fullPath;
				StatsWeaponsYaml = Path.Combine(fullPath, "EnchantmentStats_Weapons.yml");
				StatsArmorYaml = Path.Combine(fullPath, "EnchantmentStats_Armor.yml");
				ColorsYaml = Path.Combine(fullPath, "EnchantmentColors.yml");
				RequirementsYaml = Path.Combine(fullPath, "EnchantmentReqs.yml");
				ChancesWeaponsYaml = Path.Combine(fullPath, "EnchantmentChances_Weapons.yml");
				ChancesArmorYaml = Path.Combine(fullPath, "EnchantmentChances_Armor.yml");
				AdditionalRequirementsDirectory = Path.Combine(fullPath, "AdditionalEnchantmentReqs");
				OverrideChancesDirectory = Path.Combine(fullPath, "AdditionalOverrides_EnchantmentChances");
				OverrideStatsDirectory = Path.Combine(fullPath, "AdditionalOverrides_EnchantmentStats");
				OverrideColorsDirectory = Path.Combine(fullPath, "AdditionalOverrides_EnchantmentColors");
				EnsureDirectory(AdditionalRequirementsDirectory);
				EnsureDirectory(OverrideChancesDirectory);
				EnsureDirectory(OverrideStatsDirectory);
				EnsureDirectory(OverrideColorsDirectory);
				EnsureFile(ChancesWeaponsYaml, Defaults.YAML_Chances_Weapons);
				EnsureFile(ChancesArmorYaml, Defaults.YAML_Chances_Armor);
				EnsureFile(StatsWeaponsYaml, Defaults.YAML_Stats_Weapons);
				EnsureFile(StatsArmorYaml, Defaults.YAML_Stats_Armor);
				EnsureFile(ColorsYaml, Defaults.YAML_Colors);
				EnsureFile(RequirementsYaml, Defaults.YAML_Reqs);
			}
		}

		private static void EnsureDirectory(string path)
		{
			if (!Directory.Exists(path))
			{
				Directory.CreateDirectory(path);
			}
		}

		private static void EnsureFile(string path, string contents)
		{
			if (!File.Exists(path))
			{
				path.WriteFile(contents);
			}
		}
	}
	internal static class EnchantmentRequirementRepository
	{
		private static readonly Dictionary<string, SyncedData.EnchantmentReqs> OptimizedRequirements = new Dictionary<string, SyncedData.EnchantmentReqs>(StringComparer.Ordinal);

		private static List<SyncedData.EnchantmentReqs>? CachedRequirements;

		private static bool IsInitialized;

		public static void Initialize(CustomSyncedValue<List<SyncedData.EnchantmentReqs>> target)
		{
			EnsureSubscriptions(target);
			OptimizeRequirementsCache(target.Value);
		}

		public static void LoadAuthoritativeData(CustomSyncedValue<List<SyncedData.EnchantmentReqs>> target)
		{
			if (TryParseReqsText(Defaults.YAML_Reqs, "built-in defaults", out List<SyncedData.EnchantmentReqs> result, out string error))
			{
				target.Value = result;
			}
			else
			{
				Utils.print("Failed to load built-in defaults for enchantment requirements: " + error, ConsoleColor.Red);
				target.Value = new List<SyncedData.EnchantmentReqs>();
			}
			if (!TryReload(target))
			{
				Utils.print("Using built-in defaults for enchantment requirements.", ConsoleColor.Yellow);
			}
			OptimizeRequirementsCache(target.Value);
		}

		public static bool TryReload(CustomSyncedValue<List<SyncedData.EnchantmentReqs>> target)
		{
			if (!TryRead(out List<SyncedData.EnchantmentReqs> result, out string error, out List<string> warnings))
			{
				Utils.print("Skipped reload for enchantment requirements: " + error, ConsoleColor.Red);
				return false;
			}
			foreach (string item in warnings)
			{
				Utils.print(item, ConsoleColor.Yellow);
			}
			target.Value = result;
			return true;
		}

		public static SyncedData.EnchantmentReqs GetReqs(List<SyncedData.EnchantmentReqs> requirements, string prefab)
		{
			if (string.IsNullOrEmpty(prefab))
			{
				return null;
			}
			if (CachedRequirements != requirements)
			{
				OptimizeRequirementsCache(requirements);
			}
			if (!OptimizedRequirements.TryGetValue(prefab, out SyncedData.EnchantmentReqs value))
			{
				return null;
			}
			return value;
		}

		private static void EnsureSubscriptions(CustomSyncedValue<List<SyncedData.EnchantmentReqs>> target)
		{
			CustomSyncedValue<List<SyncedData.EnchantmentReqs>> target2 = target;
			if (!IsInitialized)
			{
				target2.ValueChanged += delegate
				{
					OptimizeRequirementsCache(target2.Value);
				};
				IsInitialized = true;
			}
		}

		private static void OptimizeRequirementsCache(List<SyncedData.EnchantmentReqs>? requirements)
		{
			OptimizedRequirements.Clear();
			CachedRequirements = requirements;
			if (requirements == null)
			{
				return;
			}
			foreach (SyncedData.EnchantmentReqs requirement in requirements)
			{
				if (requirement?.Items == null)
				{
					continue;
				}
				foreach (string item in requirement.Items)
				{
					if (!string.IsNullOrWhiteSpace(item))
					{
						OptimizedRequirements[item] = requirement;
					}
				}
			}
		}

		private static bool TryRead(out List<SyncedData.EnchantmentReqs> result, out string error, out List<string> warnings)
		{
			result = new List<SyncedData.EnchantmentReqs>();
			warnings = new List<string>();
			Dictionary<string, SyncedData.EnchantmentReqs> requirementsByOwner = new Dictionary<string, SyncedData.EnchantmentReqs>(StringComparer.Ordinal);
			Dictionary<string, string> itemOwners = new Dictionary<string, string>(StringComparer.Ordinal);
			bool flag = false;
			if (TryParseReqsFile(EnchantmentConfigPaths.RequirementsYaml, out List<SyncedData.EnchantmentReqs> result2, out string error2))
			{
				MergeRequirements(result2, EnchantmentConfigPaths.RequirementsYaml, result, requirementsByOwner, itemOwners, warnings);
				flag = true;
			}
			else
			{
				warnings.Add("Skipped enchantment requirements file: " + error2);
			}
			if (!TryGetYamlFiles(EnchantmentConfigPaths.AdditionalRequirementsDirectory, out string[] files, out string error3))
			{
				warnings.Add("Skipped enchantment requirements directory: " + error3);
			}
			else
			{
				string[] array = files;
				foreach (string text in array)
				{
					if (!TryParseReqsFile(text, out List<SyncedData.EnchantmentReqs> result3, out string error4))
					{
						warnings.Add("Skipped enchantment requirements file: " + error4);
						continue;
					}
					MergeRequirements(result3, text, result, requirementsByOwner, itemOwners, warnings);
					flag = true;
				}
			}
			if (!flag)
			{
				error = ((warnings.Count > 0) ? string.Join(" | ", warnings) : "No valid enchantment requirements were loaded.");
				return false;
			}
			error = string.Empty;
			return true;
		}

		private static bool TryParseReqsFile(string path, out List<SyncedData.EnchantmentReqs> result, out string error)
		{
			result = new List<SyncedData.EnchantmentReqs>();
			if (!File.Exists(path))
			{
				error = path + ": file does not exist";
				return false;
			}
			try
			{
				string text = File.ReadAllText(path);
				return TryParseReqsText(text, path, out result, out error);
			}
			catch (Exception arg)
			{
				error = $"{path}: {arg}";
				return false;
			}
		}

		private static bool TryParseReqsText(string text, string source, out List<SyncedData.EnchantmentReqs> result, out string error)
		{
			result = new List<SyncedData.EnchantmentReqs>();
			if (!HasYamlCompatibleListIndentation(text))
			{
				error = source + ": invalid reqs indentation, use spaces for list indentation and avoid tabs";
				return false;
			}
			if (!TryDeserializeReqMap(text, out Dictionary<string, List<string>> map, out error))
			{
				error = source + ": " + error;
				return false;
			}
			return TryConvertSimpleReqs(map, source, out result, out error);
		}

		private static bool TryDeserializeReqMap(string text, out Dictionary<string, List<string>> map, out string error)
		{
			map = new Dictionary<string, List<string>>();
			error = string.Empty;
			try
			{
				if (string.IsNullOrWhiteSpace(text))
				{
					error = "content is empty";
					return false;
				}
				Dictionary<string, List<string>> dictionary = new DeserializerBuilder().WithDuplicateKeyChecking().Build().Deserialize<Dictionary<string, List<string>>>(text);
				if (dictionary == null)
				{
					error = "deserialized to null";
					return false;
				}
				map = dictionary;
				return true;
			}
			catch (Exception ex)
			{
				error = ex.ToString();
				return false;
			}
		}

		private static bool TryGetYamlFiles(string directory, out string[] files, out string error)
		{
			files = Array.Empty<string>();
			if (!Directory.Exists(directory))
			{
				error = directory + ": directory does not exist";
				return false;
			}
			try
			{
				files = Directory.GetFiles(directory, "*.yml", SearchOption.TopDirectoryOnly).OrderBy<string, string>((string path) => path, StringComparer.OrdinalIgnoreCase).ToArray();
				error = string.Empty;
				return true;
			}
			catch (Exception arg)
			{
				error = $"{directory}: {arg}";
				return false;
			}
		}

		private static bool HasYamlCompatibleListIndentation(string text)
		{
			using StringReader stringReader = new StringReader(text);
			string text2;
			while ((text2 = stringReader.ReadLine()) != null)
			{
				string text3 = text2.Trim();
				if (text3.Length == 0 || text3.StartsWith("#") || !text3.StartsWith("-"))
				{
					continue;
				}
				int num = text2.IndexOf('-');
				if (num >= 0)
				{
					string source = text2.Substring(0, num);
					if (Enumerable.Contains(source, '\t') || source.Any((char c) => c != ' '))
					{
						return false;
					}
				}
			}
			return true;
		}

		private static bool TryConvertSimpleReqs(Dictionary<string, List<string>> map, string source, out List<SyncedData.EnchantmentReqs> result, out string error)
		{
			result = new List<SyncedData.EnchantmentReqs>();
			foreach (KeyValuePair<string, List<string>> item in map)
			{
				if (!TryResolveReqKey(item.Key, out SyncedData.SingleReq enchant, out SyncedData.SingleReq blessed, out string reason))
				{
					error = source + ": invalid reqs key '" + item.Key + "'. " + reason;
					return false;
				}
				result.Add(new SyncedData.EnchantmentReqs
				{
					enchant_prefab = enchant,
					blessed_enchant_prefab = blessed,
					Items = ((from item in item.Value?.Where((string item) => !string.IsNullOrWhiteSpace(item))
						select item.Trim()).Distinct<string>(StringComparer.Ordinal).ToList() ?? new List<string>())
				});
			}
			error = string.Empty;
			return true;
		}

		private static void MergeRequirements(IEnumerable<SyncedData.EnchantmentReqs> parsedRequirements, string source, List<SyncedData.EnchantmentReqs> mergedRequirements, Dictionary<string, SyncedData.EnchantmentReqs> requirementsByOwner, Dictionary<string, string> itemOwners, List<string> warnings)
		{
			foreach (SyncedData.EnchantmentReqs parsedRequirement in parsedRequirements)
			{
				if (parsedRequirement?.Items == null)
				{
					continue;
				}
				string requirementOwnerKey = GetRequirementOwnerKey(parsedRequirement);
				string requirementOwnerLabel = GetRequirementOwnerLabel(parsedRequirement);
				foreach (string item in parsedRequirement.Items)
				{
					if (string.IsNullOrWhiteSpace(item))
					{
						continue;
					}
					string text = item.Trim();
					if (itemOwners.TryGetValue(text, out string value))
					{
						warnings.Add(source + ": duplicate item prefab '" + text + "' is mapped to both '" + value + "' and '" + requirementOwnerLabel + "'. Keeping '" + value + "'.");
					}
					else
					{
						if (!requirementsByOwner.TryGetValue(requirementOwnerKey, out SyncedData.EnchantmentReqs value2))
						{
							value2 = (requirementsByOwner[requirementOwnerKey] = new SyncedData.EnchantmentReqs
							{
								enchant_prefab = parsedRequirement.enchant_prefab,
								blessed_enchant_prefab = parsedRequirement.blessed_enchant_prefab,
								Items = new List<string>()
							});
							mergedRequirements.Add(value2);
						}
						itemOwners[text] = requirementOwnerLabel;
						value2.Items.Add(text);
					}
				}
			}
		}

		private static string GetRequirementOwnerKey(SyncedData.EnchantmentReqs requirement)
		{
			string text = requirement?.enchant_prefab?.prefab?.Trim() ?? string.Empty;
			string text2 = requirement?.blessed_enchant_prefab?.prefab?.Trim() ?? string.Empty;
			return text + "|" + text2;
		}

		private static string GetRequirementOwnerLabel(SyncedData.EnchantmentReqs requirement)
		{
			if (!string.IsNullOrWhiteSpace(requirement?.enchant_prefab?.prefab))
			{
				return requirement.enchant_prefab.prefab;
			}
			return "<unknown>";
		}

		private static bool TryResolveReqKey(string key, out SyncedData.SingleReq enchant, out SyncedData.SingleReq blessed, out string reason)
		{
			enchant = null;
			blessed = null;
			reason = string.Empty;
			if (string.IsNullOrWhiteSpace(key))
			{
				reason = "Expected format '(Tier)Weapon' or '(Tier)Armor' with tiers [" + GetAllowedTierList() + "].";
				return false;
			}
			string text = key.Trim();
			if (text.Length < 4 || text[0] != '(' || text[2] != ')')
			{
				reason = "Expected exact format '(Tier)Weapon' or '(Tier)Armor' with tiers [" + GetAllowedTierList() + "].";
				return false;
			}
			char c = char.ToUpperInvariant(text[1]);
			if (!EnchantmentTierCatalog.IsValid(c))
			{
				reason = $"Tier '{text[1]}' is invalid. Allowed tiers: [{GetAllowedTierList()}].";
				return false;
			}
			string text2 = text.Substring(3);
			string arg;
			if (string.Equals(text2, "Armor", StringComparison.OrdinalIgnoreCase))
			{
				arg = "Armor";
			}
			else
			{
				if (!string.Equals(text2, "Weapon", StringComparison.OrdinalIgnoreCase))
				{
					reason = "Type segment '" + text2 + "' is invalid. Expected 'Weapon' or 'Armor'.";
					return false;
				}
				arg = "Weapon";
			}
			enchant = new SyncedData.SingleReq($"kg_EnchantScroll_{arg}_{c}");
			blessed = new SyncedData.SingleReq($"kg_EnchantScroll_{arg}_Blessed_{c}");
			return true;
		}

		private static string GetAllowedTierList()
		{
			return string.Join(", ", EnchantmentTierCatalog.AllTiers);
		}
	}
	public static class EnchantmentSettings
	{
		private static bool IsBound;

		private static readonly Dictionary<char, ConfigEntry<int>> EnchantSkillExpByTier = new Dictionary<char, ConfigEntry<int>>();

		public static ConfigEntry<int> SafetyLevel { get; private set; } = null;


		public static ConfigEntry<bool> DropEnchantmentOnUpgrade { get; private set; } = null;


		public static ConfigEntry<SyncedData.ItemDesctructionTypeEnum> ItemFailureType { get; private set; } = null;


		public static ConfigEntry<int> FailedEnchantLevelDecrease { get; private set; } = null;


		public static ConfigEntry<bool> BlessedScrollsPreventBreak { get; private set; } = null;


		public static ConfigEntry<int> BlessedScrollsAdditionalChance { get; private set; } = null;


		public static ConfigEntry<bool> AllowJewelcraftingMirrorCopyEnchant { get; private set; } = null;


		public static ConfigEntry<float> AdditionalEnchantmentChancePerLevel { get; private set; } = null;


		public static ConfigEntry<float> FailedEnchantSkillExpMultiplier { get; private set; } = null;


		public static ConfigEntry<int> EnchantmentNotificationMinLevel { get; private set; } = null;


		public static ConfigEntry<bool> EnchantmentEnableNotifications { get; private set; } = null;


		public static void Bind()
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Expected O, but got Unknown
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Expected O, but got Unknown
			if (IsBound)
			{
				return;
			}
			SafetyLevel = ValheimEnchantmentSystem.config("Enchantment", "SafetyLevel", 3, "The level below which failed enchantments stay at the current level. Set to 0 to disable.");
			DropEnchantmentOnUpgrade = ValheimEnchantmentSystem.config("Enchantment", "DropEnchantmentOnUpgrade", value: false, "Drop enchantment on item upgrade.");
			ItemFailureType = ValheimEnchantmentSystem.config("Enchantment", "ItemFailureType", SyncedData.ItemDesctructionTypeEnum.LevelDecrease, "LevelDecrease will remove FailedEnchantLevelDecrease levels on fail, Destroy will destroy item on fail, Combined will use yaml destroy chance and success chance, CombinedEasy will keep or decrease level and never destroy");
			FailedEnchantLevelDecrease = ValheimEnchantmentSystem.config("Enchantment", "FailedEnchantLevelDecrease", 1, new ConfigDescription("Number of enchantment levels removed when a failed enchantment causes a level decrease. Set to 20 to effectively clear normal enchantments on failure without destroying the item.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
			BlessedScrollsPreventBreak = ValheimEnchantmentSystem.config("Enchantment", "BlessedScrollsPreventBreak", value: true, "Blessed enchant scrolls prevent negative outcomes on failed enchant attempts. If set to false enchanting chance is increased instead.");
			BlessedScrollsAdditionalChance = ValheimEnchantmentSystem.config("Enchantment", "BlessedScrollsAdditionalChance", 25, "Enchanting chance added when using blessed enchant scrolls if the option to prevent breaking of an item in case of failed enchant is set to false.");
			AllowJewelcraftingMirrorCopyEnchant = ValheimEnchantmentSystem.config("Enchantment", "AllowJewelcraftingMirrorCopyEnchant", value: false, "Allow jewelcrafting to copy enchantment from one item to another using mirror.");
			AdditionalEnchantmentChancePerLevel = ValheimEnchantmentSystem.config("Enchantment", "AdditionalEnchantmentChancePerLevel", 0.07f, "Additional enchantment chance per level of Enchantment skill.");
			FailedEnchantSkillExpMultiplier = ValheimEnchantmentSystem.config("Enchantment", "FailedEnchantSkillExpMultiplier", 0.5f, new ConfigDescription("Multiplier applied to enchant skill EXP when an enchant attempt fails. Failure EXP = Success EXP × multiplier.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()));
			foreach (char allTier in EnchantmentTierCatalog.AllTiers)
			{
				EnchantSkillExpByTier[allTier] = ValheimEnchantmentSystem.config("Enchantment", $"Enchant Skill EXP {allTier}", EnchantmentTierCatalog.GetDefaultEnchantSkillExp(allTier), new ConfigDescription($"Skill EXP granted when enchanting with a tier {allTier} enchant scroll.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			}
			EnchantmentEnableNotifications = ValheimEnchantmentSystem.config("Notifications", "EnchantmentEnableNotifications", value: true, "Enable enchantment notifications.");
			EnchantmentNotificationMinLevel = ValheimEnchantmentSystem.config("Notifications", "EnchantmentNotificationMinLevel", 6, "The minimum level of enchantment to show notification.");
			IsBound = true;
		}

		public static bool TryGetConfiguredEnchantSkillExp(char tier, out int exp)
		{
			exp = 0;
			if (!EnchantSkillExpByTier.TryGetValue(char.ToUpperInvariant(tier), out ConfigEntry<int> value))
			{
				return false;
			}
			exp = value.Value;
			return true;
		}
	}
	internal static class EnchantmentStatRepository
	{
		private static readonly Dictionary<string, Dictionary<int, SyncedData.Stat_Data>> OptimizedOverrides = new Dictionary<string, Dictionary<int, SyncedData.Stat_Data>>();

		private static bool IsInitialized;

		public static void Initialize()
		{
			EnsureSubscriptions();
			OptimizeOverridesCache();
		}

		public static void LoadAuthoritativeData()
		{
			EnchantmentYamlConfigSupport.InitializeYamlConfig(EnchantmentConfigPaths.StatsWeaponsYaml, Defaults.YAML_Stats_Weapons, SyncedData.Synced_EnchantmentStats_Weapons, "weapon enchant stats");
			EnchantmentYamlConfigSupport.InitializeYamlConfig(EnchantmentConfigPaths.StatsArmorYaml, Defaults.YAML_Stats_Armor, SyncedData.Synced_EnchantmentStats_Armor, "armor enchant stats");
			SyncedData.Overrides_EnchantmentStats.Value = new List<SyncedData.OverrideStats>();
			TryReloadOverrides();
			OptimizeOverridesCache();
		}

		public static bool TryReloadWeaponStats()
		{
			return EnchantmentYamlConfigSupport.TryReloadYamlConfig(EnchantmentConfigPaths.StatsWeaponsYaml, SyncedData.Synced_EnchantmentStats_Weapons, "weapon enchant stats");
		}

		public static bool TryReloadArmorStats()
		{
			return EnchantmentYamlConfigSupport.TryReloadYamlConfig(EnchantmentConfigPaths.StatsArmorYaml, SyncedData.Synced_EnchantmentStats_Armor, "armor enchant stats");
		}

		public static bool TryReloadOverrides()
		{
			if (!EnchantmentYamlConfigSupport.TryReadYamlListDirectory(EnchantmentConfigPaths.OverrideStatsDirectory, out List<SyncedData.OverrideStats> result, out string error))
			{
				Utils.print("Skipped reload for enchantment stat overrides: " + error, ConsoleColor.Red);
				return false;
			}
			SyncedData.Overrides_EnchantmentStats.Value = result;
			return true;
		}

		public static SyncedData.Stat_Data GetStatIncrease(Enchantment_Core.Enchanted enchantment)
		{
			if (enchantment.level == 0)
			{
				return null;
			}
			GameObject dropPrefab = enchantment.Item.m_dropPrefab;
			string text = ((dropPrefab != null) ? ((Object)dropPrefab).name : null);
			if (text != null && OptimizedOverrides.TryGetValue(text, out Dictionary<int, SyncedData.Stat_Data> value) && value.TryGetValue(enchantment.level, out var value2))
			{
				return value2;
			}
			Dictionary<int, SyncedData.Stat_Data> dictionary = (enchantment.Item.IsWeapon() ? SyncedData.Synced_EnchantmentStats_Weapons.Value : SyncedData.Synced_EnchantmentStats_Armor.Value);
			if (!dictionary.TryGetValue(enchantment.level, out var value3))
			{
				return null;
			}
			return value3;
		}

		public static SyncedData.Stat_Data GetStatIncrease(string dropPrefab, int level, bool isWeapon)
		{
			if (level <= 0 || string.IsNullOrWhiteSpace(dropPrefab))
			{
				return null;
			}
			if (OptimizedOverrides.TryGetValue(dropPrefab, out Dictionary<int, SyncedData.Stat_Data> value) && value.TryGetValue(level, out var value2))
			{
				return value2;
			}
			Dictionary<int, SyncedData.Stat_Data> dictionary = (isWeapon ? SyncedData.Synced_EnchantmentStats_Weapons.Value : SyncedData.Synced_EnchantmentStats_Armor.Value);
			if (!dictionary.TryGetValue(level, out var value3))
			{
				return null;
			}
			return value3;
		}

		public static bool HasStatIncrease(string dropPrefab, int level, bool isWeapon)
		{
			if (level <= 0 || string.IsNullOrWhiteSpace(dropPrefab))
			{
				return false;
			}
			if (OptimizedOverrides.TryGetValue(dropPrefab, out Dictionary<int, SyncedData.Stat_Data> value) && value.ContainsKey(level))
			{
				return true;
			}
			Dictionary<int, SyncedData.Stat_Data> dictionary = (isWeapon ? SyncedData.Synced_EnchantmentStats_Weapons.Value : SyncedData.Synced_EnchantmentStats_Armor.Value);
			return dictionary.ContainsKey(level);
		}

		private static void EnsureSubscriptions()
		{
			if (!IsInitialized)
			{
				SyncedData.Overrides_EnchantmentStats.ValueChanged += OptimizeOverridesCache;
				IsInitialized = true;
			}
		}

		private static void OptimizeOverridesCache()
		{
			OptimizedOverrides.Clear();
			foreach (SyncedData.OverrideStats item in SyncedData.Overrides_EnchantmentStats.Value)
			{
				foreach (string item2 in item.Items)
				{
					OptimizedOverrides[item2] = item.Stats;
				}
			}
		}
	}
	public static class EnchantmentTierCatalog
	{
		private static readonly char[] OrderedTierValues = new char[7] { 'F', 'E', 'D', 'C', 'B', 'A', 'S' };

		private static readonly HashSet<char> ValidTiers = new HashSet<char>(OrderedTierValues);

		private static readonly Dictionary<char, int> DefaultEnchantSkillExpByTier = new Dictionary<char, int>
		{
			{ 'F', 2 },
			{ 'E', 3 },
			{ 'D', 5 },
			{ 'C', 8 },
			{ 'B', 13 },
			{ 'A', 21 },
			{ 'S', 34 }
		};

		private static readonly Dictionary<char, int> SkillScrollDefaultExpByTier = new Dictionary<char, int>
		{
			{ 'F', 2 },
			{ 'E', 3 },
			{ 'D', 5 },
			{ 'C', 8 },
			{ 'B', 13 },
			{ 'A', 21 },
			{ 'S', 34 }
		};

		private static readonly Dictionary<Biome, char> BuiltInBiomeTierByBiome = new Dictionary<Biome, char>
		{
			{
				(Biome)1,
				'F'
			},
			{
				(Biome)8,
				'F'
			},
			{
				(Biome)2,
				'E'
			},
			{
				(Biome)256,
				'E'
			},
			{
				(Biome)4,
				'D'
			},
			{
				(Biome)16,
				'C'
			},
			{
				(Biome)512,
				'B'
			},
			{
				(Biome)32,
				'A'
			},
			{
				(Biome)64,
				'S'
			}
		};

		public static IEnumerable<char> AllTiers => OrderedTierValues;

		public static IEnumerable<KeyValuePair<Biome, char>> BuiltInBiomeTiers => BuiltInBiomeTierByBiome;

		public static bool IsValid(char tier)
		{
			return ValidTiers.Contains(char.ToUpperInvariant(tier));
		}

		public static bool TryParse(string? rawTier, out char tier)
		{
			tier = '\0';
			if (string.IsNullOrWhiteSpace(rawTier))
			{
				return false;
			}
			tier = char.ToUpperInvariant(rawTier.Trim()[0]);
			return IsValid(tier);
		}

		public static bool IsBuiltInBiome(Biome biome)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return BuiltInBiomeTierByBiome.ContainsKey(biome);
		}

		public static bool TryGetDefaultBiomeTier(Biome biome, out char tier)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return BuiltInBiomeTierByBiome.TryGetValue(biome, out tier);
		}

		public static string GetDefaultBiomeTierValue(Biome biome)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetDefaultBiomeTier(biome, out var tier))
			{
				return string.Empty;
			}
			return tier.ToString();
		}

		public static int GetDefaultEnchantSkillExp(char tier)
		{
			if (!DefaultEnchantSkillExpByTier.TryGetValue(char.ToUpperInvariant(tier), out var value))
			{
				return 0;
			}
			return value;
		}

		public static int GetEnchantSkillExp(char tier)
		{
			if (EnchantmentSettings.TryGetConfiguredEnchantSkillExp(tier, out var exp))
			{
				return exp;
			}
			return GetDefaultEnchantSkillExp(tier);
		}

		public static int GetEnchantSkillExp(string? prefabName)
		{
			if (!TryGetTierFromPrefabName(prefabName, out var tier))
			{
				return 0;
			}
			return GetEnchantSkillExp(tier);
		}

		public static bool TryGetTierFromPrefabName(string? prefabName, out char tier)
		{
			tier = '\0';
			if (string.IsNullOrWhiteSpace(prefabName))
			{
				return false;
			}
			tier = char.ToUpperInvariant(prefabName[prefabName.Length - 1]);
			return IsValid(tier);
		}

		public static int GetDefaultSkillScrollExp(char tier)
		{
			if (!SkillScrollDefaultExpByTier.TryGetValue(char.ToUpperInvariant(tier), out var value))
			{
				return 0;
			}
			return value;
		}
	}
	internal static class EnchantmentYamlConfigSupport
	{
		public static void InitializeYamlConfig<T>(string path, string fallbackYaml, CustomSyncedValue<T> target, string label)
		{
			if (Utils.TryDeserializeYAML<T>(fallbackYaml, out T obj, out string error))
			{
				target.Value = obj;
			}
			else
			{
				Utils.print("Failed to load built-in defaults for " + label + ": " + error, ConsoleColor.Red);
			}
			if (!TryReloadYamlConfig(path, target, label))
			{
				Utils.print("Using built-in defaults for " + label + ".", ConsoleColor.Yellow);
			}
		}

		public static bool TryReloadYamlConfig<T>(string path, CustomSyncedValue<T> target, string label)
		{
			if (!path.TryFromYAML<T>(out T obj, out string error))
			{
				Utils.print("Skipped reload for " + label + " (" + path + "): " + error, ConsoleColor.Red);
				return false;
			}
			target.Value = obj;
			return true;
		}

		public static bool TryReadYamlListDirectory<T>(string directory, out List<T> result, out string error)
		{
			result = new List<T>();
			if (!TryGetYamlFiles(directory, out string[] files, out error))
			{
				return false;
			}
			string[] array = files;
			foreach (string text in array)
			{
				if (!text.TryFromYAML<List<T>>(out List<T> obj, out string error2))
				{
					error = text + ": " + error2;
					return false;
				}
				result.AddRange(obj);
			}
			error = string.Empty;
			return true;
		}

		private static bool TryGetYamlFiles(string directory, out string[] files, out string error)
		{
			files = Array.Empty<string>();
			if (!Directory.Exists(directory))
			{
				error = directory + ": directory does not exist";
				return false;
			}
			try
			{
				files = Directory.GetFiles(directory, "*.yml", SearchOption.TopDirectoryOnly).OrderBy<string, string>((string path) => path, StringComparer.OrdinalIgnoreCase).ToArray();
				error = string.Empty;
				return true;
			}
			catch (Exception arg)
			{
				error = $"{directory}: {arg}";
				return false;
			}
		}
	}
	[VES_Autoload(VES_Autoload.Priority.First, "OnInit", new Type[] { })]
	public static class SyncedData
	{
		[HarmonyPatch(typeof(ZNet), "Awake")]
		private static class ZNet_Awake_Patch
		{
			[UsedImplicitly]
			private static void Postfix(ZNet __instance)
			{
				if (Object.op_Implicit((Object)(object)__instance) && __instance.IsServer())
				{
					LoadAuthoritativeYamlData();
				}
			}
		}

		public enum ItemDesctructionTypeEnum
		{
			LevelDecrease,
			Destroy,
			Combined,
			CombinedEasy
		}

		public class Stat_Data : ISerializableParameter
		{
			private List<DamageModPair> cached_resistance_pairs;

			[SerializeField]
			public int durability;

			[SerializeField]
			public int durability_percentage;

			[SerializeField]
			public float armor_percentage;

			[SerializeField]
			public float armor;

			[SerializeField]
			public int damage_percentage;

			[SerializeField]
			public int damage_true;

			[SerializeField]
			public int damage_blunt;

			[SerializeField]
			public int damage_slash;

			[SerializeField]
			public int damage_pierce;

			[SerializeField]
			public int damage_chop;

			[SerializeField]
			public int damage_pickaxe;

			[SerializeField]
			public int damage_fire;

			[SerializeField]
			public int damage_frost;

			[SerializeField]
			public int damage_lightning;

			[SerializeField]
			public int damage_poison;

			[SerializeField]
			public int damage_spirit;

			[SerializeField]
			public DamageModifier resistance_blunt;

			[SerializeField]
			public DamageModifier resistance_slash;

			[SerializeField]
			public DamageModifier resistance_pierce;

			[SerializeField]
			public DamageModifier resistance_chop;

			[SerializeField]
			public DamageModifier resistance_pickaxe;

			[SerializeField]
			public DamageModifier resistance_fire;

			[SerializeField]
			public DamageModifier resistance_frost;

			[SerializeField]
			public DamageModifier resistance_lightning;

			[SerializeField]
			public DamageModifier resistance_poison;

			[SerializeField]
			public DamageModifier resistance_spirit;

			[SerializeField]
			public int attack_speed;

			[SerializeField]
			public int movement_speed;

			[SerializeField]
			public int max_hp;

			[SerializeField]
			public int max_stamina;

			[SerializeField]
			public float hp_regen;

			[SerializeField]
			public float stamina_regen;

			[SerializeField]
			public int API_backpacks_additionalrow_x;

			[SerializeField]
			public int API_backpacks_additionalrow_y;

			public List<DamageModPair> GetResistancePairs()
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0106: Unknown result type (might be due to invalid IL or missing references)
				//IL_010b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_0119: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				//IL_012e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0133: Unknown result type (might be due to invalid IL or missing references)
				//IL_0138: Unknown result type (might be due to invalid IL or missing references)
				//IL_0141: Unknown result type (might be due to invalid IL or missing references)
				//IL_014e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0156: Unknown result type (might be due to invalid IL or missing references)
				//IL_015b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0160: Unknown result type (might be due to invalid IL or missing references)
				//IL_0169: Unknown result type (might be due to invalid IL or missing references)
				//IL_0176: Unknown result type (might be due to invalid IL or missing references)
				//IL_017e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0183: Unknown result type (might be due to invalid IL or missing references)
				//IL_0188: Unknown result type (might be due to invalid IL or missing references)
				if (cached_resistance_pairs != null)
				{
					return cached_resistance_pairs;
				}
				cached_resistance_pairs = new List<DamageModPair>(10)
				{
					new DamageModPair
					{
						m_type = (DamageType)1,
						m_modifier = resistance_blunt
					},
					new DamageModPair
					{
						m_type = (DamageType)2,
						m_modifier = resistance_slash
					},
					new DamageModPair
					{
						m_type = (DamageType)4,
						m_modifier = resistance_pierce
					},
					new DamageModPair
					{
						m_type = (DamageType)8,
						m_modifier = resistance_chop
					},
					new DamageModPair
					{
						m_type = (DamageType)16,
						m_modifier = resistance_pickaxe
					},
					new DamageModPair
					{
						m_type = (DamageType)32,
						m_modifier = resistance_fire
					},
					new DamageModPair
					{
						m_type = (DamageType)64,
						m_modifier = resistance_frost
					},
					new DamageModPair
					{
						m_type = (DamageType)128,
						m_modifier = resistance_lightning
					},
					new DamageModPair
					{
						m_type = (DamageType)256,
						m_modifier = resistance_poison
					},
					new DamageModPair
					{
						m_type = (DamageType)512,
						m_modifier = resistance_spirit
					}
				};
				cached_resistance_pairs.RemoveAll((DamageModPair x) => (int)x.m_modifier == 0);
				return cached_resistance_pairs;
			}

			public void Serialize(ref ZPackage pkg)
			{
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				//IL_0132: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Unknown result type (might be due to invalid IL or missing references)
				pkg.Write(durability);
				pkg.Write(durability_percentage);
				pkg.Write(armor_percentage);
				pkg.Write(armor);
				pkg.Write(damage_percentage);
				pkg.Write(damage_true);
				pkg.Write(damage_blunt);
				pkg.Write(damage_slash);
				pkg.Write(damage_pierce);
				pkg.Write(damage_chop);
				pkg.Write(damage_pickaxe);
				pkg.Write(damage_fire);
				pkg.Write(damage_frost);
				pkg.Write(damage_lightning);
				pkg.Write(damage_poison);
				pkg.Write(damage_spirit);
				SyncedData.WriteEnum<DamageModifier>(ref pkg, resistance_blunt);
				SyncedData.WriteEnum<DamageModifier>(ref pkg, resistance_slash);
				SyncedData.WriteEnum<DamageModifier>(ref pkg, resistance_pierce);
				SyncedData.WriteEnum<DamageModifier>(ref pkg, resistance_chop);
				SyncedData.WriteEnum<DamageModifier>(ref pkg, resistance_pickaxe);
				SyncedData.WriteEnum<DamageModifier>(ref pkg, resistance_fire);
				SyncedData.WriteEnum<DamageModifier>(ref pkg, resistance_frost);
				SyncedData.WriteEnum<DamageModifier>(ref pkg, resistance_lightning);
				SyncedData.WriteEnum<DamageModifier>(ref pkg, resistance_poison);
				SyncedData.WriteEnum<DamageModifier>(ref pkg, resistance_spirit);
				pkg.Write(attack_speed);
				pkg.Write(movement_speed);
				pkg.Write(max_hp);
				pkg.Write(max_stamina);
				pkg.Write(hp_regen);
				pkg.Write(stamina_regen);
				pkg.Write(API_backpacks_additionalrow_x);
				pkg.Write(API_backpacks_additionalrow_y);
			}

			public void Deserialize(ref ZPackage pkg)
			{
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Unknown result type (might be due to invalid IL or missing references)
				//IL_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Unknown result type (might be due to invalid IL or missing references)
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				//IL_012b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0132: Unknown result type (might be due to invalid IL or missing references)
				//IL_0137: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0143: Unknown result type (might be due to invalid IL or missing references)
				durability = pkg.ReadInt();
				durability_percentage = pkg.ReadInt();
				armor_percentage = pkg.ReadSingle();
				armor = pkg.ReadSingle();
				damage_percentage = pkg.ReadInt();
				damage_true = pkg.ReadInt();
				damage_blunt = pkg.ReadInt();
				damage_slash = pkg.ReadInt();
				damage_pierce = pkg.ReadInt();
				damage_chop = pkg.ReadInt();
				damage_pickaxe = pkg.ReadInt();
				damage_fire = pkg.ReadInt();
				damage_frost = pkg.ReadInt();
				damage_lightning = pkg.ReadInt();
				damage_poison = pkg.ReadInt();
				damage_spirit = pkg.ReadInt();
				resistance_blunt = SyncedData.ReadEnum<DamageModifier>(ref pkg);
				resistance_slash = SyncedData.ReadEnum<DamageModifier>(ref pkg);
				resistance_pierce = SyncedData.ReadEnum<DamageModifier>(ref pkg);
				resistance_chop = SyncedData.ReadEnum<DamageModifier>(ref pkg);
				resistance_pickaxe = SyncedData.ReadEnum<DamageModifier>(ref pkg);
				resistance_fire = SyncedData.ReadEnum<DamageModifier>(ref pkg);
				resistance_frost = SyncedData.ReadEnum<DamageModifier>(ref pkg);
				resistance_lightning = SyncedData.ReadEnum<DamageModifier>(ref pkg);
				resistance_poison = SyncedData.ReadEnum<DamageModifier>(ref pkg);
				resistance_spirit = SyncedData.ReadEnum<DamageModifier>(ref pkg);
				attack_speed = pkg.ReadInt();
				movement_speed = pkg.ReadInt();
				max_hp = pkg.ReadInt();
				max_stamina = pkg.ReadInt();
				hp_regen = pkg.ReadSingle();
				stamina_regen = pkg.ReadSingle();
				API_backpacks_additionalrow_x = pkg.ReadInt();
				API_backpacks_additionalrow_y = pkg.ReadInt();
				cached_resistance_pairs = null;
			}
		}

		public class Chance_Data : ISerializableParameter
		{
			[SerializeField]
			public float success;

			[SerializeField]
			public float destroy;

			public void Serialize(ref ZPackage pkg)
			{
				pkg.Write(success);
				pkg.Write(destroy);
			}

			public void Deserialize(ref ZPackage pkg)
			{
				success = pkg.ReadSingle();
				destroy = pkg.ReadSingle();
			}
		}

		public class SingleReq : ISerializableParameter
		{
			[SerializeField]
			public string prefab;

			public SingleReq()
			{
			}

			public SingleReq(string prefab)
			{
				this.prefab = prefab;
			}

			public bool IsValid()
			{
				if (!string.IsNullOrEmpty(prefab) && (Object)(object)ZNetScene.instance != (Object)null)
				{
					return (Object)(object)ZNetScene.instance.GetPrefab(prefab) != (Object)null;
				}
				return false;
			}

			public void Serialize(ref ZPackage pkg)
			{
				pkg.Write(prefab ?? "");
			}

			public void Deserialize(ref ZPackage pkg)
			{
				prefab = pkg.ReadString();
			}
		}

		public class EnchantmentReqs : ISerializableParameter
		{
			[SerializeField]
			public SingleReq enchant_prefab = new SingleReq();

			[SerializeField]
			public SingleReq blessed_enchant_prefab = new SingleReq();

			[SerializeField]
			public List<string> Items = new List<string>();

			public void Serialize(ref ZPackage pkg)
			{
				WriteSerializable(ref pkg, enchant_prefab);
				WriteSerializable(ref pkg, blessed_enchant_prefab);
				WriteStringList(ref pkg, Items);
			}

			public void Deserialize(ref ZPackage pkg)
			{
				enchant_prefab = ReadSerializable<SingleReq>(ref pkg);
				blessed_enchant_prefab = ReadSerializable<SingleReq>(ref pkg);
				Items = ReadStringList(ref pkg);
			}
		}

		public class VFX_Data : ISerializableParameter
		{
			[SerializeField]
			public string color = "#00000000";

			[SerializeField]
			public int variant;

			public void Serialize(ref ZPackage pkg)
			{
				pkg.Write(color ?? "");
				pkg.Write(variant);
			}

			public void Deserialize(ref ZPackage pkg)
			{
				color = pkg.ReadString();
				variant = pkg.ReadInt();
			}
		}

		public class OverrideChances : ISerializableParameter
		{
			[SerializeField]
			public List<string> Items = new List<string>();

			[SerializeField]
			public Dictionary<int, Chance_Data> Chances = new Dictionary<int, Chance_Data>();

			public void Serialize(ref ZPackage pkg)
			{
				WriteStringList(ref pkg, Items);
				WriteSerializableDictionary(ref pkg, Chances);
			}

			public void Deserialize(ref ZPackage pkg)
			{
				Items = ReadStringList(ref pkg);
				Chances = ReadSerializableDictionary<Chance_Data>(ref pkg);
			}
		}

		public class OverrideColors : ISerializableParameter
		{
			[SerializeField]
			public List<string> Items = new List<string>();

			[SerializeField]
			public Dictionary<int, VFX_Data> Colors = new Dictionary<int, VFX_Data>();

			public void Serialize(ref ZPackage pkg)
			{
				WriteStringList(ref pkg, Items);
				WriteSerializableDictionary(ref pkg, Colors);
			}

			public void Deserialize(ref ZPackage pkg)
			{
				Items = ReadStringList(ref pkg);
				Colors = ReadSerializableDictionary<VFX_Data>(ref pkg);
			}
		}

		public class OverrideStats : ISerializableParameter
		{
			[SerializeField]
			public List<string> Items = new List<string>();

			[SerializeField]
			public Dictionary<int, Stat_Data> Stats = new Dictionary<int, Stat_Data>();

			public void Serialize(ref ZPackage pkg)
			{
				WriteStringList(ref pkg, Items);
				WriteSerializableDictionary(ref pkg, Stats);
			}

			public void Deserialize(ref ZPackage pkg)
			{
				Items = ReadStringList(ref pkg);
				Stats = ReadSerializableDictionary<Stat_Data>(ref pkg);
			}
		}

		public static readonly CustomSyncedValue<Dictionary<int, Chance_Data>> Synced_EnchantmentChances_Weapons = new CustomSyncedValue<Dictionary<int, Chance_Data>>(ValheimEnchantmentSystem.ConfigSync, "EnchantmentGlobalChances_Weapons", new Dictionary<int, Chance_Data>());

		public static readonly CustomSyncedValue<Dictionary<int, Chance_Data>> Synced_EnchantmentChances_Armor = new CustomSyncedValue<Dictionary<int, Chance_Data>>(ValheimEnchantmentSystem.ConfigSync, "EnchantmentGlobalChances_Armor", new Dictionary<int, Chance_Data>());

		public static readonly CustomSyncedValue<Dictionary<int, VFX_Data>> Synced_EnchantmentColors = new CustomSyncedValue<Dictionary<int, VFX_Data>>(ValheimEnchantmentSystem.ConfigSync, "OverridenEnchantmentColors", new Dictionary<int, VFX_Data>());

		public static readonly CustomSyncedValue<Dictionary<int, Stat_Data>> Synced_EnchantmentStats_Weapons = new CustomSyncedValue<Dictionary<int, Stat_Data>>(ValheimEnchantmentSystem.ConfigSync, "EnchantmentStats_Weapons", new Dictionary<int, Stat_Data>());

		public static readonly CustomSyncedValue<Dictionary<int, Stat_Data>> Synced_EnchantmentStats_Armor = new CustomSyncedValue<Dictionary<int, Stat_Data>>(ValheimEnchantmentSystem.ConfigSync, "EnchantmentStats_Armor", new Dictionary<int, Stat_Data>());

		public static readonly CustomSyncedValue<List<OverrideChances>> Overrides_EnchantmentChances = new CustomSyncedValue<List<OverrideChances>>(ValheimEnchantmentSystem.ConfigSync, "Overrides_EnchantmentChances", new List<OverrideChances>());

		public static readonly CustomSyncedValue<List<OverrideColors>> Overrides_EnchantmentColors = new CustomSyncedValue<List<OverrideColors>>(ValheimEnchantmentSystem.ConfigSync, "Overrides_EnchantmentColors", new List<OverrideColors>());

		public static readonly CustomSyncedValue<List<OverrideStats>> Overrides_EnchantmentStats = new CustomSyncedValue<List<OverrideStats>>(ValheimEnchantmentSystem.ConfigSync, "Overrides_EnchantmentStats", new List<OverrideStats>());

		public static readonly CustomSyncedValue<List<EnchantmentReqs>> Synced_EnchantmentReqs = new CustomSyncedValue<List<EnchantmentReqs>>(ValheimEnchantmentSystem.ConfigSync, "EnchantmentReqs", new List<EnchantmentReqs>());

		public static ConfigEntry<int> SafetyLevel => EnchantmentSettings.SafetyLevel;

		public static ConfigEntry<bool> DropEnchantmentOnUpgrade => EnchantmentSettings.DropEnchantmentOnUpgrade;

		public static ConfigEntry<ItemDesctructionTypeEnum> ItemFailureType => EnchantmentSettings.ItemFailureType;

		public static ConfigEntry<int> FailedEnchantLevelDecrease => EnchantmentSettings.FailedEnchantLevelDecrease;

		public static ConfigEntry<bool> BlessedScrollsPreventBreak => EnchantmentSettings.BlessedScrollsPreventBreak;

		public static ConfigEntry<int> BlessedScrollsAdditionalChance => EnchantmentSettings.BlessedScrollsAdditionalChance;

		public static ConfigEntry<bool> AllowJewelcraftingMirrorCopyEnchant => EnchantmentSettings.AllowJewelcraftingMirrorCopyEnchant;

		public static ConfigEntry<float> AdditionalEnchantmentChancePerLevel => EnchantmentSettings.AdditionalEnchantmentChancePerLevel;

		public static ConfigEntry<float> FailedEnchantSkillExpMultiplier => EnchantmentSettings.FailedEnchantSkillExpMultiplier;

		public static ConfigEntry<int> EnchantmentNotificationMinLevel => EnchantmentSettings.EnchantmentNotificationMinLevel;

		public static ConfigEntry<bool> EnchantmentEnableNotifications => EnchantmentSettings.EnchantmentEnableNotifications;

		[UsedImplicitly]
		private static void OnInit()
		{
			EnchantmentSettings.Bind();
			EnchantmentConfigPaths.Initialize();
			EnchantmentChanceRepository.Initialize();
			EnchantmentStatRepository.Initialize();
			EnchantmentColorRepository.Initialize();
			EnchantmentRequirementRepository.Initialize(Synced_EnchantmentReqs);
			ConfigRefreshCoordinator.Initialize();
		}

		private static void LoadAuthoritativeYamlData()
		{
			EnchantmentChanceRepository.LoadAuthoritativeData();
			EnchantmentStatRepository.LoadAuthoritativeData();
			EnchantmentColorRepository.LoadAuthoritativeData();
			EnchantmentRequirementRepository.LoadAuthoritativeData(Synced_EnchantmentReqs);
		}

		public static string GetColor(Enchantment_Core.Enchanted en, out int variant, bool trimApha)
		{
			GameObject dropPrefab = en.Item.m_dropPrefab;
			return GetColor((dropPrefab != null) ? ((Object)dropPrefab).name : null, en.level, out variant, trimApha);
		}

		public static string GetColor(string dropPrefab, int level, out int variant, bool trimApha, string defaultValue = "#00000000")
		{
			return EnchantmentColorRepository.GetColor(dropPrefab, level, out variant, trimApha, defaultValue);
		}

		public static Chance_Data GetEnchantmentChance(Enchantment_Core.Enchanted en)
		{
			GameObject dropPrefab = en.Item.m_dropPrefab;
			return GetEnchantmentChance((dropPrefab != null) ? ((Object)dropPrefab).name : null, en.level, en.Item.IsWeapon());
		}

		public static Chance_Data GetEnchantmentChance(string dropPrefab, int level)
		{
			return GetEnchantmentChance(dropPrefab, level, isWeapon: true);
		}

		public static Chance_Data GetEnchantmentChance(string dropPrefab, int level, bool isWeapon)
		{
			return EnchantmentChanceRepository.GetEnchantmentChance(dropPrefab, level, isWeapon);
		}

		public static bool IsLevelEnchantable(string dropPrefab, int level, bool isWeapon)
		{
			if (EnchantmentChanceRepository.IsLevelEnchantable(dropPrefab, level, isWeapon))
			{
				return EnchantmentStatRepository.HasStatIncrease(dropPrefab, level + 1, isWeapon);
			}
			return false;
		}

		public static Stat_Data GetStatIncrease(Enchantment_Core.Enchanted en)
		{
			return EnchantmentStatRepository.GetStatIncrease(en);
		}

		public static Stat_Data GetStatIncrease(string dropPrefab, int level, bool isWeapon)
		{
			return EnchantmentStatRepository.GetStatIncrease(dropPrefab, level, isWeapon);
		}

		public static EnchantmentReqs GetReqs(string prefab)
		{
			return EnchantmentRequirementRepository.GetReqs(Synced_EnchantmentReqs.Value, prefab);
		}

		private static void WriteEnum<TEnum>(ref ZPackage pkg, TEnum value) where TEnum : struct, Enum
		{
			pkg.Write(Convert.ToInt32(value));
		}

		private static TEnum ReadEnum<TEnum>(ref ZPackage pkg) where TEnum : struct, Enum
		{
			return (TEnum)Enum.ToObject(typeof(TEnum), pkg.ReadInt());
		}

		private static void WriteSerializable<T>(ref ZPackage pkg, T value) where T : class, ISerializableParameter
		{
			pkg.Write(value != null);
			if (value != null)
			{
				((ISerializableParameter)value).Serialize(ref pkg);
			}
		}

		private static T ReadSerializable<T>(ref ZPackage pkg) where T : class, ISerializableParameter, new()
		{
			if (!pkg.ReadBool())
			{
				return null;
			}
			T val = new T();
			((ISerializableParameter)val).Deserialize(ref pkg);
			return val;
		}

		private static void WriteStringList(ref ZPackage pkg, List<string> values)
		{
			if (values == null)
			{
				values = new List<string>();
			}
			pkg.Write(values.Count);
			foreach (string value in values)
			{
				pkg.Write(value ?? "");
			}
		}

		private static List<string> ReadStringList(ref ZPackage pkg)
		{
			int num = pkg.ReadInt();
			List<string> list = new List<string>(num);
			for (int i = 0; i < num; i++)
			{
				list.Add(pkg.ReadString());
			}
			return list;
		}

		private static void WriteSerializableDictionary<T>(ref ZPackage pkg, Dictionary<int, T> values) where T : class, ISerializableParameter
		{
			if (values == null)
			{
				values = new Dictionary<int, T>();
			}
			pkg.Write(values.Count);
			foreach (KeyValuePair<int, T> value2 in values)
			{
				pkg.Write(value2.Key);
				pkg.Write(value2.Value != null);
				T value = value2.Value;
				if (value != null)
				{
					((ISerializableParameter)value).Serialize(ref pkg);
				}
			}
		}

		private static Dictionary<int, T> ReadSerializableDictionary<T>(ref ZPackage pkg) where T : class, ISerializableParameter, new()
		{
			int num = pkg.ReadInt();
			Dictionary<int, T> dictionary = new Dictionary<int, T>(num);
			for (int i = 0; i < num; i++)
			{
				int key = pkg.ReadInt();
				if (pkg.ReadBool())
				{
					T val = new T();
					((ISerializableParameter)val).Deserialize(ref pkg);
					dictionary[key] = val;
				}
			}
			return dictionary;
		}
	}
}
namespace ServerSync
{
	[PublicAPI]
	public abstract class OwnConfigEntryBase
	{
		public object? LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[PublicAPI]
	public class SyncedConfigEntry<T> : OwnConfigEntryBase
	{
		public readonly ConfigEntry<T> SourceConfig;

		public override ConfigEntryBase BaseConfig => (ConfigEntryBase)(object)SourceConfig;

		public T Value
		{
			get
			{
				return SourceConfig.Value;
			}
			set
			{
				SourceConfig.Value = value;
			}
		}

		public SyncedConfigEntry(ConfigEntry<T> sourceConfig)
		{
			SourceConfig = sourceConfig;
			base..ctor();
		}

		public void AssignLocalValue(T value)
		{
			if (LocalBaseValue == null)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	public abstract class CustomSyncedValueBase
	{
		public object? LocalBaseValue;

		public readonly string Identifier;

		public readonly Type Type;

		private object? boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

		public object? BoxedValue
		{
			get
			{
				return boxedValue;
			}
			set
			{
				boxedValue = value;
				this.ValueChanged?.Invoke();
			}
		}

		public event Action? ValueChanged;

		protected CustomSyncedValueBase(ConfigSync configSync, string identifier, Type type, int priority)
		{
			Priority = priority;
			Identifier = identifier;
			Type = type;
			configSync.AddCustomValue(this);
			localIsOwner = configSync.IsSourceOfTruth;
			configSync.SourceOfTruthChanged += delegate(bool truth)
			{
				localIsOwner = truth;
			};
		}
	}
	[PublicAPI]
	public sealed class CustomSyncedValue<T> : CustomSyncedValueBase
	{
		public T Value
		{
			get
			{
				return (T)base.BoxedValue;
			}
			set
			{
				base.BoxedValue = value;
			}
		}

		public CustomSyncedValue(ConfigSync configSync, string identifier, T value = default(T), int priority = 0)
			: base(configSync, identifier, typeof(T), priority)
		{
			Value = value;
		}

		public void AssignLocalValue(T value)
		{
			if (localIsOwner)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal class ConfigurationManagerAttributes
	{
		[UsedImplicitly]
		public bool? ReadOnly = false;
	}
	[PublicAPI]
	public class ConfigSync
	{
		[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
		private static class SnatchCurrentlyHandlingRPC
		{
			public static ZRpc? currentRpc;

			[HarmonyPrefix]
			private static void Prefix(ZRpc __instance)
			{
				currentRpc = __instance;
			}
		}

		[HarmonyPatch(typeof(ZNet), "Awake")]
		internal static class RegisterRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance)
			{
				isServer = __instance.IsServer();
				foreach (ConfigSync configSync2 in configSyncs)
				{
					ZRoutedRpc.instance.Register<ZPackage>(configSync2.Name + " ConfigSync", (Action<long, ZPackage>)configSync2.RPC_FromOtherClientConfigSync);
					if (isServer)
					{
						configSync2.InitialSyncDone = true;
						Debug.Log((object)("Registered '" + configSync2.Name + " ConfigSync' RPC - waiting for incoming connections"));
					}
				}
				if (isServer)
				{
					((MonoBehaviour)__instance).StartCoroutine(WatchAdminListChanges());
				}
				static void SendAdmin(List<ZNetPeer> peers, bool isAdmin)
				{
					ZPackage package = ConfigsToPackage(null, null, new PackageEntry[1]
					{
						new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = isAdmin
						}
					});
					ConfigSync configSync = configSyncs.First();
					if (configSync != null)
					{
						((MonoBehaviour)ZNet.instance).StartCoroutine(configSync.sendZPackage(peers, package));
					}
				}
				static IEnumerator WatchAdminListChanges()
				{
					MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
					SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
					List<string> CurrentList = new List<string>(adminList.GetList());
					while (true)
					{
						yield return (object)new WaitForSeconds(30f);
						if (!adminList.GetList().SequenceEqual(CurrentList))
						{
							CurrentList = new List<string>(adminList.GetList());
							List<ZNetPeer> adminPeer = ZNet.instance.GetPeers().Where(delegate(ZNetPeer p)
							{
								string hostName = p.m_rpc.GetSocket().GetHostName();
								return ((object)listContainsId == null) ? adminList.Contains(hostName) : ((bool)listContainsId.Invoke(ZNet.instance, new object[2] { adminList, hostName }));
							}).ToList();
							List<ZNetPeer> nonAdminPeer = ZNet.instance.GetPeers().Except(adminPeer).ToList();
							SendAdmin(nonAdminPeer, isAdmin: false);
							SendAdmin(adminPeer, isAdmin: true);
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class RegisterClientRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				if (__instance.IsServer())
				{
					return;
				}
				foreach (ConfigSync configSync in configSyncs)
				{
					peer.m_rpc.Register<ZPackage>(configSync.Name + " ConfigSync", (Action<ZRpc, ZPackage>)configSync.RPC_FromServerConfigSync);
				}
			}
		}

		private class ParsedConfigs
		{
			public readonly Dictionary<OwnConfigEntryBase, object?> configValues = new Dictionary<OwnConfigEntryBase, object>();

			public readonly Dictionary<CustomSyncedValueBase, object?> customValues = new Dictionary<CustomSyncedValueBase, object>();
		}

		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		private class ResetConfigsOnShutdown
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				ProcessingServerUpdate = true;
				foreach (ConfigSync configSync in configSyncs)
				{
					configSync.resetConfigsFromServer();
					configSync.IsSourceOfTruth = true;
					configSync.InitialSyncDone = false;
				}
				ProcessingServerUpdate = false;
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private class SendConfigsAfterLogin
		{
			private class BufferingSocket : ZPlayFabSocket, ISocket
			{
				public volatile bool finished = false;

				public volatile int versionMatchQueued = -1;

				public readonly List<ZPackage> Package = new List<ZPackage>();

				public readonly ISocket Original;

				public BufferingSocket(ISocket original)
				{
					Original = original;
					((ZPlayFabSocket)this)..ctor();
				}

				public bool IsConnected()
				{
					return Original.IsConnected();
				}

				public ZPackage Recv()
				{
					return Original.Recv();
				}

				public int GetSendQueueSize()
				{
					return Original.GetSendQueueSize();
				}

				public int GetCurrentSendRate()
				{
					return Original.GetCurrentSendRate();
				}

				public bool IsHost()
				{
					return Original.IsHost();
				}

				public void Dispose()
				{
					Original.Dispose();
				}

				public bool GotNewData()
				{
					return Original.GotNewData();
				}

				public void Close()
				{
					Original.Close();
				}

				public string GetEndPointString()
				{
					return Original.GetEndPointString();
				}

				public void GetAndResetStats(out int totalSent, out int totalRecv)
				{
					Original.GetAndResetStats(ref totalSent, ref totalRecv);
				}

				public void GetConnectionQuality(out float localQuality, out float remoteQuality, out int ping, out float outByteSec, out float inByteSec)
				{
					Original.GetConnectionQuality(ref localQuality, ref remoteQuality, ref ping, ref outByteSec, ref inByteSec);
				}

				public ISocket Accept()
				{
					return Original.Accept();
				}

				public int GetHostPort()
				{
					return Original.GetHostPort();
				}

				public bool Flush()
				{
					return Original.Flush();
				}

				public string GetHostName()
				{
					return Original.GetHostName();
				}

				public void VersionMatch()
				{
					if (finished)
					{
						Original.VersionMatch();
					}
					else
					{
						versionMatchQueued = Package.Count;
					}
				}

				public void Send(ZPackage pkg)
				{
					//IL_0057: Unknown result type (might be due to invalid IL or missing references)
					//IL_005d: Expected O, but got Unknown
					int pos = pkg.GetPos();
					pkg.SetPos(0);
					int num = pkg.ReadInt();
					if ((num == StringExtensionMethods.GetStableHashCode("PeerInfo") || num == StringExtensionMethods.GetStableHashCode("RoutedRPC") || num == StringExtensionMethods.GetStableHashCode("ZDOData")) && !finished)
					{
						ZPackage val = new ZPackage(pkg.GetArray());
						val.SetPos(pos);
						Package.Add(val);
					}
					else
					{
						pkg.SetPos(pos);
						Original.Send(pkg);
					}
				}
			}

			[HarmonyPriority(800)]
			[HarmonyPrefix]
			private static void Prefix(ref Dictionary<Assembly, BufferingSocket>? __state, ZNet __instance, ZRpc rpc)
			{
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Invalid comparison between Unknown and I4
				if (!__instance.IsServer())
				{
					return;
				}
				BufferingSocket bufferingSocket = new BufferingSocket(rpc.GetSocket());
				AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket);
				object? obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
				ZNetPeer val = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
				if (val != null && (int)ZNet.m_onlineBackend > 0)
				{
					FieldInfo fieldInfo = AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket");
					object? value = fieldInfo.GetValue(val);
					ZPlayFabSocket val2 = (ZPlayFabSocket)((value is ZPlayFabSocket) ? value : null);
					if (val2 != null)
					{
						typeof(ZPlayFabSocket).GetField("m_remotePlayerId").SetValue(bufferingSocket, val2.m_remotePlayerId);
					}
					fieldInfo.SetValue(val, bufferingSocket);
				}
				if (__state == null)
				{
					__state = new Dictionary<Assembly, BufferingSocket>();
				}
				__state[Assembly.GetExecutingAssembly()] = bufferingSocket;
			}

			[HarmonyPostfix]
			private static void Postfix(Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
			{
				ZRpc rpc2 = rpc;
				ZNet __instance2 = __instance;
				Dictionary<Assembly, BufferingSocket> __state2 = __state;
				ZNetPeer peer;
				if (__instance2.IsServer())
				{
					object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance2, new object[1] { rpc2 });
					peer = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
					if (peer == null)
					{
						SendBufferedData();
					}
					else
					{
						((MonoBehaviour)__instance2).StartCoroutine(sendAsync());
					}
				}
				void SendBufferedData()
				{
					if (rpc2.GetSocket() is BufferingSocket bufferingSocket)
					{
						AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc2, bufferingSocket.Original);
						object? obj2 = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance2, new object[1] { rpc2 });
						ZNetPeer val = (ZNetPeer)((obj2 is ZNetPeer) ? obj2 : null);
						if (val != null)
						{
							AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, bufferingSocket.Original);
						}
					}
					BufferingSocket bufferingSocket2 = __state2[Assembly.GetExecutingAssembly()];
					bufferingSocket2.finished = true;
					for (int i = 0; i < bufferingSocket2.Package.Count; i++)
					{
						if (i == bufferingSocket2.versionMatchQueued)
						{
							bufferingSocket2.Original.VersionMatch();
						}
						bufferingSocket2.Original.Send(bufferingSocket2.Package[i]);
					}
					if (bufferingSocket2.Package.Count == bufferingSocket2.versionMatchQueued)
					{
						bufferingSocket2.Original.VersionMatch();
					}
				}
				IEnumerator sendAsync()
				{
					foreach (ConfigSync configSync in configSyncs)
					{
						List<PackageEntry> entries = new List<PackageEntry>();
						if (configSync.CurrentVersion != null)
						{
							entries.Add(new PackageEntry
							{
								section = "Internal",
								key = "serverversion",
								type = typeof(string),
								value = configSync.CurrentVersion
							});
						}
						MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						entries.Add(new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = (((object)listContainsId == null) ? ((object)adminList.Contains(rpc2.GetSocket().GetHostName())) : listContainsId.Invoke(ZNet.instance, new object[2]
							{
								adminList,
								rpc2.GetSocket().GetHostName()
							}))
						});
						ZPackage package = ConfigsToPackage(configSync.allConfigs.Select((OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, entries, partial: false);
						yield return ((MonoBehaviour)__instance2).StartCoroutine(configSync.sendZPackage(new List<ZNetPeer> { peer }, package));
					}
					SendBufferedData();
				}
			}
		}

		private class PackageEntry
		{
			public string section = null;

			public string key = null;

			public Type type = null;

			public object? value;
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
		private static class PreventSavingServerInfo
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, ref string __result)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || isWritableConfig(ownConfigEntryBase))
				{
					return true;
				}
				__result = TomlTypeConverter.ConvertToString(ownConfigEntryBase.LocalBaseValue, __instance.SettingType);
				return false;
			}
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "SetSerializedValue")]
		private static class PreventConfigRereadChangingValues
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, string value)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || ownConfigEntryBase.LocalBaseValue == null)
				{
					return true;
				}
				try
				{
					ownConfigEntryBase.LocalBaseValue = TomlTypeConverter.ConvertToValue(value, __instance.SettingType);
				}
				catch (Exception ex)
				{
					Debug.LogWarning((object)$"Config value of setting \"{__instance.Definition}\" could not be parsed and will be ignored. Reason: {ex.Message}; Value: {value}");
				}
				return false;
			}
		}

		private class InvalidDeserializationTypeException : Exception
		{
			public string expected = null;

			public string received = null;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		public string? DisplayName;

		public string? CurrentVersion;

		public string? MinimumRequiredVersion;

		public bool ModRequired = false;

		private bool? forceConfigLocking;

		private bool isSourceOfTruth = true;

		private static readonly HashSet<ConfigSync> configSyncs;

		private readonly HashSet<OwnConfigEntryBase> allConfigs = new HashSet<OwnConfigEntryBase>();

		private HashSet<CustomSyncedValueBase> allCustomValues = new HashSet<CustomSyncedValueBase>();

		private static bool isServer;

		private static bool lockExempt;

		private OwnConfigEntryBase? lockedConfig = null;

		private const byte PARTIAL_CONFIGS = 1;

		private const byte FRAGMENTED_CONFIG = 2;

		private const byte COMPRESSED_CONFIG = 4;

		private readonly Dictionary<string, SortedDictionary<int, byte[]>> configValueCache = new Dictionary<string, SortedDictionary<int, byte[]>>();

		private readonly List<KeyValuePair<long, string>> cacheExpirations = new List<KeyValuePair<long, string>>();

		private static long packageCounter;

		public bool IsLocked
		{
			get
			{
				bool? flag = forceConfigLocking;
				bool num;
				if (!flag.HasValue)
				{
					if (lockedConfig == null)
					{
						goto IL_0052;
					}
					num = ((IConvertible)lockedConfig.BaseConfig.BoxedValue).ToInt32(CultureInfo.InvariantCulture) != 0;
				}
				else
				{
					num = flag.GetValueOrDefault();
				}
				if (!num)
				{
					goto IL_0052;
				}
				int result = ((!lockExempt) ? 1 : 0);
				goto IL_0053;
				IL_0053:
				return (byte)result != 0;
				IL_0052:
				result = 0;
				goto IL_0053;
			}
			set
			{
				forceConfigLocking = value;
			}
		}

		public bool IsAdmin => lockExempt || isSourceOfTruth;

		public bool IsSourceOfTruth
		{
			get
			{
				return isSourceOfTruth;
			}
			private set
			{
				if (value != isSourceOfTruth)
				{
					isSourceOfTruth = value;
					this.SourceOfTruthChanged?.Invoke(value);
				}
			}
		}

		public bool InitialSyncDone { get; private set; } = false;


		public event Action<bool>? SourceOfTruthChanged;

		private event Action? lockedConfigChanged;

		static ConfigSync()
		{
			ProcessingServerUpdate = false;
			configSyncs = new HashSet<ConfigSync>();
			lockExempt = false;
			packageCounter = 0L;
			RuntimeHelpers.RunClassConstructor(typeof(VersionCheck).TypeHandle);
		}

		public ConfigSync(string name)
		{
			Name = name;
			configSyncs.Add(this);
			new VersionCheck(this);
		}

		public SyncedConfigEntry<T> AddConfigEntry<T>(ConfigEntry<T> configEntry)
		{
			ConfigEntry<T> configEntry2 = configEntry;
			OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)(object)configEntry2);
			SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
			if (syncedEntry == null)
			{
				syncedEntry = new SyncedConfigEntry<T>(configEntry2);
				AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(((ConfigEntryBase)configEntry2).Description, new object[1]
				{
					new ConfigurationManagerAttributes()
				}.Concat(((ConfigEntryBase)configEntry2).Description.Tags ?? Array.Empty<object>()).Concat(new SyncedConfigEntry<T>[1] { syncedEntry }).ToArray());
				configEntry2.SettingChanged += delegate
				{
					if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
					{
						Broadcast(ZRoutedRpc.Everybody, (ConfigEntryBase)configEntry2);
					}
				};
				allConfigs.Add(syncedEntry);
			}
			return syncedEntry;
		}

		public SyncedConfigEntry<T> AddLockingConfigEntry<T>(ConfigEntry<T> lockingConfig) where T : IConvertible
		{
			if (lockedConfig != null)
			{
				throw new Exception("Cannot initialize locking ConfigEntry twice");
			}
			lockedConfig = AddConfigEntry<T>(lockingConfig);
			lockingConfig.SettingChanged += delegate
			{
				this.lockedConfigChanged?.Invoke();
			};
			return (SyncedConfigEntry<T>)lockedConfig;
		}

		internal void AddCustomValue(CustomSyncedValueBase customValue)
		{
			CustomSyncedValueBase customValue2 = customValue;
			if (allCustomValues.Select((CustomSyncedValueBase v) => v.Identifier).Concat(new string[1] { "serverversion" }).Contains(customValue2.Identifier))
			{
				throw new Exception("Cannot have multiple settings with the same name or with a reserved name (serverversion)");
			}
			allCustomValues.Add(customValue2);
			allCustomValues = new HashSet<CustomSyncedValueBase>(allCustomValues.OrderByDescending((CustomSyncedValueBase v) => v.Priority));
			customValue2.ValueChanged += delegate
			{
				if (!ProcessingServerUpdate)
				{
					Broadcast(ZRoutedRpc.Everybody, customValue2);
				}
			};
		}

		private void RPC_FromServerConfigSync(ZRpc rpc, ZPackage package)
		{
			lockedConfigChanged += serverLockedSettingChanged;
			IsSourceOfTruth = false;
			if (HandleConfigSyncRPC(0L, package, clientUpdate: false))
			{
				InitialSyncDone = true;
			}
		}

		private void RPC_FromOtherClientConfigSync(long sender, ZPackage package)
		{
			HandleConfigSyncRPC(sender, package, clientUpdate: true);
		}

		private bool HandleConfigSyncRPC(long sender, ZPackage package, bool clientUpdate)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Expected O, but got Unknown
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Expected O, but got Unknown
			try
			{
				if (isServer && IsLocked)
				{
					ZRpc? currentRpc = SnatchCurrentlyHandlingRPC.currentRpc;
					object obj;
					if (currentRpc == null)
					{
						obj = null;
					}
					else
					{
						ISocket socket = currentRpc.GetSocket();
						obj = ((socket != null) ? socket.GetHostName() : null);
					}
					string text = (string)obj;
					if (text != null)
					{
						MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						if (!(((object)methodInfo == null) ? val.Contains(text) : ((bool)methodInfo.Invoke(ZNet.instance, new object[2] { val, text }))))
						{
							return false;
						}
					}
				}
				cacheExpirations.RemoveAll(delegate(KeyValuePair<long, string> kv)
				{
					if (kv.Key < DateTimeOffset.Now.Ticks)
					{
						configValueCache.Remove(kv.Value);
						return true;
					}
					return false;
				});
				byte b = package.ReadByte();
				if ((b & 2u) != 0)
				{
					long num = package.ReadLong();
					string text2 = sender.ToString() + num;
					if (!configValueCache.TryGetValue(text2, out SortedDictionary<int, byte[]> value))
					{
						value = new SortedDictionary<int, byte[]>();
						configValueCache[text2] = value;
						cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text2));
					}
					int key = package.ReadInt();
					int num2 = package.ReadInt();
					value.Add(key, package.ReadByteArray());
					if (value.Count < num2)
					{
						return false;
					}
					configValueCache.Remove(text2);
					package = new ZPackage(value.Values.SelectMany((byte[] a) => a).ToArray());
					b = package.ReadByte();
				}
				ProcessingServerUpdate = true;
				if ((b & 4u) != 0)
				{
					byte[] buffer = package.ReadByteArray();
					MemoryStream stream = new MemoryStream(buffer);
					MemoryStream memoryStream = new MemoryStream();
					using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
					{
						deflateStream.CopyTo(memoryStream);
					}
					package = new ZPackage(memoryStream.ToArray());
					b = package.ReadByte();
				}
				if ((b & 1) == 0)
				{
					resetConfigsFromServer();
				}
				ParsedConfigs parsedConfigs = ReadConfigsFromPackage(package);
				ConfigFile val2 = null;
				bool saveOnConfigSet = false;
				foreach (KeyValuePair<OwnConfigEntryBase, object> configValue in parsedConfigs.configValues)
				{
					if (!isServer && configValue.Key.LocalBaseValue == null)
					{
						configValue.Key.LocalBaseValue = configValue.Key.BaseConfig.BoxedValue;
					}
					if (val2 == null)
					{
						val2 = configValue.Key.BaseConfig.ConfigFile;
						saveOnConfigSet = val2.SaveOnConfigSet;
						val2.SaveOnConfigSet = false;
					}
					configValue.Key.BaseConfig.BoxedValue = configValue.Value;
				}
				if (val2 != null)
				{
					val2.SaveOnConfigSet = saveOnConfigSet;
					val2.Save();
				}
				foreach (KeyValuePair<CustomSyncedValueBase, object> customValue in parsedConfigs.customValues)
				{
					if (!isServer)
					{
						CustomSyncedValueBase key2 = customValue.Key;
						if (key2.LocalBaseValue == null)
						{
							key2.LocalBaseValue = customValue.Key.BoxedValue;
						}
					}
					customValue.Key.BoxedValue = customValue.Value;
				}
				Debug.Log((object)string.Format("Received {0} configs and {1} custom values from {2} for mod {3}", parsedConfigs.configValues.Count, parsedConfigs.customValues.Count, (isServer || clientUpdate) ? $"client {sender}" : "the server", DisplayName ?? Name));
				if (!isServer)
				{
					serverLockedSettingChanged();
				}
				return true;
			}
			finally
			{
				ProcessingServerUpdate = false;
			}
		}

		private ParsedConfigs ReadConfigsFromPackage(ZPackage package)
		{
			ParsedConfigs parsedConfigs = new ParsedConfigs();
			Dictionary<string, OwnConfigEntryBase> dictionary = allConfigs.Where((OwnConfigEntryBase c) => c.SynchronizedConfig).ToDictionary((OwnConfigEntryBase c) => c.BaseConfig.Definition.Section + "_" + c.BaseConfig.Definition.Key, (OwnConfigEntryBase c) => c);
			Dictionary<string, CustomSyncedValueBase> dictionary2 = allCustomValues.ToDictionary((CustomSyncedValueBase c) => c.Identifier, (CustomSyncedValueBase c) => c);
			int num = package.ReadInt();
			for (int i = 0; i < num; i++)
			{
				string text = package.ReadString();
				string text2 = package.ReadString();
				string text3 = package.ReadString();
				Type type = Type.GetType(text3);
				if (text3 == "" || type != null)
				{
					object obj;
					try
					{
						obj = ((text3 == "") ? null : ReadValueWithTypeFromZPackage(package, type));
					}
					catch (InvalidDeserializationTypeException ex)
					{
						Debug.LogWarning((object)("Got unexpected struct internal type " + ex.received + " for field " + ex.field + " struct " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + ex.expected));
						continue;
					}
					OwnConfigEntryBase value2;
					if (text == "Internal")
					{
						CustomSyncedValueBase value;
						if (text2 == "serverversion")
						{
							if (obj?.ToString() != CurrentVersion)
							{
								Debug.LogWarning((object)("Received server version is not equal: server version = " + (obj?.ToString() ?? "null") + "; local version = " + (CurrentVersion ?? "unknown")));
							}
						}
						else if (text2 == "lockexempt")
						{
							if (obj is bool flag)
							{
								lockExempt = flag;
							}
						}
						else if (dictionary2.TryGetValue(text2, out value))
						{
							if ((text3 == "" && (!value.Type.IsValueType || Nullable.GetUnderlyingType(value.Type) != null)) || GetZPackageTypeString(value.Type) == text3)
							{
								parsedConfigs.customValues[value] = obj;
								continue;
							}
							Debug.LogWarning((object)("Got unexpected type " + text3 + " for internal value " + text2 + " for mod " + (DisplayName ?? Name) + ", expecting " + value.Type.AssemblyQualifiedName));
						}
					}
					else if (dictionary.TryGetValue(text + "_" + text2, out value2))
					{
						Type type2 = configType(value2.BaseConfig);
						if ((text3 == "" && (!type2.IsValueType || Nullable.GetUnderlyingType(type2) != null)) || GetZPackageTypeString(type2) == text3)
						{
							parsedConfigs.configValues[value2] = obj;
							continue;
						}
						Debug.LogWarning((object)("Got unexpected type " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + type2.AssemblyQualifiedName));
					}
					else
					{
						Debug.LogWarning((object)("Received unknown config entry " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ". This may happen if client and server versions of the mod do not match."));
					}
					continue;
				}
				Debug.LogWarning((object)("Got invalid type " + text3 + ", abort reading of received configs"));
				return new ParsedConfigs();
			}
			return parsedConfigs;
		}

		private static bool isWritableConfig(OwnConfigEntryBase config)
		{
			OwnConfigEntryBase config2 = config;
			ConfigSync configSync = configSyncs.FirstOrDefault((ConfigSync cs) => cs.allConfigs.Contains(config2));
			if (configSync == null)
			{
				return true;
			}
			return configSync.IsSourceOfTruth || !config2.SynchronizedConfig || config2.LocalBaseValue == null || (!configSync.IsLocked && (config2 != configSync.lockedConfig || lockExempt));
		}

		private void serverLockedSettingChanged()
		{
			foreach (OwnConfigEntryBase allConfig in allConfigs)
			{
				configAttribute<ConfigurationManagerAttributes>(allConfig.BaseConfig).ReadOnly = !isWritableConfig(allConfig);
			}
		}

		private void resetConfigsFromServer()
		{
			ConfigFile val = null;
			bool saveOnConfigSet = false;
			foreach (OwnConfigEntryBase item in allConfigs.Where((OwnConfigEntryBase config) => config.LocalBaseValue != null))
			{
				if (val == null)
				{
					val = item.BaseConfig.ConfigFile;
					saveOnConfigSet = val.SaveOnConfigSet;
					val.SaveOnConfigSet = false;
				}
				item.BaseConfig.BoxedValue = item.LocalBaseValue;
				item.LocalBaseValue = null;
			}
			if (val != null)
			{
				val.SaveOnConfigSet = saveOnConfigSet;
			}
			foreach (CustomSyncedValueBase item2 in allCustomValues.Where((CustomSyncedValueBase config) => config.LocalBaseValue != null))
			{
				item2.BoxedValue = item2.LocalBaseValue;
				item2.LocalBaseValue = null;
			}
			lockedConfigChanged -= serverLockedSettingChanged;
			serverLockedSettingChanged();
		}

		private IEnumerator<bool> distributeConfigToPeers(ZNetPeer peer, ZPackage package)
		{
			ZNetPeer peer2 = peer;
			ZRoutedRpc rpc = ZRoutedRpc.instance;
			if (rpc == null)
			{
				yield break;
			}
			byte[] data = package.GetArray();
			if (data != null && data.LongLength > 250000)
			{
				int fragments = (int)(1 + (data.LongLength - 1) / 250000);
				long packageIdentifier = ++packageCounter;
				int fragment = 0;
				while (fragment < fragments)
				{
					foreach (bool item in waitForQueue())
					{
						yield return item;
					}
					if (peer2.m_socket.IsConnected())
					{
						ZPackage fragmentedPackage = new ZPackage();
						fragmentedPackage.Write((byte)2);
						fragmentedPackage.Write(packageIdentifier);
						fragmentedPackage.Write(fragment);
						fragmentedPackage.Write(fragments);
						fragmentedPackage.Write(data.Skip(250000 * fragment).Take(250000).ToArray());
						SendPackage(fragmentedPackage);
						if (fragment != fragments - 1)
						{
							yield return true;
						}
						int num = fragment + 1;
						fragment = num;
						continue;
					}
					break;
				}
				yield break;
			}
			foreach (bool item2 in waitForQueue())
			{
				yield return item2;
			}
			SendPackage(package);
			void SendPackage(ZPackage pkg)
			{
				string text = Name + " ConfigSync";
				if (isServer)
				{
					peer2.m_rpc.Invoke(text, new object[1] { pkg });
				}
				else
				{
					rpc.InvokeRoutedRPC(peer2.m_server ? 0 : peer2.m_uid, text, new object[1] { pkg });
				}
			}
			IEnumerable<bool> waitForQueue()
			{
				float timeout = Time.time + 30f;
				while (peer2.m_socket.GetSendQueueSize() > 20000)
				{
					if (Time.time > timeout)
					{
						Debug.Log((object)$"Disconnecting {peer2.m_uid} after 30 seconds config sending timeout");
						peer2.m_rpc.Invoke("Error", new object[1] { (object)(ConnectionStatus)5 });
						ZNet.instance.Disconnect(peer2);
						break;
					}
					yield return false;
				}
			}
		}

		private IEnumerator sendZPackage(long target, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return Enumerable.Empty<object>().GetEnumerator();
			}
			List<ZNetPeer> list = (List<ZNetPeer>)AccessTools.DeclaredField(typeof(ZRoutedRpc), "m_peers").GetValue(ZRoutedRpc.instance);
			if (target != ZRoutedRpc.Everybody)
			{
				list = list.Where((ZNetPeer p) => p.m_uid == target).ToList();
			}
			return sendZPackage(list, package);
		}

		private IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
		{
			ZPackage package2 = package;
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				yield break;
			}
			byte[] rawData = package2.GetArray();
			if (rawData != null && rawData.LongLength > 10000)
			{
				ZPackage compressedPackage = new ZPackage();
				compressedPackage.Write((byte)4);
				MemoryStream output = new MemoryStream();
				using (DeflateStream deflateStream = new DeflateStream(output, CompressionLevel.Optimal))
				{
					deflateStream.Write(rawData, 0, rawData.Length);
				}
				compressedPackage.Write(output.ToArray());
				package2 = compressedPackage;
			}
			List<IEnumerator<bool>> writers = (from peer in peers
				where peer.IsReady()
				select peer into p
				select distributeConfigToPeers(p, package2)).ToList();
			writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			while (writers.Count > 0)
			{
				yield return null;
				writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			}
		}

		private void Broadcast(long target, params ConfigEntryBase[] configs)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(configs);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private void Broadcast(long target, params CustomSyncedValueBase[] customValues)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(null, customValues);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private static OwnConfigEntryBase? configData(ConfigEntryBase config)
		{
			return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
		}

		public static SyncedConfigEntry<T>? ConfigData<T>(ConfigEntry<T> config)
		{
			return ((ConfigEntryBase)config).Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
		}

		private static T configAttribute<T>(ConfigEntryBase config)
		{
			return config.Description.Tags.OfType<T>().First();
		}

		private static Type configType(ConfigEntryBase config)
		{
			return configType(config.SettingType);
		}

		private static Type configType(Type type)
		{
			return type.IsEnum ? Enum.GetUnderlyingType(type) : type;
		}

		private static ZPackage ConfigsToPackage(IEnumerable<ConfigEntryBase>? configs = null, IEnumerable<CustomSyncedValueBase>? customValues = null, IEnumerable<PackageEntry>? packageEntries = null, bool partial = true)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			List<ConfigEntryBase> list = configs?.Where((ConfigEntryBase config) => configData(config).SynchronizedConfig).ToList() ?? new List<ConfigEntryBase>();
			List<CustomSyncedValueBase> list2 = customValues?.ToList() ?? new List<CustomSyncedValueBase>();
			ZPackage val = new ZPackage();
			val.Write((byte)(partial ? 1 : 0));
			val.Write(list.Count + list2.Count + (packageEntries?.Count() ?? 0));
			foreach (PackageEntry item in packageEntries ?? Array.Empty<PackageEntry>())
			{
				AddEntryToPackage(val, item);
			}
			foreach (CustomSyncedValueBase item2 in list2)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = "Internal",
					key = item2.Identifier,
					type = item2.Type,
					value = item2.BoxedValue
				});
			}
			foreach (ConfigEntryBase item3 in list)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = item3.Definition.Section,
					key = item3.Definition.Key,
					type = configType(item3),
					value = item3.BoxedValue
				});
			}
			return val;
		}

		private static void AddEntryToPackage(ZPackage package, PackageEntry entry)
		{
			package.Write(entry.section);
			package.Write(entry.key);
			package.Write((entry.value == null) ? "" : GetZPackageTypeString(entry.type));
			AddValueToZPackage(package, entry.value);
		}

		private static string GetZPackageTypeString(Type type)
		{
			return type.AssemblyQualifiedName;
		}

		private static void AddValueToZPackage(ZPackage package, object? value)
		{
			Type type = value?.GetType();
			if (value is Enum)
			{
				value = ((IConvertible)value).ToType(Enum.GetUnderlyingType(value.GetType()), CultureInfo.InvariantCulture);
			}
			else
			{
				if (value is ICollection collection)
				{
					package.Write(collection.Count);
					{
						foreach (object item in collection)
						{
							AddValueToZPackage(package, item);
						}
						return;
					}
				}
				if ((object)type != null && type.IsValueType && !type.IsPrimitive)
				{
					FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					package.Write(fields.Length);
					FieldInfo[] array = fields;
					foreach (FieldInfo fieldInfo in array)
					{
						package.Write(GetZPackageTypeString(fieldInfo.FieldType));
						AddValueToZPackage(package, fieldInfo.GetValue(value));
					}
					return;
				}
			}
			ZRpc.Serialize(new object[1] { value }, ref package);
		}

		private static object ReadValueWithTypeFromZPackage(ZPackage package, Type type)
		{
			if ((object)type != null && type.IsValueType && !type.IsPrimitive && !type.IsEnum)
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				int num = package.ReadInt();
				if (num != fields.Length)
				{
					throw new InvalidDeserializationTypeException
					{
						received = $"(field count: {num})",
						expected = $"(field count: {fields.Length})"
					};
				}
				object uninitializedObject = FormatterServices.GetUninitializedObject(type);
				FieldInfo[] array = fields;
				foreach (FieldInfo fieldInfo in array)
				{
					string text = package.ReadString();
					if (text != GetZPackageTypeString(fieldInfo.FieldType))
					{
						throw new InvalidDeserializationTypeException
						{
							received = text,
							expected = GetZPackageTypeString(fieldInfo.FieldType),
							field = fieldInfo.Name
						};
					}
					fieldInfo.SetValue(uninitializedObject, ReadValueWithTypeFromZPackage(package, fieldInfo.FieldType));
				}
				return uninitializedObject;
			}
			if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<, >))
			{
				int num2 = package.ReadInt();
				IDictionary dictionary = (IDictionary)Activator.CreateInstance(type);
				Type type2 = typeof(KeyValuePair<, >).MakeGenericType(type.GenericTypeArguments);
				FieldInfo field = type2.GetField("key", BindingFlags.Instance | BindingFlags.NonPublic);
				FieldInfo field2 = type2.GetField("value", BindingFlags.Instance | BindingFlags.NonPublic);
				for (int j = 0; j < num2; j++)
				{
					object obj = ReadValueWithTypeFromZPackage(package, type2);
					dictionary.Add(field.GetValue(obj), field2.GetValue(obj));
				}
				return dictionary;
			}
			if (type != typeof(List<string>) && type.IsGenericType)
			{
				Type type3 = typeof(ICollection<>).MakeGenericType(type.GenericTypeArguments[0]);
				if ((object)type3 != null && type3.IsAssignableFrom(type))
				{
					int num3 = package.ReadInt();
					object obj2 = Activator.CreateInstance(type);
					MethodInfo method = type3.GetMethod("Add");
					for (int k = 0; k < num3; k++)
					{
						method.Invoke(obj2, new object[1] { ReadValueWithTypeFromZPackage(package, type.GenericTypeArguments[0]) });
					}
					return obj2;
				}
			}
			ParameterInfo parameterInfo = (ParameterInfo)FormatterServices.GetUninitializedObject(typeof(ParameterInfo));
			AccessTools.DeclaredField(typeof(ParameterInfo), "ClassImpl").SetValue(parameterInfo, type);
			List<object> source = new List<object>();
			ZRpc.Deserialize(new ParameterInfo[2] { null, parameterInfo }, package, ref source);
			return source.First();
		}
	}
	[PublicAPI]
	[HarmonyPatch]
	public class VersionCheck
	{
		private static readonly HashSet<VersionCheck> versionChecks;

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		private string? displayName;

		private string? currentVersion;

		private string? minimumRequiredVersion;

		public bool ModRequired = true;

		private string? ReceivedCurrentVersion;

		private string? ReceivedMinimumRequiredVersion;

		private readonly List<ZRpc> ValidatedClients = new List<ZRpc>();

		private ConfigSync? ConfigSync;

		public string DisplayName
		{
			get
			{
				return displayName ?? Name;
			}
			set
			{
				displayName = value;
			}
		}

		public string CurrentVersion
		{
			get
			{
				return currentVersion ?? "0.0.0";
			}
			set
			{
				currentVersion = value;
			}
		}

		public string MinimumRequiredVersion
		{
			get
			{
				return minimumRequiredVersion ?? (ModRequired ? CurrentVersion : "0.0.0");
			}
			set
			{
				minimumRequiredVersion = value;
			}
		}

		private static void PatchServerSync()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			Patches patchInfo = PatchProcessor.GetPatchInfo((MethodBase)AccessTools.DeclaredMethod(typeof(ZNet), "Awake", (Type[])null, (Type[])null));
			if (patchInfo != null && patchInfo.Postfixes.Count((Patch p) => p.PatchMethod.DeclaringType == typeof(ConfigSync.RegisterRPCPatch)) > 0)
			{
				return;
			}
			Harmony val = new Harmony("org.bepinex.helpers.ServerSync");
			foreach (Type item in from t in typeof(ConfigSync).GetNestedTypes(BindingFlags.NonPublic).Concat(new Type[1] { typeof(VersionCheck) })
				where t.IsClass
				select t)
			{
				val.PatchAll(item);
			}
		}

		static VersionCheck()
		{
			versionChecks = new HashSet<VersionCheck>();
			notProcessedNames = new Dictionary<string, string>();
			typeof(ThreadingHelper).GetMethod("StartSyncInvoke").Invoke(ThreadingHelper.Instance, new object[1]
			{
				new Action(PatchServerSync)
			});
		}

		public VersionCheck(string name)
		{
			Name = name;
			ModRequired = true;
			versionChecks.Add(this);
		}

		public VersionCheck(ConfigSync configSync)
		{
			ConfigSync = configSync;
			Name = ConfigSync.Name;
			versionChecks.Add(this);
		}

		public void Initialize()
		{
			ReceivedCurrentVersion = null;
			ReceivedMinimumRequiredVersion = null;
			if (ConfigSync != null)
			{
				Name = ConfigSync.Name;
				DisplayName = ConfigSync.DisplayName;
				CurrentVersion = ConfigSync.CurrentVersion;
				MinimumRequiredVersion = ConfigSync.MinimumRequiredVersion;
				ModRequired = ConfigSync.ModRequired;
			}
		}

		private bool IsVersionOk()
		{
			if (ReceivedMinimumRequiredVersion == null || ReceivedCurrentVersion == null)
			{
				return !ModRequired;
			}
			bool flag = new System.Version(CurrentVersion) >= new System.Version(ReceivedMinimumRequiredVersion);
			bool flag2 = new System.Version(ReceivedCurrentVersion) >= new System.Version(MinimumRequiredVersion);
			return flag && flag2;
		}

		private string ErrorClient()
		{
			if (ReceivedMinimumRequiredVersion == null)
			{
				return DisplayName + " is not installed on the server.";
			}
			return (new System.Version(CurrentVersion) >= new System.Version(ReceivedMinimumRequiredVersion)) ? (DisplayName + " may not be higher than version " + ReceivedCurrentVersion + ". You have version " + CurrentVersion + ".") : (DisplayName + " needs to be at least version " + ReceivedMinimumRequiredVersion + ". You have version " + CurrentVersion + ".");
		}

		private string ErrorServer(ZRpc rpc)
		{
			return "Disconnect: The client (" + rpc.GetSocket().GetHostName() + ") doesn't have the correct " + DisplayName + " version " + MinimumRequiredVersion;
		}

		private string Error(ZRpc? rpc = null)
		{
			return (rpc == null) ? ErrorClient() : ErrorServer(rpc);
		}

		private static VersionCheck[] GetFailedClient()
		{
			return versionChecks.Where((VersionCheck check) => !check.IsVersionOk()).ToArray();
		}

		private static VersionCheck[] GetFailedServer(ZRpc rpc)
		{
			ZRpc rpc2 = rpc;
			return versionChecks.Where((VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc2)).ToArray();
		}

		private static void Logout()
		{
			Game.instance.Logout(true, true);
			AccessTools.DeclaredField(typeof(ZNet), "m_connectionStatus").SetValue(null, (object)(ConnectionStatus)3);
		}

		private static void DisconnectClient(ZRpc rpc)
		{
			rpc.Invoke("Error", new object[1] { 3 });
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg)
		{
			CheckVersion(rpc, pkg, null);
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg, Action<ZRpc, ZPackage>? original)
		{
			string text = pkg.ReadString();
			string text2 = pkg.ReadString();
			string text3 = pkg.ReadString();
			bool flag = false;
			foreach (VersionCheck versionCheck in versionChecks)
			{
				if (!(text != versionCheck.Name))
				{
					Debug.Log((object)("Received " + versionCheck.DisplayName + " version " + text3 + " and minimum version " + text2 + " from the " + (ZNet.instance.IsServer() ? "client" : "server") + "."));
					versionCheck.ReceivedMinimumRequiredVersion = text2;
					versionCheck.ReceivedCurrentVersion = text3;
					if (ZNet.instance.IsServer() && versionCheck.IsVersionOk())
					{
						versionCheck.ValidatedClients.Add(rpc);
					}
					flag = true;
				}
			}
			if (flag)
			{
				return;
			}
			pkg.SetPos(0);
			if (original != null)
			{
				original(rpc, pkg);
				if (pkg.GetPos() == 0)
				{
					notProcessedNames.Add(text, text3);
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		[HarmonyPrefix]
		private static bool RPC_PeerInfo(ZRpc rpc, ZNet __instance)
		{
			VersionCheck[] array = (__instance.IsServer() ? GetFailedServer(rpc) : GetFailedClient());
			if (array.Length == 0)
			{
				return true;
			}
			VersionCheck[] array2 = array;
			foreach (VersionCheck versionCheck in array2)
			{
				Debug.LogWarning((object)versionCheck.Error(rpc));
			}
			if (__instance.IsServer())
			{
				DisconnectClient(rpc);
			}
			else
			{
				Logout();
			}
			return false;
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		[HarmonyPrefix]
		private static void RegisterAndCheckVersion(ZNetPeer peer, ZNet __instance)
		{
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Expected O, but got Unknown
			notProcessedNames.Clear();
			IDictionary dictionary = (IDictionary)typeof(ZRpc).GetField("m_functions", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(peer.m_rpc);
			if (dictionary.Contains(StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")))
			{
				object obj = dictionary[StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")];
				Action<ZRpc, ZPackage> action = (Action<ZRpc, ZPackage>)obj.GetType().GetField("m_action", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj);
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)delegate(ZRpc rpc, ZPackage pkg)
				{
					CheckVersion(rpc, pkg, action);
				});
			}
			else
			{
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)CheckVersion);
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.Initialize();
				if (versionCheck.ModRequired || __instance.IsServer())
				{
					Debug.Log((object)("Sending " + versionCheck.DisplayName + " version " + versionCheck.CurrentVersion + " and minimum version " + versionCheck.MinimumRequiredVersion + " to the " + (__instance.IsServer() ? "client" : "server") + "."));
					ZPackage val = new ZPackage();
					val.Write(versionCheck.Name);
					val.Write(versionCheck.MinimumRequiredVersion);
					val.Write(versionCheck.CurrentVersion);
					peer.m_rpc.Invoke("ServerSync VersionCheck", new object[1] { val });
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "Disconnect")]
		[HarmonyPrefix]
		private static void RemoveDisconnected(ZNetPeer peer, ZNet __instance)
		{
			if (!__instance.IsServer())
			{
				return;
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.ValidatedClients.Remove(peer.m_rpc);
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
		[HarmonyPostfix]
		private static void ShowConnectionError(FejdStartup __instance)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.m_connectionFailedPanel.activeSelf || (int)ZNet.GetConnectionStatus() != 3)
			{
				return;
			}
			bool flag = false;
			VersionCheck[] failedClient = GetFailedClient();
			if (failedClient.Length != 0)
			{
				string text = string.Join("\n", failedClient.Select((VersionCheck check) => check.Error()));
				TMP_Text connectionFailedError = __instance.m_connectionFailedError;
				connectionFailedError.text = connectionFailedError.text + "\n" + text;
				flag = true;
			}
			foreach (KeyValuePair<string, string> item in notProcessedNames.OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> kv) => kv.Key))
			{
				if (!__instance.m_connectionFailedError.text.Contains(item.Key))
				{
					TMP_Text connectionFailedError2 = __instance.m_connectionFailedError;
					connectionFailedError2.text = connectionFailedError2.text + "\nServer expects you to have " + item.Key + " (Version: " + item.Value + ") installed.";
					flag = true;
				}
			}
			if (flag)
			{
				RectTransform component = ((Component)__instance.m_connectionFailedPanel.transform.Find("Image")).GetComponent<RectTransform>();
				Vector2 sizeDelta = component.sizeDelta;
				sizeDelta.x = 675f;
				component.sizeDelta = sizeDelta;
				__instance.m_connectionFailedError.ForceMeshUpdate(false, false);
				float num = __instance.m_connectionFailedError.renderedHeight + 105f;
				RectTransform component2 = ((Component)((Component)component).transform.Find("ButtonOk")).GetComponent<RectTransform>();
				component2.anchoredPosition = new Vector2(component2.anchoredPosition.x, component2.anchoredPosition.y - (num - component.sizeDelta.y) / 2f);
				sizeDelta = component.sizeDelta;
				sizeDelta.y = num;
				component.sizeDelta = sizeDelta;
			}
		}
	}
}
namespace fastJSON
{
	internal class DynamicJson : DynamicObject, IEnumerable
	{
		private IDictionary<string, object> _dictionary { get; set; }

		private List<object> _list { get; set; }

		public DynamicJson(string json)
		{
			object obj = JSON.Parse(json);
			if (obj is IDictionary<string, object>)
			{
				_dictionary = (IDictionary<string, object>)obj;
			}
			else
			{
				_list = (List<object>)obj;
			}
		}

		private DynamicJson(object dictionary)
		{
			if (dictionary is IDictionary<string, object>)
			{
				_dictionary = (IDictionary<string, object>)dictionary;
			}
		}

		public override IEnumerable<string> GetDynamicMemberNames()
		{
			return _dictionary.Keys.ToList();
		}

		public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
		{
			object obj = indexes[0];
			if (obj is int)
			{
				result = _list[(int)obj];
			}
			else
			{
				result = _dictionary[(string)obj];
			}
			if (result is IDictionary<string, object>)
			{
				result = new DynamicJson(result as IDictionary<string, object>);
			}
			return true;
		}

		public override bool TryGetMember(GetMemberBinder binder, out object result)
		{
			if (!_dictionary.TryGetValue(binder.Name, out result) && !_dictionary.TryGetValue(binder.Name.ToLowerInvariant(), out result))
			{
				return false;
			}
			if (result is IDictionary<string, object>)
			{
				result = new DynamicJson(result as IDictionary<string, object>);
			}
			else if (result is List<object>)
			{
				List<object> list = new List<object>();
				foreach (object item in (List<object>)result)
				{
					if (item is IDictionary<string, object>)
					{
						list.Add(new DynamicJson(item as IDictionary<string, object>));
					}
					else
					{
						list.Add(item);
					}
				}
				result = list;
			}
			return _dictionary.ContainsKey(binder.Name);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			foreach (object item in _list)
			{
				yield return new DynamicJson(item as IDictionary<string, object>);
			}
		}
	}
	public sealed class DatasetSchema
	{
		public List<string> Info;

		public string Name;
	}
	public class DataMemberAttribute : Attribute
	{
		public string Name { get; set; }
	}
	internal static class Formatter
	{
		private static void AppendIndent(StringBuilder sb, int count, string indent)
		{
			while (count > 0)
			{
				sb.Append(indent);
				count--;
			}
		}

		public static string PrettyPrint(string input)
		{
			return PrettyPrint(input, new string(' ', JSON.Parameters.FormatterIndentSpaces));
		}

		public static string PrettyPrint(string input, string spaces)
		{
			StringBuilder stringBuilder = new StringBuilder();
			int num = 0;
			int length = input.Length;
			char[] array = input.ToCharArray();
			for (int i = 0; i < length; i++)
			{
				char c = array[i];
				if (c == '"')
				{
					bool flag = true;
					while (flag)
					{
						stringBuilder.Append(c);
						c = array[++i];
						switch (c)
						{
						case '\\':
							stringBuilder.Append(c);
							c = array[++i];
							break;
						case '"':
							flag = false;
							break;
						}
					}
				}
				switch (c)
				{
				case '[':
				case '{':
					stringBuilder.Append(c);
					stringBuilder.AppendLine();
					AppendIndent(stringBuilder, ++num, spaces);
					break;
				case ']':
				case '}':
					stringBuilder.AppendLine();
					AppendIndent(stringBuilder, --num, spaces);
					stringBuilder.Append(c);
					break;
				case ',':
					stringBuilder.Append(c);
					stringBuilder.AppendLine();
					AppendIndent(stringBuilder, num, spaces);
					break;
				case ':':
					stringBuilder.Append(" : ");
					break;
				default:
					if (!char.IsWhiteSpace(c))
					{
						stringBuilder.Append(c);
					}
					break;
				}
			}
			return stringBuilder.ToString();
		}
	}
	public class Helper
	{
		public static bool IsNullable(Type t)
		{
			if (!t.IsGenericType)
			{
				return false;
			}
			Type genericTypeDefinition = t.GetGenericTypeDefinition();
			return genericTypeDefinition.Equals(typeof(Nullable<>));
		}

		public static Type UnderlyingTypeOf(Type t)
		{
			return Reflection.Instance.GetGenericArguments(t)[0];
		}

		public static DateTimeOffset CreateDateTimeOffset(int year, int month, int day, int hour, int min, int sec, int milli, int extraTicks, TimeSpan offset)
		{
			DateTimeOffset dateTimeOffset = new DateTimeOffset(year, month, day, hour, min, sec, milli, offset);
			if (extraTicks > 0)
			{
				return dateTimeOffset + TimeSpan.FromTicks(extraTicks);
			}
			return dateTimeOffset;
		}

		public static bool BoolConv(object v)
		{
			bool result = false;
			if (v is bool)
			{
				result = (bool)v;
			}
			else if (v is long)
			{
				result = (((long)v > 0) ? true : false);
			}
			else if (v is string)
			{
				string text = (string)v;
				switch (text.ToLowerInvariant())
				{
				case "1":
				case "true":
				case "yes":
				case "on":
					result = true;
					break;
				}
			}
			return result;
		}

		public static long AutoConv(object value, JSONParameters param)
		{
			if (value is string)
			{
				if (param.AutoConvertStringToNumbers)
				{
					string text = (string)value;
					return CreateLong(text, 0, text.Length);
				}
				throw new Exception("AutoConvertStringToNumbers is disabled for converting string : " + value);
			}
			if (value is long)
			{
				return (long)value;
			}
			return Convert.ToInt64(value);
		}

		public unsafe static long CreateLong(string s, int index, int count)
		{
			long num = 0L;
			int num2 = 1;
			fixed (char* ptr = s)
			{
				char* ptr2 = ptr;
				ptr2 += index;
				if (*ptr2 == '-')
				{
					num2 = -1;
					ptr2++;
					count--;
				}
				if (*ptr2 == '+')
				{
					ptr2++;
					count--;
				}
				while (count > 0)
				{
					num = num * 10 + (*ptr2 - 48);
					ptr2++;
					count--;
				}
			}
			return num * num2;
		}

		public unsafe static long CreateLong(char[] s, int index, int count)
		{
			long num = 0L;
			int num2 = 1;
			fixed (char* ptr = s)
			{
				char* ptr2 = ptr;
				ptr2 += index;
				if (*ptr2 == '-')
				{
					num2 = -1;
					ptr2++;
					count--;
				}
				if (*ptr2 == '+')
				{
					ptr2++;
					count--;
				}
				while (count > 0)
				{
					num = num * 10 + (*ptr2 - 48);
					ptr2++;
					count--;
				}
			}
			return num * num2;
		}

		public unsafe static int CreateInteger(string s, int index, int count)
		{
			int num = 0;
			int num2 = 1;
			fixed (char* ptr = s)
			{
				char* ptr2 = ptr;
				ptr2 += index;
				if (*ptr2 == '-')
				{
					num2 = -1;
					ptr2++;
					count--;
				}
				if (*ptr2 == '+')
				{
					ptr2++;
					count--;
				}
				while (count > 0)
				{
					num = num * 10 + (*ptr2 - 48);
					ptr2++;
					count--;
				}
			}
			return num * num2;
		}

		public static object CreateEnum(Type pt, object v)
		{
			return Enum.Parse(pt, v.ToString(), ignoreCase: true);
		}

		public static Guid CreateGuid(string s)
		{
			if (s.Length > 30)
			{
				return new Guid(s);
			}
			return new Guid(Convert.FromBase64String(s));
		}

		public static StringDictionary CreateSD(Dictionary<string, object> d)
		{
			StringDictionary stringDictionary = new StringDictionary();
			foreach (KeyValuePair<string, object> item in d)
			{
				stringDictionary.Add(item.Key, (string)item.Value);
			}
			return stringDictionary;
		}

		public static NameValueCollection CreateNV(Dictionary<string, object> d)
		{
			NameValueCollection nameValueCollection = new NameValueCollection();
			foreach (KeyValuePair<string, object> item in d)
			{
				nameValueCollection.Add(item.Key, (string)item.Value);
			}
			return nameValueCollection;
		}

		public static object CreateDateTimeOffset(string value)
		{
			int milli = 0;
			int extraTicks = 0;
			int num = 0;
			int num2 = 0;
			int year = CreateInteger(value, 0, 4);
			int month = CreateInteger(value, 5, 2);
			int day = CreateInteger(value, 8, 2);
			int hour = CreateInteger(value, 11, 2);
			int min = CreateInteger(value, 14, 2);
			int sec = CreateInteger(value, 17, 2);
			int num3 = 20;
			if (value.Length > 21 && value[19] == '.')
			{
				milli = CreateInteger(value, num3, 3);
				num3 = 23;
				if (value.Length > 25 && char.IsDigit(value[num3]))
				{
					extraTicks = CreateInteger(value, num3, 4);
					num3 = 27;
				}
			}
			if (value[num3] == 'Z')
			{
				return CreateDateTimeOffset(year, month, day, hour, min, sec, milli, extraTicks, TimeSpan.Zero);
			}
			if (value[num3] == ' ')
			{
				num3++;
			}
			num = CreateInteger(value, num3 + 1, 2);
			num2 = CreateInteger(value, num3 + 1 + 2 + 1, 2);
			if (value[num3] == '-')
			{
				num = -num;
			}
			return CreateDateTimeOffset(year, month, day, hour, min, sec, milli, extraTicks, new TimeSpan(num, num2, 0));
		}

		public static DateTime CreateDateTime(string value, bool UseUTCDateTime)
		{
			if (value.Length < 19)
			{
				return DateTime.MinValue;
			}
			bool flag = false;
			int millisecond = 0;
			int year = CreateInteger(value, 0, 4);
			int month = CreateInteger(value, 5, 2);
			int day = CreateInteger(value, 8, 2);
			int hour = CreateInteger(value, 11, 2);
			int minute = CreateInteger(value, 14, 2);
			int second = CreateInteger(value, 17, 2);
			if (value.Length > 21 && value[19] == '.')
			{
				millisecond = CreateInteger(value, 20, 3);
			}
			if (value[value.Length - 1] == 'Z')
			{
				flag = true;
			}
			if (!UseUTCDateTime && !flag)
			{
				return new DateTime(year, month, day, hour, minute, second, millisecond);
			}
			return new DateTime(year, month, day, hour, minute, second, millisecond, DateTimeKind.Utc).ToLocalTime();
		}
	}
	internal sealed class JSONSerializer
	{
		private StringBuilder _output = new StringBuilder();

		private int _before;

		private int _MAX_DEPTH = 20;

		private int _current_depth;

		private Dictionary<string, int> _globalTypes = new Dictionary<string, int>();

		private Dictionary<object, int> _cirobj;

		private JSONParameters _params;

		private bool _useEscapedUnicode;

		private bool _TypesWritten;

		internal JSONSerializer(JSONParameters param)
		{
			if (param.OverrideObjectHashCodeChecking)
			{
				_cirobj = new Dictionary<object, int>(10, ReferenceEqualityComparer.Default);
			}
			else
			{
				_cirobj = new Dictionary<object, int>();
			}
			_params = param;
			_useEscapedUnicode = _params.UseEscapedUnicode;
			_MAX_DEPTH = _params.SerializerMaxDepth;
		}

		internal string ConvertToJSON(object obj)
		{
			WriteValue(obj);
			if (_params.UsingGlobalTypes && _globalTypes != null && _globalTypes.Count > 0)
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append("\"$types\":{");
				bool flag = false;
				foreach (KeyValuePair<string, int> globalType in _globalTypes)
				{
					if (flag)
					{
						stringBuilder.Append(',');
					}
					flag = true;
					stringBuilder.Append('"');
					stringBuilder.Append(globalType.Key);
					stringBuilder.Append("\":\"");
					stringBuilder.Append(globalType.Value);
					stringBuilder.Append('"');
				}
				stringBuilder.Append("},");
				_output.Insert(_before, stringBuilder.ToString());
			}
			return _output.ToString();
		}

		private void WriteValue(object obj)
		{
			if (obj == null || obj is DBNull)
			{
				_output.Append("null");
			}
			else if (obj is string || obj is char)
			{
				WriteString(obj.ToString());
			}
			else if (obj is Guid)
			{
				WriteGuid((Guid)obj);
			}
			else if (obj is bool)
			{
				_output.Append(((bool)obj) ? "true" : "false");
			}
			else if (obj is int || obj is long || obj is decimal || obj is byte || obj is short || obj is sbyte || obj is ushort || obj is uint || obj is ulong)
			{
				_output.Append(((IConvertible)obj).ToString(NumberFormatInfo.InvariantInfo));
			}
			else if (obj is double || obj is double)
			{
				double d = (double)obj;
				if (double.IsNaN(d))
				{
					_output.Append("\"NaN\"");
				}
				else if (double.IsInfinity(d))
				{
					_output.Append('"');
					_output.Append(((IConvertible)obj).ToString(NumberFormatInfo.InvariantInfo));
					_output.Append('"');
				}
				else
				{
					_output.Append(((IConvertible)obj).ToString(NumberFormatInfo.InvariantInfo));
				}
			}
			else if (obj is float || obj is float)
			{
				float f = (float)obj;
				if (float.IsNaN(f))
				{
					_output.Append("\"NaN\"");
				}
				else if (float.IsInfinity(f))
				{
					_output.Append('"');
					_output.Append(((IConvertible)obj).ToString(NumberFormatInfo.InvariantInfo));
					_output.Append('"');
				}
				else
				{
					_output.Append(((IConvertible)obj).ToString(NumberFormatInfo.InvariantInfo));
				}
			}
			else if (obj is DateTime)
			{
				WriteDateTime((DateTime)obj);
			}
			else if (obj is DateTimeOffset)
			{
				WriteDateTimeOffset((DateTimeOffset)obj);
			}
			else if (obj is TimeSpan)
			{
				_output.Append(((TimeSpan)obj).Ticks);
			}
			else if (!_params.KVStyleStringDictionary && obj is IEnumerable<KeyValuePair<string, object>>)
			{
				WriteStringDictionary((IEnumerable<KeyValuePair<string, object>>)obj);
			}
			else if (!_params.KVStyleStringDictionary && obj is IDictionary && obj.GetType().IsGenericType && Reflection.Instance.GetGenericArguments(obj.GetType())[0] == typeof(string))
			{
				WriteStringDictionary((IDictionary)obj);
			}
			else if (obj is IDictionary)
			{
				WriteDictionary((IDictionary)obj);
			}
			else if (obj is byte[])
			{
				WriteBytes((byte[])obj);
			}
			else if (obj is StringDictionary)
			{
				WriteSD((StringDictionary)obj);
			}
			else if (obj is NameValueCollection)
			{
				WriteNV((NameValueCollection)obj);
			}
			else if (obj is Array)
			{
				WriteArrayRanked((Array)obj);
			}
			else if (obj is IEnumerable)
			{
				WriteArray((IEnumerable)obj);
			}
			else if (obj is Enum)
			{
				WriteEnum((Enum)obj);
			}
			else if (Reflection.Instance.IsTypeRegistered(obj.GetType()))
			{
				WriteCustom(obj);
			}
			else
			{
				WriteObject(obj);
			}
		}

		private void WriteDateTimeOffset(DateTimeOffset d)
		{
			DateTime dt = (_params.UseUTCDateTime ? d.UtcDateTime : d.DateTime);
			write_date_value(dt);
			long num = dt.Ticks % 10000000;
			_output.Append('.');
			_output.Append(num.ToString("0000000", NumberFormatInfo.InvariantInfo));
			if (_params.UseUTCDateTime)
			{
				_output.Append('Z');
			}
			else
			{
				if (d.Offset.Hours > 0)
				{
					_output.Append('+');
				}
				else
				{
					_output.Append('-');
				}
				_output.Append(d.Offset.Hours.ToString("00", NumberFormatInfo.InvariantInfo));
				_output.Append(':');
				_output.Append(d.Offset.Minutes.ToString("00", NumberFormatInfo.InvariantInfo));
			}
			_output.Append('"');
		}

		private void WriteNV(NameValueCollection nameValueCollection)
		{
			_output.Append('{');
			bool flag = false;
			foreach (string item in nameValueCollection)
			{
				if (_params.SerializeNullValues || nameValueCollection[item] != null)
				{
					if (flag)
					{
						_output.Append(',');
					}
					if (_params.SerializeToLowerCaseNames)
					{
						WritePair(item.ToLowerInvariant(), nameValueCollection[item]);
					}
					else
					{
						WritePair(item, nameValueCollection[item]);
					}
					flag = true;
				}
			}
			_output.Append('}');
		}

		private void WriteSD(StringDictionary stringDictionary)
		{
			_output.Append('{');
			bool flag = false;
			foreach (DictionaryEntry item in stringDictionary)
			{
				if (_params.SerializeNullValues || item.Value != null)
				{
					if (flag)
					{
						_output.Append(',');
					}
					string text = (string)item.Key;
					if (_params.SerializeToLowerCaseNames)
					{
						WritePair(text.ToLowerInvariant(), item.Value);
					}
					else
					{
						WritePair(text, item.Value);
					}
					flag = true;
				}
			}
			_output.Append('}');
		}

		private void WriteCustom(object obj)
		{
			Reflection.Instance._customSerializer.TryGetValue(obj.GetType(), out var value);
			WriteStringFast(value(obj));
		}

		private void WriteEnum(Enum e)
		{
			if (_params.UseValuesOfEnums)
			{
				WriteValue(Convert.ToInt32(e));
			}
			else
			{
				WriteStringFast(e.ToString());
			}
		}

		private void WriteGuid(Guid g)
		{
			if (!_params.UseFastGuid)
			{
				WriteStringFast(g.ToString());
			}
			else
			{
				WriteBytes(g.ToByteArray());
			}
		}

		private void WriteBytes(byte[] bytes)
		{
			WriteStringFast(Convert.ToBase64String(bytes, 0, bytes.Length, Base64FormattingOptions.None));
		}

		private void WriteDateTime(DateTime dateTime)
		{
			DateTime dt = dateTime;
			if (_params.UseUTCDateTime)
			{
				dt = dateTime.ToUniversalTime();
			}
			write_date_value(dt);
			if (_params.DateTimeMilliseconds)
			{
				_output.Append('.');
				_output.Append(dt.Millisecond.ToString("000", NumberFormatInfo.InvariantInfo));
			}
			if (_params.UseUTCDateTime)
			{
				_output.Append('Z');
			}
			_output.Append('"');
		}

		private void write_date_value(DateTime dt)
		{
			_output.Append('"');
			_output.Append(dt.Year.ToString("0000", NumberFormatInfo.InvariantInfo));
			_output.Append('-');
			_output.Append(dt.Month.ToString("00", NumberFormatInfo.InvariantInfo));
			_output.Append('-');
			_output.Append(dt.Day.ToString("00", NumberFormatInfo.InvariantInfo));
			_output.Append('T');
			_output.Append(dt.Hour.ToString("00", NumberFormatInfo.InvariantInfo));
			_output.Append(':');
			_output.Append(dt.Minute.ToString("00", NumberFormatInfo.InvariantInfo));
			_output.Append(':');
			_output.Append(dt.Second.ToString("00", NumberFormatInfo.InvariantInfo));
		}

		private void WriteObject(object obj)
		{
			int value = 0;
			if (!_cirobj.TryGetValue(obj, out value))
			{
				_cirobj.Add(obj, _cirobj.Count + 1);
			}
			else if (_current_depth > 0 && !_params.InlineCircularReferences)
			{
				_output.Append("{\"$i\":");
				_output.Append(value.ToString());
				_output.Append('}');
				return;
			}
			if (!_params.UsingGlobalTypes)
			{
				_output.Append('{');
			}
			else if (!_TypesWritten)
			{
				_output.Append('{');
				_before = _output.Length;
			}
			else
			{
				_output.Append('{');
			}
			_TypesWritten = true;
			_current_depth++;
			if (_current_depth > _MAX_DEPTH)
			{
				throw new Exception("Serializer encountered maximum depth of " + _MAX_DEPTH);
			}
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			Type type = obj.GetType();
			bool flag = false;
			if (_params.UseExtensions)
			{
				if (!_params.UsingGlobalTypes)
				{
					WritePairFast("$type", Reflection.Instance.GetTypeAssemblyName(type));
				}
				else
				{
					int value2 = 0;
					string typeAssemblyName = Reflection.Instance.GetTypeAssemblyName(type);
					if (!_globalTypes.TryGetValue(typeAssemblyName, out value2))
					{
						value2 = _globalTypes.Count + 1;
						_globalTypes.Add(typeAssemblyName, value2);
					}
					WritePairFast("$type", value2.ToString());
				}
				flag = true;
			}
			Getters[] getters = Reflection.Instance.GetGetters(type, _params.IgnoreAttributes);
			int num = getters.Length;
			for (int i = 0; i < num; i++)
			{
				Getters getters2 = getters[i];
				if (!_params.ShowReadOnlyProperties && getters2.ReadOnly)
				{
					continue;
				}
				object obj2 = getters2.Getter(obj);
				if (!_params.SerializeNullValues && (obj2 == null || obj2 is DBNull))
				{
					continue;
				}
				if (flag)
				{
					_output.Append(',');
				}
				if (getters2.memberName != null)
				{
					WritePair(getters2.memberName, obj2);
				}
				else if (_params.SerializeToLowerCaseNames)
				{
					WritePair(getters2.lcName, obj2);
				}
				else
				{
					WritePair(getters2.Name, obj2);
				}
				if (obj2 != null && _params.UseExtensions)
				{
					Type type2 = obj2.GetType();
					if (type2 == typeof(object))
					{
						dictionary.Add(getters2.Name, type2.ToString());
					}
				}
				flag = true;
			}
			if (dictionary.Count > 0 && _params.UseExtensions)
			{
				_output.Append(",\"$map\":");
				WriteStringDictionary(dictionary);
			}
			_output.Append('}');
			_current_depth--;
		}

		private void WritePairFast(string name, string value)
		{
			WriteStringFast(name);
			_output.Append(':');
			WriteStringFast(value);
		}

		private void WritePair(string name, object value)
		{
			WriteString(name);
			_output.Append(':');
			WriteValue(value);
		}

		private void WriteArray(IEnumerable array)
		{
			_output.Append('[');
			bool flag = false;
			foreach (object item in array)
			{
				if (flag)
				{
					_output.Append(',');
				}
				WriteValue(item);
				flag = true;
			}
			_output.Append(']');
		}

		private void WriteArrayRanked(Array array)
		{
			if (array.Rank == 1)
			{
				WriteArray(array);
				return;
			}
			_output.Append('[');
			bool flag = false;
			foreach (object item in array)
			{
				if (flag)
				{
					_output.Append(',');
				}
				WriteValue(item);
				flag = true;
			}
			_output.Append(']');
		}

		private void WriteStringDictionary(IDictionary dic)
		{
			_output.Append('{');
			bool flag = false;
			foreach (DictionaryEntry item in dic)
			{
				if (_params.SerializeNullValues || item.Value != null)
				{
					if (flag)
					{
						_output.Append(',');
					}
					string text = (string)item.Key;
					if (_params.SerializeToLowerCaseNames)
					{
						WritePair(text.ToLowerInvariant(), item.Value);
					}
					else
					{
						WritePair(text, item.Value);
					}
					flag = true;
				}
			}
			_output.Append('}');
		}

		private void WriteStringDictionary(IEnumerable<KeyValuePair<string, object>> dic)
		{
			_output.Append('{');
			bool flag = false;
			foreach (KeyValuePair<string, object> item in dic)
			{
				if (_params.SerializeNullValues || item.Value != null)
				{
					if (flag)
					{
						_output.Append(',');
					}
					string key = item.Key;
					if (_params.SerializeToLowerCaseNames)
					{
						WritePair(key.ToLowerInvariant(), item.Value);
					}
					else
					{
						WritePair(key, item.Value);
					}
					flag = true;
				}
			}
			_output.Append('}');
		}

		private void WriteDictionary(IDictionary dic)
		{
			_output.Append('[');
			bool flag = false;
			foreach (DictionaryEntry item in dic)
			{
				if (flag)
				{
					_output.Append(',');
				}
				_output.Append('{');
				WritePair("k", item.Key);
				_output.Append(',');
				WritePair("v", item.Value);
				_output.Append('}');
				flag = true;
			}
			_output.Append(']');
		}

		private void WriteStringFast(string s)
		{
			_output.Append('"');
			_output.Append(s);
			_output.Append('"');
		}

		private void WriteString(string s)
		{
			_output.Append('"');
			int num = -1;
			int length = s.Length;
			for (int i = 0; i < length; i++)
			{
				char c = s[i];
				if (_useEscapedUnicode)
				{
					if (c >= ' ' && c < '\u0080' && c != '"' && c != '\\')
					{
						if (num == -1)
						{
							num = i;
						}
						continue;
					}
				}
				else if (c != '\t' && c != '\n' && c != '\r' && c != '"' && c != '\\' && c != 0)
				{
					if (num == -1)
					{
						num = i;
					}
					continue;
				}
				if (num != -1)
				{
					_output.Append(s, num, i - num);
					num = -1;
				}
				switch (c)
				{
				case '\t':
					_output.Append('\\').Append('t');
					continue;
				case '\r':
					_output.Append('\\').Append('r');
					continue;
				case '\n':
					_output.Append('\\').Append('n');
					continue;
				case '"':
				case '\\':
					_output.Append('\\');
					_output.Append(c);
					continue;
				case '\0':
					_output.Append("\\u0000");
					continue;
				}
				if (_useEscapedUnicode)
				{
					_output.Append("\\u");
					StringBuilder output = _output;
					int num2 = c;
					output.Append(num2.ToString("X4", NumberFormatInfo.InvariantInfo));
				}
				else
				{
					_output.Append(c);
				}
			}
			if (num != -1)
			{
				_output.Append(s, num, s.Length - num);
			}
			_output.Append('"');
		}
	}
	public sealed class JSONParameters
	{
		public bool UseOptimizedDatasetSchema = true;

		public bool UseFastGuid = true;

		public bool SerializeNullValues = true;

		public bool UseUTCDateTime = true;

		public bool ShowReadOnlyProperties;

		public bool UsingGlobalTypes = true;

		[Obsolete("Not needed anymore and will always match")]
		public bool IgnoreCaseOnDeserialize;

		public bool EnableAnonymousTypes;

		public bool UseExtensions = true;

		public bool UseEscapedUnicode = true;

		public bool KVStyleStringDictionary;

		public bool UseValuesOfEnums;

		public List<Type> IgnoreAttributes = new List<Type>
		{
			typeof(XmlIgnoreAttribute),
			typeof(NonSerializedAttribute)
		};

		public bool ParametricConstructorOverride;

		public bool DateTimeMilliseconds;

		public byte SerializerMaxDepth = 20;

		public bool InlineCircularReferences;

		public bool SerializeToLowerCaseNames;

		public byte FormatterIndentSpaces = 3;

		public bool AllowNonQuotedKeys;

		public bool AutoConvertStringToNumbers = true;

		public bool OverrideObjectHashCodeChecking;

		[Obsolete("Racist term removed, please use BadListTypeChecking")]
		public bool BlackListTypeChecking = true;

		public bool BadListTypeChecking = true;

		public bool FullyQualifiedDataSetSchema;

		public void FixValues()
		{
			if (!UseExtensions)
			{
				UsingGlobalTypes = false;
				InlineCircularReferences = true;
			}
			if (EnableAnonymousTypes)
			{
				ShowReadOnlyProperties = true;
			}
		}

		public JSONParameters MakeCopy()
		{
			return new JSONParameters
			{
				AllowNonQuotedKeys = AllowNonQuotedKeys,
				DateTimeMilliseconds = DateTimeMilliseconds,
				EnableAnonymousTypes = EnableAnonymousTypes,
				FormatterIndentSpaces = FormatterIndentSpaces,
				IgnoreAttributes = new List<Type>(IgnoreAttributes),
				InlineCircularReferences = InlineCircularReferences,
				KVStyleStringDictionary = KVStyleStringDictionary,
				ParametricConstructorOverride = ParametricConstructorOverride,
				SerializeNullValues = SerializeNullValues,
				SerializerMaxDepth = SerializerMaxDepth,
				SerializeToLowerCaseNames = SerializeToLowerCaseNames,
				ShowReadOnlyProperties = ShowReadOnlyProperties,
				UseEscapedUnicode = UseEscapedUnicode,
				UseExtensions = UseExtensions,
				UseFastGuid = UseFastGuid,
				UseOptimizedDatasetSchema = UseOptimizedDatasetSchema,
				UseUTCDateTime = UseUTCDateTime,
				UseValuesOfEnums = UseValuesOfEnums,
				UsingGlobalTypes = UsingGlobalTypes,
				AutoConvertStringToNumbers = AutoConvertStringToNumbers,
				OverrideObjectHashCodeChecking = OverrideObjectHashCodeChecking,
				FullyQualifiedDataSetSchema = FullyQualifiedDataSetSchema,
				BadListTypeChecking = BadListTypeChecking
			};
		}
	}
	public static class JSON
	{
		public static JSONParameters Parameters = new JSONParameters();

		public static string ToNiceJSON(object obj)
		{
			string input = ToJSON(obj, Parameters);
			return Beautify(input);
		}

		public static string ToNiceJSON(object obj, JSONParameters param)
		{
			string input = ToJSON(obj, param);
			return Beautify(input, param.FormatterIndentSpaces);
		}

		public static string ToJSON(object obj)
		{
			return ToJSON(obj, Parameters);
		}

		public static string ToJSON(object obj, JSONParameters param)
		{
			param.FixValues();
			param = param.MakeCopy();
			Type c = null;
			if (obj == null)
			{
				return "null";
			}
			if (obj.GetType().IsGenericType)
			{
				c = Reflection.Instance.GetGenericTypeDefinition(obj.GetType());
			}
			if (typeof(IDictionary).IsAssignableFrom(c) || typeof(List<>).IsAssignableFrom(c))
			{
				param.UsingGlobalTypes = false;
			}
			if (param.EnableAnonymousTypes)
			{
				param.UseExtensions = false;
				param.UsingGlobalTypes = false;
			}
			return new JSONSerializer(param).ConvertToJSON(obj);
		}

		public static object Parse(string json)
		{
			return new JsonParser(json, Parameters.AllowNonQuotedKeys).Decode(null);
		}

		public static dynamic ToDynamic(string json)
		{
			return new DynamicJson(json);
		}

		public static T ToObject<T>(string json)
		{
			return new deserializer(Parameters).ToObject<T>(json);
		}

		public static T ToObject<T>(string json, JSONParameters param)
		{
			return new deserializer(param).ToObject<T>(json);
		}

		public static object ToObject(string json)
		{
			return new deserializer(Parameters).ToObject(json, null);
		}

		public static object ToObject(string json, JSONParameters param)
		{
			return new deserializer(param).ToObject(json, null);
		}

		public static object ToObject(string json, Type type)
		{
			return new deserializer(Parameters).ToObject(json, type);
		}

		public static object ToObject(string json, Type type, JSONParameters par)
		{
			return new deserializer(par).ToObject(json, type);
		}

		public static object FillObject(object input, string json)
		{
			if (!(new JsonParser(json, Parameters.AllowNonQuotedKeys).Decode(input.GetType()) is Dictionary<string, object> d))
			{
				return null;
			}
			return new deserializer(Parameters).ParseDictionary(d, null, input.GetType(), input);
		}

		public static object DeepCopy(object obj)
		{
			return new deserializer(Parameters).ToObject(ToJSON(obj));
		}

		public static T DeepCopy<T>(T obj)
		{
			return new deserializer(Parameters).ToObject<T>(ToJSON(obj));
		}

		public static string Beautify(string input)
		{
			string spaces = new string(' ', Parameters.FormatterIndentSpaces);
			return Formatter.PrettyPrint(input, spaces);
		}

		public static string Beautify(string input, byte spaces)
		{
			string spaces2 = new string(' ', spaces);
			return Formatter.PrettyPrint(input, spaces2);
		}

		public static void RegisterCustomType(Type type, Reflection.Serialize serializer, Reflection.Deserialize deserializer)
		{
			Reflection.Instance.RegisterCustomType(type, serializer, deserializer);
		}

		public static void ClearReflectionCache()
		{
			Reflection.Instance.ClearReflectionCache();
		}
	}
	internal class deserializer
	{
		private JSONParameters _params;

		private bool _usingglobals;

		private Dictionary<object, int> _circobj;

		private Dictionary<int, object> _cirrev = new Dictionary<int, object>();

		public deserializer(JSONParameters param)
		{
			if (param.OverrideObjectHashCodeChecking)
			{
				_circobj = new Dictionary<object, int>(10, ReferenceEqualityComparer.Default);
			}
			else
			{
				_circobj = new Dictionary<object, int>();
			}
			param.FixValues();
			_params = param.MakeCopy();
		}

		public T ToObject<T>(string json)
		{
			Type typeFromHandle = typeof(T);
			object obj = ToObject(json, typeFromHandle);
			if (typeFromHandle.IsArray)
			{
				if ((obj as ICollection).Count == 0)
				{
					Type elementType = typeFromHandle.GetElementType();
					object obj2 = Array.CreateInstance(elementType, 0);
					return (T)obj2;
				}
				return (T)obj;
			}
			return (T)obj;
		}

		public object ToObject(string json)
		{
			return ToObject(json, null);
		}

		public object ToObject(string json, Type type)
		{
			Type type2 = null;
			if (type != null && type.IsGenericType)
			{
				type2 = Reflection.Instance.GetGenericTypeDefinition(type);
			}
			_usingglobals = _params.UsingGlobalTypes;
			if (typeof(IDictionary).IsAssignableFrom(type2) || typeof(List<>).IsAssignableFrom(type2))
			{
				_usingglobals = false;
			}
			object obj = new JsonParser(json, _params.AllowNonQuotedKeys).Decode(type);
			if (obj == null)
			{
				return null;
			}
			if (obj is IDictionary)
			{
				if (type != null && typeof(Dictionary<, >).IsAssignableFrom(type2))
				{
					return RootDictionary(obj, type);
				}
				return ParseDictionary(obj as Dictionary<string, object>, null, type, null);
			}
			if (obj is List<object>)
			{
				if (!(type != null))
				{
					List<object> list = (List<object>)obj;
					if (list.Count > 0 && list[0].GetType() == typeof(Dictionary<string, object>))
					{
						Dictionary<string, object> globaltypes = new Dictionary<string, object>();
						List<object> list2 = new List<object>();
						{
							foreach (object item in list)
							{
								list2.Add(ParseDictionary((Dictionary<string, object>)item, globaltypes, null, null));
							}
							return list2;
						}
					}
					return list.ToArray();
				}
				if (typeof(Dictionary<, >).IsAssignableFrom(type2))
				{
					return RootDictionary(obj, type);
				}
				if (type2 == typeof(List<>))
				{
					return RootList(obj, type);
				}
				if (type.IsArray)
				{
					return RootArray(obj, type);
				}
				if (type == typeof(Hashtable))
				{
					return RootHashTable((List<object>)obj);
				}
			}
			else if (type != null && obj.GetType() != type)
			{
				return ChangeType(obj, type);
			}
			return obj;
		}

		private object RootHashTable(List<object> o)
		{
			Hashtable hashtable = new Hashtable();
			foreach (Dictionary<string, object> item in o)
			{
				object obj = item["k"];
				object obj2 = item["v"];
				if (obj is Dictionary<string, object>)
				{
					obj = ParseDictionary((Dictionary<string, object>)obj, null, typeof(object), null);
				}
				if (obj2 is Dictionary<string, object>)
				{
					obj2 = ParseDictionary((Dictionary<string, object>)obj2, null, typeof(object), null);
				}
				hashtable.Add(obj, obj2);
			}
			return hashtable;
		}

		private object ChangeType(object value, Type conversionType)
		{
			if (conversionType == typeof(object))
			{
				return value;
			}
			if (conversionType == typeof(int))
			{
				if (!(value is string text))
				{
					return (int)(long)value;
				}
				if (_params.AutoConvertStringToNumbers)
				{
					return Helper.CreateInteger(text, 0, text.Length);
				}
				throw new Exception("AutoConvertStringToNumbers is disabled for converting string : " + value);
			}
			if (conversionType == typeof(long))
			{
				if (!(value is string text2))
				{
					return (long)value;
				}
				if (_params.AutoConvertStringToNumbers)
				{
					return Helper.CreateLong(text2, 0, text2.Length);
				}
				throw new Exception("AutoConvertStringToNumbers is disabled for converting string : " + value);
			}
			if (conversionType == typeof(string))
			{
				return (string)value;
			}
			if (conversionType.IsEnum)
			{
				return Helper.CreateEnum(conversionType, value);
			}
			if (conversionType == typeof(DateTime))
			{
				return Helper.CreateDateTime((string)value, _params.UseUTCDateTime);
			}
			if (conversionType == typeof(DateTimeOffset))
			{
				return Helper.CreateDateTimeOffset((string)value);
			}
			if (Reflection.Instance.IsTypeRegistered(conversionType))
			{
				return Reflection.Instance.CreateCustom((string)value, conversionType);
			}
			if (Helper.IsNullable(conversionType))
			{
				if (value == null)
				{
					return value;
				}
				conversionType = Helper.UnderlyingTypeOf(conversionType);
			}
			if (conversionType == typeof(Guid))
			{
				return Helper.CreateGuid((string)value);
			}
			if (conversionType == typeof(byte[]))
			{
				return Convert.FromBase64String((string)value);
			}
			if (conversionType == typeof(TimeSpan))
			{
				return new TimeSpan((long)value);
			}
			return Convert.ChangeType(value, conversionType, CultureInfo.InvariantCulture);
		}

		private object RootList(object parse, Type type)
		{
			Type[] genericArguments = Reflection.Instance.GetGenericArguments(type);
			IList list = (IList)Reflection.Instance.FastCreateList(type, ((IList)parse).Count);
			DoParseList((IList)parse, genericArguments[0], list);
			return list;
		}

		private void DoParseList(IList parse, Type it, IList o)
		{
			Dictionary<string, object> globaltypes = new Dictionary<string, object>();
			foreach (object item in parse)
			{
				_usingglobals = false;
				object obj = item;
				obj = ((!(item is Dictionary<string, object> d)) ? ChangeType(item, it) : ParseDictionary(d, globaltypes, it, null));
				o.Add(obj);
			}
		}

		private object RootArray(object parse, Type type)
		{
			Type elementType = type.GetElementType();
			IList list = (IList)Reflection.Instance.FastCreateInstance(typeof(List<>).MakeGenericType(elementType));
			DoParseList((IList)parse, elementType, list);
			Array array = Array.CreateInstance(elementType, list.Count);
			list.CopyTo(array, 0);
			return array;
		}

		private object RootDictionary(object parse, Type type)
		{
			Type[] genericArguments = Reflection.Instance.GetGenericArguments(type);
			Type type2 = null;
			Type type3 = null;
			bool flag = false;
			if (genericArguments != null)
			{
				type2 = genericArguments[0];
				type3 = genericArguments[1];
				if (type3 != null)
				{
					flag = type3.Name.StartsWith("Dictionary");
				}
			}
			Type elementType = type3.GetElementType();
			if (parse is Dictionary<string, object>)
			{
				IDictionary dictionary = (IDictionary)Reflection.Instance.FastCreateInstance(type);
				{
					foreach (KeyValuePair<string, object> item in (Dictionary<string, object>)parse)
					{
						object key = ChangeType(item.Key, type2);
						object value = ((!flag) ? ((!(item.Value is Dictionary<string, object>)) ? ((type3.IsArray && type3 != typeof(byte[])) ? CreateArray((List<object>)item.Value, type3, elementType, null) : ((!(item.Value is IList)) ? ChangeType(item.Value, type3) : CreateGenericList((List<object>)item.Value, type3, type2, null))) : ParseDictionary(item.Value as Dictionary<string, object>, null, type3, null)) : RootDictionary(item.Value, type3));
						dictionary.Add(key, value);
					}
					return dictionary;
				}
			}
			if (parse is List<object>)
			{
				return CreateDictionary(parse as List<object>, type, genericArguments, null);
			}
			return null;
		}

		internal object ParseDictionary(Dictionary<string, object> d, Dictionary<string, object> globaltypes, Type type, object input)
		{
			object value = "";
			if (type == typeof(NameValueCollection))
			{
				return Helper.CreateNV(d);
			}
			if (type == typeof(StringDictionary))
			{
				return Helper.CreateSD(d);
			}
			if (d.TryGetValue("$i", out value))
			{
				object value2 = null;
				_cirrev.TryGetValue((int)(long)value, out value2);
				return value2;
			}
			if (d.TryGetValue("$types", out value))
			{
				_usingglobals = true;
				if (globaltypes == null)
				{
					globaltypes = new Dictionary<string, object>();
				}
				foreach (KeyValuePair<string, object> item in (Dictionary<string, object>)value)
				{
					globaltypes.Add((string)item.Value, item.Key);
				}
			}
			if (globaltypes != null)
			{
				_usingglobals = true;
			}
			bool flag = d.TryGetValue("$type", out value);
			if (!flag && type == typeof(object))
			{
				return d;
			}
			if (flag)
			{
				if (_usingglobals)
				{
					object value3 = "";
					if (globaltypes != null && globaltypes.TryGetValue((string)value, out value3))
					{
						value = value3;
					}
				}
				type = Reflection.Instance.GetTypeFromCache((string)value, _params.BadListTypeChecking);
			}
			if (type == null)
			{
				throw new Exception("Cannot determine type : " + value);
			}
			string fullName = type.FullName;
			object obj = input;
			if (obj == null)
			{
				obj = ((!_params.ParametricConstructorOverride) ? Reflection.Instance.FastCreateInstance(type) : FormatterServices.GetUninitializedObject(type));
			}
			int value4 = 0;
			if (!_circobj.TryGetValue(obj, out value4))
			{
				value4 = _circobj.Count + 1;
				_circobj.Add(obj, value4);
				_cirrev.Add(value4, obj);
			}
			Dictionary<string, myPropInfo> dictionary = Reflection.Instance.Getproperties(type, fullName, _params.ShowReadOnlyProperties);
			foreach (KeyValuePair<string, object> item2 in d)
			{
				string key = item2.Key;
				object value5 = item2.Value;
				string text = key;
				if (text == "$map")
				{
					ProcessMap(obj, dictionary, (Dictionary<string, object>)d[text]);
				}
				else
				{
					if ((!dictionary.TryGetValue(text, out var value6) && !dictionary.TryGetValue(text.ToLowerInvariant(), out value6)) || !value6.CanWrite)
					{
						continue;
					}
					object value7 = null;
					if (value5 != null)
					{
						switch (value6.Type)
						{
						case myPropInfoType.Int:
							value7 = (int)Helper.AutoConv(value5, _params);
							break;
						case myPropInfoType.Long:
							value7 = Helper.AutoConv(value5, _params);
							break;
						case myPropInfoType.String:
							value7 = value5.ToString();
							break;
						case myPropInfoType.Bool:
							value7 = Helper.BoolConv(value5);
							break;
						case myPropInfoType.DateTime:
							value7 = Helper.CreateDateTime((string)value5, _params.UseUTCDateTime);
							break;
						case myPropInfoType.Enum:
							value7 = Helper.CreateEnum(value6.pt, value5);
							break;
						case myPropInfoType.Guid:
							value7 = Helper.CreateGuid((string)value5);
							break;
						case myPropInfoType.Array:
							if (!value6.IsValueType)
							{
								value7 = CreateArray((List<object>)value5, value6.pt, value6.bt, globaltypes);
							}
							break;
						case myPropInfoType.ByteArray:
							value7 = Convert.FromBase64String((string)value5);
							break;
						case myPropInfoType.Dictionary:
							value7 = CreateDictionary((List<object>)value5, value6.pt, value6.GenericTypes, globaltypes);
							break;
						case myPropInfoType.StringKeyDictionary:
							value7 = CreateStringKeyDictionary((Dictionary<string, object>)value5, value6.pt, value6.GenericTypes, globaltypes);
							break;
						case myPropInfoType.NameValue:
							value7 = Helper.CreateNV((Dictionary<string, object>)value5);
							break;
						case myPropInfoType.StringDictionary:
							value7 = Helper.CreateSD((Dictionary<string, object>)value5);
							break;
						case myPropInfoType.Custom:
							value7 = Reflection.Instance.CreateCustom((string)value5, value6.pt);
							break;
						default:
							value7 = ((value6.IsGenericType && !value6.IsValueType && value5 is List<object>) ? CreateGenericList((List<object>)value5, value6.pt, value6.bt, globaltypes) : (((value6.IsClass || value6.IsStruct || value6.IsInterface) && value5 is Dictionary<string, object>) ? ParseDictionary((Dictionary<string, object>)value5, globaltypes, value6.pt, null) : ((!(value5 is List<object>)) ? ((!value6.IsValueType) ? value5 : ChangeType(value5, value6.changeType)) : CreateArray((List<object>)value5, value6.pt, typeof(object), globaltypes))));
							break;
						}
					}
					obj = value6.setter(obj, value7);
				}
			}
			return obj;
		}

		private static void ProcessMap(object obj, Dictionary<string, myPropInfo> props, Dictionary<string, object> dic)
		{
			foreach (KeyValuePair<string, object> item in dic)
			{
				myPropInfo myPropInfo2 = props[item.Key];
				object obj2 = myPropInfo2.getter(obj);
				Type typeFromCache = Reflection.Instance.GetTypeFromCache((string)item.Value, badlistChecking: true);
				if (typeFromCache == typeof(Guid))
				{
					myPropInfo2.setter(obj, Helper.CreateGuid((string)obj2));
				}
			}
		}

		private object CreateArray(List<object> data, Type pt, Type bt, Dictionary<string, object> globalTypes)
		{
			if (bt == null)
			{
				bt = typeof(object);
			}
			Array array = Array.CreateInstance(bt, data.Count);
			Type elementType = bt.GetElementType();
			for (int i = 0; i < data.Count; i++)
			{
				object obj = data[i];
				if (obj != null)
				{
					if (obj is IDictionary)
					{
						array.SetValue(ParseDictionary((Dictionary<string, object>)obj, globalTypes, bt, null), i);
					}
					else if (obj is ICollection)
					{
						array.SetValue(CreateArray((List<object>)obj, bt, elementType, globalTypes), i);
					}
					else
					{
						array.SetValue(ChangeType(obj, bt), i);
					}
				}
			}
			return array;
		}

		private object CreateGenericList(List<object> data, Type pt, Type bt, Dictionary<string, object> globalTypes)
		{
			if (pt != typeof(object))
			{
				IList list = (IList)Reflection.Instance.FastCreateList(pt, data.Count);
				Type type = Reflection.Instance.GetGenericArguments(pt)[0];
				{
					foreach (object datum in data)
					{
						if (datum is IDictionary)
						{
							list.Add(ParseDictionary((Dictionary<string, object>)datum, globalTypes, type, null));
						}
						else if (datum is List<object>)
						{
							if (bt.IsGenericType)
							{
								list.Add((List<object>)datum);
							}
							else
							{
								list.Add(((List<object>)datum).ToArray());
							}
						}
						else
						{
							list.Add(ChangeType(datum, type));
						}
					}
					return list;
				}
			}
			return data;
		}

		private object CreateStringKeyDictionary(Dictionary<string, object> reader, Type pt, Type[] types, Dictionary<string, object> globalTypes)
		{
			IDictionary dictionary = (IDictionary)Reflection.Instance.FastCreateInstance(pt);
			Type type = null;
			Type type2 = null;
			if (types != null)
			{
				type2 = types[1];
			}
			Type bt = null;
			Type[] genericArguments = Reflection.Instance.GetGenericArguments(type2);
			if (genericArguments.Length != 0)
			{
				bt = genericArguments[0];
			}
			type = type2.GetElementType();
			foreach (KeyValuePair<string, object> item in reader)
			{
				string key = item.Key;
				object obj = null;
				obj = ((!(item.Value is Dictionary<string, object>)) ? ((types != null && type2.IsArray) ? ((!(item.Value is Array)) ? CreateArray((List<object>)item.Value, type2, type, globalTypes) : item.Value) : ((!(item.Value is IList)) ? ChangeType(item.Value, type2) : CreateGenericList((List<object>)item.Value, type2, bt, globalTypes))) : ParseDictionary((Dictionary<string, object>)item.Value, globalTypes, type2, null));
				dictionary.Add(key, obj);
			}
			return dictionary;
		}

		private object CreateDictionary(List<object> reader, Type pt, Type[] types, Dictionary<string, object> globalTypes)
		{
			IDictionary dictionary = (IDictionary)Reflection.Instance.FastCreateInstance(pt);
			Type type = null;
			Type type2 = null;
			Type bt = null;
			if (types != null)
			{
				type = types[0];
				type2 = types[1];
			}
			Type bt2 = type2;
			if (type2 != null)
			{
				Type[] genericArguments = Reflection.Instance.GetGenericArguments(type2);
				if (genericArguments.Length != 0)
				{
					bt = genericArguments[0];
				}
				bt2 = type2.GetElementType();
			}
			bool flag = typeof(IDictionary).IsAssignableFrom(type2);
			foreach (Dictionary<string, object> item in reader)
			{
				object obj = item["k"];
				object obj2 = item["v"];
				obj = ((!(obj is Dictionary<string, object>)) ? ChangeType(obj, type) : ParseDictionary((Dictionary<string, object>)obj, globalTypes, type, null));
				obj2 = ((!flag) ? ((!(obj2 is Dictionary<string, object>)) ? ((types != null && type2.IsArray) ? CreateArray((List<object>)obj2, type2, bt2, globalTypes) : ((!(obj2 is IList)) ? ChangeType(obj2, type2) : CreateGenericList((List<object>)obj2, type2, bt, globalTypes))) : ParseDictionary((Dictionary<string, object>)obj2, globalTypes, type2, null)) : RootDictionary(obj2, type2));
				dictionary.Add(obj, obj2);
			}
			return dictionary;
		}
	}
	internal sealed class JsonParser
	{
		private enum Token
		{
			None = -1,
			Curly_Open,
			Curly_Close,
			Squared_Open,
			Squared_Close,
			Colon,
			Comma,
			String,
			Number,
			True,
			False,
			Null,
			PosInfinity,
			NegInfinity,
			NaN
		}

		private readonly char[] json;

		private readonly StringBuilder s = new StringBuilder();

		private Token lookAheadToken = Token.None;

		private int index;

		private bool allownonquotedkey;

		private int _len;

		private SafeDictionary<string, bool> _lookup;

		private SafeDictionary<Type, bool> _seen;

		private bool _parseJsonType;

		private bool _parseType;

		internal JsonParser(string json, bool AllowNonQuotedKeys)
		{
			allownonquotedkey = AllowNonQuotedKeys;
			this.json = json.ToCharArray();
			_len = json.Length;
		}

		private void SetupLookup()
		{
			_lookup = new SafeDictionary<string, bool>();
			_seen = new SafeDictionary<Type, bool>();
			_lookup.Add("$types", value: true);
			_lookup.Add("$type", value: true);
			_lookup.Add("$i", value: true);
			_lookup.Add("$map", value: true);
			_lookup.Add("$schema", value: true);
			_lookup.Add("k", value: true);
			_lookup.Add("v", value: true);
		}

		public unsafe object Decode(Type objtype)
		{
			fixed (char* p = json)
			{
				if (objtype != null && !CheckForTypeInJson(p))
				{
					_parseJsonType = true;
					SetupLookup();
					BuildLookup(objtype);
					if (!_parseJsonType || _lookup.Count() == 7)
					{
						_lookup = null;
					}
				}
				return ParseValue(p);
			}
		}

		private unsafe bool CheckForTypeInJson(char* p)
		{
			int i = 0;
			for (int num = ((_len > 1000) ? 1000 : _len); i < num; i++)
			{
				if (p[i] == '$' && p[i + 1] == 't' && p[i + 2] == 'y' && p[i + 3] == 'p' && p[i + 4] == 'e' && p[i + 5] == 's')
				{
					return true;
				}
			}
			return false;
		}

		private void BuildGenericTypeLookup(Type t)
		{
			if (_seen.TryGetValue(t, out var _))
			{
				return;
			}
			Type[] genericArguments = t.GetGenericArguments();
			foreach (Type type in genericArguments)
			{
				if (!type.IsPrimitive)
				{
					bool flag = type.IsValueType && !type.IsEnum;
					if ((type.IsClass || flag || type.IsAbstract) && type != typeof(string) && type != typeof(DateTime) && type != typeof(Guid))
					{
						BuildLookup(type);
					}
				}
			}
		}

		private void BuildArrayTypeLookup(Type t)
		{
			if (!_seen.TryGetValue(t, out var _))
			{
				bool flag = t.IsValueType && !t.IsEnum;
				if ((t.IsClass || flag) && t != typeof(string) && t != typeof(DateTime) && t != typeof(Guid))
				{
					BuildLookup(t.GetElementType());
				}
			}
		}

		private void BuildLookup(Type objtype)
		{
			if (objtype == null || objtype == typeof(NameValueCollection) || objtype == typeof(StringDictionary) || typeof(IDictionary).IsAssignableFrom(objtype) || _seen.TryGetValue(objtype, out var _))
			{
				return;
			}
			if (objtype.IsGenericType)
			{
				BuildGenericTypeLookup(objtype);
				return;
			}
			if (objtype.IsArray)
			{
				BuildArrayTypeLookup(objtype);
				return;
			}
			_seen.Add(objtype, value: true);
			foreach (KeyValuePair<string, myPropInfo> item in Reflection.Instance.Getproperties(objtype, objtype.FullName, ShowReadOnlyProperties: true))
			{
				Type pt = item.Value.pt;
				_lookup.Add(item.Key, value: true);
				if (pt.IsArray)
				{
					BuildArrayTypeLookup(pt);
				}
				if (pt.IsGenericType)
				{
					if (typeof(IDictionary).IsAssignableFrom(pt))
					{
						_parseJsonType = false;
						break;
					}
					BuildGenericTypeLookup(pt);
				}
				if (pt.FullName.IndexOf("System.") == -1)
				{
					BuildLookup(pt);
				}
			}
		}

		private bool InLookup(string name)
		{
			if (_lookup == null)
			{
				return true;
			}
			bool value;
			return _lookup.TryGetValue(name.ToLowerInvariant(), out value);
		}

		private unsafe Dictionary<string, object> ParseObject(char* p)
		{
			Dictionary<string, object> dictionary = new Dictionary<string, object>();
			ConsumeToken();
			while (true)
			{
				switch (LookAhead(p))
				{
				case Token.Comma:
					ConsumeToken();
					continue;
				case Token.Curly_Close:
					ConsumeToken();
					return dictionary;
				}
				string text = ParseKey(p);
				Token token = NextToken(p);
				if (token != Token.Colon)
				{
					throw new Exception("Expected colon at index " + index);
				}
				if (_parseJsonType)
				{
					if (text == "$types")
					{
						_parseType = true;
						Dictionary<string, object> dictionary2 = (Dictionary<string, object>)ParseValue(p);
						_parseType = false;
						if (_lookup == null)
						{
							SetupLookup();
						}
						foreach (string key in dictionary2.Keys)
						{
							BuildLookup(Reflection.Instance.GetTypeFromCache(key, badlistChecking: true));
						}
						dictionary[text] = dictionary2;
					}
					else if (text == "$schema")
					{
						_parseType = true;
						object value = ParseValue(p);
						_parseType = false;
						dictionary[text] = value;
					}
					else if (_parseType || InLookup(text))
					{
						dictionary[text] = ParseValue(p);
					}
					else
					{
						SkipValue(p);
					}
				}
				else
				{
					dictionary[text] = ParseValue(p);
				}
			}
		}

		private unsafe void SkipValue(char* p)
		{
			switch (LookAhead(p))
			{
			case Token.Number:
				ParseNumber(p, skip: true);
				break;
			case Token.String:
				SkipString(p);
				break;
			case Token.Curly_Open:
				SkipObject(p);
				break;
			case Token.Squared_Open:
				SkipArray(p);
				break;
			case Token.True:
			case Token.False:
			case Token.Null:
			case Token.PosInfinity:
			case Token.NegInfinity:
			case Token.NaN:
				ConsumeToken();
				break;
			case Token.Curly_Close:
			case Token.Squared_Close:
			case Token.Colon:
			case Token.Comma:
				break;
			}
		}

		private unsafe void SkipObject(char* p)
		{
			ConsumeToken();
			while (true)
			{
				switch (LookAhead(p))
				{
				case Token.Comma:
					ConsumeToken();
					continue;
				case Token.Curly_Close:
					ConsumeToken();
					return;
				}
				SkipString(p);
				Token token = NextToken(p);
				if (token != Token.Colon)
				{
					throw new Exception("Expected colon at index " + index);
				}
				SkipValue(p);
			}
		}

		private unsafe void SkipArray(char* p)
		{
			ConsumeToken();
			while (true)
			{
				switch (LookAhead(p))
				{
				case Token.Comma:
					ConsumeToken();
					break;
				case Token.Squared_Close:
					ConsumeToken();
					return;
				default:
					SkipValue(p);
					break;
				}
			}
		}

		private unsafe void SkipString(char* p)
		{
			ConsumeToken();
			int len = _len;
			while (index < len)
			{
				switch (p[index++])
				{
				case '"':
					return;
				case '\\':
				{
					char c = p[index++];
					if (c == 'u')
					{
						index += 4;
					}
					break;
				}
				}
			}
		}

		private unsafe List<object> ParseArray(char* p)
		{
			List<object> list = new List<object>();
			ConsumeToken();
			while (true)
			{
				switch (LookAhead(p))
				{
				case Token.Comma:
					ConsumeToken();
					break;
				case Token.Squared_Close:
					ConsumeToken();
					return list;
				default:
					list.Add(ParseValue(p));
					break;
				}
			}
		}

		private unsafe object ParseValue(char* p)
		{
			switch (LookAhead(p))
			{
			case Token.Number:
				return ParseNumber(p, skip: false);
			case Token.String:
				return ParseString(p);
			case Token.Curly_Open:
				return ParseObject(p);
			case Token.Squared_Open:
				return ParseArray(p);
			case Token.True:
				ConsumeToken();
				return true;
			case Token.False:
				ConsumeToken();
				return false;
			case Token.Null:
				ConsumeToken();
				return null;
			case Token.PosInfinity:
				ConsumeToken();
				return double.PositiveInfinity;
			case Token.NegInfinity:
				ConsumeToken();
				return double.NegativeInfinity;
			case Token.NaN:
				ConsumeToken();
				return double.NaN;
			default:
				throw new Exception("Unrecognized token at index " + index);
			}
		}

		private unsafe string ParseKey(char* p)
		{
			if (!allownonquotedkey || p[index - 1] == '"')
			{
				return ParseString(p);
			}
			ConsumeToken();
			int len = _len;
			int num = 0;
			while (index + num < len)
			{
				char c = p[index + num++];
				if (c == ':')
				{
					string result = UnsafeSubstring(p, index, num - 1).Trim();
					index += num - 1;
					return result;
				}
			}
			throw new Exception("Unable to read key");
		}

		private unsafe string ParseString(char* p)
		{
			char c = p[index - 1];
			ConsumeToken();
			if (s.Length > 0)
			{
				s.Length = 0;
			}
			int len = _len;
			int num = 0;
			while (index + num < len)
			{
				char c2 = p[index + num++];
				if (c2 == '\\')
				{
					break;
				}
				if (c2 == c)
				{
					string result = UnsafeSubstring(p, index, num - 1);
					index += num;
					return result;
				}
			}
			while (index < len)
			{
				char c3 = p[index++];
				if (c3 == c)
				{
					return s.ToString();
				}
				if (c3 != '\\')
				{
					s.Append(c3);
					continue;
				}
				c3 = p[index++];
				switch (c3)
				{
				case 'b':
					s.Append('\b');
					continue;
				case 'f':
					s.Append('\f');
					continue;
				case 'n':
					s.Append('\n');
					continue;
				case 'r':
					s.Append('\r');
					continue;
				case 't':
					s.Append('\t');
					continue;
				case 'u':
				{
					uint num2 = ParseUnicode(p[index], p[index + 1], p[index + 2], p[index + 3]);
					s.Append((char)num2);
					index += 4;
					continue;
				}
				}
				if (c3 == '\r' || c3 == '\n' || c3 == ' ' || c3 == '\t')
				{
					while (c3 == '\r' || c3 == '\n' || c3 == ' ' || c3 == '\t')
					{
						index++;
						c3 = p[index];
						if (c3 == '\r' || c3 == '\n')
						{
							c3 = p[index + 1];
							if (c3 == '\r' || c3 == '\n')
							{
								index += 2;
								c3 = p[index];
							}
							break;
						}
					}
				}
				else
				{
					s.Append(c3);
				}
			}
			return s.ToString();
		}

		private unsafe string ParseJson5String(char* p)
		{
			throw new NotImplementedException();
		}

		private uint ParseSingleChar(char c1, uint multipliyer)
		{
			uint result = 0u;
			if (c1 >= '0' && c1 <= '9')
			{
				result = (uint)(c1 - 48) * multipliyer;
			}
			else if (c1 >= 'A' && c1 <= 'F')
			{
				result = (uint)(c1 - 65 + 10) * multipliyer;
			}
			else if (c1 >= 'a' && c1 <= 'f')
			{
				result = (uint)(c1 - 97 + 10) * multipliyer;
			}
			return result;
		}

		private uint ParseUnicode(char c1, char c2, char c3, char c4)
		{
			uint num = ParseSingleChar(c1, 4096u);
			uint num2 = ParseSingleChar(c2, 256u);
			uint num3 = ParseSingleChar(c3, 16u);
			uint num4 = ParseSingleChar(c4, 1u);
			return num + num2 + num3 + num4;
		}

		private unsafe object ParseNumber(char* p, bool skip)
		{
			ConsumeToken();
			int num = index - 1;
			bool flag = false;
			bool flag2 = false;
			bool flag3 = true;
			if (p[num] == '.')
			{
				flag = true;
			}
			while (index != _len)
			{
				switch (p[index])
				{
				case 'X':
				case 'x':
					index++;
					return ReadHexNumber(p);
				case '+':
				case '-':
				case '0':
				case '1':
				case '2':
				case '3':
				case '4':
				case '5':
				case '6':
				case '7':
				case '8':
				case '9':
					index++;
					break;
				case 'E':
				case 'e':
					flag2 = true;
					index++;
					break;
				case '.':
					index++;
					flag = true;
					break;
				case 'N':
				case 'n':
					index += 3;
					return double.NaN;
				default:
					flag3 = false;
					break;
				}
				if (index == _len)
				{
					flag3 = false;
				}
				if (!flag3)
				{
					break;
				}
			}
			if (skip)
			{
				return 0;
			}
			int num2 = index - num;
			if (flag2 || num2 > 31)
			{
				string text = UnsafeSubstring(p, num, num2);
				return double.Parse(text, NumberFormatInfo.InvariantInfo);
			}
			if (!flag && num2 < 20)
			{
				return Helper.CreateLong(json, num, num2);
			}
			string text2 = UnsafeSubstring(p, num, num2);
			return decimal.Parse(text2, NumberFormatInfo.InvariantInfo);
		}

		private unsafe object ReadHexNumber(char* p)
		{
			long num = 0L;
			bool flag = true;
			while (flag && index < _len)
			{
				char c = p[index];
				switch (c)
				{
				case '0':
				case '1':
				case '2':
				case '3':
				case '4':
				case '5':
				case '6':
				case '7':
				case '8':
				case '9':
					index++;
					num = (num << 4) + (c - 48);
					break;
				case 'a':
				case 'b':
				case 'c':
				case 'd':
				case 'e':
				case 'f':
					index++;
					num = (num << 4) + (c - 97) + 10;
					break;
				case 'A':
				case 'B':
				case 'C':
				case 'D':
				case 'E':
				case 'F':
					index++;
					num = (num << 4) + (c - 65) + 10;
					break;
				default:
					flag = false;
					break;
				}
			}
			return num;
		}

		private unsafe Token LookAhead(char* p)
		{
			if (lookAheadToken != Token.None)
			{
				return lookAheadToken;
			}
			return lookAheadToken = NextTokenCore(p);
		}

		private void ConsumeToken()
		{
			lookAheadToken = Token.None;
		}

		private unsafe Token NextToken(char* p)
		{
			Token result = ((lookAheadToken != Token.None) ? lookAheadToken : NextTokenCore(p));
			lookAheadToken = Token.None;
			return result;
		}

		private unsafe void SkipWhitespace(char* p)
		{
			char c;
			do
			{
				c = p[index];
				if (c == '/' && p[index + 1] == '/')
				{
					index++;
					index++;
					do
					{
						c = p[index];
					}
					while (c != '\r' && c != '\n' && ++index < _len);
				}
				if (c != '/' || p[index + 1] != '*')
				{
					continue;
				}
				index++;
				index++;
				do
				{
					c = p[index];
					if (c == '*' && p[index + 1] == '/')
					{
						index += 2;
						c = p[index];
						break;
					}
				}
				while (++index < _len);
			}
			while ((c == ' ' || c == '\t' || c == '\n' || c == '\r') && ++index < _len);
		}

		private unsafe Token NextTokenCore(char* p)
		{
			int len = _len;
			SkipWhitespace(p);
			if (index == len)
			{
				throw new Exception("Reached end of string unexpectedly");
			}
			char c = p[index];
			index++;
			switch (c)
			{
			case '{':
				return Token.Curly_Open;
			case '}':
				return Token.Curly_Close;
			case '[':
				return Token.Squared_Open;
			case ']':
				return Token.Squared_Close;
			case ',':
				return Token.Comma;
			case '"':
			case '\'':
				return Token.String;
			case '-':
				if (p[index] == 'i' || p[index] == 'I')
				{
					index += 8;
					return Token.NegInfinity;
				}
				return Token.Number;
			case '+':
				if (p[index] == 'i' || p[index] == 'I')
				{
					index += 8;
					return Token.PosInfinity;
				}
				return Token.Number;
			case '.':
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
				return Token.Number;
			case ':':
				return Token.Colon;
			case 'I':
			case 'i':
				index += 7;
				return Token.PosInfinity;
			case 'f':
				if (len - index >= 4 && p[index] == 'a' && p[index + 1] == 'l' && p[index + 2] == 's' && p[index + 3] == 'e')
				{
					index += 4;
					return Token.False;
				}
				break;
			case 't':
				if (len - index >= 3 && p[index] == 'r' && p[index + 1] == 'u' && p[index + 2] == 'e')
				{
					index += 3;
					return Token.True;
				}
				break;
			case 'N':
			case 'n':
				if (len - index >= 3 && p[index] == 'u' && p[index + 1] == 'l' && p[index + 2] == 'l')
				{
					index += 3;
					return Token.Null;
				}
				if (len - index >= 2 && p[index] == 'a' && (p[index + 1] == 'n' || p[index + 1] == 'N'))
				{
					index += 2;
					return Token.NaN;
				}
				break;
			}
			if (allownonquotedkey)
			{
				index--;
				return Token.String;
			}
			throw new Exception("Could not find token at index " + --index + " got '" + p[index].ToString() + "'");
		}

		private unsafe static string UnsafeSubstring(char* p, int startIndex, int length)
		{
			return new string(p, startIndex, length);
		}
	}
	public struct Getters
	{
		public string Name;

		public string lcName;

		public string memberName;

		public Reflection.GenericGetter Getter;

		public bool ReadOnly;
	}
	public enum myPropInfoType
	{
		Int,
		Long,
		String,
		Bool,
		DateTime,
		Enum,
		Guid,
		Array,
		ByteArray,
		Dictionary,
		StringKeyDictionary,
		NameValue,
		StringDictionary,
		Hashtable,
		DataSet,
		DataTable,
		Custom,
		Unknown
	}
	public class myPropInfo
	{
		public Type pt;

		public Type bt;

		public Type changeType;

		public Reflection.GenericSetter setter;

		public Reflection.GenericGetter getter;

		public Type[] GenericTypes;

		public string Name;

		public string memberName;

		public myPropInfoType Type;

		public bool CanWrite;

		public bool IsClass;

		public bool IsValueType;

		public bool IsGenericType;

		public bool IsStruct;

		public bool IsInterface;
	}
	public sealed class Reflection
	{
		public delegate string Serialize(object data);

		public delegate object Deserialize(string data);

		public delegate object GenericSetter(object target, object value);

		public delegate object GenericGetter(object obj);

		private delegate object CreateObject();

		private delegate object CreateList(int capacity);

		private static readonly Reflection instance;

		public static bool RDBMode;

		private SafeDictionary<Type, string> _tyname = new SafeDictionary<Type, string>(10);

		private SafeDictionary<string, Type> _typecache = new SafeDictionary<string, Type>(10);

		private SafeDictionary<Type, CreateObject> _constrcache = new SafeDictionary<Type, CreateObject>(10);

		private SafeDictionary<Type, CreateList> _conlistcache = new SafeDictionary<Type, CreateList>(10);

		private SafeDictionary<Type, Getters[]> _getterscache = new SafeDictionary<Type, Getters[]>(10);

		private SafeDictionary<string, Dictionary<string, myPropInfo>> _propertycache = new SafeDictionary<string, Dictionary<string, myPropInfo>>(10);

		private SafeDictionary<Type, Type[]> _genericTypes = new SafeDictionary<Type, Type[]>(10);

		private SafeDictionary<Type, Type> _genericTypeDef = new SafeDictionary<Type, Type>(10);

		private static SafeDictionary<short, OpCode> _opCodes;

		private static List<string> _badlistTypes;

		private static UTF8Encoding utf8;

		internal SafeDictionary<Type, Serialize> _customSerializer = new SafeDictionary<Type, Serialize>();

		internal SafeDictionary<Type, Deserialize> _customDeserializer = new SafeDictionary<Type, Deserialize>();

		public static Reflection Instance => instance;

		static Reflection()
		{
			instance = new Reflection();
			RDBMode = false;
			_badlistTypes = new List<string> { "system.configuration.install.assemblyinstaller", "system.activities.presentation.workflowdesigner", "system.windows.resourcedictionary", "system.windows.data.objectdataprovider", "system.windows.forms.bindingsource", "microsoft.exchange.management.systemmanager.winforms.exchangesettingsprovider" };
			utf8 = new UTF8Encoding();
		}

		private Reflection()
		{
		}

		private static bool TryGetOpCode(short code, out OpCode opCode)
		{
			if (_opCodes != null)
			{
				return _opCodes.TryGetValue(code, out opCode);
			}
			SafeDictionary<short, OpCode> safeDictionary = new SafeDictionary<short, OpCode>();
			FieldInfo[] fields = typeof(OpCodes).GetFields(BindingFlags.Static | BindingFlags.Public);
			foreach (FieldInfo fieldInfo in fields)
			{
				if (typeof(OpCode).IsAssignableFrom(fieldInfo.FieldType))
				{
					OpCode value = (OpCode)fieldInfo.GetValue(null);
					if (value.OpCodeType != OpCodeType.Nternal)
					{
						safeDictionary.Add(value.Value, value);
					}
				}
			}
			_opCodes = safeDictionary;
			return _opCodes.TryGetValue(code, out opCode);
		}

		public static byte[] UTF8GetBytes(string str)
		{
			return utf8.GetBytes(str);
		}

		public static string UTF8GetString(byte[] bytes, int offset, int len)
		{
			return utf8.GetString(bytes, offset, len);
		}

		public unsafe static byte[] UnicodeGetBytes(string str)
		{
			int num = str.Length * 2;
			byte[] array = new byte[num];
			fixed (void* value = str)
			{
				Marshal.Copy(new IntPtr(value), array, 0, num);
			}
			return array;
		}

		public static string UnicodeGetString(byte[] b)
		{
			return UnicodeGetString(b, 0, b.Length);
		}

		public unsafe static string UnicodeGetString(byte[] bytes, int offset, int buflen)
		{
			string text = "";
			fixed (byte* ptr = bytes)
			{
				char* value = (char*)(ptr + offset);
				text = new string(value, 0, buflen / 2);
			}
			return text;
		}

		internal object CreateCustom(string v, Type type)
		{
			_customDeserializer.TryGetValue(type, out var value);
			return value(v);
		}

		internal void RegisterCustomType(Type type, Serialize serializer, Deserialize deserializer)
		{
			if (type != null && serializer != null && deserializer != null)
			{
				_customSerializer.Add(type, serializer);
				_customDeserializer.Add(type, deserializer);
				Instance.ResetPropertyCache();
			}
		}

		internal bool IsTypeRegistered(Type t)
		{
			if (_customSerializer.Count() == 0)
			{
				return false;
			}
			Serialize value;
			return _customSerializer.TryGetValue(t, out value);
		}

		public Type GetGenericTypeDefinition(Type t)
		{
			Type value = null;
			if (_genericTypeDef.TryGetValue(t, out value))
			{
				return value;
			}
			value = t.GetGenericTypeDefinition();
			_genericTypeDef.Add(t, value);
			return value;
		}

		public Type[] GetGenericArguments(Type t)
		{
			Type[] value = null;
			if (_genericTypes.TryGetValue(t, out value))
			{
				return value;
			}
			value = t.GetGenericArguments();
			_genericTypes.Add(t, value);
			return value;
		}

		public Dictionary<string, myPropInfo> Getproperties(Type type, string typename, bool ShowReadOnlyProperties)
		{
			Dictionary<string, myPropInfo> value = null;
			if (_propertycache.TryGetValue(typename, out value))
			{
				return value;
			}
			value = new Dictionary<string, myPropInfo>(10);
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public;
			PropertyInfo[] properties = type.GetProperties(bindingAttr);
			PropertyInfo[] array = properties;
			foreach (PropertyInfo propertyInfo in array)
			{
				if (propertyInfo.GetIndexParameters().Length != 0)
				{
					continue;
				}
				myPropInfo myPropInfo2 = CreateMyProp(propertyInfo.PropertyType, propertyInfo.Name);
				myPropInfo2.setter = CreateSetMethod(type, propertyInfo, ShowReadOnlyProperties);
				if (myPropInfo2.setter != null)
				{
					myPropInfo2.CanWrite = true;
				}
				myPropInfo2.getter = CreateGetMethod(type, propertyInfo);
				object[] customAttributes = propertyInfo.GetCustomAttributes(inherit: true);
				object[] array2 = customAttributes;
				foreach (object obj in array2)
				{
					if (obj is DataMemberAttribute)
					{
						DataMemberAttribute dataMemberAttribute = (DataMemberAttribute)obj;
						if (dataMemberAttribute.Name != "")
						{
							myPropInfo2.memberName = dataMemberAttribute.Name;
						}
					}
				}
				if (myPropInfo2.memberName != null)
				{
					value.Add(myPropInfo2.memberName, myPropInfo2);
				}
				else
				{
					value.Add(propertyInfo.Name.ToLowerInvariant(), myPropInfo2);
				}
			}
			FieldInfo[] fields = type.GetFields(bindingAttr);
			FieldInfo[] array3 = fields;
			foreach (FieldInfo fieldInfo in array3)
			{
				myPropInfo myPropInfo3 = CreateMyProp(fieldInfo.FieldType, fieldInfo.Name);
				if (fieldInfo.IsLiteral)
				{
					continue;
				}
				if (!fieldInfo.IsInitOnly)
				{
					myPropInfo3.setter = CreateSetField(type, fieldInfo);
				}
				if (myPropInfo3.setter != null)
				{
					myPropInfo3.CanWrite = true;
				}
				myPropInfo3.getter = CreateGetField(type, fieldInfo);
				object[] customAttributes2 = fieldInfo.GetCustomAttributes(inherit: true);
				object[] array4 = customAttributes2;
				foreach (object obj2 in array4)
				{
					if (obj2 is DataMemberAttribute)
					{
						DataMemberAttribute dataMemberAttribute2 = (DataMemberAttribute)obj2;
						if (dataMemberAttribute2.Name != "")
						{
							myPropInfo3.memberName = dataMemberAttribute2.Name;
						}
					}
				}
				if (myPropInfo3.memberName != null)
				{
					value.Add(myPropInfo3.memberName, myPropInfo3);
				}
				else
				{
					value.Add(fieldInfo.Name.ToLowerInvariant(), myPropInfo3);
				}
			}
			_propertycache.Add(typename, value);
			return value;
		}

		private myPropInfo CreateMyProp(Type t, string name)
		{
			myPropInfo myPropInfo2 = new myPropInfo();
			myPropInfoType type = myPropInfoType.Unknown;
			if (t == typeof(int) || t == typeof(int?))
			{
				type = myPropInfoType.Int;
			}
			else if (t == typeof(long) || t == typeof(long?))
			{
				type = myPropInfoType.Long;
			}
			else if (t == typeof(string))
			{
				type = myPropInfoType.String;
			}
			else if (t == typeof(bool) || t == typeof(bool?))
			{
				type = myPropInfoType.Bool;
			}
			else if (t == typeof(DateTime) || t == typeof(DateTime?))
			{
				type = myPropInfoType.DateTime;
			}
			else if (t.IsEnum)
			{
				type = myPropInfoType.Enum;
			}
			else if (t == typeof(Guid) || t == typeof(Guid?))
			{
				type = myPropInfoType.Guid;
			}
			else if (t == typeof(StringDictionary))
			{
				type = myPropInfoType.StringDictionary;
			}
			else if (t == typeof(NameValueCollection))
			{
				type = myPropInfoType.NameValue;
			}
			else if (t.IsArray)
			{
				myPropInfo2.bt = t.GetElementType();
				type = ((!(t == typeof(byte[]))) ? myPropInfoType.Array : myPropInfoType.ByteArray);
			}
			else if (t.Name.Contains("Dictionary"))
			{
				myPropInfo2.GenericTypes = Instance.GetGenericArguments(t);
				type = ((myPropInfo2.GenericTypes.Length == 0 || !(myPropInfo2.GenericTypes[0] == typeof(string))) ? myPropInfoType.Dictionary : myPropInfoType.StringKeyDictionary);
			}
			else if (IsTypeRegistered(t))
			{
				type = myPropInfoType.Custom;
			}
			if (t.IsValueType && !t.IsPrimitive && !t.IsEnum && t != typeof(decimal))
			{
				myPropInfo2.IsStruct = true;
			}
			myPropInfo2.IsInterface = t.IsInterface;
			myPropInfo2.IsClass = t.IsClass;
			myPropInfo2.IsValueType = t.IsValueType;
			if (t.IsGenericType)
			{
				myPropInfo2.IsGenericType = true;
				myPropInfo2.bt = Instance.GetGenericArguments(t)[0];
			}
			myPropInfo2.pt = t;
			myPropInfo2.Name = name;
			myPropInfo2.changeType = GetChangeType(t);
			myPropInfo2.Type = type;
			return myPropInfo2;
		}

		private Type GetChangeType(Type conversionType)
		{
			if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
			{
				return Instance.GetGenericArguments(conversionType)[0];
			}
			return conversionType;
		}

		public string GetTypeAssemblyName(Type t)
		{
			string value = "";
			if (_tyname.TryGetValue(t, out value))
			{
				return value;
			}
			string assemblyQualifiedName = t.AssemblyQualifiedName;
			_tyname.Add(t, assemblyQualifiedName);
			return assemblyQualifiedName;
		}

		internal Type GetTypeFromCache(string typename, bool badlistChecking)
		{
			Type value = null;
			if (_typecache.TryGetValue(typename, out value))
			{
				return value;
			}
			if (badlistChecking)
			{
				string text = typename.Trim().ToLowerInvariant();
				foreach (string badlistType in _badlistTypes)
				{
					if (text.StartsWith(badlistType, StringComparison.Ordinal))
					{
						throw new Exception("Black list type encountered, possible attack vector when using $type : " + typename);
					}
				}
			}
			Type type = Type.GetType(typename);
			_typecache.Add(typename, type);
			return type;
		}

		internal object FastCreateList(Type objtype, int capacity)
		{
			try
			{
				int capacity2 = 10;
				if (capacity > 10)
				{
					capacity2 = capacity;
				}
				CreateList value = null;
				if (_conlistcache.TryGetValue(objtype, out value))
				{
					if (value != null)
					{
						return value(capacity2);
					}
					return FastCreateInstance(objtype);
				}
				ConstructorInfo constructor = objtype.GetConstructor(new Type[1] { typeof(int) });
				if (constructor != null)
				{
					DynamicMethod dynamicMethod = new DynamicMethod("_fcil", objtype, new Type[1] { typeof(int) }, restrictedSkipVisibility: true);
					ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
					iLGenerator.Emit(OpCodes.Ldarg_0);
					iLGenerator.Emit(OpCodes.Newobj, objtype.GetConstructor(new Type[1] { typeof(int) }));
					iLGenerator.Emit(OpCodes.Ret);
					value = (CreateList)dynamicMethod.CreateDelegate(typeof(CreateList));
					_conlistcache.Add(objtype, value);
					return value(capacity2);
				}
				_conlistcache.Add(objtype, null);
				return FastCreateInstance(objtype);
			}
			catch (Exception innerException)
			{
				throw new Exception($"Failed to fast create instance for type '{objtype.FullName}' from assembly '{objtype.AssemblyQualifiedName}'", innerException);
			}
		}

		internal object FastCreateInstance(Type objtype)
		{
			try
			{
				CreateObject value = null;
				if (_constrcache.TryGetValue(objtype, out value))
				{
					return value();
				}
				if (objtype.IsClass)
				{
					DynamicMethod dynamicMethod = new DynamicMethod("_fcic", objtype, null, restrictedSkipVisibility: true);
					ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
					iLGenerator.Emit(OpCodes.Newobj, objtype.GetConstructor(Type.EmptyTypes));
					iLGenerator.Emit(OpCodes.Ret);
					value = (CreateObject)dynamicMethod.CreateDelegate(typeof(CreateObject));
					_constrcache.Add(objtype, value);
				}
				else
				{
					DynamicMethod dynamicMethod2 = new DynamicMethod("_fcis", typeof(object), null, restrictedSkipVisibility: true);
					ILGenerator iLGenerator2 = dynamicMethod2.GetILGenerator();
					LocalBuilder local = iLGenerator2.DeclareLocal(objtype);
					iLGenerator2.Emit(OpCodes.Ldloca_S, local);
					iLGenerator2.Emit(OpCodes.Initobj, objtype);
					iLGenerator2.Emit(OpCodes.Ldloc_0);
					iLGenerator2.Emit(OpCodes.Box, objtype);
					iLGenerator2.Emit(OpCodes.Ret);
					value = (CreateObject)dynamicMethod2.CreateDelegate(typeof(CreateObject));
					_constrcache.Add(objtype, value);
				}
				return value();
			}
			catch (Exception innerException)
			{
				throw new Exception($"Failed to fast create instance for type '{objtype.FullName}' from assembly '{objtype.AssemblyQualifiedName}'", innerException);
			}
		}

		internal static GenericSetter CreateSetField(Type type, FieldInfo fieldInfo)
		{
			Type[] array = new Type[2];
			array[0] = (array[1] = typeof(object));
			DynamicMethod dynamicMethod = new DynamicMethod("_csf", typeof(object), array, type, skipVisibility: true);
			ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
			if (!type.IsClass)
			{
				LocalBuilder local = iLGenerator.DeclareLocal(type);
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Unbox_Any, type);
				iLGenerator.Emit(OpCodes.Stloc_0);
				iLGenerator.Emit(OpCodes.Ldloca_S, local);
				iLGenerator.Emit(OpCodes.Ldarg_1);
				if (fieldInfo.FieldType.IsClass)
				{
					iLGenerator.Emit(OpCodes.Castclass, fieldInfo.FieldType);
				}
				else
				{
					iLGenerator.Emit(OpCodes.Unbox_Any, fieldInfo.FieldType);
				}
				iLGenerator.Emit(OpCodes.Stfld, fieldInfo);
				iLGenerator.Emit(OpCodes.Ldloc_0);
				iLGenerator.Emit(OpCodes.Box, type);
				iLGenerator.Emit(OpCodes.Ret);
			}
			else
			{
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Ldarg_1);
				if (fieldInfo.FieldType.IsValueType)
				{
					iLGenerator.Emit(OpCodes.Unbox_Any, fieldInfo.FieldType);
				}
				iLGenerator.Emit(OpCodes.Stfld, fieldInfo);
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Ret);
			}
			return (GenericSetter)dynamicMethod.CreateDelegate(typeof(GenericSetter));
		}

		internal static FieldInfo GetGetterBackingField(PropertyInfo autoProperty)
		{
			MethodInfo getMethod = autoProperty.GetGetMethod();
			if (!getMethod.IsDefined(typeof(CompilerGeneratedAttribute), inherit: false))
			{
				return null;
			}
			byte[] array = getMethod.GetMethodBody()?.GetILAsByteArray() ?? new byte[0];
			OpCode opCode;
			for (int i = 0; i < array.Length; i += ((opCode.OperandType != OperandType.InlineNone) ? ((opCode.OperandType == OperandType.ShortInlineBrTarget || opCode.OperandType == OperandType.ShortInlineI || opCode.OperandType == OperandType.ShortInlineVar) ? 1 : ((opCode.OperandType == OperandType.InlineVar) ? 2 : ((opCode.OperandType == OperandType.InlineI8 || opCode.OperandType == OperandType.InlineR) ? 8 : ((opCode.OperandType == OperandType.InlineSwitch) ? (4 * (BitConverter.ToInt32(array, i) + 1)) : 4)))) : 0))
			{
				byte b = array[i++];
				if (!TryGetOpCode(b, out opCode) && (i >= array.Length || !TryGetOpCode((short)(b * 256 + array[i++]), out opCode)))
				{
					throw new NotSupportedException("Unknown IL code detected.");
				}
				if (opCode == OpCodes.Ldfld && opCode.OperandType == OperandType.InlineField && i + 4 <= array.Length)
				{
					return getMethod.Module.ResolveMember(BitConverter.ToInt32(array, i), getMethod.DeclaringType?.GetGenericArguments(), null) as FieldInfo;
				}
			}
			return null;
		}

		internal static GenericSetter CreateSetMethod(Type type, PropertyInfo propertyInfo, bool ShowReadOnlyProperties)
		{
			MethodInfo setMethod = propertyInfo.GetSetMethod(ShowReadOnlyProperties);
			if (setMethod == null)
			{
				if (!ShowReadOnlyProperties)
				{
					return null;
				}
				FieldInfo getterBackingField = GetGetterBackingField(propertyInfo);
				if (!(getterBackingField != null))
				{
					return null;
				}
				return CreateSetField(type, getterBackingField);
			}
			Type[] array = new Type[2];
			array[0] = (array[1] = typeof(object));
			DynamicMethod dynamicMethod = new DynamicMethod("_csm", typeof(object), array, restrictedSkipVisibility: true);
			ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
			if (!type.IsClass)
			{
				LocalBuilder local = iLGenerator.DeclareLocal(type);
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Unbox_Any, type);
				iLGenerator.Emit(OpCodes.Stloc_0);
				iLGenerator.Emit(OpCodes.Ldloca_S, local);
				iLGenerator.Emit(OpCodes.Ldarg_1);
				if (propertyInfo.PropertyType.IsClass)
				{
					iLGenerator.Emit(OpCodes.Castclass, propertyInfo.PropertyType);
				}
				else
				{
					iLGenerator.Emit(OpCodes.Unbox_Any, propertyInfo.PropertyType);
				}
				iLGenerator.EmitCall(OpCodes.Call, setMethod, null);
				iLGenerator.Emit(OpCodes.Ldloc_0);
				iLGenerator.Emit(OpCodes.Box, type);
			}
			else if (!setMethod.IsStatic)
			{
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Castclass, propertyInfo.DeclaringType);
				iLGenerator.Emit(OpCodes.Ldarg_1);
				if (propertyInfo.PropertyType.IsClass)
				{
					iLGenerator.Emit(OpCodes.Castclass, propertyInfo.PropertyType);
				}
				else
				{
					iLGenerator.Emit(OpCodes.Unbox_Any, propertyInfo.PropertyType);
				}
				iLGenerator.EmitCall(OpCodes.Callvirt, setMethod, null);
				iLGenerator.Emit(OpCodes.Ldarg_0);
			}
			else
			{
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Ldarg_1);
				if (propertyInfo.PropertyType.IsClass)
				{
					iLGenerator.Emit(OpCodes.Castclass, propertyInfo.PropertyType);
				}
				else
				{
					iLGenerator.Emit(OpCodes.Unbox_Any, propertyInfo.PropertyType);
				}
				iLGenerator.Emit(OpCodes.Call, setMethod);
			}
			iLGenerator.Emit(OpCodes.Ret);
			return (GenericSetter)dynamicMethod.CreateDelegate(typeof(GenericSetter));
		}

		internal static GenericGetter CreateGetField(Type type, FieldInfo fieldInfo)
		{
			DynamicMethod dynamicMethod = new DynamicMethod("_cgf", typeof(object), new Type[1] { typeof(object) }, type, skipVisibility: true);
			ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
			if (!type.IsClass)
			{
				LocalBuilder local = iLGenerator.DeclareLocal(type);
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Unbox_Any, type);
				iLGenerator.Emit(OpCodes.Stloc_0);
				iLGenerator.Emit(OpCodes.Ldloca_S, local);
				iLGenerator.Emit(OpCodes.Ldfld, fieldInfo);
				if (fieldInfo.FieldType.IsValueType)
				{
					iLGenerator.Emit(OpCodes.Box, fieldInfo.FieldType);
				}
			}
			else
			{
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Ldfld, fieldInfo);
				if (fieldInfo.FieldType.IsValueType)
				{
					iLGenerator.Emit(OpCodes.Box, fieldInfo.FieldType);
				}
			}
			iLGenerator.Emit(OpCodes.Ret);
			return (GenericGetter)dynamicMethod.CreateDelegate(typeof(GenericGetter));
		}

		internal static GenericGetter CreateGetMethod(Type type, PropertyInfo propertyInfo)
		{
			MethodInfo getMethod = propertyInfo.GetGetMethod();
			if (getMethod == null)
			{
				return null;
			}
			DynamicMethod dynamicMethod = new DynamicMethod("_cgm", typeof(object), new Type[1] { typeof(object) }, type, skipVisibility: true);
			ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
			if (!type.IsClass)
			{
				LocalBuilder local = iLGenerator.DeclareLocal(type);
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Unbox_Any, type);
				iLGenerator.Emit(OpCodes.Stloc_0);
				iLGenerator.Emit(OpCodes.Ldloca_S, local);
				iLGenerator.EmitCall(OpCodes.Call, getMethod, null);
				if (propertyInfo.PropertyType.IsValueType)
				{
					iLGenerator.Emit(OpCodes.Box, propertyInfo.PropertyType);
				}
			}
			else
			{
				if (!getMethod.IsStatic)
				{
					iLGenerator.Emit(OpCodes.Ldarg_0);
					iLGenerator.Emit(OpCodes.Castclass, propertyInfo.DeclaringType);
					iLGenerator.EmitCall(OpCodes.Callvirt, getMethod, null);
				}
				else
				{
					iLGenerator.Emit(OpCodes.Call, getMethod);
				}
				if (propertyInfo.PropertyType.IsValueType)
				{
					iLGenerator.Emit(OpCodes.Box, propertyInfo.PropertyType);
				}
			}
			iLGenerator.Emit(OpCodes.Ret);
			return (GenericGetter)dynamicMethod.CreateDelegate(typeof(GenericGetter));
		}

		public Getters[] GetGetters(Type type, List<Type> IgnoreAttributes)
		{
			Getters[] value = null;
			if (_getterscache.TryGetValue(type, out value))
			{
				return value;
			}
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public;
			PropertyInfo[] properties = type.GetProperties(bindingAttr);
			List<Getters> list = new List<Getters>();
			PropertyInfo[] array = properties;
			foreach (PropertyInfo propertyInfo in array)
			{
				bool readOnly = false;
				if (propertyInfo.GetIndexParameters().Length != 0)
				{
					continue;
				}
				if (!propertyInfo.CanWrite)
				{
					readOnly = true;
				}
				if (IgnoreAttributes != null)
				{
					bool flag = false;
					foreach (Type IgnoreAttribute in IgnoreAttributes)
					{
						if (propertyInfo.IsDefined(IgnoreAttribute, inherit: false))
						{
							flag = true;
							break;
						}
					}
					if (flag)
					{
						continue;
					}
				}
				string memberName = null;
				object[] customAttributes = propertyInfo.GetCustomAttributes(inherit: true);
				object[] array2 = customAttributes;
				foreach (object obj in array2)
				{
					if (obj is DataMemberAttribute)
					{
						DataMemberAttribute dataMemberAttribute = (DataMemberAttribute)obj;
						if (dataMemberAttribute.Name != "")
						{
							memberName = dataMemberAttribute.Name;
						}
					}
				}
				GenericGetter genericGetter = CreateGetMethod(type, propertyInfo);
				if (genericGetter != null)
				{
					list.Add(new Getters
					{
						Getter = genericGetter,
						Name = propertyInfo.Name,
						lcName = propertyInfo.Name.ToLowerInvariant(),
						memberName = memberName,
						ReadOnly = readOnly
					});
				}
			}
			FieldInfo[] fields = type.GetFields(bindingAttr);
			FieldInfo[] array3 = fields;
			foreach (FieldInfo fieldInfo in array3)
			{
				bool readOnly2 = false;
				if (fieldInfo.IsInitOnly)
				{
					readOnly2 = true;
				}
				if (IgnoreAttributes != null)
				{
					bool flag2 = false;
					foreach (Type IgnoreAttribute2 in IgnoreAttributes)
					{
						if (fieldInfo.IsDefined(IgnoreAttribute2, inherit: false))
						{
							flag2 = true;
							break;
						}
					}
					if (flag2)
					{
						continue;
					}
				}
				string memberName2 = null;
				object[] customAttributes2 = fieldInfo.GetCustomAttributes(inherit: true);
				object[] array4 = customAttributes2;
				foreach (object obj2 in array4)
				{
					if (obj2 is DataMemberAttribute)
					{
						DataMemberAttribute dataMemberAttribute2 = (DataMemberAttribute)obj2;
						if (dataMemberAttribute2.Name != "")
						{
							memberName2 = dataMemberAttribute2.Name;
						}
					}
				}
				if (!fieldInfo.IsLiteral)
				{
					GenericGetter genericGetter2 = CreateGetField(type, fieldInfo);
					if (genericGetter2 != null)
					{
						list.Add(new Getters
						{
							Getter = genericGetter2,
							Name = fieldInfo.Name,
							lcName = fieldInfo.Name.ToLowerInvariant(),
							memberName = memberName2,
							ReadOnly = readOnly2
						});
					}
				}
			}
			value = list.ToArray();
			_getterscache.Add(type, value);
			return value;
		}

		internal void ResetPropertyCache()
		{
			_propertycache = new SafeDictionary<string, Dictionary<string, myPropInfo>>();
		}

		internal void ClearReflectionCache()
		{
			_tyname = new SafeDictionary<Type, string>(10);
			_typecache = new SafeDictionary<string, Type>(10);
			_constrcache = new SafeDictionary<Type, CreateObject>(10);
			_getterscache = new SafeDictionary<Type, Getters[]>(10);
			_propertycache = new SafeDictionary<string, Dictionary<string, myPropInfo>>(10);
			_genericTypes = new SafeDictionary<Type, Type[]>(10);
			_genericTypeDef = new SafeDictionary<Type, Type>(10);
		}
	}
	public class ReferenceEqualityComparer : IEqualityComparer, IEqualityComparer<object>
	{
		public static ReferenceEqualityComparer Default { get; } = new ReferenceEqualityComparer();


		public new bool Equals(object x, object y)
		{
			return x.Equals(y);
		}

		public int GetHashCode(object obj)
		{
			return RuntimeHelpers.GetHashCode(obj);
		}
	}
	public sealed class SafeDictionary<TKey, TValue>
	{
		private readonly object _Padlock = new object();

		private readonly Dictionary<TKey, TValue> _Dictionary;

		public TValue this[TKey key]
		{
			get
			{
				lock (_Padlock)
				{
					return _Dictionary[key];
				}
			}
			set
			{
				lock (_Padlock)
				{
					_Dictionary[key] = value;
				}
			}
		}

		public SafeDictionary(int capacity)
		{
			_Dictionary = new Dictionary<TKey, TValue>(capacity);
		}

		public SafeDictionary()
		{
			_Dictionary = new Dictionary<TKey, TValue>();
		}

		public bool TryGetValue(TKey key, out TValue value)
		{
			lock (_Padlock)
			{
				return _Dictionary.TryGetValue(key, out value);
			}
		}

		public int Count()
		{
			lock (_Padlock)
			{
				return _Dictionary.Count;
			}
		}

		public void Add(TKey key, TValue value)
		{
			lock (_Padlock)
			{
				if (!_Dictionary.ContainsKey(key))
				{
					_Dictionary.Add(key, value);
				}
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
}
namespace YamlDotNet
{
	internal sealed class CultureInfoAdapter : CultureInfo
	{
		private readonly IFormatProvider provider;

		public CultureInfoAdapter(CultureInfo baseCulture, IFormatProvider provider)
			: base(baseCulture.Name)
		{
			this.provider = provider;
		}

		public override object? GetFormat(Type formatType)
		{
			return provider.GetFormat(formatType);
		}
	}
	internal static class Polyfills
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool Contains(this string source, char c)
		{
			return source.IndexOf(c) != -1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool EndsWith(this string source, char c)
		{
			if (source.Length > 0)
			{
				return source[source.Length - 1] == c;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool StartsWith(this string source, char c)
		{
			if (source.Length > 0)
			{
				return source[0] == c;
			}
			return false;
		}
	}
	internal static class PropertyInfoExtensions
	{
		public static object? ReadValue(this PropertyInfo property, object target)
		{
			return property.GetValue(target, null);
		}
	}
	internal static class ReflectionExtensions
	{
		private static readonly Func<PropertyInfo, bool> IsInstance = (PropertyInfo property) => !(property.GetMethod ?? property.SetMethod).IsStatic;

		private static readonly Func<PropertyInfo, bool> IsInstancePublic = (PropertyInfo property) => IsInstance(property) && (property.GetMethod ?? property.SetMethod).IsPublic;

		public static Type? BaseType(this Type type)
		{
			return type.GetTypeInfo().BaseType;
		}

		public static bool IsValueType(this Type type)
		{
			return type.GetTypeInfo().IsValueType;
		}

		public static bool IsGenericType(this Type type)
		{
			return type.GetTypeInfo().IsGenericType;
		}

		public static bool IsGenericTypeDefinition(this Type type)
		{
			return type.GetTypeInfo().IsGenericTypeDefinition;
		}

		public static Type? GetImplementationOfOpenGenericInterface(this Type type, Type openGenericType)
		{
			if (!openGenericType.IsGenericType || !openGenericType.IsInterface)
			{
				throw new ArgumentException("The type must be a generic type definition and an interface", "openGenericType");
			}
			if (IsGenericDefinitionOfType(type, openGenericType))
			{
				return type;
			}
			return type.FindInterfaces((Type t, object context) => IsGenericDefinitionOfType(t, context), openGenericType).FirstOrDefault();
			static bool IsGenericDefinitionOfType(Type t, object? context)
			{
				if (t.IsGenericType)
				{
					return t.GetGenericTypeDefinition() == (Type)context;
				}
				return false;
			}
		}

		public static bool IsInterface(this Type type)
		{
			return type.GetTypeInfo().IsInterface;
		}

		public static bool IsEnum(this Type type)
		{
			return type.GetTypeInfo().IsEnum;
		}

		public static bool IsRequired(this MemberInfo member)
		{
			return member.GetCustomAttributes(inherit: true).Any((object x) => x.GetType().FullName == "System.Runtime.CompilerServices.RequiredMemberAttribute");
		}

		public static bool HasDefaultConstructor(this Type type, bool allowPrivateConstructors)
		{
			BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public;
			if (allowPrivateConstructors)
			{
				bindingFlags |= BindingFlags.NonPublic;
			}
			if (!type.IsValueType)
			{
				return type.GetConstructor(bindingFlags, null, Type.EmptyTypes, null) != null;
			}
			return true;
		}

		public static bool IsAssignableFrom(this Type type, Type source)
		{
			return type.IsAssignableFrom(source.GetTypeInfo());
		}

		public static bool IsAssignableFrom(this Type type, TypeInfo source)
		{
			return type.GetTypeInfo().IsAssignableFrom(source);
		}

		public static TypeCode GetTypeCode(this Type type)
		{
			if (type.IsEnum())
			{
				type = Enum.GetUnderlyingType(type);
			}
			if (type == typeof(bool))
			{
				return TypeCode.Boolean;
			}
			if (type == typeof(char))
			{
				return TypeCode.Char;
			}
			if (type == typeof(sbyte))
			{
				return TypeCode.SByte;
			}
			if (type == typeof(byte))
			{
				return TypeCode.Byte;
			}
			if (type == typeof(short))
			{
				return TypeCode.Int16;
			}
			if (type == typeof(ushort))
			{
				return TypeCode.UInt16;
			}
			if (type == typeof(int))
			{
				return TypeCode.Int32;
			}
			if (type == typeof(uint))
			{
				return TypeCode.UInt32;
			}
			if (type == typeof(long))
			{
				return TypeCode.Int64;
			}
			if (type == typeof(ulong))
			{
				return TypeCode.UInt64;
			}
			if (type == typeof(float))
			{
				return TypeCode.Single;
			}
			if (type == typeof(double))
			{
				return TypeCode.Double;
			}
			if (type == typeof(decimal))
			{
				return TypeCode.Decimal;
			}
			if (type == typeof(DateTime))
			{
				return TypeCode.DateTime;
			}
			if (type == typeof(string))
			{
				return TypeCode.String;
			}
			return TypeCode.Object;
		}

		public static bool IsDbNull(this object value)
		{
			return value?.GetType()?.FullName == "System.DBNull";
		}

		public static Type[] GetGenericArguments(this Type type)
		{
			return type.GetTypeInfo().GenericTypeArguments;
		}

		public static PropertyInfo? GetPublicProperty(this Type type, string name)
		{
			string name2 = name;
			return type.GetProperties(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public).FirstOrDefault((PropertyInfo p) => p.Name == name2);
		}

		public static FieldInfo? GetPublicStaticField(this Type type, string name)
		{
			return type.GetRuntimeField(name);
		}

		public static IEnumerable<PropertyInfo> GetProperties(this Type type, bool includeNonPublic)
		{
			Func<PropertyInfo, bool> predicate = (includeNonPublic ? IsInstance : IsInstancePublic);
			if (!type.IsInterface())
			{
				return type.GetRuntimeProperties().Where(predicate);
			}
			return new Type[1] { type }.Concat(type.GetInterfaces()).SelectMany((Type i) => i.GetRuntimeProperties().Where(predicate));
		}

		public static IEnumerable<PropertyInfo> GetPublicProperties(this Type type)
		{
			return type.GetProperties(includeNonPublic: false);
		}

		public static IEnumerable<FieldInfo> GetPublicFields(this Type type)
		{
			return from f in type.GetRuntimeFields()
				where !f.IsStatic && f.IsPublic
				select f;
		}

		public static IEnumerable<MethodInfo> GetPublicStaticMethods(this Type type)
		{
			return from m in type.GetRuntimeMethods()
				where m.IsPublic && m.IsStatic
				select m;
		}

		public static MethodInfo GetPrivateStaticMethod(this Type type, string name)
		{
			string name2 = name;
			return type.GetRuntimeMethods().FirstOrDefault((MethodInfo m) => !m.IsPublic && m.IsStatic && m.Name.Equals(name2)) ?? throw new MissingMethodException("Expected to find a method named '" + name2 + "' in '" + type.FullName + "'.");
		}

		public static MethodInfo? GetPublicStaticMethod(this Type type, string name, params Type[] parameterTypes)
		{
			string name2 = name;
			Type[] parameterTypes2 = parameterTypes;
			return type.GetRuntimeMethods().FirstOrDefault(delegate(MethodInfo m)
			{
				if (m.IsPublic && m.IsStatic && m.Name.Equals(name2))
				{
					ParameterInfo[] parameters = m.GetParameters();
					if (parameters.Length == parameterTypes2.Length)
					{
						return parameters.Zip(parameterTypes2, (ParameterInfo pi, Type pt) => pi.ParameterType == pt).All((bool r) => r);
					}
					return false;
				}
				return false;
			});
		}

		public static MethodInfo? GetPublicInstanceMethod(this Type type, string name)
		{
			string name2 = name;
			return type.GetRuntimeMethods().FirstOrDefault((MethodInfo m) => m.IsPublic && !m.IsStatic && m.Name.Equals(name2));
		}

		public static MethodInfo? GetGetMethod(this PropertyInfo property, bool nonPublic)
		{
			MethodInfo methodInfo = property.GetMethod;
			if (!nonPublic && !methodInfo.IsPublic)
			{
				methodInfo = null;
			}
			return methodInfo;
		}

		public static MethodInfo? GetSetMethod(this PropertyInfo property)
		{
			return property.SetMethod;
		}

		public static IEnumerable<Type> GetInterfaces(this Type type)
		{
			return type.GetTypeInfo().ImplementedInterfaces;
		}

		public static bool IsInstanceOf(this Type type, object o)
		{
			if (!(o.GetType() == type))
			{
				return o.GetType().GetTypeInfo().IsSubclassOf(type);
			}
			return true;
		}

		public static Attribute[] GetAllCustomAttributes<TAttribute>(this PropertyInfo member)
		{
			return Attribute.GetCustomAttributes(member, typeof(TAttribute), inherit: true);
		}

		public static bool AcceptsNull(this MemberInfo member)
		{
			object[] customAttributes = member.DeclaringType.GetCustomAttributes(inherit: true);
			object obj = customAttributes.FirstOrDefault((object x) => x.GetType().FullName == "System.Runtime.CompilerServices.NullableContextAttribute");
			int num = 0;
			if (obj != null)
			{
				Type type = obj.GetType();
				PropertyInfo property = type.GetProperty("Flag");
				num = (byte)property.GetValue(obj);
			}
			object[] customAttributes2 = member.GetCustomAttributes(inherit: true);
			object obj2 = customAttributes2.FirstOrDefault((object x) => x.GetType().FullName == "System.Runtime.CompilerServices.NullableAttribute");
			PropertyInfo propertyInfo = (obj2?.GetType())?.GetProperty("NullableFlags");
			byte[] source = (byte[])propertyInfo.GetValue(obj2);
			return source.Any((byte x) => x == 2) || num == 2;
		}
	}
	internal static class StandardRegexOptions
	{
		public const RegexOptions Compiled = RegexOptions.Compiled;
	}
}
namespace YamlDotNet.Serialization
{
	public abstract class BuilderSkeleton<TBuilder> where TBuilder : BuilderSkeleton<TBuilder>
	{
		internal INamingConvention namingConvention = NullNamingConvention.Instance;

		internal INamingConvention enumNamingConvention = NullNamingConvention.Instance;

		internal ITypeResolver typeResolver;

		internal readonly YamlAttributeOverrides overrides;

		internal readonly LazyComponentRegistrationList<Nothing, IYamlTypeConverter> typeConverterFactories;

		internal readonly LazyComponentRegistrationList<ITypeInspector, ITypeInspector> typeInspectorFactories;

		internal bool ignoreFields;

		internal bool includeNonPublicProperties;

		internal Settings settings;

		internal YamlFormatter yamlFormatter = YamlFormatter.Default;

		protected abstract TBuilder Self { get; }

		internal BuilderSkeleton(ITypeResolver typeResolver)
		{
			overrides = new YamlAttributeOverrides();
			typeConverterFactories = new LazyComponentRegistrationList<Nothing, IYamlTypeConverter>
			{
				{
					typeof(YamlDotNet.Serialization.Converters.GuidConverter),
					(Nothing _) => new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: false)
				},
				{
					typeof(SystemTypeConverter),
					(Nothing _) => new SystemTypeConverter()
				}
			};
			typeInspectorFactories = new LazyComponentRegistrationList<ITypeInspector, ITypeInspector>();
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			settings = new Settings();
		}

		public TBuilder IgnoreFields()
		{
			ignoreFields = true;
			return Self;
		}

		public TBuilder IncludeNonPublicProperties()
		{
			includeNonPublicProperties = true;
			return Self;
		}

		public TBuilder EnablePrivateConstructors()
		{
			settings.AllowPrivateConstructors = true;
			return Self;
		}

		public TBuilder WithNamingConvention(INamingConvention namingConvention)
		{
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
			return Self;
		}

		public TBuilder WithEnumNamingConvention(INamingConvention enumNamingConvention)
		{
			this.enumNamingConvention = enumNamingConvention;
			return Self;
		}

		public TBuilder WithTypeResolver(ITypeResolver typeResolver)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			return Self;
		}

		public abstract TBuilder WithTagMapping(TagName tag, Type type);

		public TBuilder WithAttributeOverride<TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
		{
			overrides.Add(propertyAccessor, attribute);
			return Self;
		}

		public TBuilder WithAttributeOverride(Type type, string member, Attribute attribute)
		{
			overrides.Add(type, member, attribute);
			return Self;
		}

		public TBuilder WithTypeConverter(IYamlTypeConverter typeConverter)
		{
			return WithTypeConverter(typeConverter, delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeConverter(IYamlTypeConverter typeConverter, Action<IRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where)
		{
			IYamlTypeConverter typeConverter2 = typeConverter;
			if (typeConverter2 == null)
			{
				throw new ArgumentNullException("typeConverter");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter2.GetType(), (Nothing _) => typeConverter2));
			return Self;
		}

		public TBuilder WithTypeConverter<TYamlTypeConverter>(WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where) where TYamlTypeConverter : IYamlTypeConverter
		{
			WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory2 = typeConverterFactory;
			if (typeConverterFactory2 == null)
			{
				throw new ArgumentNullException("typeConverterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (IYamlTypeConverter wrapped, Nothing _) => typeConverterFactory2(wrapped)));
			return Self;
		}

		public TBuilder WithoutTypeConverter<TYamlTypeConverter>() where TYamlTypeConverter : IYamlTypeConverter
		{
			return WithoutTypeConverter(typeof(TYamlTypeConverter));
		}

		public TBuilder WithoutTypeConverter(Type converterType)
		{
			if (converterType == null)
			{
				throw new ArgumentNullException("converterType");
			}
			typeConverterFactories.Remove(converterType);
			return Self;
		}

		public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : ITypeInspector
		{
			return WithTypeInspector(typeInspectorFactory, delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory, Action<IRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			Func<ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
			if (typeInspectorFactory2 == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector inner) => typeInspectorFactory2(inner)));
			return Self;
		}

		public TBuilder WithTypeInspector<TTypeInspector>(WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
			if (typeInspectorFactory2 == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector wrapped, ITypeInspector inner) => typeInspectorFactory2(wrapped, inner)));
			return Self;
		}

		public TBuilder WithoutTypeInspector<TTypeInspector>() where TTypeInspector : ITypeInspector
		{
			return WithoutTypeInspector(typeof(TTypeInspector));
		}

		public TBuilder WithoutTypeInspector(Type inspectorType)
		{
			if (inspectorType == null)
			{
				throw new ArgumentNullException("inspectorType");
			}
			typeInspectorFactories.Remove(inspectorType);
			return Self;
		}

		public TBuilder WithYamlFormatter(YamlFormatter formatter)
		{
			yamlFormatter = formatter ?? throw new ArgumentNullException("formatter");
			return Self;
		}

		protected IEnumerable<IYamlTypeConverter> BuildTypeConverters()
		{
			return typeConverterFactories.BuildComponentList();
		}
	}
	public delegate TComponent WrapperFactory<TComponentBase, TComponent>(TComponentBase wrapped) where TComponent : TComponentBase;
	public delegate TComponent WrapperFactory<TArgument, TComponentBase, TComponent>(TComponentBase wrapped, TArgument argument) where TComponent : TComponentBase;
	[Flags]
	public enum DefaultValuesHandling
	{
		Preserve = 0,
		OmitNull = 1,
		OmitDefaults = 2,
		OmitEmptyCollections = 4
	}
	public sealed class Deserializer : IDeserializer
	{
		private readonly IValueDeserializer valueDeserializer;

		public Deserializer()
			: this(new DeserializerBuilder().BuildValueDeserializer())
		{
		}

		private Deserializer(IValueDeserializer valueDeserializer)
		{
			this.valueDeserializer = valueDeserializer ?? throw new ArgumentNullException("valueDeserializer");
		}

		public static Deserializer FromValueDeserializer(IValueDeserializer valueDeserializer)
		{
			return new Deserializer(valueDeserializer);
		}

		public T Deserialize<T>(string input)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize<T>(input2);
		}

		public T Deserialize<T>(TextReader input)
		{
			return Deserialize<T>(new Parser(input));
		}

		public T Deserialize<T>(IParser parser)
		{
			return (T)Deserialize(parser, typeof(T));
		}

		public object? Deserialize(string input)
		{
			return Deserialize<object>(input);
		}

		public object? Deserialize(TextReader input)
		{
			return Deserialize<object>(input);
		}

		public object? Deserialize(IParser parser)
		{
			return Deserialize<object>(parser);
		}

		public object? Deserialize(string input, Type type)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize(input2, type);
		}

		public object? Deserialize(TextReader input, Type type)
		{
			return Deserialize(new Parser(input), type);
		}

		public object? Deserialize(IParser parser, Type type)
		{
			if (parser == null)
			{
				throw new ArgumentNullException("parser");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			YamlDotNet.Core.Events.StreamStart @event;
			bool flag = parser.TryConsume<YamlDotNet.Core.Events.StreamStart>(out @event);
			YamlDotNet.Core.Events.DocumentStart event2;
			bool flag2 = parser.TryConsume<YamlDotNet.Core.Events.DocumentStart>(out event2);
			object result = null;
			if (!parser.Accept<YamlDotNet.Core.Events.DocumentEnd>(out var _) && !parser.Accept<YamlDotNet.Core.Events.StreamEnd>(out var _))
			{
				using SerializerState serializerState = new SerializerState();
				result = valueDeserializer.DeserializeValue(parser, type, serializerState, valueDeserializer);
				serializerState.OnDeserialization();
			}
			if (flag2)
			{
				parser.Consume<YamlDotNet.Core.Events.DocumentEnd>();
			}
			if (flag)
			{
				parser.Consume<YamlDotNet.Core.Events.StreamEnd>();
			}
			return result;
		}
	}
	public sealed class DeserializerBuilder : BuilderSkeleton<DeserializerBuilder>
	{
		private Lazy<IObjectFactory> objectFactory;

		private readonly LazyComponentRegistrationList<Nothing, INodeDeserializer> nodeDeserializerFactories;

		private readonly LazyComponentRegistrationList<Nothing, INodeTypeResolver> nodeTypeResolverFactories;

		private readonly Dictionary<TagName, Type> tagMappings;

		private readonly Dictionary<Type, Type> typeMappings;

		private readonly ITypeConverter typeConverter;

		private bool ignoreUnmatched;

		private bool duplicateKeyChecking;

		private bool attemptUnknownTypeDeserialization;

		private bool enforceNullability;

		private bool caseInsensitivePropertyMatching;

		private bool enforceRequiredProperties;

		protected override DeserializerBuilder Self => this;

		public DeserializerBuilder()
			: base((ITypeResolver)new StaticTypeResolver())
		{
			typeMappings = new Dictionary<Type, Type>();
			objectFactory = new Lazy<IObjectFactory>(() => new DefaultObjectFactory(typeMappings, settings), isThreadSafe: true);
			tagMappings = new Dictionary<TagName, Type>
			{
				{
					FailsafeSchema.Tags.Map,
					typeof(Dictionary<object, object>)
				},
				{
					FailsafeSchema.Tags.Str,
					typeof(string)
				},
				{
					JsonSchema.Tags.Bool,
					typeof(bool)
				},
				{
					JsonSchema.Tags.Float,
					typeof(double)
				},
				{
					JsonSchema.Tags.Int,
					typeof(int)
				},
				{
					DefaultSchema.Tags.Timestamp,
					typeof(DateTime)
				}
			};
			typeInspectorFactories.Add(typeof(CachedTypeInspector), (ITypeInspector inner) => new CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(NamingConventionTypeInspector), (ITypeInspector inner) => (!(namingConvention is NullNamingConvention)) ? new NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(YamlAttributesTypeInspector), (ITypeInspector inner) => new YamlAttributesTypeInspector(inner));
			typeInspectorFactories.Add(typeof(YamlAttributeOverridesInspector), (ITypeInspector inner) => (overrides == null) ? inner : new YamlAttributeOverridesInspector(inner, overrides.Clone()));
			typeInspectorFactories.Add(typeof(ReadableAndWritablePropertiesTypeInspector), (ITypeInspector inner) => new ReadableAndWritablePropertiesTypeInspector(inner));
			nodeDeserializerFactories = new LazyComponentRegistrationList<Nothing, INodeDeserializer>
			{
				{
					typeof(YamlConvertibleNodeDeserializer),
					(Nothing _) => new YamlConvertibleNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(YamlSerializableNodeDeserializer),
					(Nothing _) => new YamlSerializableNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(TypeConverterNodeDeserializer),
					(Nothing _) => new TypeConverterNodeDeserializer(BuildTypeConverters())
				},
				{
					typeof(NullNodeDeserializer),
					(Nothing _) => new NullNodeDeserializer()
				},
				{
					typeof(ScalarNodeDeserializer),
					(Nothing _) => new ScalarNodeDeserializer(attemptUnknownTypeDeserialization, typeConverter, BuildTypeInspector(), yamlFormatter, enumNamingConvention)
				},
				{
					typeof(ArrayNodeDeserializer),
					(Nothing _) => new ArrayNodeDeserializer(enumNamingConvention, BuildTypeInspector())
				},
				{
					typeof(DictionaryNodeDeserializer),
					(Nothing _) => new DictionaryNodeDeserializer(objectFactory.Value, duplicateKeyChecking)
				},
				{
					typeof(CollectionNodeDeserializer),
					(Nothing _) => new CollectionNodeDeserializer(objectFactory.Value, enumNamingConvention, BuildTypeInspector())
				},
				{
					typeof(EnumerableNodeDeserializer),
					(Nothing _) => new EnumerableNodeDeserializer()
				},
				{
					typeof(ObjectNodeDeserializer),
					(Nothing _) => new ObjectNodeDeserializer(objectFactory.Value, BuildTypeInspector(), ignoreUnmatched, duplicateKeyChecking, typeConverter, enumNamingConvention, enforceNullability, caseInsensitivePropertyMatching, enforceRequiredProperties, BuildTypeConverters())
				},
				{
					typeof(FsharpListNodeDeserializer),
					(Nothing _) => new FsharpListNodeDeserializer(BuildTypeInspector(), enumNamingConvention)
				}
			};
			nodeTypeResolverFactories = new LazyComponentRegistrationList<Nothing, INodeTypeResolver>
			{
				{
					typeof(MappingNodeTypeResolver),
					(Nothing _) => new MappingNodeTypeResolver(typeMappings)
				},
				{
					typeof(YamlConvertibleTypeResolver),
					(Nothing _) => new YamlConvertibleTypeResolver()
				},
				{
					typeof(YamlSerializableTypeResolver),
					(Nothing _) => new YamlSerializableTypeResolver()
				},
				{
					typeof(TagNodeTypeResolver),
					(Nothing _) => new TagNodeTypeResolver(tagMappings)
				},
				{
					typeof(PreventUnknownTagsNodeTypeResolver),
					(Nothing _) => new PreventUnknownTagsNodeTypeResolver()
				},
				{
					typeof(DefaultContainersNodeTypeResolver),
					(Nothing _) => new DefaultContainersNodeTypeResolver()
				}
			};
			typeConverter = new ReflectionTypeConverter();
		}

		public ITypeInspector BuildTypeInspector()
		{
			ITypeInspector typeInspector = new WritablePropertiesTypeInspector(typeResolver, includeNonPublicProperties);
			if (!ignoreFields)
			{
				typeInspector = new CompositeTypeInspector(new ReadableFieldsTypeInspector(typeResolver), typeInspector);
			}
			return typeInspectorFactories.BuildComponentChain(typeInspector);
		}

		public DeserializerBuilder WithAttemptingUnquotedStringTypeDeserialization()
		{
			attemptUnknownTypeDeserialization = true;
			return this;
		}

		public DeserializerBuilder WithObjectFactory(IObjectFactory objectFactory)
		{
			IObjectFactory objectFactory2 = objectFactory;
			if (objectFactory2 == null)
			{
				throw new ArgumentNullException("objectFactory");
			}
			this.objectFactory = new Lazy<IObjectFactory>(() => objectFactory2, isThreadSafe: true);
			return this;
		}

		public DeserializerBuilder WithObjectFactory(Func<Type, object> objectFactory)
		{
			if (objectFactory == null)
			{
				throw new ArgumentNullException("objectFactory");
			}
			return WithObjectFactory(new LambdaObjectFactory(objectFactory));
		}

		public DeserializerBuilder WithNodeDeserializer(INodeDeserializer nodeDeserializer)
		{
			return WithNodeDeserializer(nodeDeserializer, delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> w)
			{
				w.OnTop();
			});
		}

		public DeserializerBuilder WithNodeDeserializer(INodeDeserializer nodeDeserializer, Action<IRegistrationLocationSelectionSyntax<INodeDeserializer>> where)
		{
			INodeDeserializer nodeDeserializer2 = nodeDeserializer;
			if (nodeDeserializer2 == null)
			{
				throw new ArgumentNullException("nodeDeserializer");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer2.GetType(), (Nothing _) => nodeDeserializer2));
			return this;
		}

		public DeserializerBuilder WithNodeDeserializer<TNodeDeserializer>(WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeDeserializer>> where) where TNodeDeserializer : INodeDeserializer
		{
			WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory2 = nodeDeserializerFactory;
			if (nodeDeserializerFactory2 == null)
			{
				throw new ArgumentNullException("nodeDeserializerFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (INodeDeserializer wrapped, Nothing _) => nodeDeserializerFactory2(wrapped)));
			return this;
		}

		public DeserializerBuilder WithoutNodeDeserializer<TNodeDeserializer>() where TNodeDeserializer : INodeDeserializer
		{
			return WithoutNodeDeserializer(typeof(TNodeDeserializer));
		}

		public DeserializerBuilder WithoutNodeDeserializer(Type nodeDeserializerType)
		{
			if (nodeDeserializerType == null)
			{
				throw new ArgumentNullException("nodeDeserializerType");
			}
			nodeDeserializerFactories.Remove(nodeDeserializerType);
			return this;
		}

		public DeserializerBuilder WithTypeDiscriminatingNodeDeserializer(Action<ITypeDiscriminatingNodeDeserializerOptions> configureTypeDiscriminatingNodeDeserializerOptions, int maxDepth = -1, int maxLength = -1)
		{
			TypeDiscriminatingNodeDeserializerOptions typeDiscriminatingNodeDeserializerOptions = new TypeDiscriminatingNodeDeserializerOptions();
			configureTypeDiscriminatingNodeDeserializerOptions(typeDiscriminatingNodeDeserializerOptions);
			TypeDiscriminatingNodeDeserializer nodeDeserializer = new TypeDiscriminatingNodeDeserializer(nodeDeserializerFactories.BuildComponentList(), typeDiscriminatingNodeDeserializerOptions.discriminators, maxDepth, maxLength);
			return WithNodeDeserializer(nodeDeserializer, delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> s)
			{
				s.Before<DictionaryNodeDeserializer>();
			});
		}

		public DeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver)
		{
			return WithNodeTypeResolver(nodeTypeResolver, delegate(IRegistrationLocationSelectionSyntax<INodeTypeResolver> w)
			{
				w.OnTop();
			});
		}

		public DeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver, Action<IRegistrationLocationSelectionSyntax<INodeTypeResolver>> where)
		{
			INodeTypeResolver nodeTypeResolver2 = nodeTypeResolver;
			if (nodeTypeResolver2 == null)
			{
				throw new ArgumentNullException("nodeTypeResolver");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver2.GetType(), (Nothing _) => nodeTypeResolver2));
			return this;
		}

		public DeserializerBuilder WithNodeTypeResolver<TNodeTypeResolver>(WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeTypeResolver>> where) where TNodeTypeResolver : INodeTypeResolver
		{
			WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory2 = nodeTypeResolverFactory;
			if (nodeTypeResolverFactory2 == null)
			{
				throw new ArgumentNullException("nodeTypeResolverFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (INodeTypeResolver wrapped, Nothing _) => nodeTypeResolverFactory2(wrapped)));
			return this;
		}

		public DeserializerBuilder WithCaseInsensitivePropertyMatching()
		{
			caseInsensitivePropertyMatching = true;
			return this;
		}

		public DeserializerBuilder WithEnforceNullability()
		{
			enforceNullability = true;
			return this;
		}

		public DeserializerBuilder WithEnforceRequiredMembers()
		{
			enforceRequiredProperties = true;
			return this;
		}

		public DeserializerBuilder WithoutNodeTypeResolver<TNodeTypeResolver>() where TNodeTypeResolver : INodeTypeResolver
		{
			return WithoutNodeTypeResolver(typeof(TNodeTypeResolver));
		}

		public DeserializerBuilder WithoutNodeTypeResolver(Type nodeTypeResolverType)
		{
			if (nodeTypeResolverType == null)
			{
				throw new ArgumentNullException("nodeTypeResolverType");
			}
			nodeTypeResolverFactories.Remove(nodeTypeResolverType);
			return this;
		}

		public override DeserializerBuilder WithTagMapping(TagName tag, Type type)
		{
			if (tag.IsEmpty)
			{
				throw new ArgumentException("Non-specific tags cannot be maped");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (tagMappings.TryGetValue(tag, out Type value))
			{
				throw new ArgumentException($"Type already has a registered type '{value.FullName}' for tag '{tag}'", "tag");
			}
			tagMappings.Add(tag, type);
			return this;
		}

		public DeserializerBuilder WithTypeMapping<TInterface, TConcrete>() where TConcrete : TInterface
		{
			Type typeFromHandle = typeof(TInterface);
			Type typeFromHandle2 = typeof(TConcrete);
			if (!typeFromHandle.IsAssignableFrom(typeFromHandle2))
			{
				throw new InvalidOperationException("The type '" + typeFromHandle2.Name + "' does not implement interface '" + typeFromHandle.Name + "'.");
			}
			if (!DictionaryExtensions.TryAdd(typeMappings, typeFromHandle, typeFromHandle2))
			{
				typeMappings[typeFromHandle] = typeFromHandle2;
			}
			return this;
		}

		public DeserializerBuilder WithoutTagMapping(TagName tag)
		{
			if (tag.IsEmpty)
			{
				throw new ArgumentException("Non-specific tags cannot be maped");
			}
			if (!tagMappings.Remove(tag))
			{
				throw new KeyNotFoundException($"Tag '{tag}' is not registered");
			}
			return this;
		}

		public DeserializerBuilder IgnoreUnmatchedProperties()
		{
			ignoreUnmatched = true;
			return this;
		}

		public DeserializerBuilder WithDuplicateKeyChecking()
		{
			duplicateKeyChecking = true;
			return this;
		}

		public IDeserializer Build()
		{
			if (FsharpHelper.Instance == null)
			{
				FsharpHelper.Instance = new DefaultFsharpHelper();
			}
			return Deserializer.FromValueDeserializer(BuildValueDeserializer());
		}

		public IValueDeserializer BuildValueDeserializer()
		{
			return new AliasValueDeserializer(new NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList(), typeConverter, enumNamingConvention, BuildTypeInspector()));
		}
	}
	public sealed class EmissionPhaseObjectGraphVisitorArgs
	{
		private readonly IEnumerable<IObjectGraphVisitor<Nothing>> preProcessingPhaseVisitors;

		public IObjectGraphVisitor<IEmitter> InnerVisitor { get; private set; }

		public IEventEmitter EventEmitter { get; private set; }

		public ObjectSerializer NestedObjectSerializer { get; private set; }

		public IEnumerable<IYamlTypeConverter> TypeConverters { get; private set; }

		public EmissionPhaseObjectGraphVisitorArgs(IObjectGraphVisitor<IEmitter> innerVisitor, IEventEmitter eventEmitter, IEnumerable<IObjectGraphVisitor<Nothing>> preProcessingPhaseVisitors, IEnumerable<IYamlTypeConverter> typeConverters, ObjectSerializer nestedObjectSerializer)
		{
			InnerVisitor = innerVisitor ?? throw new ArgumentNullException("innerVisitor");
			EventEmitter = eventEmitter ?? throw new ArgumentNullException("eventEmitter");
			this.preProcessingPhaseVisitors = preProcessingPhaseVisitors ?? throw new ArgumentNullException("preProcessingPhaseVisitors");
			TypeConverters = typeConverters ?? throw new ArgumentNullException("typeConverters");
			NestedObjectSerializer = nestedObjectSerializer ?? throw new ArgumentNullException("nestedObjectSerializer");
		}

		public T GetPreProcessingPhaseObjectGraphVisitor<T>() where T : IObjectGraphVisitor<Nothing>
		{
			return preProcessingPhaseVisitors.OfType<T>().Single();
		}
	}
	public abstract class EventInfo
	{
		public IObjectDescriptor Source { get; }

		protected EventInfo(IObjectDescriptor source)
		{
			Source = source ?? throw new ArgumentNullException("source");
		}
	}
	public class AliasEventInfo : EventInfo
	{
		public AnchorName Alias { get; }

		public bool NeedsExpansion { get; set; }

		public AliasEventInfo(IObjectDescriptor source, AnchorName alias)
			: base(source)
		{
			if (alias.IsEmpty)
			{
				throw new ArgumentNullException("alias");
			}
			Alias = alias;
		}
	}
	public class ObjectEventInfo : EventInfo
	{
		public AnchorName Anchor { get; set; }

		public TagName Tag { get; set; }

		protected ObjectEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	public sealed class ScalarEventInfo : ObjectEventInfo
	{
		public string RenderedValue { get; set; }

		public ScalarStyle Style { get; set; }

		public bool IsPlainImplicit { get; set; }

		public bool IsQuotedImplicit { get; set; }

		public ScalarEventInfo(IObjectDescriptor source)
			: base(source)
		{
			Style = source.ScalarStyle;
			RenderedValue = string.Empty;
		}
	}
	public sealed class MappingStartEventInfo : ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public MappingStyle Style { get; set; }

		public MappingStartEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	public sealed class MappingEndEventInfo : EventInfo
	{
		public MappingEndEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	public sealed class SequenceStartEventInfo : ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public SequenceStyle Style { get; set; }

		public SequenceStartEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	public sealed class SequenceEndEventInfo : EventInfo
	{
		public SequenceEndEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	public interface IAliasProvider
	{
		AnchorName GetAlias(object target);
	}
	public interface IDeserializer
	{
		T Deserialize<T>(string input);

		T Deserialize<T>(TextReader input);

		T Deserialize<T>(IParser parser);

		object? Deserialize(string input);

		object? Deserialize(TextReader input);

		object? Deserialize(IParser parser);

		object? Deserialize(string input, Type type);

		object? Deserialize(TextReader input, Type type);

		object? Deserialize(IParser parser, Type type);
	}
	public interface IEventEmitter
	{
		void Emit(AliasEventInfo eventInfo, IEmitter emitter);

		void Emit(ScalarEventInfo eventInfo, IEmitter emitter);

		void Emit(MappingStartEventInfo eventInfo, IEmitter emitter);

		void Emit(MappingEndEventInfo eventInfo, IEmitter emitter);

		void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter);

		void Emit(SequenceEndEventInfo eventInfo, IEmitter emitter);
	}
	public interface INamingConvention
	{
		string Apply(string value);

		string Reverse(string value);
	}
	public interface INodeDeserializer
	{
		bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer);
	}
	public interface INodeTypeResolver
	{
		bool Resolve(NodeEvent? nodeEvent, ref Type currentType);
	}
	public interface IObjectAccessor
	{
		void Set(string name, object target, object value);

		object? Read(string name, object target);
	}
	public interface IObjectDescriptor
	{
		object? Value { get; }

		Type Type { get; }

		Type StaticType { get; }

		ScalarStyle ScalarStyle { get; }
	}
	public static class ObjectDescriptorExtensions
	{
		public static object NonNullValue(this IObjectDescriptor objectDescriptor)
		{
			return objectDescriptor.Value ?? throw new InvalidOperationException("Attempted to use a IObjectDescriptor of type '" + objectDescriptor.Type.FullName + "' whose Value is null at a point whete it is invalid to do so. This may indicate a bug in YamlDotNet.");
		}
	}
	public interface IObjectFactory
	{
		object Create(Type type);

		object? CreatePrimitive(Type type);

		bool GetDictionary(IObjectDescriptor descriptor, out IDictionary? dictionary, out Type[]? genericArguments);

		Type GetValueType(Type type);

		void ExecuteOnDeserializing(object value);

		void ExecuteOnDeserialized(object value);

		void ExecuteOnSerializing(object value);

		void ExecuteOnSerialized(object value);
	}
	public interface IObjectGraphTraversalStrategy
	{
		void Traverse<TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context, ObjectSerializer serializer);
	}
	public interface IObjectGraphVisitor<TContext>
	{
		bool Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, TContext context, ObjectSerializer serializer);

		bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, TContext context, ObjectSerializer serializer);

		bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, TContext context, ObjectSerializer serializer);

		void VisitScalar(IObjectDescriptor scalar, TContext context, ObjectSerializer serializer);

		void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, TContext context, ObjectSerializer serializer);

		void VisitMappingEnd(IObjectDescriptor mapping, TContext context, ObjectSerializer serializer);

		void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, TContext context, ObjectSerializer serializer);

		void VisitSequenceEnd(IObjectDescriptor sequence, TContext context, ObjectSerializer serializer);
	}
	public interface IPropertyDescriptor
	{
		string Name { get; }

		bool AllowNulls { get; }

		bool CanWrite { get; }

		Type Type { get; }

		Type? TypeOverride { get; set; }

		int Order { get; set; }

		ScalarStyle ScalarStyle { get; set; }

		bool Required { get; }

		Type? ConverterType { get; }

		T? GetCustomAttribute<T>() where T : Attribute;

		IObjectDescriptor Read(object target);

		void Write(object target, object? value);
	}
	public interface IRegistrationLocationSelectionSyntax<TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;

		void Before<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;

		void After<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;

		void OnTop();

		void OnBottom();
	}
	public interface ITrackingRegistrationLocationSelectionSyntax<TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
	}
	public interface ISerializer
	{
		string Serialize(object? graph);

		string Serialize(object? graph, Type type);

		void Serialize(TextWriter writer, object? graph);

		void Serialize(TextWriter writer, object? graph, Type type);

		void Serialize(IEmitter emitter, object? graph);

		void Serialize(IEmitter emitter, object? graph, Type type);
	}
	public interface ITypeInspector
	{
		IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container);

		IPropertyDescriptor GetProperty(Type type, object? container, string name, [MaybeNullWhen(true)] bool ignoreUnmatched, bool caseInsensitivePropertyMatching);

		string GetEnumName(Type enumType, string name);

		string GetEnumValue(object enumValue);
	}
	public interface ITypeResolver
	{
		Type Resolve(Type staticType, object? actualValue);
	}
	public interface IValueDeserializer
	{
		object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer);
	}
	public interface IValuePromise
	{
		event Action<object?> ValueAvailable;
	}
	public interface IValueSerializer
	{
		void SerializeValue(IEmitter emitter, object? value, Type? type);
	}
	public interface IYamlConvertible
	{
		void Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer);

		void Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer);
	}
	public delegate object? ObjectDeserializer(Type type);
	public delegate void ObjectSerializer(object? value, Type? type = null);
	[Obsolete("Please use IYamlConvertible instead")]
	public interface IYamlSerializable
	{
		void ReadYaml(IParser parser);

		void WriteYaml(IEmitter emitter);
	}
	public interface IYamlTypeConverter
	{
		bool Accepts(Type type);

		object? ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer);

		void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer);
	}
	internal sealed class LazyComponentRegistrationList<TArgument, TComponent> : IEnumerable<Func<TArgument, TComponent>>, IEnumerable
	{
		public sealed class LazyComponentRegistration
		{
			public readonly Type ComponentType;

			public readonly Func<TArgument, TComponent> Factory;

			public LazyComponentRegistration(Type componentType, Func<TArgument, TComponent> factory)
			{
				ComponentType = componentType;
				Factory = factory;
			}
		}

		public sealed class TrackingLazyComponentRegistration
		{
			public readonly Type ComponentType;

			public readonly Func<TComponent, TArgument, TComponent> Factory;

			public TrackingLazyComponentRegistration(Type componentType, Func<TComponent, TArgument, TComponent> factory)
			{
				ComponentType = componentType;
				Factory = factory;
			}
		}

		private class RegistrationLocationSelector : IRegistrationLocationSelectionSyntax<TComponent>
		{
			private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;

			private readonly LazyComponentRegistration newRegistration;

			public RegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, LazyComponentRegistration newRegistration)
			{
				this.registrations = registrations;
				this.newRegistration = newRegistration;
			}

			void IRegistrationLocationSelectionSyntax<TComponent>.InsteadOf<TRegistrationType>()
			{
				if (newRegistration.ComponentType != typeof(TRegistrationType))
				{
					registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				}
				int index = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries[index] = newRegistration;
			}

			void IRegistrationLocationSelectionSyntax<TComponent>.After<TRegistrationType>()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				int num = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries.Insert(num + 1, newRegistration);
			}

			void IRegistrationLocationSelectionSyntax<TComponent>.Before<TRegistrationType>()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				int index = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries.Insert(index, newRegistration);
			}

			void IRegistrationLocationSelectionSyntax<TComponent>.OnBottom()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				registrations.entries.Add(newRegistration);
			}

			void IRegistrationLocationSelectionSyntax<TComponent>.OnTop()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				registrations.entries.Insert(0, newRegistration);
			}
		}

		private class TrackingRegistrationLocationSelector : ITrackingRegistrationLocationSelectionSyntax<TComponent>
		{
			private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;

			private readonly TrackingLazyComponentRegistration newRegistration;

			public TrackingRegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, TrackingLazyComponentRegistration newRegistration)
			{
				this.registrations = registrations;
				this.newRegistration = newRegistration;
			}

			void ITrackingRegistrationLocationSelectionSyntax<TComponent>.InsteadOf<TRegistrationType>()
			{
				if (newRegistration.ComponentType != typeof(TRegistrationType))
				{
					registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				}
				int index = registrations.EnsureRegistrationExists<TRegistrationType>();
				Func<TArgument, TComponent> innerComponentFactory = registrations.entries[index].Factory;
				registrations.entries[index] = new LazyComponentRegistration(newRegistration.ComponentType, (TArgument arg) => newRegistration.Factory(innerComponentFactory(arg), arg));
			}
		}

		private readonly List<LazyComponentRegistration> entries = new List<LazyComponentRegistration>();

		public int Count => entries.Count;

		public IEnumerable<Func<TArgument, TComponent>> InReverseOrder
		{
			get
			{
				int i = entries.Count - 1;
				while (i >= 0)
				{
					yield return entries[i].Factory;
					int num = i - 1;
					i = num;
				}
			}
		}

		public LazyComponentRegistrationList<TArgument, TComponent> Clone()
		{
			LazyComponentRegistrationList<TArgument, TComponent> lazyComponentRegistrationList = new LazyComponentRegistrationList<TArgument, TComponent>();
			foreach (LazyComponentRegistration entry in entries)
			{
				lazyComponentRegistrationList.entries.Add(entry);
			}
			return lazyComponentRegistrationList;
		}

		public void Clear()
		{
			entries.Clear();
		}

		public void Add(Type componentType, Func<TArgument, TComponent> factory)
		{
			entries.Add(new LazyComponentRegistration(componentType, factory));
		}

		public void Remove(Type componentType)
		{
			for (int i = 0; i < entries.Count; i++)
			{
				if (entries[i].ComponentType == componentType)
				{
					entries.RemoveAt(i);
					return;
				}
			}
			throw new KeyNotFoundException("A component registration of type '" + componentType.FullName + "' was not found.");
		}

		public IRegistrationLocationSelectionSyntax<TComponent> CreateRegistrationLocationSelector(Type componentType, Func<TArgument, TComponent> factory)
		{
			return new RegistrationLocationSelector(this, new LazyComponentRegistration(componentType, factory));
		}

		public ITrackingRegistrationLocationSelectionSyntax<TComponent> CreateTrackingRegistrationLocationSelector(Type componentType, Func<TComponent, TArgument, TComponent> factory)
		{
			return new TrackingRegistrationLocationSelector(this, new TrackingLazyComponentRegistration(componentType, factory));
		}

		public IEnumerator<Func<TArgument, TComponent>> GetEnumerator()
		{
			return entries.Select((LazyComponentRegistration e) => e.Factory).GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		private int IndexOfRegistration(Type registrationType)
		{
			for (int i = 0; i < entries.Count; i++)
			{
				if (registrationType == entries[i].ComponentType)
				{
					return i;
				}
			}
			return -1;
		}

		private void EnsureNoDuplicateRegistrationType(Type componentType)
		{
			if (IndexOfRegistration(componentType) != -1)
			{
				throw new InvalidOperationException("A component of type '" + componentType.FullName + "' has already been registered.");
			}
		}

		private int EnsureRegistrationExists<TRegistrationType>()
		{
			int num = IndexOfRegistration(typeof(TRegistrationType));
			if (num == -1)
			{
				throw new InvalidOperationException("A component of type '" + typeof(TRegistrationType).FullName + "' has not been registered.");
			}
			return num;
		}
	}
	internal static class LazyComponentRegistrationListExtensions
	{
		public static TComponent BuildComponentChain<TComponent>(this LazyComponentRegistrationList<TComponent, TComponent> registrations, TComponent innerComponent)
		{
			return registrations.InReverseOrder.Aggregate(innerComponent, (TComponent inner, Func<TComponent, TComponent> factory) => factory(inner));
		}

		public static TComponent BuildComponentChain<TArgument, TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TComponent innerComponent, Func<TComponent, TArgument> argumentBuilder)
		{
			Func<TComponent, TArgument> argumentBuilder2 = argumentBuilder;
			return registrations.InReverseOrder.Aggregate(innerComponent, (TComponent inner, Func<TArgument, TComponent> factory) => factory(argumentBuilder2(inner)));
		}

		public static List<TComponent> BuildComponentList<TComponent>(this LazyComponentRegistrationList<Nothing, TComponent> registrations)
		{
			return registrations.Select((Func<Nothing, TComponent> factory) => factory(default(Nothing))).ToList();
		}

		public static List<TComponent> BuildComponentList<TArgument, TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TArgument argument)
		{
			TArgument argument2 = argument;
			return registrations.Select((Func<TArgument, TComponent> factory) => factory(argument2)).ToList();
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct Nothing
	{
	}
	public sealed class ObjectDescriptor : IObjectDescriptor
	{
		public object? Value { get; private set; }

		public Type Type { get; private set; }

		public Type StaticType { get; private set; }

		public ScalarStyle ScalarStyle { get; private set; }

		public ObjectDescriptor(object? value, Type type, Type staticType)
			: this(value, type, staticType, ScalarStyle.Any)
		{
		}

		public ObjectDescriptor(object? value, Type type, Type staticType, ScalarStyle scalarStyle)
		{
			Value = value;
			Type = type ?? throw new ArgumentNullException("type");
			StaticType = staticType ?? throw new ArgumentNullException("staticType");
			ScalarStyle = scalarStyle;
		}
	}
	public delegate IObjectGraphTraversalStrategy ObjectGraphTraversalStrategyFactory(ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion);
	public sealed class PropertyDescriptor : IPropertyDescriptor
	{
		private readonly IPropertyDescriptor baseDescriptor;

		public bool AllowNulls => baseDescriptor.AllowNulls;

		public string Name { get; set; }

		public bool Required => baseDescriptor.Required;

		public Type Type => baseDescriptor.Type;

		public Type? TypeOverride
		{
			get
			{
				return baseDescriptor.TypeOverride;
			}
			set
			{
				baseDescriptor.TypeOverride = value;
			}
		}

		public Type? ConverterType => baseDescriptor.ConverterType;

		public int Order { get; set; }

		public ScalarStyle ScalarStyle
		{
			get
			{
				return baseDescriptor.ScalarStyle;
			}
			set
			{
				baseDescriptor.ScalarStyle = value;
			}
		}

		public bool CanWrite => baseDescriptor.CanWrite;

		public PropertyDescriptor(IPropertyDescriptor baseDescriptor)
		{
			this.baseDescriptor = baseDescriptor;
			Name = baseDescriptor.Name;
		}

		public void Write(object target, object? value)
		{
			baseDescriptor.Write(target, value);
		}

		public T? GetCustomAttribute<T>() where T : Attribute
		{
			return baseDescriptor.GetCustomAttribute<T>();
		}

		public IObjectDescriptor Read(object target)
		{
			return baseDescriptor.Read(target);
		}
	}
	public sealed class Serializer : ISerializer
	{
		private readonly IValueSerializer valueSerializer;

		private readonly EmitterSettings emitterSettings;

		public Serializer()
			: this(new SerializerBuilder().BuildValueSerializer(), EmitterSettings.Default)
		{
		}

		private Serializer(IValueSerializer valueSerializer, EmitterSettings emitterSettings)
		{
			this.valueSerializer = valueSerializer ?? throw new ArgumentNullException("valueSerializer");
			this.emitterSettings = emitterSettings ?? throw new ArgumentNullException("emitterSettings");
		}

		public static Serializer FromValueSerializer(IValueSerializer valueSerializer, EmitterSettings emitterSettings)
		{
			return new Serializer(valueSerializer, emitterSettings);
		}

		public string Serialize(object? graph)
		{
			using StringWriter stringWriter = new StringWriter();
			Serialize(stringWriter, graph);
			return stringWriter.ToString();
		}

		public string Serialize(object? graph, Type type)
		{
			using StringWriter stringWriter = new StringWriter();
			Serialize(stringWriter, graph, type);
			return stringWriter.ToString();
		}

		public void Serialize(TextWriter writer, object? graph)
		{
			Serialize(new Emitter(writer, emitterSettings), graph);
		}

		public void Serialize(TextWriter writer, object? graph, Type type)
		{
			Serialize(new Emitter(writer, emitterSettings), graph, type);
		}

		public void Serialize(IEmitter emitter, object? graph)
		{
			if (emitter == null)
			{
				throw new ArgumentNullException("emitter");
			}
			EmitDocument(emitter, graph, null);
		}

		public void Serialize(IEmitter emitter, object? graph, Type type)
		{
			if (emitter == null)
			{
				throw new ArgumentNullException("emitter");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			EmitDocument(emitter, graph, type);
		}

		private void EmitDocument(IEmitter emitter, object? graph, Type? type)
		{
			emitter.Emit(new YamlDotNet.Core.Events.StreamStart());
			emitter.Emit(new YamlDotNet.Core.Events.DocumentStart());
			valueSerializer.SerializeValue(emitter, graph, type);
			emitter.Emit(new YamlDotNet.Core.Events.DocumentEnd(isImplicit: true));
			emitter.Emit(new YamlDotNet.Core.Events.StreamEnd());
		}
	}
	public sealed class SerializerBuilder : BuilderSkeleton<SerializerBuilder>
	{
		private class ValueSerializer : IValueSerializer
		{
			private readonly IObjectGraphTraversalStrategy traversalStrategy;

			private readonly IEventEmitter eventEmitter;

			private readonly IEnumerable<IYamlTypeConverter> typeConverters;

			private readonly LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

			private readonly LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories;

			public ValueSerializer(IObjectGraphTraversalStrategy traversalStrategy, IEventEmitter eventEmitter, IEnumerable<IYamlTypeConverter> typeConverters, LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories, LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories)
			{
				this.traversalStrategy = traversalStrategy;
				this.eventEmitter = eventEmitter;
				this.typeConverters = typeConverters;
				this.preProcessingPhaseObjectGraphVisitorFactories = preProcessingPhaseObjectGraphVisitorFactories;
				this.emissionPhaseObjectGraphVisitorFactories = emissionPhaseObjectGraphVisitorFactories;
			}

			public void SerializeValue(IEmitter emitter, object? value, Type? type)
			{
				IEmitter emitter2 = emitter;
				Type type2 = type ?? ((value != null) ? value.GetType() : typeof(object));
				Type staticType = type ?? typeof(object);
				ObjectDescriptor graph = new ObjectDescriptor(value, type2, staticType);
				List<IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitors = preProcessingPhaseObjectGraphVisitorFactories.BuildComponentList(typeConverters);
				IObjectGraphVisitor<IEmitter> visitor = emissionPhaseObjectGraphVisitorFactories.BuildComponentChain<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>>(new EmittingObjectGraphVisitor(eventEmitter), (IObjectGraphVisitor<IEmitter> inner) => new EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
				foreach (IObjectGraphVisitor<Nothing> item in preProcessingPhaseObjectGraphVisitors)
				{
					traversalStrategy.Traverse(graph, item, default(Nothing), NestedObjectSerializer);
				}
				traversalStrategy.Traverse(graph, visitor, emitter2, NestedObjectSerializer);
				void NestedObjectSerializer(object? v, Type? t)
				{
					SerializeValue(emitter2, v, t);
				}
			}
		}

		private ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory;

		private readonly LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

		private readonly LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories;

		private readonly LazyComponentRegistrationList<IEventEmitter, IEventEmitter> eventEmitterFactories;

		private readonly Dictionary<Type, TagName> tagMappings = new Dictionary<Type, TagName>();

		private readonly IObjectFactory objectFactory;

		private int maximumRecursion = 50;

		private EmitterSettings emitterSettings = EmitterSettings.Default;

		private DefaultValuesHandling defaultValuesHandlingConfiguration;

		private ScalarStyle defaultScalarStyle;

		private bool quoteNecessaryStrings;

		private bool quoteYaml1_1Strings;

		protected override SerializerBuilder Self => this;

		public SerializerBuilder()
			: base((ITypeResolver)new DynamicTypeResolver())
		{
			typeInspectorFactories.Add(typeof(CachedTypeInspector), (ITypeInspector inner) => new CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(NamingConventionTypeInspector), (ITypeInspector inner) => (!(namingConvention is NullNamingConvention)) ? new NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(YamlAttributesTypeInspector), (ITypeInspector inner) => new YamlAttributesTypeInspector(inner));
			typeInspectorFactories.Add(typeof(YamlAttributeOverridesInspector), (ITypeInspector inner) => (overrides == null) ? inner : new YamlAttributeOverridesInspector(inner, overrides.Clone()));
			preProcessingPhaseObjectGraphVisitorFactories = new LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> { 
			{
				typeof(AnchorAssigner),
				(IEnumerable<IYamlTypeConverter> typeConverters) => new AnchorAssigner(typeConverters)
			} };
			emissionPhaseObjectGraphVisitorFactories = new LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>>
			{
				{
					typeof(CustomSerializationObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new CustomSerializationObjectGraphVisitor(args.InnerVisitor, args.TypeConverters, args.NestedObjectSerializer)
				},
				{
					typeof(AnchorAssigningObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new AnchorAssigningObjectGraphVisitor(args.InnerVisitor, args.EventEmitter, args.GetPreProcessingPhaseObjectGraphVisitor<AnchorAssigner>())
				},
				{
					typeof(DefaultValuesObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new DefaultValuesObjectGraphVisitor(defaultValuesHandlingConfiguration, args.InnerVisitor, new DefaultObjectFactory())
				},
				{
					typeof(CommentsObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new CommentsObjectGraphVisitor(args.InnerVisitor)
				}
			};
			eventEmitterFactories = new LazyComponentRegistrationList<IEventEmitter, IEventEmitter> { 
			{
				typeof(TypeAssigningEventEmitter),
				(IEventEmitter inner) => new TypeAssigningEventEmitter(inner, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings, defaultScalarStyle, yamlFormatter, enumNamingConvention, BuildTypeInspector())
			} };
			objectFactory = new DefaultObjectFactory();
			objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new FullObjectGraphTraversalStrategy(typeInspector, typeResolver, maximumRecursion, namingConvention, objectFactory);
		}

		public SerializerBuilder WithQuotingNecessaryStrings(bool quoteYaml1_1Strings = false)
		{
			quoteNecessaryStrings = true;
			this.quoteYaml1_1Strings = quoteYaml1_1Strings;
			return this;
		}

		public SerializerBuilder WithDefaultScalarStyle(ScalarStyle style)
		{
			defaultScalarStyle = style;
			return this;
		}

		public SerializerBuilder WithMaximumRecursion(int maximumRecursion)
		{
			if (maximumRecursion <= 0)
			{
				throw new ArgumentOutOfRangeException("maximumRecursion", $"The maximum recursion specified ({maximumRecursion}) is invalid. It should be a positive integer.");
			}
			this.maximumRecursion = maximumRecursion;
			return this;
		}

		public SerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			Func<IEventEmitter, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			return WithEventEmitter((IEventEmitter e, ITypeInspector _) => eventEmitterFactory2(e), where);
		}

		public SerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			if (eventEmitterFactory2 == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter inner) => eventEmitterFactory2(inner, BuildTypeInspector())));
			return Self;
		}

		public SerializerBuilder WithEventEmitter<TEventEmitter>(WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			if (eventEmitterFactory2 == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateTrackingRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter wrapped, IEventEmitter inner) => eventEmitterFactory2(wrapped, inner)));
			return Self;
		}

		public SerializerBuilder WithoutEventEmitter<TEventEmitter>() where TEventEmitter : IEventEmitter
		{
			return WithoutEventEmitter(typeof(TEventEmitter));
		}

		public SerializerBuilder WithoutEventEmitter(Type eventEmitterType)
		{
			if (eventEmitterType == null)
			{
				throw new ArgumentNullException("eventEmitterType");
			}
			eventEmitterFactories.Remove(eventEmitterType);
			return this;
		}

		public override SerializerBuilder WithTagMapping(TagName tag, Type type)
		{
			if (tag.IsEmpty)
			{
				throw new ArgumentException("Non-specific tags cannot be maped");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (tagMappings.TryGetValue(type, out var value))
			{
				throw new ArgumentException($"Type already has a registered tag '{value}' for type '{type.FullName}'", "type");
			}
			tagMappings.Add(type, tag);
			return this;
		}

		public SerializerBuilder WithoutTagMapping(Type type)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (!tagMappings.Remove(type))
			{
				throw new KeyNotFoundException("Tag for type '" + type.FullName + "' is not registered");
			}
			return this;
		}

		public SerializerBuilder EnsureRoundtrip()
		{
			objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new RoundtripObjectGraphTraversalStrategy(typeConverters, typeInspector, typeResolver, maximumRecursion, namingConvention, settings, objectFactory);
			WithEventEmitter((IEventEmitter inner) => new TypeAssigningEventEmitter(inner, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings, defaultScalarStyle, yamlFormatter, enumNamingConvention, BuildTypeInspector()), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
			return WithTypeInspector((ITypeInspector inner) => new ReadableAndWritablePropertiesTypeInspector(inner), delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> loc)
			{
				loc.OnBottom();
			});
		}

		public SerializerBuilder DisableAliases()
		{
			preProcessingPhaseObjectGraphVisitorFactories.Remove(typeof(AnchorAssigner));
			emissionPhaseObjectGraphVisitorFactories.Remove(typeof(AnchorAssigningObjectGraphVisitor));
			return this;
		}

		[Obsolete("The default behavior is now to always emit default values, thefore calling this method has no effect. This behavior is now controlled by ConfigureDefaultValuesHandling.", true)]
		public SerializerBuilder EmitDefaults()
		{
			return ConfigureDefaultValuesHandling(DefaultValuesHandling.Preserve);
		}

		public SerializerBuilder ConfigureDefaultValuesHandling(DefaultValuesHandling configuration)
		{
			defaultValuesHandlingConfiguration = configuration;
			return this;
		}

		public SerializerBuilder JsonCompatible()
		{
			emitterSettings = emitterSettings.WithMaxSimpleKeyLength(int.MaxValue).WithoutAnchorName().WithUtf16SurrogatePairs();
			return WithTypeConverter(new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: true), delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.InsteadOf<YamlDotNet.Serialization.Converters.GuidConverter>();
			}).WithTypeConverter(new DateTime8601Converter(ScalarStyle.DoubleQuoted)).WithEventEmitter((IEventEmitter inner) => new JsonEventEmitter(inner, yamlFormatter, enumNamingConvention, BuildTypeInspector()), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
		}

		public SerializerBuilder WithNewLine(string newLine)
		{
			emitterSettings = emitterSettings.WithNewLine(newLine);
			return this;
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			TObjectGraphVisitor objectGraphVisitor2 = objectGraphVisitor;
			if (objectGraphVisitor2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitor");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> _) => objectGraphVisitor2));
			return this;
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory2(typeConverters)));
			return this;
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> _) => objectGraphVisitorFactory2(wrapped)));
			return this;
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			WrapperFactory<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory2(wrapped, typeConverters)));
			return this;
		}

		public SerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithoutPreProcessingPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

		public SerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor(Type objectGraphVisitorType)
		{
			if (objectGraphVisitorType == null)
			{
				throw new ArgumentNullException("objectGraphVisitorType");
			}
			preProcessingPhaseObjectGraphVisitorFactories.Remove(objectGraphVisitorType);
			return this;
		}

		public SerializerBuilder WithObjectGraphTraversalStrategyFactory(ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory)
		{
			this.objectGraphTraversalStrategyFactory = objectGraphTraversalStrategyFactory;
			return this;
		}

		public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory2(args)));
			return this;
		}

		public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			WrapperFactory<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<IEmitter> wrapped, EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory2(wrapped, args)));
			return this;
		}

		public SerializerBuilder WithoutEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithoutEmissionPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

		public SerializerBuilder WithoutEmissionPhaseObjectGraphVisitor(Type objectGraphVisitorType)
		{
			if (objectGraphVisitorType == null)
			{
				throw new ArgumentNullException("objectGraphVisitorType");
			}
			emissionPhaseObjectGraphVisitorFactories.Remove(objectGraphVisitorType);
			return this;
		}

		public SerializerBuilder WithIndentedSequences()
		{
			emitterSettings = emitterSettings.WithIndentedSequences();
			return this;
		}

		public ISerializer Build()
		{
			if (FsharpHelper.Instance == null)
			{
				FsharpHelper.Instance = new DefaultFsharpHelper();
			}
			return Serializer.FromValueSerializer(BuildValueSerializer(), emitterSettings);
		}

		public IValueSerializer BuildValueSerializer()
		{
			IEnumerable<IYamlTypeConverter> typeConverters = BuildTypeConverters();
			ITypeInspector typeInspector = BuildTypeInspector();
			IObjectGraphTraversalStrategy traversalStrategy = objectGraphTraversalStrategyFactory(typeInspector, typeResolver, typeConverters, maximumRecursion);
			IEventEmitter eventEmitter = eventEmitterFactories.BuildComponentChain(new WriterEventEmitter());
			return new ValueSerializer(traversalStrategy, eventEmitter, typeConverters, preProcessingPhaseObjectGraphVisitorFactories.Clone(), emissionPhaseObjectGraphVisitorFactories.Clone());
		}

		public ITypeInspector BuildTypeInspector()
		{
			ITypeInspector typeInspector = new ReadablePropertiesTypeInspector(typeResolver, includeNonPublicProperties);
			if (!ignoreFields)
			{
				typeInspector = new CompositeTypeInspector(new ReadableFieldsTypeInspector(typeResolver), typeInspector);
			}
			return typeInspectorFactories.BuildComponentChain(typeInspector);
		}
	}
	public class Settings
	{
		public bool AllowPrivateConstructors { get; set; }
	}
	public abstract class StaticBuilderSkeleton<TBuilder> where TBuilder : StaticBuilderSkeleton<TBuilder>
	{
		internal INamingConvention namingConvention = NullNamingConvention.Instance;

		internal INamingConvention enumNamingConvention = NullNamingConvention.Instance;

		internal ITypeResolver typeResolver;

		internal readonly LazyComponentRegistrationList<Nothing, IYamlTypeConverter> typeConverterFactories;

		internal readonly LazyComponentRegistrationList<ITypeInspector, ITypeInspector> typeInspectorFactories;

		internal bool includeNonPublicProperties;

		internal Settings settings;

		internal YamlFormatter yamlFormatter = YamlFormatter.Default;

		protected abstract TBuilder Self { get; }

		internal StaticBuilderSkeleton(ITypeResolver typeResolver)
		{
			typeConverterFactories = new LazyComponentRegistrationList<Nothing, IYamlTypeConverter> { 
			{
				typeof(YamlDotNet.Serialization.Converters.GuidConverter),
				(Nothing _) => new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: false)
			} };
			typeInspectorFactories = new LazyComponentRegistrationList<ITypeInspector, ITypeInspector>();
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			settings = new Settings();
		}

		public TBuilder WithNamingConvention(INamingConvention namingConvention)
		{
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
			return Self;
		}

		public TBuilder WithEnumNamingConvention(INamingConvention enumNamingConvention)
		{
			this.enumNamingConvention = enumNamingConvention ?? throw new ArgumentNullException("enumNamingConvention");
			return Self;
		}

		public TBuilder WithTypeResolver(ITypeResolver typeResolver)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			return Self;
		}

		public abstract TBuilder WithTagMapping(TagName tag, Type type);

		public TBuilder WithTypeConverter(IYamlTypeConverter typeConverter)
		{
			return WithTypeConverter(typeConverter, delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeConverter(IYamlTypeConverter typeConverter, Action<IRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where)
		{
			IYamlTypeConverter typeConverter2 = typeConverter;
			if (typeConverter2 == null)
			{
				throw new ArgumentNullException("typeConverter");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter2.GetType(), (Nothing _) => typeConverter2));
			return Self;
		}

		public TBuilder WithTypeConverter<TYamlTypeConverter>(WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where) where TYamlTypeConverter : IYamlTypeConverter
		{
			WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory2 = typeConverterFactory;
			if (typeConverterFactory2 == null)
			{
				throw new ArgumentNullException("typeConverterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (IYamlTypeConverter wrapped, Nothing _) => typeConverterFactory2(wrapped)));
			return Self;
		}

		public TBuilder WithoutTypeConverter<TYamlTypeConverter>() where TYamlTypeConverter : IYamlTypeConverter
		{
			return WithoutTypeConverter(typeof(TYamlTypeConverter));
		}

		public TBuilder WithoutTypeConverter(Type converterType)
		{
			if (converterType == null)
			{
				throw new ArgumentNullException("converterType");
			}
			typeConverterFactories.Remove(converterType);
			return Self;
		}

		public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : ITypeInspector
		{
			return WithTypeInspector(typeInspectorFactory, delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory, Action<IRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			Func<ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
			if (typeInspectorFactory2 == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector inner) => typeInspectorFactory2(inner)));
			return Self;
		}

		public TBuilder WithTypeInspector<TTypeInspector>(WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
			if (typeInspectorFactory2 == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector wrapped, ITypeInspector inner) => typeInspectorFactory2(wrapped, inner)));
			return Self;
		}

		public TBuilder WithoutTypeInspector<TTypeInspector>() where TTypeInspector : ITypeInspector
		{
			return WithoutTypeInspector(typeof(TTypeInspector));
		}

		public TBuilder WithoutTypeInspector(Type inspectorType)
		{
			if (inspectorType == null)
			{
				throw new ArgumentNullException("inspectorType");
			}
			typeInspectorFactories.Remove(inspectorType);
			return Self;
		}

		public TBuilder WithYamlFormatter(YamlFormatter formatter)
		{
			yamlFormatter = formatter ?? throw new ArgumentNullException("formatter");
			return Self;
		}

		protected IEnumerable<IYamlTypeConverter> BuildTypeConverters()
		{
			return typeConverterFactories.BuildComponentList();
		}
	}
	public abstract class StaticContext
	{
		public virtual bool IsKnownType(Type type)
		{
			throw new NotImplementedException();
		}

		public virtual ITypeResolver GetTypeResolver()
		{
			throw new NotImplementedException();
		}

		public virtual StaticObjectFactory GetFactory()
		{
			throw new NotImplementedException();
		}

		public virtual ITypeInspector GetTypeInspector()
		{
			throw new NotImplementedException();
		}
	}
	public sealed class StaticDeserializerBuilder : StaticBuilderSkeleton<StaticDeserializerBuilder>
	{
		private readonly StaticContext context;

		private readonly StaticObjectFactory factory;

		private readonly LazyComponentRegistrationList<Nothing, INodeDeserializer> nodeDeserializerFactories;

		private readonly LazyComponentRegistrationList<Nothing, INodeTypeResolver> nodeTypeResolverFactories;

		private readonly Dictionary<TagName, Type> tagMappings;

		private readonly ITypeConverter typeConverter;

		private readonly Dictionary<Type, Type> typeMappings;

		private bool ignoreUnmatched;

		private bool duplicateKeyChecking;

		private bool attemptUnknownTypeDeserialization;

		private bool enforceNullability;

		private bool caseInsensitivePropertyMatching;

		protected override StaticDeserializerBuilder Self => this;

		public StaticDeserializerBuilder(StaticContext context)
			: base(context.GetTypeResolver())
		{
			this.context = context;
			factory = context.GetFactory();
			typeMappings = new Dictionary<Type, Type>();
			tagMappings = new Dictionary<TagName, Type>
			{
				{
					FailsafeSchema.Tags.Map,
					typeof(Dictionary<object, object>)
				},
				{
					FailsafeSchema.Tags.Str,
					typeof(string)
				},
				{
					JsonSchema.Tags.Bool,
					typeof(bool)
				},
				{
					JsonSchema.Tags.Float,
					typeof(double)
				},
				{
					JsonSchema.Tags.Int,
					typeof(int)
				},
				{
					DefaultSchema.Tags.Timestamp,
					typeof(DateTime)
				}
			};
			typeInspectorFactories.Add(typeof(CachedTypeInspector), (ITypeInspector inner) => new CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(NamingConventionTypeInspector), (ITypeInspector inner) => (!(namingConvention is NullNamingConvention)) ? new NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(YamlAttributesTypeInspector), (ITypeInspector inner) => new YamlAttributesTypeInspector(inner));
			nodeDeserializerFactories = new LazyComponentRegistrationList<Nothing, INodeDeserializer>
			{
				{
					typeof(YamlConvertibleNodeDeserializer),
					(Nothing _) => new YamlConvertibleNodeDeserializer(factory)
				},
				{
					typeof(YamlSerializableNodeDeserializer),
					(Nothing _) => new YamlSerializableNodeDeserializer(factory)
				},
				{
					typeof(TypeConverterNodeDeserializer),
					(Nothing _) => new TypeConverterNodeDeserializer(BuildTypeConverters())
				},
				{
					typeof(NullNodeDeserializer),
					(Nothing _) => new NullNodeDeserializer()
				},
				{
					typeof(ScalarNodeDeserializer),
					(Nothing _) => new ScalarNodeDeserializer(attemptUnknownTypeDeserialization, typeConverter, BuildTypeInspector(), yamlFormatter, enumNamingConvention)
				},
				{
					typeof(StaticArrayNodeDeserializer),
					(Nothing _) => new StaticArrayNodeDeserializer(factory)
				},
				{
					typeof(StaticDictionaryNodeDeserializer),
					(Nothing _) => new StaticDictionaryNodeDeserializer(factory, duplicateKeyChecking)
				},
				{
					typeof(StaticCollectionNodeDeserializer),
					(Nothing _) => new StaticCollectionNodeDeserializer(factory)
				},
				{
					typeof(ObjectNodeDeserializer),
					(Nothing _) => new ObjectNodeDeserializer(factory, BuildTypeInspector(), ignoreUnmatched, duplicateKeyChecking, typeConverter, enumNamingConvention, enforceNullability, caseInsensitivePropertyMatching, enforceRequiredProperties: false, BuildTypeConverters())
				}
			};
			nodeTypeResolverFactories = new LazyComponentRegistrationList<Nothing, INodeTypeResolver>
			{
				{
					typeof(MappingNodeTypeResolver),
					(Nothing _) => new MappingNodeTypeResolver(typeMappings)
				},
				{
					typeof(YamlConvertibleTypeResolver),
					(Nothing _) => new YamlConvertibleTypeResolver()
				},
				{
					typeof(YamlSerializableTypeResolver),
					(Nothing _) => new YamlSerializableTypeResolver()
				},
				{
					typeof(TagNodeTypeResolver),
					(Nothing _) => new TagNodeTypeResolver(tagMappings)
				},
				{
					typeof(PreventUnknownTagsNodeTypeResolver),
					(Nothing _) => new PreventUnknownTagsNodeTypeResolver()
				},
				{
					typeof(DefaultContainersNodeTypeResolver),
					(Nothing _) => new DefaultContainersNodeTypeResolver()
				}
			};
			typeConverter = new NullTypeConverter();
		}

		public ITypeInspector BuildTypeInspector()
		{
			ITypeInspector typeInspector = context.GetTypeInspector();
			return typeInspectorFactories.BuildComponentChain(typeInspector);
		}

		public StaticDeserializerBuilder WithAttemptingUnquotedStringTypeDeserialization()
		{
			attemptUnknownTypeDeserialization = true;
			return this;
		}

		public StaticDeserializerBuilder WithNodeDeserializer(INodeDeserializer nodeDeserializer)
		{
			return WithNodeDeserializer(nodeDeserializer, delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> w)
			{
				w.OnTop();
			});
		}

		public StaticDeserializerBuilder WithNodeDeserializer(INodeDeserializer nodeDeserializer, Action<IRegistrationLocationSelectionSyntax<INodeDeserializer>> where)
		{
			INodeDeserializer nodeDeserializer2 = nodeDeserializer;
			if (nodeDeserializer2 == null)
			{
				throw new ArgumentNullException("nodeDeserializer");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer2.GetType(), (Nothing _) => nodeDeserializer2));
			return this;
		}

		public StaticDeserializerBuilder WithNodeDeserializer<TNodeDeserializer>(WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeDeserializer>> where) where TNodeDeserializer : INodeDeserializer
		{
			WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory2 = nodeDeserializerFactory;
			if (nodeDeserializerFactory2 == null)
			{
				throw new ArgumentNullException("nodeDeserializerFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (INodeDeserializer wrapped, Nothing _) => nodeDeserializerFactory2(wrapped)));
			return this;
		}

		public StaticDeserializerBuilder WithCaseInsensitivePropertyMatching()
		{
			caseInsensitivePropertyMatching = true;
			return this;
		}

		public StaticDeserializerBuilder WithEnforceNullability()
		{
			enforceNullability = true;
			return this;
		}

		public StaticDeserializerBuilder WithoutNodeDeserializer<TNodeDeserializer>() where TNodeDeserializer : INodeDeserializer
		{
			return WithoutNodeDeserializer(typeof(TNodeDeserializer));
		}

		public StaticDeserializerBuilder WithoutNodeDeserializer(Type nodeDeserializerType)
		{
			if (nodeDeserializerType == null)
			{
				throw new ArgumentNullException("nodeDeserializerType");
			}
			nodeDeserializerFactories.Remove(nodeDeserializerType);
			return this;
		}

		public StaticDeserializerBuilder WithTypeDiscriminatingNodeDeserializer(Action<ITypeDiscriminatingNodeDeserializerOptions> configureTypeDiscriminatingNodeDeserializerOptions, int maxDepth = -1, int maxLength = -1)
		{
			TypeDiscriminatingNodeDeserializerOptions typeDiscriminatingNodeDeserializerOptions = new TypeDiscriminatingNodeDeserializerOptions();
			configureTypeDiscriminatingNodeDeserializerOptions(typeDiscriminatingNodeDeserializerOptions);
			TypeDiscriminatingNodeDeserializer nodeDeserializer = new TypeDiscriminatingNodeDeserializer(nodeDeserializerFactories.BuildComponentList(), typeDiscriminatingNodeDeserializerOptions.discriminators, maxDepth, maxLength);
			return WithNodeDeserializer(nodeDeserializer, delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> s)
			{
				s.Before<DictionaryNodeDeserializer>();
			});
		}

		public StaticDeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver)
		{
			return WithNodeTypeResolver(nodeTypeResolver, delegate(IRegistrationLocationSelectionSyntax<INodeTypeResolver> w)
			{
				w.OnTop();
			});
		}

		public StaticDeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver, Action<IRegistrationLocationSelectionSyntax<INodeTypeResolver>> where)
		{
			INodeTypeResolver nodeTypeResolver2 = nodeTypeResolver;
			if (nodeTypeResolver2 == null)
			{
				throw new ArgumentNullException("nodeTypeResolver");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver2.GetType(), (Nothing _) => nodeTypeResolver2));
			return this;
		}

		public StaticDeserializerBuilder WithNodeTypeResolver<TNodeTypeResolver>(WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeTypeResolver>> where) where TNodeTypeResolver : INodeTypeResolver
		{
			WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory2 = nodeTypeResolverFactory;
			if (nodeTypeResolverFactory2 == null)
			{
				throw new ArgumentNullException("nodeTypeResolverFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (INodeTypeResolver wrapped, Nothing _) => nodeTypeResolverFactory2(wrapped)));
			return this;
		}

		public StaticDeserializerBuilder WithoutNodeTypeResolver<TNodeTypeResolver>() where TNodeTypeResolver : INodeTypeResolver
		{
			return WithoutNodeTypeResolver(typeof(TNodeTypeResolver));
		}

		public StaticDeserializerBuilder WithoutNodeTypeResolver(Type nodeTypeResolverType)
		{
			if (nodeTypeResolverType == null)
			{
				throw new ArgumentNullException("nodeTypeResolverType");
			}
			nodeTypeResolverFactories.Remove(nodeTypeResolverType);
			return this;
		}

		public override StaticDeserializerBuilder WithTagMapping(TagName tag, Type type)
		{
			if (tag.IsEmpty)
			{
				throw new ArgumentException("Non-specific tags cannot be maped");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (tagMappings.TryGetValue(tag, out Type value))
			{
				throw new ArgumentException($"Type already has a registered type '{value.FullName}' for tag '{tag}'", "tag");
			}
			tagMappings.Add(tag, type);
			return this;
		}

		public StaticDeserializerBuilder WithTypeMapping<TInterface, TConcrete>() where TConcrete : TInterface
		{
			Type typeFromHandle = typeof(TInterface);
			Type typeFromHandle2 = typeof(TConcrete);
			if (!typeFromHandle.IsAssignableFrom(typeFromHandle2))
			{
				throw new InvalidOperationException("The type '" + typeFromHandle2.Name + "' does not implement interface '" + typeFromHandle.Name + "'.");
			}
			typeMappings[typeFromHandle] = typeFromHandle2;
			return this;
		}

		public StaticDeserializerBuilder WithoutTagMapping(TagName tag)
		{
			if (tag.IsEmpty)
			{
				throw new ArgumentException("Non-specific tags cannot be maped");
			}
			if (!tagMappings.Remove(tag))
			{
				throw new KeyNotFoundException($"Tag '{tag}' is not registered");
			}
			return this;
		}

		public StaticDeserializerBuilder IgnoreUnmatchedProperties()
		{
			ignoreUnmatched = true;
			return this;
		}

		public StaticDeserializerBuilder WithDuplicateKeyChecking()
		{
			duplicateKeyChecking = true;
			return this;
		}

		public IDeserializer Build()
		{
			return Deserializer.FromValueDeserializer(BuildValueDeserializer());
		}

		public IValueDeserializer BuildValueDeserializer()
		{
			return new AliasValueDeserializer(new NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList(), typeConverter, enumNamingConvention, BuildTypeInspector()));
		}
	}
	public sealed class StaticSerializerBuilder : StaticBuilderSkeleton<StaticSerializerBuilder>
	{
		private class ValueSerializer : IValueSerializer
		{
			private readonly IObjectGraphTraversalStrategy traversalStrategy;

			private readonly IEventEmitter eventEmitter;

			private readonly IEnumerable<IYamlTypeConverter> typeConverters;

			private readonly LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

			private readonly LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories;

			public ValueSerializer(IObjectGraphTraversalStrategy traversalStrategy, IEventEmitter eventEmitter, IEnumerable<IYamlTypeConverter> typeConverters, LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories, LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories)
			{
				this.traversalStrategy = traversalStrategy;
				this.eventEmitter = eventEmitter;
				this.typeConverters = typeConverters;
				this.preProcessingPhaseObjectGraphVisitorFactories = preProcessingPhaseObjectGraphVisitorFactories;
				this.emissionPhaseObjectGraphVisitorFactories = emissionPhaseObjectGraphVisitorFactories;
			}

			public void SerializeValue(IEmitter emitter, object? value, Type? type)
			{
				IEmitter emitter2 = emitter;
				Type type2 = type ?? ((value != null) ? value.GetType() : typeof(object));
				Type staticType = type ?? typeof(object);
				ObjectDescriptor graph = new ObjectDescriptor(value, type2, staticType);
				List<IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitors = preProcessingPhaseObjectGraphVisitorFactories.BuildComponentList(typeConverters);
				foreach (IObjectGraphVisitor<Nothing> item in preProcessingPhaseObjectGraphVisitors)
				{
					traversalStrategy.Traverse(graph, item, default(Nothing), NestedObjectSerializer);
				}
				IObjectGraphVisitor<IEmitter> visitor = emissionPhaseObjectGraphVisitorFactories.BuildComponentChain<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>>(new EmittingObjectGraphVisitor(eventEmitter), (IObjectGraphVisitor<IEmitter> inner) => new EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
				traversalStrategy.Traverse(graph, visitor, emitter2, NestedObjectSerializer);
				void NestedObjectSerializer(object? v, Type? t)
				{
					SerializeValue(emitter2, v, t);
				}
			}
		}

		private readonly StaticContext context;

		private readonly StaticObjectFactory factory;

		private ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory;

		private readonly LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

		private readonly LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories;

		private readonly LazyComponentRegistrationList<IEventEmitter, IEventEmitter> eventEmitterFactories;

		private readonly Dictionary<Type, TagName> tagMappings = new Dictionary<Type, TagName>();

		private int maximumRecursion = 50;

		private EmitterSettings emitterSettings = EmitterSettings.Default;

		private DefaultValuesHandling defaultValuesHandlingConfiguration;

		private bool quoteNecessaryStrings;

		private bool quoteYaml1_1Strings;

		private ScalarStyle defaultScalarStyle;

		protected override StaticSerializerBuilder Self => this;

		public StaticSerializerBuilder(StaticContext context)
			: base((ITypeResolver)new DynamicTypeResolver())
		{
			this.context = context;
			factory = context.GetFactory();
			typeInspectorFactories.Add(typeof(CachedTypeInspector), (ITypeInspector inner) => new CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(NamingConventionTypeInspector), (ITypeInspector inner) => (!(namingConvention is NullNamingConvention)) ? new NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(YamlAttributesTypeInspector), (ITypeInspector inner) => new YamlAttributesTypeInspector(inner));
			preProcessingPhaseObjectGraphVisitorFactories = new LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> { 
			{
				typeof(AnchorAssigner),
				(IEnumerable<IYamlTypeConverter> typeConverters) => new AnchorAssigner(typeConverters)
			} };
			emissionPhaseObjectGraphVisitorFactories = new LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>>
			{
				{
					typeof(CustomSerializationObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new CustomSerializationObjectGraphVisitor(args.InnerVisitor, args.TypeConverters, args.NestedObjectSerializer)
				},
				{
					typeof(AnchorAssigningObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new AnchorAssigningObjectGraphVisitor(args.InnerVisitor, args.EventEmitter, args.GetPreProcessingPhaseObjectGraphVisitor<AnchorAssigner>())
				},
				{
					typeof(DefaultValuesObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new DefaultValuesObjectGraphVisitor(defaultValuesHandlingConfiguration, args.InnerVisitor, factory)
				},
				{
					typeof(CommentsObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new CommentsObjectGraphVisitor(args.InnerVisitor)
				}
			};
			eventEmitterFactories = new LazyComponentRegistrationList<IEventEmitter, IEventEmitter> { 
			{
				typeof(TypeAssigningEventEmitter),
				(IEventEmitter inner) => new TypeAssigningEventEmitter(inner, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings, defaultScalarStyle, yamlFormatter, enumNamingConvention, BuildTypeInspector())
			} };
			objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new FullObjectGraphTraversalStrategy(typeInspector, typeResolver, maximumRecursion, namingConvention, factory);
		}

		public StaticSerializerBuilder WithQuotingNecessaryStrings(bool quoteYaml1_1Strings = false)
		{
			quoteNecessaryStrings = true;
			this.quoteYaml1_1Strings = quoteYaml1_1Strings;
			return this;
		}

		public StaticSerializerBuilder WithQuotingNecessaryStrings()
		{
			quoteNecessaryStrings = true;
			return this;
		}

		public StaticSerializerBuilder WithDefaultScalarStyle(ScalarStyle style)
		{
			defaultScalarStyle = style;
			return this;
		}

		public StaticSerializerBuilder WithMaximumRecursion(int maximumRecursion)
		{
			if (maximumRecursion <= 0)
			{
				throw new ArgumentOutOfRangeException("maximumRecursion", $"The maximum recursion specified ({maximumRecursion}) is invalid. It should be a positive integer.");
			}
			this.maximumRecursion = maximumRecursion;
			return this;
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			Func<IEventEmitter, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			return WithEventEmitter((IEventEmitter e, ITypeInspector _) => eventEmitterFactory2(e), where);
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			if (eventEmitterFactory2 == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter inner) => eventEmitterFactory2(inner, BuildTypeInspector())));
			return Self;
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			if (eventEmitterFactory2 == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateTrackingRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter wrapped, IEventEmitter inner) => eventEmitterFactory2(wrapped, inner)));
			return Self;
		}

		public StaticSerializerBuilder WithoutEventEmitter<TEventEmitter>() where TEventEmitter : IEventEmitter
		{
			return WithoutEventEmitter(typeof(TEventEmitter));
		}

		public StaticSerializerBuilder WithoutEventEmitter(Type eventEmitterType)
		{
			if (eventEmitterType == null)
			{
				throw new ArgumentNullException("eventEmitterType");
			}
			eventEmitterFactories.Remove(eventEmitterType);
			return this;
		}

		public override StaticSerializerBuilder WithTagMapping(TagName tag, Type type)
		{
			if (tag.IsEmpty)
			{
				throw new ArgumentException("Non-specific tags cannot be maped");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (tagMappings.TryGetValue(type, out var value))
			{
				throw new ArgumentException($"Type already has a registered tag '{value}' for type '{type.FullName}'", "type");
			}
			tagMappings.Add(type, tag);
			return this;
		}

		public StaticSerializerBuilder WithoutTagMapping(Type type)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (!tagMappings.Remove(type))
			{
				throw new KeyNotFoundException("Tag for type '" + type.FullName + "' is not registered");
			}
			return this;
		}

		public StaticSerializerBuilder EnsureRoundtrip()
		{
			objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new RoundtripObjectGraphTraversalStrategy(typeConverters, typeInspector, typeResolver, maximumRecursion, namingConvention, settings, factory);
			WithEventEmitter((IEventEmitter inner) => new TypeAssigningEventEmitter(inner, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings: false, ScalarStyle.Plain, YamlFormatter.Default, enumNamingConvention, BuildTypeInspector()), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
			return WithTypeInspector((ITypeInspector inner) => new ReadableAndWritablePropertiesTypeInspector(inner), delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> loc)
			{
				loc.OnBottom();
			});
		}

		public StaticSerializerBuilder DisableAliases()
		{
			preProcessingPhaseObjectGraphVisitorFactories.Remove(typeof(AnchorAssigner));
			emissionPhaseObjectGraphVisitorFactories.Remove(typeof(AnchorAssigningObjectGraphVisitor));
			return this;
		}

		[Obsolete("The default behavior is now to always emit default values, thefore calling this method has no effect. This behavior is now controlled by ConfigureDefaultValuesHandling.", true)]
		public StaticSerializerBuilder EmitDefaults()
		{
			return ConfigureDefaultValuesHandling(DefaultValuesHandling.Preserve);
		}

		public StaticSerializerBuilder ConfigureDefaultValuesHandling(DefaultValuesHandling configuration)
		{
			defaultValuesHandlingConfiguration = configuration;
			return this;
		}

		public StaticSerializerBuilder JsonCompatible()
		{
			emitterSettings = emitterSettings.WithMaxSimpleKeyLength(int.MaxValue).WithoutAnchorName().WithUtf16SurrogatePairs();
			return WithTypeConverter(new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: true), delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.InsteadOf<YamlDotNet.Serialization.Converters.GuidConverter>();
			}).WithTypeConverter(new DateTime8601Converter(ScalarStyle.DoubleQuoted)).WithEventEmitter((IEventEmitter inner) => new JsonEventEmitter(inner, yamlFormatter, enumNamingConvention, BuildTypeInspector()), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
		}

		public StaticSerializerBuilder WithNewLine(string newLine)
		{
			emitterSettings = emitterSettings.WithNewLine(newLine);
			return this;
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			TObjectGraphVisitor objectGraphVisitor2 = objectGraphVisitor;
			if (objectGraphVisitor2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitor");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> _) => objectGraphVisitor2));
			return this;
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory2(typeConverters)));
			return this;
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> _) => objectGraphVisitorFactory2(wrapped)));
			return this;
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			WrapperFactory<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory2(wrapped, typeConverters)));
			return this;
		}

		public StaticSerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithoutPreProcessingPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

		public StaticSerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor(Type objectGraphVisitorType)
		{
			if (objectGraphVisitorType == null)
			{
				throw new ArgumentNullException("objectGraphVisitorType");
			}
			preProcessingPhaseObjectGraphVisitorFactories.Remove(objectGraphVisitorType);
			return this;
		}

		public StaticSerializerBuilder WithObjectGraphTraversalStrategyFactory(ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory)
		{
			this.objectGraphTraversalStrategyFactory = objectGraphTraversalStrategyFactory;
			return this;
		}

		public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory2(args)));
			return this;
		}

		public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			WrapperFactory<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<IEmitter> wrapped, EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory2(wrapped, args)));
			return this;
		}

		public StaticSerializerBuilder WithoutEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithoutEmissionPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

		public StaticSerializerBuilder WithoutEmissionPhaseObjectGraphVisitor(Type objectGraphVisitorType)
		{
			if (objectGraphVisitorType == null)
			{
				throw new ArgumentNullException("objectGraphVisitorType");
			}
			emissionPhaseObjectGraphVisitorFactories.Remove(objectGraphVisitorType);
			return this;
		}

		public StaticSerializerBuilder WithIndentedSequences()
		{
			emitterSettings = emitterSettings.WithIndentedSequences();
			return this;
		}

		public ISerializer Build()
		{
			return Serializer.FromValueSerializer(BuildValueSerializer(), emitterSettings);
		}

		public IValueSerializer BuildValueSerializer()
		{
			IEnumerable<IYamlTypeConverter> typeConverters = BuildTypeConverters();
			ITypeInspector typeInspector = BuildTypeInspector();
			IObjectGraphTraversalStrategy traversalStrategy = objectGraphTraversalStrategyFactory(typeInspector, typeResolver, typeConverters, maximumRecursion);
			IEventEmitter eventEmitter = eventEmitterFactories.BuildComponentChain(new WriterEventEmitter());
			return new ValueSerializer(traversalStrategy, eventEmitter, typeConverters, preProcessingPhaseObjectGraphVisitorFactories.Clone(), emissionPhaseObjectGraphVisitorFactories.Clone());
		}

		public ITypeInspector BuildTypeInspector()
		{
			ITypeInspector typeInspector = context.GetTypeInspector();
			return typeInspectorFactories.BuildComponentChain(typeInspector);
		}
	}
	public sealed class StreamFragment : IYamlConvertible
	{
		private readonly List<ParsingEvent> events = new List<ParsingEvent>();

		public IList<ParsingEvent> Events => events;

		void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
		{
			events.Clear();
			int num = 0;
			do
			{
				if (!parser.MoveNext())
				{
					throw new InvalidOperationException("The parser has reached the end before deserialization completed.");
				}
				ParsingEvent current = parser.Current;
				events.Add(current);
				num += current.NestingIncrease;
			}
			while (num > 0);
		}

		void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
		{
			foreach (ParsingEvent @event in events)
			{
				emitter.Emit(@event);
			}
		}
	}
	public sealed class TagMappings
	{
		private readonly Dictionary<string, Type> mappings;

		public TagMappings()
		{
			mappings = new Dictionary<string, Type>();
		}

		public TagMappings(IDictionary<string, Type> mappings)
		{
			this.mappings = new Dictionary<string, Type>(mappings);
		}

		public void Add(string tag, Type mapping)
		{
			mappings.Add(tag, mapping);
		}

		internal Type? GetMapping(string tag)
		{
			if (!mappings.TryGetValue(tag, out Type value))
			{
				return null;
			}
			return value;
		}
	}
	public sealed class YamlAttributeOverrides
	{
		private readonly struct AttributeKey
		{
			public readonly Type AttributeType;

			public readonly string PropertyName;

			public AttributeKey(Type attributeType, string propertyName)
			{
				AttributeType = attributeType;
				PropertyName = propertyName;
			}

			public override bool Equals(object? obj)
			{
				if (obj is AttributeKey attributeKey && AttributeType.Equals(attributeKey.AttributeType))
				{
					return PropertyName.Equals(attributeKey.PropertyName);
				}
				return false;
			}

			public override int GetHashCode()
			{
				return YamlDotNet.Core.HashCode.CombineHashCodes(AttributeType.GetHashCode(), PropertyName.GetHashCode());
			}
		}

		private sealed class AttributeMapping
		{
			public readonly Type RegisteredType;

			public readonly Attribute Attribute;

			public AttributeMapping(Type registeredType, Attribute attribute)
			{
				RegisteredType = registeredType;
				Attribute = attribute;
			}

			public override bool Equals(object? obj)
			{
				if (obj is AttributeMapping attributeMapping && RegisteredType.Equals(attributeMapping.RegisteredType))
				{
					return Attribute.Equals(attributeMapping.Attribute);
				}
				return false;
			}

			public override int GetHashCode()
			{
				return YamlDotNet.Core.HashCode.CombineHashCodes(RegisteredType.GetHashCode(), Attribute.GetHashCode());
			}

			public int Matches(Type matchType)
			{
				int num = 0;
				Type type = matchType;
				while (type != null)
				{
					num++;
					if (type == RegisteredType)
					{
						return num;
					}
					type = type.BaseType();
				}
				if (matchType.GetInterfaces().Contains(RegisteredType))
				{
					return num;
				}
				return 0;
			}
		}

		private readonly Dictionary<AttributeKey, List<AttributeMapping>> overrides = new Dictionary<AttributeKey, List<AttributeMapping>>();

		[return: MaybeNull]
		public T GetAttribute<T>(Type type, string member) where T : Attribute
		{
			if (overrides.TryGetValue(new AttributeKey(typeof(T), member), out List<AttributeMapping> value))
			{
				int num = 0;
				AttributeMapping attributeMapping = null;
				foreach (AttributeMapping item in value)
				{
					int num2 = item.Matches(type);
					if (num2 > num)
					{
						num = num2;
						attributeMapping = item;
					}
				}
				if (num > 0)
				{
					return (T)attributeMapping.Attribute;
				}
			}
			return null;
		}

		public void Add(Type type, string member, Attribute attribute)
		{
			AttributeMapping item = new AttributeMapping(type, attribute);
			AttributeKey key = new AttributeKey(attribute.GetType(), member);
			if (!overrides.TryGetValue(key, out List<AttributeMapping> value))
			{
				value = new List<AttributeMapping>();
				overrides.Add(key, value);
			}
			else if (value.Contains(item))
			{
				throw new InvalidOperationException($"Attribute ({attribute}) already set for Type {type.FullName}, Member {member}");
			}
			value.Add(item);
		}

		public YamlAttributeOverrides Clone()
		{
			YamlAttributeOverrides yamlAttributeOverrides = new YamlAttributeOverrides();
			foreach (KeyValuePair<AttributeKey, List<AttributeMapping>> @override in overrides)
			{
				foreach (AttributeMapping item in @override.Value)
				{
					yamlAttributeOverrides.Add(item.RegisteredType, @override.Key.PropertyName, item.Attribute);
				}
			}
			return yamlAttributeOverrides;
		}

		public void Add<TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
		{
			PropertyInfo propertyInfo = propertyAccessor.AsProperty();
			Add(typeof(TClass), propertyInfo.Name, attribute);
		}
	}
	public sealed class YamlAttributeOverridesInspector : ReflectionTypeInspector
	{
		public sealed class OverridePropertyDescriptor : IPropertyDescriptor
		{
			private readonly IPropertyDescriptor baseDescriptor;

			private readonly YamlAttributeOverrides overrides;

			private readonly Type classType;

			public string Name => baseDescriptor.Name;

			public bool Required => baseDescriptor.Required;

			public bool AllowNulls => baseDescriptor.AllowNulls;

			public bool CanWrite => baseDescriptor.CanWrite;

			public Type Type => baseDescriptor.Type;

			public Type? TypeOverride
			{
				get
				{
					return baseDescriptor.TypeOverride;
				}
				set
				{
					baseDescriptor.TypeOverride = value;
				}
			}

			public Type? ConverterType => GetCustomAttribute<YamlConverterAttribute>()?.ConverterType ?? baseDescriptor.ConverterType;

			public int Order
			{
				get
				{
					return baseDescriptor.Order;
				}
				set
				{
					baseDescriptor.Order = value;
				}
			}

			public ScalarStyle ScalarStyle
			{
				get
				{
					return baseDescriptor.ScalarStyle;
				}
				set
				{
					baseDescriptor.ScalarStyle = value;
				}
			}

			public OverridePropertyDescriptor(IPropertyDescriptor baseDescriptor, YamlAttributeOverrides overrides, Type classType)
			{
				this.baseDescriptor = baseDescriptor;
				this.overrides = overrides;
				this.classType = classType;
			}

			public void Write(object target, object? value)
			{
				baseDescriptor.Write(target, value);
			}

			public T? GetCustomAttribute<T>() where T : Attribute
			{
				T attribute = overrides.GetAttribute<T>(classType, Name);
				return attribute ?? baseDescriptor.GetCustomAttribute<T>();
			}

			public IObjectDescriptor Read(object target)
			{
				return baseDescriptor.Read(target);
			}
		}

		private readonly ITypeInspector innerTypeDescriptor;

		private readonly YamlAttributeOverrides overrides;

		public YamlAttributeOverridesInspector(ITypeInspector innerTypeDescriptor, YamlAttributeOverrides overrides)
		{
			this.innerTypeDescriptor = innerTypeDescriptor;
			this.overrides = overrides;
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			Type type2 = type;
			IEnumerable<IPropertyDescriptor> enumerable = innerTypeDescriptor.GetProperties(type2, container);
			if (overrides != null)
			{
				enumerable = enumerable.Select((Func<IPropertyDescriptor, IPropertyDescriptor>)((IPropertyDescriptor p) => new OverridePropertyDescriptor(p, overrides, type2)));
			}
			return enumerable;
		}
	}
	public sealed class YamlAttributesTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

		public YamlAttributesTypeInspector(ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor;
		}

		public override string GetEnumName(Type enumType, string name)
		{
			return innerTypeDescriptor.GetEnumName(enumType, name);
		}

		public override string GetEnumValue(object enumValue)
		{
			return innerTypeDescriptor.GetEnumValue(enumValue);
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return from p in (from p in innerTypeDescriptor.GetProperties(type, container)
					where p.GetCustomAttribute<YamlIgnoreAttribute>() == null
					select p).Select((Func<IPropertyDescriptor, IPropertyDescriptor>)delegate(IPropertyDescriptor p)
				{
					PropertyDescriptor propertyDescriptor = new PropertyDescriptor(p);
					YamlMemberAttribute customAttribute = p.GetCustomAttribute<YamlMemberAttribute>();
					if (customAttribute != null)
					{
						if (customAttribute.SerializeAs != null)
						{
							propertyDescriptor.TypeOverride = customAttribute.SerializeAs;
						}
						propertyDescriptor.Order = customAttribute.Order;
						propertyDescriptor.ScalarStyle = customAttribute.ScalarStyle;
						if (customAttribute.Alias != null)
						{
							propertyDescriptor.Name = customAttribute.Alias;
						}
					}
					return propertyDescriptor;
				})
				orderby p.Order
				select p;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
	public sealed class YamlConverterAttribute : Attribute
	{
		public Type ConverterType { get; }

		public YamlConverterAttribute(Type converterType)
		{
			ConverterType = converterType;
		}
	}
	public class YamlFormatter
	{
		public static YamlFormatter Default { get; } = new YamlFormatter();


		public NumberFormatInfo NumberFormat { get; set; } = new NumberFormatInfo
		{
			CurrencyDecimalSeparator = ".",
			CurrencyGroupSeparator = "_",
			CurrencyGroupSizes = new int[1] { 3 },
			CurrencySymbol = string.Empty,
			CurrencyDecimalDigits = 99,
			NumberDecimalSeparator = ".",
			NumberGroupSeparator = "_",
			NumberGroupSizes = new int[1] { 3 },
			NumberDecimalDigits = 99,
			NaNSymbol = ".nan",
			PositiveInfinitySymbol = ".inf",
			NegativeInfinitySymbol = "-.inf"
		};


		public virtual Func<object, ITypeInspector, INamingConvention, string> FormatEnum { get; set; } = delegate(object value, ITypeInspector typeInspector, INamingConvention enumNamingConvention)
		{
			string empty = string.Empty;
			empty = ((value != null) ? typeInspector.GetEnumValue(value) : string.Empty);
			return enumNamingConvention.Apply(empty);
		};


		public virtual Func<object, bool> PotentiallyQuoteEnums { get; set; } = (object _) => true;


		public string FormatNumber(object number)
		{
			return Convert.ToString(number, NumberFormat);
		}

		public string FormatNumber(double number)
		{
			return number.ToString("G", NumberFormat);
		}

		public string FormatNumber(float number)
		{
			return number.ToString("G", NumberFormat);
		}

		public string FormatBoolean(object boolean)
		{
			if (!boolean.Equals(true))
			{
				return "false";
			}
			return "true";
		}

		public string FormatDateTime(object dateTime)
		{
			return ((DateTime)dateTime).ToString("o", CultureInfo.InvariantCulture);
		}

		public string FormatTimeSpan(object timeSpan)
		{
			return ((TimeSpan)timeSpan).ToString();
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	public sealed class YamlIgnoreAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	public sealed class YamlMemberAttribute : Attribute
	{
		private DefaultValuesHandling? defaultValuesHandling;

		public string? Description { get; set; }

		public Type? SerializeAs { get; set; }

		public int Order { get; set; }

		public string? Alias { get; set; }

		public bool ApplyNamingConventions { get; set; }

		public ScalarStyle ScalarStyle { get; set; }

		public DefaultValuesHandling DefaultValuesHandling
		{
			get
			{
				return defaultValuesHandling.GetValueOrDefault();
			}
			set
			{
				defaultValuesHandling = value;
			}
		}

		public bool IsDefaultValuesHandlingSpecified => defaultValuesHandling.HasValue;

		public YamlMemberAttribute()
		{
			ScalarStyle = ScalarStyle.Any;
			ApplyNamingConventions = true;
		}

		public YamlMemberAttribute(Type serializeAs)
			: this()
		{
			SerializeAs = serializeAs ?? throw new ArgumentNullException("serializeAs");
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum, Inherited = false, AllowMultiple = true)]
	public sealed class YamlSerializableAttribute : Attribute
	{
		public YamlSerializableAttribute()
		{
		}

		public YamlSerializableAttribute(Type serializableType)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	public sealed class YamlStaticContextAttribute : Attribute
	{
	}
}
namespace YamlDotNet.Serialization.ValueDeserializers
{
	public sealed class AliasValueDeserializer : IValueDeserializer
	{
		private sealed class AliasState : Dictionary<AnchorName, ValuePromise>, IPostDeserializationCallback
		{
			public void OnDeserialization()
			{
				foreach (ValuePromise value in base.Values)
				{
					if (!value.HasValue)
					{
						YamlDotNet.Core.Events.AnchorAlias alias = value.Alias;
						Mark start = alias.Start;
						Mark end = alias.End;
						throw new AnchorNotFoundException(in start, in end, $"Anchor '{alias.Value}' not found");
					}
				}
			}
		}

		private sealed class ValuePromise : IValuePromise
		{
			private object? value;

			public readonly YamlDotNet.Core.Events.AnchorAlias? Alias;

			public bool HasValue { get; private set; }

			public object? Value
			{
				get
				{
					if (!HasValue)
					{
						throw new InvalidOperationException("Value not set");
					}
					return value;
				}
				set
				{
					if (HasValue)
					{
						throw new InvalidOperationException("Value already set");
					}
					HasValue = true;
					this.value = value;
					this.ValueAvailable?.Invoke(value);
				}
			}

			public event Action<object?>? ValueAvailable;

			public ValuePromise(YamlDotNet.Core.Events.AnchorAlias alias)
			{
				Alias = alias;
			}

			public ValuePromise(object? value)
			{
				HasValue = true;
				this.value = value;
			}
		}

		private readonly IValueDeserializer innerDeserializer;

		public AliasValueDeserializer(IValueDeserializer innerDeserializer)
		{
			this.innerDeserializer = innerDeserializer ?? throw new ArgumentNullException("innerDeserializer");
		}

		public object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
		{
			if (parser.TryConsume<YamlDotNet.Core.Events.AnchorAlias>(out var @event))
			{
				AliasState aliasState = state.Get<AliasState>();
				if (!aliasState.TryGetValue(@event.Value, out ValuePromise value))
				{
					Mark start = @event.Start;
					Mark end = @event.End;
					throw new AnchorNotFoundException(in start, in end, $"Alias ${@event.Value} cannot precede anchor declaration");
				}
				if (!value.HasValue)
				{
					return value;
				}
				return value.Value;
			}
			AnchorName anchorName = AnchorName.Empty;
			if (parser.Accept<NodeEvent>(out var event2) && !event2.Anchor.IsEmpty)
			{
				anchorName = event2.Anchor;
				AliasState aliasState2 = state.Get<AliasState>();
				if (!aliasState2.ContainsKey(anchorName))
				{
					aliasState2[anchorName] = new ValuePromise(new YamlDotNet.Core.Events.AnchorAlias(anchorName));
				}
			}
			object obj = innerDeserializer.DeserializeValue(parser, expectedType, state, nestedObjectDeserializer);
			if (!anchorName.IsEmpty)
			{
				AliasState aliasState3 = state.Get<AliasState>();
				if (!aliasState3.TryGetValue(anchorName, out ValuePromise value2))
				{
					aliasState3.Add(anchorName, new ValuePromise(obj));
				}
				else if (!value2.HasValue)
				{
					value2.Value = obj;
				}
				else
				{
					aliasState3[anchorName] = new ValuePromise(obj);
				}
			}
			return obj;
		}
	}
	public sealed class NodeValueDeserializer : IValueDeserializer
	{
		private readonly IList<INodeDeserializer> deserializers;

		private readonly IList<INodeTypeResolver> typeResolvers;

		private readonly ITypeConverter typeConverter;

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public NodeValueDeserializer(IList<INodeDeserializer> deserializers, IList<INodeTypeResolver> typeResolvers, ITypeConverter typeConverter, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			this.deserializers = deserializers ?? throw new ArgumentNullException("deserializers");
			this.typeResolvers = typeResolvers ?? throw new ArgumentNullException("typeResolvers");
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
			this.enumNamingConvention = enumNamingConvention ?? throw new ArgumentNullException("enumNamingConvention");
			this.typeInspector = typeInspector;
		}

		public object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
		{
			IParser parser2 = parser;
			SerializerState state2 = state;
			IValueDeserializer nestedObjectDeserializer2 = nestedObjectDeserializer;
			parser2.Accept<NodeEvent>(out var @event);
			Type typeFromEvent = GetTypeFromEvent(@event, expectedType);
			ObjectDeserializer rootDeserializer = (Type x) => DeserializeValue(parser2, x, state2, nestedObjectDeserializer2);
			Mark start;
			Mark end;
			try
			{
				foreach (INodeDeserializer deserializer in deserializers)
				{
					if (deserializer.Deserialize(parser2, typeFromEvent, (IParser r, Type t) => nestedObjectDeserializer2.DeserializeValue(r, t, state2, nestedObjectDeserializer2), out object value, rootDeserializer))
					{
						return typeConverter.ChangeType(value, expectedType, enumNamingConvention, typeInspector);
					}
				}
			}
			catch (YamlException)
			{
				throw;
			}
			catch (Exception innerException)
			{
				start = @event?.Start ?? Mark.Empty;
				end = @event?.End ?? Mark.Empty;
				throw new YamlException(in start, in end, "Exception during deserialization", innerException);
			}
			start = @event?.Start ?? Mark.Empty;
			end = @event?.End ?? Mark.Empty;
			throw new YamlException(in start, in end, "No node deserializer was able to deserialize the node into type " + expectedType.AssemblyQualifiedName);
		}

		private Type GetTypeFromEvent(NodeEvent? nodeEvent, Type currentType)
		{
			foreach (INodeTypeResolver typeResolver in typeResolvers)
			{
				if (typeResolver.Resolve(nodeEvent, ref currentType))
				{
					break;
				}
			}
			return currentType;
		}
	}
}
namespace YamlDotNet.Serialization.Utilities
{
	public interface IPostDeserializationCallback
	{
		void OnDeserialization();
	}
	public interface ITypeConverter
	{
		object? ChangeType(object? value, Type expectedType, INamingConvention enumNamingConvention, ITypeInspector typeInspector);
	}
	public class NullTypeConverter : ITypeConverter
	{
		public object? ChangeType(object? value, Type expectedType, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return value;
		}
	}
	internal sealed class ObjectAnchorCollection
	{
		private readonly Dictionary<string, object> objectsByAnchor = new Dictionary<string, object>();

		private readonly Dictionary<object, string> anchorsByObject = new Dictionary<object, string>();

		public object this[string anchor]
		{
			get
			{
				if (objectsByAnchor.TryGetValue(anchor, out object value))
				{
					return value;
				}
				throw new AnchorNotFoundException("The anchor '" + anchor + "' does not exists");
			}
		}

		public void Add(string anchor, object @object)
		{
			objectsByAnchor.Add(anchor, @object);
			if (@object != null)
			{
				anchorsByObject.Add(@object, anchor);
			}
		}

		public bool TryGetAnchor(object @object, [MaybeNullWhen(false)] out string? anchor)
		{
			return anchorsByObject.TryGetValue(@object, out anchor);
		}
	}
	public class ReflectionTypeConverter : ITypeConverter
	{
		public object? ChangeType(object? value, Type expectedType, ITypeInspector typeInspector)
		{
			return ChangeType(value, expectedType, NullNamingConvention.Instance, typeInspector);
		}

		public object? ChangeType(object? value, Type expectedType, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return TypeConverter.ChangeType(value, expectedType, enumNamingConvention, typeInspector);
		}
	}
	public sealed class SerializerState : IDisposable
	{
		private readonly Dictionary<Type, object> items = new Dictionary<Type, object>();

		public T Get<T>() where T : class, new()
		{
			if (!items.TryGetValue(typeof(T), out object value))
			{
				value = new T();
				items.Add(typeof(T), value);
			}
			return (T)value;
		}

		public void OnDeserialization()
		{
			foreach (IPostDeserializationCallback item in items.Values.OfType<IPostDeserializationCallback>())
			{
				item.OnDeserialization();
			}
		}

		public void Dispose()
		{
			foreach (IDisposable item in items.Values.OfType<IDisposable>())
			{
				item.Dispose();
			}
		}
	}
	internal static class StringExtensions
	{
		private static string ToCamelOrPascalCase(string str, Func<char, char> firstLetterTransform)
		{
			string text = Regex.Replace(str, "([_\\-])(?<char>[a-z])", (Match match) => match.Groups["char"].Value.ToUpperInvariant(), RegexOptions.IgnoreCase);
			return firstLetterTransform(text[0]) + text.Substring(1);
		}

		public static string ToCamelCase(this string str)
		{
			return ToCamelOrPascalCase(str, char.ToLowerInvariant);
		}

		public static string ToPascalCase(this string str)
		{
			return ToCamelOrPascalCase(str, char.ToUpperInvariant);
		}

		public static string FromCamelCase(this string str, string separator)
		{
			string separator2 = separator;
			str = char.ToLower(str[0], CultureInfo.InvariantCulture) + str.Substring(1);
			str = Regex.Replace(str.ToCamelCase(), "(?<char>[A-Z])", (Match match) => separator2 + match.Groups["char"].Value.ToLowerInvariant());
			return str;
		}
	}
	public static class TypeConverter
	{
		public static T ChangeType<T>(object? value, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return (T)ChangeType(value, typeof(T), enumNamingConvention, typeInspector);
		}

		public static object? ChangeType(object? value, Type destinationType, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return ChangeType(value, destinationType, CultureInfo.InvariantCulture, enumNamingConvention, typeInspector);
		}

		public static object? ChangeType(object? value, Type destinationType, IFormatProvider provider, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return ChangeType(value, destinationType, new CultureInfoAdapter(CultureInfo.CurrentCulture, provider), enumNamingConvention, typeInspector);
		}

		public static object? ChangeType(object? value, Type destinationType, CultureInfo culture, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			if (value == null || value.IsDbNull())
			{
				if (!destinationType.IsValueType())
				{
					return null;
				}
				return Activator.CreateInstance(destinationType);
			}
			Type type = value.GetType();
			if (destinationType == type || destinationType.IsAssignableFrom(type))
			{
				return value;
			}
			if (destinationType.IsGenericType())
			{
				Type genericTypeDefinition = destinationType.GetGenericTypeDefinition();
				if (genericTypeDefinition == typeof(Nullable<>) || FsharpHelper.IsOptionType(genericTypeDefinition))
				{
					Type destinationType2 = destinationType.GetGenericArguments()[0];
					object obj = ChangeType(value, destinationType2, culture, enumNamingConvention, typeInspector);
					return Activator.CreateInstance(destinationType, obj);
				}
			}
			if (destinationType.IsEnum())
			{
				object result = value;
				if (value is string value2)
				{
					string name = enumNamingConvention.Reverse(value2);
					name = typeInspector.GetEnumName(destinationType, name);
					result = Enum.Parse(destinationType, name, ignoreCase: true);
				}
				return result;
			}
			if (destinationType == typeof(bool))
			{
				if ("0".Equals(value))
				{
					return false;
				}
				if ("1".Equals(value))
				{
					return true;
				}
			}
			System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(type);
			if (converter != null && converter.CanConvertTo(destinationType))
			{
				return converter.ConvertTo(null, culture, value, destinationType);
			}
			System.ComponentModel.TypeConverter converter2 = TypeDescriptor.GetConverter(destinationType);
			if (converter2 != null && converter2.CanConvertFrom(type))
			{
				return converter2.ConvertFrom(null, culture, value);
			}
			Type[] array = new Type[2] { type, destinationType };
			foreach (Type type2 in array)
			{
				foreach (MethodInfo publicStaticMethod2 in type2.GetPublicStaticMethods())
				{
					if (!publicStaticMethod2.IsSpecialName || (!(publicStaticMethod2.Name == "op_Implicit") && !(publicStaticMethod2.Name == "op_Explicit")) || !destinationType.IsAssignableFrom(publicStaticMethod2.ReturnParameter.ParameterType))
					{
						continue;
					}
					ParameterInfo[] parameters = publicStaticMethod2.GetParameters();
					if (parameters.Length == 1 && parameters[0].ParameterType.IsAssignableFrom(type))
					{
						try
						{
							return publicStaticMethod2.Invoke(null, new object[1] { value });
						}
						catch (TargetInvocationException ex)
						{
							throw ex.InnerException;
						}
					}
				}
			}
			if (type == typeof(string))
			{
				try
				{
					MethodInfo publicStaticMethod = destinationType.GetPublicStaticMethod("Parse", typeof(string), typeof(IFormatProvider));
					if (publicStaticMethod != null)
					{
						return publicStaticMethod.Invoke(null, new object[2] { value, culture });
					}
					publicStaticMethod = destinationType.GetPublicStaticMethod("Parse", typeof(string));
					if (publicStaticMethod != null)
					{
						return publicStaticMethod.Invoke(null, new object[1] { value });
					}
				}
				catch (TargetInvocationException ex2)
				{
					throw ex2.InnerException;
				}
			}
			if (destinationType == typeof(TimeSpan))
			{
				return TimeSpan.Parse((string)ChangeType(value, typeof(string), CultureInfo.InvariantCulture, enumNamingConvention, typeInspector), CultureInfo.InvariantCulture);
			}
			return Convert.ChangeType(value, destinationType, CultureInfo.InvariantCulture);
		}

		public static void RegisterTypeConverter<TConvertible, TConverter>() where TConverter : System.ComponentModel.TypeConverter
		{
			if (!TypeDescriptor.GetAttributes(typeof(TConvertible)).OfType<TypeConverterAttribute>().Any((TypeConverterAttribute a) => a.ConverterTypeName == typeof(TConverter).AssemblyQualifiedName))
			{
				TypeDescriptor.AddAttributes(typeof(TConvertible), new TypeConverterAttribute(typeof(TConverter)));
			}
		}
	}
	internal sealed class TypeConverterCache
	{
		private readonly IYamlTypeConverter[] typeConverters;

		private readonly ConcurrentDictionary<Type, (bool HasMatch, IYamlTypeConverter? TypeConverter)> cache = new ConcurrentDictionary<Type, (bool, IYamlTypeConverter)>();

		public TypeConverterCache(IEnumerable<IYamlTypeConverter>? typeConverters)
			: this(typeConverters?.ToArray() ?? Array.Empty<IYamlTypeConverter>())
		{
		}

		public TypeConverterCache(IYamlTypeConverter[] typeConverters)
		{
			this.typeConverters = typeConverters;
		}

		public bool TryGetConverterForType(Type type, [NotNullWhen(true)] out IYamlTypeConverter? typeConverter)
		{
			(bool, IYamlTypeConverter) orAdd = DictionaryExtensions.GetOrAdd(cache, type, (Type t, IYamlTypeConverter[] tc) => LookupTypeConverter(t, tc), typeConverters);
			typeConverter = orAdd.Item2;
			return orAdd.Item1;
		}

		public IYamlTypeConverter GetConverterByType(Type converter)
		{
			IYamlTypeConverter[] array = typeConverters;
			foreach (IYamlTypeConverter yamlTypeConverter in array)
			{
				if (yamlTypeConverter.GetType() == converter)
				{
					return yamlTypeConverter;
				}
			}
			throw new ArgumentException("IYamlTypeConverter of type " + converter.FullName + " not found", "converter");
		}

		private static (bool HasMatch, IYamlTypeConverter? TypeConverter) LookupTypeConverter(Type type, IYamlTypeConverter[] typeConverters)
		{
			foreach (IYamlTypeConverter yamlTypeConverter in typeConverters)
			{
				if (yamlTypeConverter.Accepts(type))
				{
					return (true, yamlTypeConverter);
				}
			}
			return (false, null);
		}
	}
}
namespace YamlDotNet.Serialization.TypeResolvers
{
	public sealed class DynamicTypeResolver : ITypeResolver
	{
		public Type Resolve(Type staticType, object? actualValue)
		{
			if (actualValue == null)
			{
				return staticType;
			}
			return actualValue.GetType();
		}
	}
	public class StaticTypeResolver : ITypeResolver
	{
		public virtual Type Resolve(Type staticType, object? actualValue)
		{
			if (actualValue != null)
			{
				if (actualValue.GetType().IsEnum)
				{
					return staticType;
				}
				switch (actualValue.GetType().GetTypeCode())
				{
				case TypeCode.Boolean:
					return typeof(bool);
				case TypeCode.Char:
					return typeof(char);
				case TypeCode.SByte:
					return typeof(sbyte);
				case TypeCode.Byte:
					return typeof(byte);
				case TypeCode.Int16:
					return typeof(short);
				case TypeCode.UInt16:
					return typeof(ushort);
				case TypeCode.Int32:
					return typeof(int);
				case TypeCode.UInt32:
					return typeof(uint);
				case TypeCode.Int64:
					return typeof(long);
				case TypeCode.UInt64:
					return typeof(ulong);
				case TypeCode.Single:
					return typeof(float);
				case TypeCode.Double:
					return typeof(double);
				case TypeCode.Decimal:
					return typeof(decimal);
				case TypeCode.String:
					return typeof(string);
				case TypeCode.DateTime:
					return typeof(DateTime);
				}
			}
			return staticType;
		}
	}
}
namespace YamlDotNet.Serialization.TypeInspectors
{
	public class CachedTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

		private readonly ConcurrentDictionary<Type, List<IPropertyDescriptor>> cache = new ConcurrentDictionary<Type, List<IPropertyDescriptor>>();

		private readonly ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> enumNameCache = new ConcurrentDictionary<Type, ConcurrentDictionary<string, string>>();

		private readonly ConcurrentDictionary<object, string> enumValueCache = new ConcurrentDictionary<object, string>();

		public CachedTypeInspector(ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
		}

		public override string GetEnumName(Type enumType, string name)
		{
			ConcurrentDictionary<string, string> orAdd = enumNameCache.GetOrAdd(enumType, (Type _) => new ConcurrentDictionary<string, string>());
			return DictionaryExtensions.GetOrAdd(orAdd, name, delegate(string n, (Type enumType, ITypeInspector innerTypeDescriptor) context)
			{
				var (enumType2, typeInspector) = context;
				return typeInspector.GetEnumName(enumType2, n);
			}, (enumType, innerTypeDescriptor));
		}

		public override string GetEnumValue(object enumValue)
		{
			return DictionaryExtensions.GetOrAdd(enumValueCache, enumValue, delegate(object _, (object enumValue, ITypeInspector innerTypeDescriptor) context)
			{
				var (enumValue2, typeInspector) = context;
				return typeInspector.GetEnumValue(enumValue2);
			}, (enumValue, innerTypeDescriptor));
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return DictionaryExtensions.GetOrAdd(cache, type, delegate(Type t, (object container, ITypeInspector innerTypeDescriptor) context)
			{
				var (container2, typeInspector) = context;
				return typeInspector.GetProperties(t, container2).ToList();
			}, (container, innerTypeDescriptor));
		}
	}
	public class CompositeTypeInspector : TypeInspectorSkeleton
	{
		private readonly IEnumerable<ITypeInspector> typeInspectors;

		public CompositeTypeInspector(params ITypeInspector[] typeInspectors)
			: this((IEnumerable<ITypeInspector>)typeInspectors)
		{
		}

		public CompositeTypeInspector(IEnumerable<ITypeInspector> typeInspectors)
		{
			this.typeInspectors = typeInspectors?.ToList() ?? throw new ArgumentNullException("typeInspectors");
		}

		public override string GetEnumName(Type enumType, string name)
		{
			foreach (ITypeInspector typeInspector in typeInspectors)
			{
				try
				{
					return typeInspector.GetEnumName(enumType, name);
				}
				catch
				{
				}
			}
			throw new ArgumentOutOfRangeException("enumType,name", "Name not found on enum type");
		}

		public override string GetEnumValue(object enumValue)
		{
			if (enumValue == null)
			{
				throw new ArgumentNullException("enumValue");
			}
			foreach (ITypeInspector typeInspector in typeInspectors)
			{
				try
				{
					return typeInspector.GetEnumValue(enumValue);
				}
				catch
				{
				}
			}
			throw new ArgumentOutOfRangeException("enumValue", $"Value not found for ({enumValue})");
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			Type type2 = type;
			object container2 = container;
			return typeInspectors.SelectMany((ITypeInspector i) => i.GetProperties(type2, container2));
		}
	}
	public class NamingConventionTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

		private readonly INamingConvention namingConvention;

		public NamingConventionTypeInspector(ITypeInspector innerTypeDescriptor, INamingConvention namingConvention)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
		}

		public override string GetEnumName(Type enumType, string name)
		{
			return innerTypeDescriptor.GetEnumName(enumType, name);
		}

		public override string GetEnumValue(object enumValue)
		{
			return innerTypeDescriptor.GetEnumValue(enumValue);
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return innerTypeDescriptor.GetProperties(type, container).Select(delegate(IPropertyDescriptor p)
			{
				YamlMemberAttribute customAttribute = p.GetCustomAttribute<YamlMemberAttribute>();
				return (customAttribute != null && !customAttribute.ApplyNamingConventions) ? p : new PropertyDescriptor(p)
				{
					Name = namingConvention.Apply(p.Name)
				};
			});
		}
	}
	public class ReadableAndWritablePropertiesTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

		public ReadableAndWritablePropertiesTypeInspector(ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
		}

		public override string GetEnumName(Type enumType, string name)
		{
			return innerTypeDescriptor.GetEnumName(enumType, name);
		}

		public override string GetEnumValue(object enumValue)
		{
			return innerTypeDescriptor.GetEnumValue(enumValue);
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return from p in innerTypeDescriptor.GetProperties(type, container)
				where p.CanWrite
				select p;
		}
	}
	public class ReadableFieldsTypeInspector : ReflectionTypeInspector
	{
		protected class ReflectionFieldDescriptor : IPropertyDescriptor
		{
			private readonly FieldInfo fieldInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => fieldInfo.Name;

			public bool Required => fieldInfo.IsRequired();

			public Type Type => fieldInfo.FieldType;

			public Type? ConverterType { get; }

			public Type? TypeOverride { get; set; }

			public bool AllowNulls => fieldInfo.AcceptsNull();

			public int Order { get; set; }

			public bool CanWrite => !fieldInfo.IsInitOnly;

			public ScalarStyle ScalarStyle { get; set; }

			public ReflectionFieldDescriptor(FieldInfo fieldInfo, ITypeResolver typeResolver)
			{
				this.fieldInfo = fieldInfo;
				this.typeResolver = typeResolver;
				YamlConverterAttribute customAttribute = fieldInfo.GetCustomAttribute<YamlConverterAttribute>();
				if (customAttribute != null)
				{
					ConverterType = customAttribute.ConverterType;
				}
				ScalarStyle = ScalarStyle.Any;
			}

			public void Write(object target, object? value)
			{
				fieldInfo.SetValue(target, value);
			}

			public T? GetCustomAttribute<T>() where T : Attribute
			{
				object[] customAttributes = fieldInfo.GetCustomAttributes(typeof(T), inherit: true);
				return (T)customAttributes.FirstOrDefault();
			}

			public IObjectDescriptor Read(object target)
			{
				object value = fieldInfo.GetValue(target);
				Type type = TypeOverride ?? typeResolver.Resolve(Type, value);
				return new ObjectDescriptor(value, type, Type, ScalarStyle);
			}
		}

		private readonly ITypeResolver typeResolver;

		public ReadableFieldsTypeInspector(ITypeResolver typeResolver)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return type.GetPublicFields().Select((Func<FieldInfo, IPropertyDescriptor>)((FieldInfo p) => new ReflectionFieldDescriptor(p, typeResolver)));
		}
	}
	public class ReadablePropertiesTypeInspector : ReflectionTypeInspector
	{
		protected class ReflectionPropertyDescriptor : IPropertyDescriptor
		{
			private readonly PropertyInfo propertyInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => propertyInfo.Name;

			public bool Required => propertyInfo.IsRequired();

			public Type Type => propertyInfo.PropertyType;

			public Type? TypeOverride { get; set; }

			public Type? ConverterType { get; set; }

			public bool AllowNulls => propertyInfo.AcceptsNull();

			public int Order { get; set; }

			public bool CanWrite => propertyInfo.CanWrite;

			public ScalarStyle ScalarStyle { get; set; }

			public ReflectionPropertyDescriptor(PropertyInfo propertyInfo, ITypeResolver typeResolver)
			{
				this.propertyInfo = propertyInfo ?? throw new ArgumentNullException("propertyInfo");
				this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
				ScalarStyle = ScalarStyle.Any;
				YamlConverterAttribute customAttribute = propertyInfo.GetCustomAttribute<YamlConverterAttribute>();
				if (customAttribute != null)
				{
					ConverterType = customAttribute.ConverterType;
				}
			}

			public void Write(object target, object? value)
			{
				propertyInfo.SetValue(target, value, null);
			}

			public T? GetCustomAttribute<T>() where T : Attribute
			{
				Attribute[] allCustomAttributes = propertyInfo.GetAllCustomAttributes<T>();
				return (T)allCustomAttributes.FirstOrDefault();
			}

			public IObjectDescriptor Read(object target)
			{
				object obj = propertyInfo.ReadValue(target);
				Type type = TypeOverride ?? typeResolver.Resolve(Type, obj);
				return new ObjectDescriptor(obj, type, Type, ScalarStyle);
			}
		}

		private readonly ITypeResolver typeResolver;

		private readonly bool includeNonPublicProperties;

		public ReadablePropertiesTypeInspector(ITypeResolver typeResolver)
			: this(typeResolver, includeNonPublicProperties: false)
		{
		}

		public ReadablePropertiesTypeInspector(ITypeResolver typeResolver, bool includeNonPublicProperties)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			this.includeNonPublicProperties = includeNonPublicProperties;
		}

		private static bool IsValidProperty(PropertyInfo property)
		{
			if (property.CanRead)
			{
				return property.GetGetMethod(nonPublic: true).GetParameters().Length == 0;
			}
			return false;
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return type.GetProperties(includeNonPublicProperties).Where(IsValidProperty).Select((Func<PropertyInfo, IPropertyDescriptor>)((PropertyInfo p) => new ReflectionPropertyDescriptor(p, typeResolver)));
		}
	}
	public abstract class ReflectionTypeInspector : TypeInspectorSkeleton
	{
		public override string GetEnumName(Type enumType, string name)
		{
			return name;
		}

		public override string GetEnumValue(object enumValue)
		{
			if (enumValue == null)
			{
				return string.Empty;
			}
			return enumValue.ToString();
		}
	}
	public abstract class TypeInspectorSkeleton : ITypeInspector
	{
		public abstract string GetEnumName(Type enumType, string name);

		public abstract string GetEnumValue(object enumValue);

		public abstract IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container);

		public IPropertyDescriptor GetProperty(Type type, object? container, string name, [MaybeNullWhen(true)] bool ignoreUnmatched, bool caseInsensitivePropertyMatching)
		{
			string name2 = name;
			IEnumerable<IPropertyDescriptor> enumerable = ((!caseInsensitivePropertyMatching) ? (from p in GetProperties(type, container)
				where p.Name == name2
				select p) : (from p in GetProperties(type, container)
				where p.Name.Equals(name2, StringComparison.OrdinalIgnoreCase)
				select p));
			using IEnumerator<IPropertyDescriptor> enumerator = enumerable.GetEnumerator();
			if (!enumerator.MoveNext())
			{
				if (ignoreUnmatched)
				{
					return null;
				}
				throw new SerializationException("Property '" + name2 + "' not found on type '" + type.FullName + "'.");
			}
			IPropertyDescriptor current = enumerator.Current;
			if (enumerator.MoveNext())
			{
				throw new SerializationException("Multiple properties with the name/alias '" + name2 + "' already exists on type '" + type.FullName + "', maybe you're misusing YamlAlias or maybe you are using the wrong naming convention? The matching properties are: " + string.Join(", ", enumerable.Select((IPropertyDescriptor p) => p.Name).ToArray()));
			}
			return current;
		}
	}
	public class WritablePropertiesTypeInspector : ReflectionTypeInspector
	{
		protected class ReflectionPropertyDescriptor : IPropertyDescriptor
		{
			private readonly PropertyInfo propertyInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => propertyInfo.Name;

			public bool Required => propertyInfo.IsRequired();

			public Type Type => propertyInfo.PropertyType;

			public Type? TypeOverride { get; set; }

			public Type? ConverterType { get; set; }

			public bool AllowNulls => propertyInfo.AcceptsNull();

			public int Order { get; set; }

			public bool CanWrite => propertyInfo.CanWrite;

			public ScalarStyle ScalarStyle { get; set; }

			public ReflectionPropertyDescriptor(PropertyInfo propertyInfo, ITypeResolver typeResolver)
			{
				this.propertyInfo = propertyInfo ?? throw new ArgumentNullException("propertyInfo");
				this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
				ScalarStyle = ScalarStyle.Any;
				YamlConverterAttribute customAttribute = propertyInfo.GetCustomAttribute<YamlConverterAttribute>();
				if (customAttribute != null)
				{
					ConverterType = customAttribute.ConverterType;
				}
			}

			public void Write(object target, object? value)
			{
				propertyInfo.SetValue(target, value, null);
			}

			public T? GetCustomAttribute<T>() where T : Attribute
			{
				Attribute[] allCustomAttributes = propertyInfo.GetAllCustomAttributes<T>();
				return (T)allCustomAttributes.FirstOrDefault();
			}

			public IObjectDescriptor Read(object target)
			{
				object obj = propertyInfo.ReadValue(target);
				Type type = TypeOverride ?? typeResolver.Resolve(Type, obj);
				return new ObjectDescriptor(obj, type, Type, ScalarStyle);
			}
		}

		private readonly ITypeResolver typeResolver;

		private readonly bool includeNonPublicProperties;

		public WritablePropertiesTypeInspector(ITypeResolver typeResolver)
			: this(typeResolver, includeNonPublicProperties: false)
		{
		}

		public WritablePropertiesTypeInspector(ITypeResolver typeResolver, bool includeNonPublicProperties)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			this.includeNonPublicProperties = includeNonPublicProperties;
		}

		private static bool IsValidProperty(PropertyInfo property)
		{
			if (property.CanWrite)
			{
				return property.GetSetMethod(nonPublic: true).GetParameters().Length == 1;
			}
			return false;
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return type.GetProperties(includeNonPublicProperties).Where(IsValidProperty).Select((Func<PropertyInfo, IPropertyDescriptor>)((PropertyInfo p) => new ReflectionPropertyDescriptor(p, typeResolver)))
				.ToArray();
		}
	}
}
namespace YamlDotNet.Serialization.Schemas
{
	public sealed class FailsafeSchema
	{
		public static class Tags
		{
			public static readonly TagName Map = new TagName("tag:yaml.org,2002:map");

			public static readonly TagName Seq = new TagName("tag:yaml.org,2002:seq");

			public static readonly TagName Str = new TagName("tag:yaml.org,2002:str");
		}
	}
	public sealed class JsonSchema
	{
		public static class Tags
		{
			public static readonly TagName Null = new TagName("tag:yaml.org,2002:null");

			public static readonly TagName Bool = new TagName("tag:yaml.org,2002:bool");

			public static readonly TagName Int = new TagName("tag:yaml.org,2002:int");

			public static readonly TagName Float = new TagName("tag:yaml.org,2002:float");
		}
	}
	public sealed class CoreSchema
	{
		public static class Tags
		{
		}
	}
	public sealed class DefaultSchema
	{
		public static class Tags
		{
			public static readonly TagName Timestamp = new TagName("tag:yaml.org,2002:timestamp");
		}
	}
}
namespace YamlDotNet.Serialization.ObjectGraphVisitors
{
	public sealed class AnchorAssigner : PreProcessingPhaseObjectGraphVisitorSkeleton, IAliasProvider
	{
		private class AnchorAssignment
		{
			public AnchorName Anchor;
		}

		private readonly Dictionary<object, AnchorAssignment> assignments = new Dictionary<object, AnchorAssignment>();

		private uint nextId;

		public AnchorAssigner(IEnumerable<IYamlTypeConverter> typeConverters)
			: base(typeConverters)
		{
		}

		protected override bool Enter(IObjectDescriptor value, ObjectSerializer serializer)
		{
			if (value.Value != null && assignments.TryGetValue(value.Value, out AnchorAssignment value2))
			{
				if (value2.Anchor.IsEmpty)
				{
					value2.Anchor = new AnchorName("o" + nextId.ToString(CultureInfo.InvariantCulture));
					nextId++;
				}
				return false;
			}
			return true;
		}

		protected override bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, ObjectSerializer serializer)
		{
			return true;
		}

		protected override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, ObjectSerializer serializer)
		{
			return true;
		}

		protected override void VisitScalar(IObjectDescriptor scalar, ObjectSerializer serializer)
		{
		}

		protected override void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, ObjectSerializer serializer)
		{
			VisitObject(mapping);
		}

		protected override void VisitMappingEnd(IObjectDescriptor mapping, ObjectSerializer serializer)
		{
		}

		protected override void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, ObjectSerializer serializer)
		{
			VisitObject(sequence);
		}

		protected override void VisitSequenceEnd(IObjectDescriptor sequence, ObjectSerializer serializer)
		{
		}

		private void VisitObject(IObjectDescriptor value)
		{
			if (value.Value != null)
			{
				assignments.Add(value.Value, new AnchorAssignment());
			}
		}

		AnchorName IAliasProvider.GetAlias(object target)
		{
			if (target != null && assignments.TryGetValue(target, out AnchorAssignment value))
			{
				return value.Anchor;
			}
			return AnchorName.Empty;
		}
	}
	public sealed class AnchorAssigningObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		private readonly IEventEmitter eventEmitter;

		private readonly IAliasProvider aliasProvider;

		private readonly HashSet<AnchorName> emittedAliases = new HashSet<AnchorName>();

		public AnchorAssigningObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor, IEventEmitter eventEmitter, IAliasProvider aliasProvider)
			: base(nextVisitor)
		{
			this.eventEmitter = eventEmitter;
			this.aliasProvider = aliasProvider;
		}

		public override bool Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			if (value.Value != null)
			{
				AnchorName alias = aliasProvider.GetAlias(value.Value);
				if (!alias.IsEmpty && !emittedAliases.Add(alias))
				{
					AliasEventInfo aliasEventInfo = new AliasEventInfo(value, alias);
					eventEmitter.Emit(aliasEventInfo, context);
					return aliasEventInfo.NeedsExpansion;
				}
			}
			return base.Enter(propertyDescriptor, value, context, serializer);
		}

		public override void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context, ObjectSerializer serializer)
		{
			AnchorName alias = aliasProvider.GetAlias(mapping.NonNullValue());
			eventEmitter.Emit(new MappingStartEventInfo(mapping)
			{
				Anchor = alias
			}, context);
		}

		public override void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context, ObjectSerializer serializer)
		{
			AnchorName alias = aliasProvider.GetAlias(sequence.NonNullValue());
			eventEmitter.Emit(new SequenceStartEventInfo(sequence)
			{
				Anchor = alias
			}, context);
		}

		public override void VisitScalar(IObjectDescriptor scalar, IEmitter context, ObjectSerializer serializer)
		{
			ScalarEventInfo scalarEventInfo = new ScalarEventInfo(scalar);
			if (scalar.Value != null)
			{
				scalarEventInfo.Anchor = aliasProvider.GetAlias(scalar.Value);
			}
			eventEmitter.Emit(scalarEventInfo, context);
		}
	}
	public abstract class ChainedObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
	{
		private readonly IObjectGraphVisitor<IEmitter> nextVisitor;

		protected ChainedObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
		{
			this.nextVisitor = nextVisitor;
		}

		public virtual bool Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return nextVisitor.Enter(propertyDescriptor, value, context, serializer);
		}

		public virtual bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return nextVisitor.EnterMapping(key, value, context, serializer);
		}

		public virtual bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return nextVisitor.EnterMapping(key, value, context, serializer);
		}

		public virtual void VisitScalar(IObjectDescriptor scalar, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitScalar(scalar, context, serializer);
		}

		public virtual void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitMappingStart(mapping, keyType, valueType, context, serializer);
		}

		public virtual void VisitMappingEnd(IObjectDescriptor mapping, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitMappingEnd(mapping, context, serializer);
		}

		public virtual void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitSequenceStart(sequence, elementType, context, serializer);
		}

		public virtual void VisitSequenceEnd(IObjectDescriptor sequence, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitSequenceEnd(sequence, context, serializer);
		}
	}
	public sealed class CommentsObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		public CommentsObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			YamlMemberAttribute customAttribute = key.GetCustomAttribute<YamlMemberAttribute>();
			if (customAttribute != null && customAttribute.Description != null)
			{
				context.Emit(new YamlDotNet.Core.Events.Comment(customAttribute.Description, isInline: false));
			}
			return base.EnterMapping(key, value, context, serializer);
		}
	}
	public sealed class CustomSerializationObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		private readonly TypeConverterCache typeConverters;

		private readonly ObjectSerializer nestedObjectSerializer;

		public CustomSerializationObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor, IEnumerable<IYamlTypeConverter> typeConverters, ObjectSerializer nestedObjectSerializer)
			: base(nextVisitor)
		{
			this.typeConverters = new TypeConverterCache(typeConverters);
			this.nestedObjectSerializer = nestedObjectSerializer;
		}

		public override bool Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			if (propertyDescriptor?.ConverterType != null)
			{
				IYamlTypeConverter converterByType = typeConverters.GetConverterByType(propertyDescriptor.ConverterType);
				converterByType.WriteYaml(context, value.Value, value.Type, serializer);
				return false;
			}
			if (typeConverters.TryGetConverterForType(value.Type, out IYamlTypeConverter typeConverter))
			{
				typeConverter.WriteYaml(context, value.Value, value.Type, serializer);
				return false;
			}
			if (value.Value is IYamlConvertible yamlConvertible)
			{
				yamlConvertible.Write(context, nestedObjectSerializer);
				return false;
			}
			if (value.Value is IYamlSerializable yamlSerializable)
			{
				yamlSerializable.WriteYaml(context);
				return false;
			}
			return base.Enter(propertyDescriptor, value, context, serializer);
		}
	}
	public sealed class DefaultExclusiveObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		public DefaultExclusiveObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		private static object? GetDefault(Type type)
		{
			if (!type.IsValueType())
			{
				return null;
			}
			return Activator.CreateInstance(type);
		}

		public override bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			if (!object.Equals(value.Value, GetDefault(value.Type)))
			{
				return base.EnterMapping(key, value, context, serializer);
			}
			return false;
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			DefaultValueAttribute customAttribute = key.GetCustomAttribute<DefaultValueAttribute>();
			object objB = ((customAttribute != null) ? customAttribute.Value : GetDefault(key.Type));
			if (!object.Equals(value.Value, objB))
			{
				return base.EnterMapping(key, value, context, serializer);
			}
			return false;
		}
	}
	public sealed class DefaultValuesObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		private readonly DefaultValuesHandling handling;

		private readonly IObjectFactory factory;

		public DefaultValuesObjectGraphVisitor(DefaultValuesHandling handling, IObjectGraphVisitor<IEmitter> nextVisitor, IObjectFactory factory)
			: base(nextVisitor)
		{
			this.handling = handling;
			this.factory = factory;
		}

		private object? GetDefault(Type type)
		{
			return factory.CreatePrimitive(type);
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			DefaultValuesHandling defaultValuesHandling = handling;
			YamlMemberAttribute customAttribute = key.GetCustomAttribute<YamlMemberAttribute>();
			if (customAttribute != null && customAttribute.IsDefaultValuesHandlingSpecified)
			{
				defaultValuesHandling = customAttribute.DefaultValuesHandling;
			}
			if ((defaultValuesHandling & DefaultValuesHandling.OmitNull) != 0 && value.Value == null)
			{
				return false;
			}
			if ((defaultValuesHandling & DefaultValuesHandling.OmitEmptyCollections) != 0 && value.Value is IEnumerable enumerable)
			{
				IEnumerator enumerator = enumerable.GetEnumerator();
				bool flag = enumerator.MoveNext();
				if (enumerator is IDisposable disposable)
				{
					disposable.Dispose();
				}
				if (!flag)
				{
					return false;
				}
			}
			if ((defaultValuesHandling & DefaultValuesHandling.OmitDefaults) != 0)
			{
				object objB = key.GetCustomAttribute<DefaultValueAttribute>()?.Value ?? GetDefault(key.Type);
				if (object.Equals(value.Value, objB))
				{
					return false;
				}
			}
			return base.EnterMapping(key, value, context, serializer);
		}
	}
	public sealed class EmittingObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
	{
		private readonly IEventEmitter eventEmitter;

		public EmittingObjectGraphVisitor(IEventEmitter eventEmitter)
		{
			this.eventEmitter = eventEmitter;
		}

		bool IObjectGraphVisitor<IEmitter>.Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return true;
		}

		bool IObjectGraphVisitor<IEmitter>.EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return true;
		}

		bool IObjectGraphVisitor<IEmitter>.EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return true;
		}

		void IObjectGraphVisitor<IEmitter>.VisitScalar(IObjectDescriptor scalar, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new ScalarEventInfo(scalar), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new MappingStartEventInfo(mapping), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitMappingEnd(IObjectDescriptor mapping, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new MappingEndEventInfo(mapping), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new SequenceStartEventInfo(sequence), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitSequenceEnd(IObjectDescriptor sequence, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new SequenceEndEventInfo(sequence), context);
		}
	}
	public abstract class PreProcessingPhaseObjectGraphVisitorSkeleton : IObjectGraphVisitor<Nothing>
	{
		protected readonly IEnumerable<IYamlTypeConverter> typeConverters;

		private readonly TypeConverterCache typeConverterCache;

		public PreProcessingPhaseObjectGraphVisitorSkeleton(IEnumerable<IYamlTypeConverter> typeConverters)
		{
			typeConverterCache = new TypeConverterCache((IYamlTypeConverter[])(this.typeConverters = typeConverters?.ToArray() ?? Array.Empty<IYamlTypeConverter>()));
		}

		bool IObjectGraphVisitor<Nothing>.Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, Nothing context, ObjectSerializer serializer)
		{
			if (typeConverterCache.TryGetConverterForType(value.Type, out IYamlTypeConverter _))
			{
				return false;
			}
			if (value.Value is IYamlConvertible)
			{
				return false;
			}
			if (value.Value is IYamlSerializable)
			{
				return false;
			}
			return Enter(value, serializer);
		}

		bool IObjectGraphVisitor<Nothing>.EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, Nothing context, ObjectSerializer serializer)
		{
			return EnterMapping(key, value, serializer);
		}

		bool IObjectGraphVisitor<Nothing>.EnterMapping(IObjectDescriptor key, IObjectDescriptor value, Nothing context, ObjectSerializer serializer)
		{
			return EnterMapping(key, value, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitMappingEnd(IObjectDescriptor mapping, Nothing context, ObjectSerializer serializer)
		{
			VisitMappingEnd(mapping, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, Nothing context, ObjectSerializer serializer)
		{
			VisitMappingStart(mapping, keyType, valueType, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitScalar(IObjectDescriptor scalar, Nothing context, ObjectSerializer serializer)
		{
			VisitScalar(scalar, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitSequenceEnd(IObjectDescriptor sequence, Nothing context, ObjectSerializer serializer)
		{
			VisitSequenceEnd(sequence, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitSequenceStart(IObjectDescriptor sequence, Type elementType, Nothing context, ObjectSerializer serializer)
		{
			VisitSequenceStart(sequence, elementType, serializer);
		}

		protected abstract bool Enter(IObjectDescriptor value, ObjectSerializer serializer);

		protected abstract bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, ObjectSerializer serializer);

		protected abstract bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, ObjectSerializer serializer);

		protected abstract void VisitMappingEnd(IObjectDescriptor mapping, ObjectSerializer serializer);

		protected abstract void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, ObjectSerializer serializer);

		protected abstract void VisitScalar(IObjectDescriptor scalar, ObjectSerializer serializer);

		protected abstract void VisitSequenceEnd(IObjectDescriptor sequence, ObjectSerializer serializer);

		protected abstract void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, ObjectSerializer serializer);
	}
}
namespace YamlDotNet.Serialization.ObjectGraphTraversalStrategies
{
	public class FullObjectGraphTraversalStrategy : IObjectGraphTraversalStrategy
	{
		protected readonly struct ObjectPathSegment
		{
			public readonly object Name;

			public readonly IObjectDescriptor Value;

			public ObjectPathSegment(object name, IObjectDescriptor value)
			{
				Name = name;
				Value = value;
			}
		}

		private readonly int maxRecursion;

		private readonly ITypeInspector typeDescriptor;

		private readonly ITypeResolver typeResolver;

		private readonly INamingConvention namingConvention;

		private readonly IObjectFactory objectFactory;

		public FullObjectGraphTraversalStrategy(ITypeInspector typeDescriptor, ITypeResolver typeResolver, int maxRecursion, INamingConvention namingConvention, IObjectFactory objectFactory)
		{
			if (maxRecursion <= 0)
			{
				throw new ArgumentOutOfRangeException("maxRecursion", maxRecursion, "maxRecursion must be greater than 1");
			}
			this.typeDescriptor = typeDescriptor ?? throw new ArgumentNullException("typeDescriptor");
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			this.maxRecursion = maxRecursion;
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		void IObjectGraphTraversalStrategy.Traverse<TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context, ObjectSerializer serializer)
		{
			Traverse(null, "<root>", graph, visitor, context, new Stack<ObjectPathSegment>(maxRecursion), serializer);
		}

		protected virtual void Traverse<TContext>(IPropertyDescriptor? propertyDescriptor, object name, IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			if (path.Count >= maxRecursion)
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("Too much recursion when traversing the object graph.");
				stringBuilder.AppendLine("The path to reach this recursion was:");
				Stack<KeyValuePair<string, string>> stack = new Stack<KeyValuePair<string, string>>(path.Count);
				int num = 0;
				foreach (ObjectPathSegment item in path)
				{
					string text = item.Name?.ToString() ?? string.Empty;
					num = Math.Max(num, text.Length);
					stack.Push(new KeyValuePair<string, string>(text, item.Value.Type.FullName));
				}
				foreach (KeyValuePair<string, string> item2 in stack)
				{
					stringBuilder.Append(" -> ").Append(item2.Key.PadRight(num)).Append("  [")
						.Append(item2.Value)
						.AppendLine("]");
				}
				throw new MaximumRecursionLevelReachedException(stringBuilder.ToString());
			}
			if (!visitor.Enter(propertyDescriptor, value, context, serializer))
			{
				return;
			}
			path.Push(new ObjectPathSegment(name, value));
			try
			{
				TypeCode typeCode = value.Type.GetTypeCode();
				switch (typeCode)
				{
				case TypeCode.Boolean:
				case TypeCode.Char:
				case TypeCode.SByte:
				case TypeCode.Byte:
				case TypeCode.Int16:
				case TypeCode.UInt16:
				case TypeCode.Int32:
				case TypeCode.UInt32:
				case TypeCode.Int64:
				case TypeCode.UInt64:
				case TypeCode.Single:
				case TypeCode.Double:
				case TypeCode.Decimal:
				case TypeCode.DateTime:
				case TypeCode.String:
					visitor.VisitScalar(value, context, serializer);
					return;
				case TypeCode.Empty:
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
				if (value.IsDbNull())
				{
					visitor.VisitScalar(new ObjectDescriptor(null, typeof(object), typeof(object)), context, serializer);
				}
				if (value.Value == null || value.Type == typeof(TimeSpan))
				{
					visitor.VisitScalar(value, context, serializer);
					return;
				}
				Type underlyingType = Nullable.GetUnderlyingType(value.Type);
				Type type = underlyingType ?? FsharpHelper.GetOptionUnderlyingType(value.Type);
				object obj = ((type != null) ? FsharpHelper.GetValue(value) : null);
				if (underlyingType != null)
				{
					Traverse(propertyDescriptor, "Value", new ObjectDescriptor(value.Value, underlyingType, value.Type, value.ScalarStyle), visitor, context, path, serializer);
				}
				else if (type != null && obj != null)
				{
					Traverse(propertyDescriptor, "Value", new ObjectDescriptor(FsharpHelper.GetValue(value), type, value.Type, value.ScalarStyle), visitor, context, path, serializer);
				}
				else
				{
					TraverseObject(propertyDescriptor, value, visitor, context, path, serializer);
				}
			}
			finally
			{
				path.Pop();
			}
		}

		protected virtual void TraverseObject<TContext>(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			IDictionary dictionary;
			Type[] genericArguments;
			if (typeof(IDictionary).IsAssignableFrom(value.Type))
			{
				TraverseDictionary(propertyDescriptor, value, visitor, typeof(object), typeof(object), context, path, serializer);
			}
			else if (objectFactory.GetDictionary(value, out dictionary, out genericArguments))
			{
				TraverseDictionary(propertyDescriptor, new ObjectDescriptor(dictionary, value.Type, value.StaticType, value.ScalarStyle), visitor, genericArguments[0], genericArguments[1], context, path, serializer);
			}
			else if (typeof(IEnumerable).IsAssignableFrom(value.Type))
			{
				TraverseList(propertyDescriptor, value, visitor, context, path, serializer);
			}
			else
			{
				TraverseProperties(value, visitor, context, path, serializer);
			}
		}

		protected virtual void TraverseDictionary<TContext>(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor dictionary, IObjectGraphVisitor<TContext> visitor, Type keyType, Type valueType, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			visitor.VisitMappingStart(dictionary, keyType, valueType, context, serializer);
			bool flag = dictionary.Type.FullName.Equals("System.Dynamic.ExpandoObject");
			foreach (DictionaryEntry? item in (IDictionary)dictionary.NonNullValue())
			{
				DictionaryEntry value = item.Value;
				object obj = (flag ? namingConvention.Apply(value.Key.ToString()) : value.Key);
				ObjectDescriptor objectDescriptor = GetObjectDescriptor(obj, keyType);
				ObjectDescriptor objectDescriptor2 = GetObjectDescriptor(value.Value, valueType);
				if (visitor.EnterMapping(objectDescriptor, objectDescriptor2, context, serializer))
				{
					Traverse(propertyDescriptor, obj, objectDescriptor, visitor, context, path, serializer);
					Traverse(propertyDescriptor, obj, objectDescriptor2, visitor, context, path, serializer);
				}
			}
			visitor.VisitMappingEnd(dictionary, context, serializer);
		}

		private void TraverseList<TContext>(IPropertyDescriptor propertyDescriptor, IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			Type valueType = objectFactory.GetValueType(value.Type);
			visitor.VisitSequenceStart(value, valueType, context, serializer);
			int num = 0;
			foreach (object item in (IEnumerable)value.NonNullValue())
			{
				Traverse(propertyDescriptor, num, GetObjectDescriptor(item, valueType), visitor, context, path, serializer);
				num++;
			}
			visitor.VisitSequenceEnd(value, context, serializer);
		}

		protected virtual void TraverseProperties<TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			if (context.GetType() != typeof(Nothing))
			{
				objectFactory.ExecuteOnSerializing(value.Value);
			}
			visitor.VisitMappingStart(value, typeof(string), typeof(object), context, serializer);
			object obj = value.NonNullValue();
			foreach (IPropertyDescriptor property in typeDescriptor.GetProperties(value.Type, obj))
			{
				IObjectDescriptor value2 = property.Read(obj);
				if (visitor.EnterMapping(property, value2, context, serializer))
				{
					Traverse(null, property.Name, new ObjectDescriptor(property.Name, typeof(string), typeof(string), ScalarStyle.Plain), visitor, context, path, serializer);
					Traverse(property, property.Name, value2, visitor, context, path, serializer);
				}
			}
			visitor.VisitMappingEnd(value, context, serializer);
			if (context.GetType() != typeof(Nothing))
			{
				objectFactory.ExecuteOnSerialized(value.Value);
			}
		}

		private ObjectDescriptor GetObjectDescriptor(object? value, Type staticType)
		{
			return new ObjectDescriptor(value, typeResolver.Resolve(staticType, value), staticType);
		}
	}
	public class RoundtripObjectGraphTraversalStrategy : FullObjectGraphTraversalStrategy
	{
		private readonly TypeConverterCache converters;

		private readonly Settings settings;

		public RoundtripObjectGraphTraversalStrategy(IEnumerable<IYamlTypeConverter> converters, ITypeInspector typeDescriptor, ITypeResolver typeResolver, int maxRecursion, INamingConvention namingConvention, Settings settings, IObjectFactory factory)
			: base(typeDescriptor, typeResolver, maxRecursion, namingConvention, factory)
		{
			this.converters = new TypeConverterCache(converters);
			this.settings = settings;
		}

		protected override void TraverseProperties<TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			if (!value.Type.HasDefaultConstructor(settings.AllowPrivateConstructors) && !converters.TryGetConverterForType(value.Type, out IYamlTypeConverter _))
			{
				throw new InvalidOperationException($"Type '{value.Type}' cannot be deserialized because it does not have a default constructor or a type converter.");
			}
			base.TraverseProperties(value, visitor, context, path, serializer);
		}
	}
}
namespace YamlDotNet.Serialization.ObjectFactories
{
	public class DefaultObjectFactory : ObjectFactoryBase
	{
		private readonly Dictionary<Type, ConcurrentDictionary<Type, MethodInfo[]>> stateMethods = new Dictionary<Type, ConcurrentDictionary<Type, MethodInfo[]>>
		{
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnDeserializedAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			},
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnDeserializingAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			},
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnSerializedAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			},
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnSerializingAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			}
		};

		private readonly Dictionary<Type, Type> defaultGenericInterfaceImplementations = new Dictionary<Type, Type>
		{
			{
				typeof(IEnumerable<>),
				typeof(List<>)
			},
			{
				typeof(ICollection<>),
				typeof(List<>)
			},
			{
				typeof(IList<>),
				typeof(List<>)
			},
			{
				typeof(IDictionary<, >),
				typeof(Dictionary<, >)
			}
		};

		private readonly Dictionary<Type, Type> defaultNonGenericInterfaceImplementations = new Dictionary<Type, Type>
		{
			{
				typeof(IEnumerable),
				typeof(List<object>)
			},
			{
				typeof(ICollection),
				typeof(List<object>)
			},
			{
				typeof(IList),
				typeof(List<object>)
			},
			{
				typeof(IDictionary),
				typeof(Dictionary<object, object>)
			}
		};

		private readonly Settings settings;

		public DefaultObjectFactory()
			: this(new Dictionary<Type, Type>(), new Settings())
		{
		}

		public DefaultObjectFactory(IDictionary<Type, Type> mappings)
			: this(mappings, new Settings())
		{
		}

		public DefaultObjectFactory(IDictionary<Type, Type> mappings, Settings settings)
		{
			foreach (KeyValuePair<Type, Type> mapping in mappings)
			{
				if (!mapping.Key.IsAssignableFrom(mapping.Value))
				{
					throw new InvalidOperationException($"Type '{mapping.Value}' does not implement type '{mapping.Key}'.");
				}
				defaultNonGenericInterfaceImplementations.Add(mapping.Key, mapping.Value);
			}
			this.settings = settings;
		}

		public override object Create(Type type)
		{
			if (type.IsInterface())
			{
				Type value2;
				if (type.IsGenericType())
				{
					if (defaultGenericInterfaceImplementations.TryGetValue(type.GetGenericTypeDefinition(), out Type value))
					{
						type = value.MakeGenericType(type.GetGenericArguments());
					}
				}
				else if (defaultNonGenericInterfaceImplementations.TryGetValue(type, out value2))
				{
					type = value2;
				}
			}
			try
			{
				return Activator.CreateInstance(type, settings.AllowPrivateConstructors);
			}
			catch (Exception innerException)
			{
				string message = "Failed to create an instance of type '" + type.FullName + "'.";
				throw new InvalidOperationException(message, innerException);
			}
		}

		public override void ExecuteOnDeserialized(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnDeserializedAttribute), value);
		}

		public override void ExecuteOnDeserializing(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnDeserializingAttribute), value);
		}

		public override void ExecuteOnSerialized(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnSerializedAttribute), value);
		}

		public override void ExecuteOnSerializing(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnSerializingAttribute), value);
		}

		private void ExecuteState(Type attributeType, object value)
		{
			if (value != null)
			{
				Type type = value.GetType();
				MethodInfo[] array = GetStateMethods(attributeType, type);
				MethodInfo[] array2 = array;
				foreach (MethodInfo methodInfo in array2)
				{
					methodInfo.Invoke(value, null);
				}
			}
		}

		private MethodInfo[] GetStateMethods(Type attributeType, Type valueType)
		{
			Type attributeType2 = attributeType;
			ConcurrentDictionary<Type, MethodInfo[]> concurrentDictionary = stateMethods[attributeType2];
			return concurrentDictionary.GetOrAdd(valueType, delegate(Type type)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				return methods.Where((MethodInfo x) => x.GetCustomAttributes(attributeType2, inherit: true).Length != 0).ToArray();
			});
		}
	}
	public sealed class LambdaObjectFactory : ObjectFactoryBase
	{
		private readonly Func<Type, object> factory;

		public LambdaObjectFactory(Func<Type, object> factory)
		{
			this.factory = factory ?? throw new ArgumentNullException("factory");
		}

		public override object Create(Type type)
		{
			return factory(type);
		}
	}
	public abstract class ObjectFactoryBase : IObjectFactory
	{
		public abstract object Create(Type type);

		public virtual object? CreatePrimitive(Type type)
		{
			if (!type.IsValueType())
			{
				return null;
			}
			return Activator.CreateInstance(type);
		}

		public virtual void ExecuteOnDeserialized(object value)
		{
		}

		public virtual void ExecuteOnDeserializing(object value)
		{
		}

		public virtual void ExecuteOnSerialized(object value)
		{
		}

		public virtual void ExecuteOnSerializing(object value)
		{
		}

		public virtual bool GetDictionary(IObjectDescriptor descriptor, out IDictionary? dictionary, out Type[]? genericArguments)
		{
			Type implementationOfOpenGenericInterface = descriptor.Type.GetImplementationOfOpenGenericInterface(typeof(IDictionary<, >));
			if (implementationOfOpenGenericInterface != null)
			{
				genericArguments = implementationOfOpenGenericInterface.GetGenericArguments();
				object obj = Activator.CreateInstance(typeof(GenericDictionaryToNonGenericAdapter<, >).MakeGenericType(genericArguments), descriptor.Value);
				dictionary = obj as IDictionary;
				return true;
			}
			genericArguments = null;
			dictionary = null;
			return false;
		}

		public virtual Type GetValueType(Type type)
		{
			Type implementationOfOpenGenericInterface = type.GetImplementationOfOpenGenericInterface(typeof(IEnumerable<>));
			return (implementationOfOpenGenericInterface != null) ? implementationOfOpenGenericInterface.GetGenericArguments()[0] : typeof(object);
		}
	}
	public abstract class StaticObjectFactory : IObjectFactory
	{
		public abstract object Create(Type type);

		public abstract Array CreateArray(Type type, int count);

		public abstract bool IsDictionary(Type type);

		public abstract bool IsArray(Type type);

		public abstract bool IsList(Type type);

		public abstract Type GetKeyType(Type type);

		public abstract Type GetValueType(Type type);

		public virtual object? CreatePrimitive(Type type)
		{
			return Type.GetTypeCode(type) switch
			{
				TypeCode.Boolean => false, 
				TypeCode.Byte => (byte)0, 
				TypeCode.Int16 => (short)0, 
				TypeCode.Int32 => 0, 
				TypeCode.Int64 => 0L, 
				TypeCode.SByte => (sbyte)0, 
				TypeCode.UInt16 => (ushort)0, 
				TypeCode.UInt32 => 0u, 
				TypeCode.UInt64 => 0uL, 
				TypeCode.Single => 0f, 
				TypeCode.Double => 0.0, 
				TypeCode.Decimal => 0m, 
				TypeCode.Char => '\0', 
				TypeCode.DateTime => default(DateTime), 
				_ => null, 
			};
		}

		public bool GetDictionary(IObjectDescriptor descriptor, out IDictionary? dictionary, out Type[]? genericArguments)
		{
			dictionary = null;
			genericArguments = null;
			return false;
		}

		public abstract void ExecuteOnDeserializing(object value);

		public abstract void ExecuteOnDeserialized(object value);

		public abstract void ExecuteOnSerializing(object value);

		public abstract void ExecuteOnSerialized(object value);
	}
}
namespace YamlDotNet.Serialization.NodeTypeResolvers
{
	public sealed class DefaultContainersNodeTypeResolver : INodeTypeResolver
	{
		bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (currentType == typeof(object))
			{
				if (nodeEvent is SequenceStart)
				{
					currentType = typeof(List<object>);
					return true;
				}
				if (nodeEvent is MappingStart)
				{
					currentType = typeof(Dictionary<object, object>);
					return true;
				}
			}
			return false;
		}
	}
	public class MappingNodeTypeResolver : INodeTypeResolver
	{
		private readonly IDictionary<Type, Type> mappings;

		public MappingNodeTypeResolver(IDictionary<Type, Type> mappings)
		{
			if (mappings == null)
			{
				throw new ArgumentNullException("mappings");
			}
			foreach (KeyValuePair<Type, Type> mapping in mappings)
			{
				if (!mapping.Key.IsAssignableFrom(mapping.Value))
				{
					throw new InvalidOperationException($"Type '{mapping.Value}' does not implement type '{mapping.Key}'.");
				}
			}
			this.mappings = mappings;
		}

		public bool Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (mappings.TryGetValue(currentType, out Type value))
			{
				currentType = value;
				return true;
			}
			return false;
		}
	}
	public class PreventUnknownTagsNodeTypeResolver : INodeTypeResolver
	{
		bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty)
			{
				Mark start = nodeEvent.Start;
				Mark end = nodeEvent.End;
				throw new YamlException(in start, in end, $"Encountered an unresolved tag '{nodeEvent.Tag}'");
			}
			return false;
		}
	}
	public sealed class TagNodeTypeResolver : INodeTypeResolver
	{
		private readonly IDictionary<TagName, Type> tagMappings;

		public TagNodeTypeResolver(IDictionary<TagName, Type> tagMappings)
		{
			this.tagMappings = tagMappings ?? throw new ArgumentNullException("tagMappings");
		}

		bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty && tagMappings.TryGetValue(nodeEvent.Tag, out Type value))
			{
				currentType = value;
				return true;
			}
			return false;
		}
	}
	[Obsolete("The mechanism that this class uses to specify type names is non-standard. Register the tags explicitly instead of using this convention.")]
	public sealed class TypeNameInTagNodeTypeResolver : INodeTypeResolver
	{
		bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty)
			{
				Type type = Type.GetType(nodeEvent.Tag.Value.Substring(1), throwOnError: false);
				if (type != null)
				{
					currentType = type;
					return true;
				}
			}
			return false;
		}
	}
	public sealed class YamlConvertibleTypeResolver : INodeTypeResolver
	{
		public bool Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			return typeof(IYamlConvertible).IsAssignableFrom(currentType);
		}
	}
	public sealed class YamlSerializableTypeResolver : INodeTypeResolver
	{
		public bool Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			return typeof(IYamlSerializable).IsAssignableFrom(currentType);
		}
	}
}
namespace YamlDotNet.Serialization.NodeDeserializers
{
	public sealed class ArrayNodeDeserializer : INodeDeserializer
	{
		private sealed class ArrayList : IList, ICollection, IEnumerable
		{
			private object?[] data;

			public bool IsFixedSize => false;

			public bool IsReadOnly => false;

			public object? this[int index]
			{
				get
				{
					return data[index];
				}
				set
				{
					data[index] = value;
				}
			}

			public int Count { get; private set; }

			public bool IsSynchronized => false;

			public object SyncRoot => data;

			public ArrayList()
			{
				Clear();
			}

			public int Add(object? value)
			{
				if (Count == data.Length)
				{
					Array.Resize(ref data, data.Length * 2);
				}
				data[Count] = value;
				return Count++;
			}

			public void Clear()
			{
				data = new object[10];
				Count = 0;
			}

			bool IList.Contains(object? value)
			{
				throw new NotSupportedException();
			}

			int IList.IndexOf(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Insert(int index, object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Remove(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.RemoveAt(int index)
			{
				throw new NotSupportedException();
			}

			public void CopyTo(Array array, int index)
			{
				Array.Copy(data, 0, array, index, Count);
			}

			public IEnumerator GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return data[i];
					int num = i + 1;
					i = num;
				}
			}
		}

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public ArrayNodeDeserializer(INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!expectedType.IsArray)
			{
				value = false;
				return false;
			}
			Type itemType = expectedType.GetElementType();
			ArrayList arrayList = new ArrayList();
			Array array = null;
			CollectionNodeDeserializer.DeserializeHelper(itemType, parser, nestedObjectDeserializer, arrayList, canUpdate: true, enumNamingConvention, typeInspector, PromiseResolvedHandler);
			array = Array.CreateInstance(itemType, arrayList.Count);
			arrayList.CopyTo(array, 0);
			value = array;
			return true;
			void PromiseResolvedHandler(int index, object? value)
			{
				if (array == null)
				{
					throw new InvalidOperationException("Destination array is still null");
				}
				array.SetValue(YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(value, itemType, enumNamingConvention, typeInspector), index);
			}
		}
	}
	public abstract class CollectionDeserializer
	{
		protected static void DeserializeHelper(Type tItem, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IList result, bool canUpdate, IObjectFactory objectFactory)
		{
			IList result2 = result;
			parser.Consume<SequenceStart>();
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem);
				if (obj is IValuePromise valuePromise)
				{
					if (!canUpdate)
					{
						Mark start = current?.Start ?? Mark.Empty;
						Mark end = current?.End ?? Mark.Empty;
						throw new ForwardAnchorNotSupportedException(in start, in end, "Forward alias references are not allowed because this type does not implement IList<>");
					}
					int index = result2.Add(objectFactory.CreatePrimitive(tItem));
					valuePromise.ValueAvailable += delegate(object? v)
					{
						result2[index] = v;
					};
				}
				else
				{
					result2.Add(obj);
				}
			}
		}
	}
	public sealed class CollectionNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public CollectionNodeDeserializer(IObjectFactory objectFactory, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			bool canUpdate = true;
			Type implementationOfOpenGenericInterface = expectedType.GetImplementationOfOpenGenericInterface(typeof(ICollection<>));
			Type type;
			IList list;
			if (implementationOfOpenGenericInterface != null)
			{
				Type[] genericArguments = implementationOfOpenGenericInterface.GetGenericArguments();
				type = genericArguments[0];
				value = objectFactory.Create(expectedType);
				list = value as IList;
				if (list == null)
				{
					Type implementationOfOpenGenericInterface2 = expectedType.GetImplementationOfOpenGenericInterface(typeof(IList<>));
					canUpdate = implementationOfOpenGenericInterface2 != null;
					list = (IList)Activator.CreateInstance(typeof(GenericCollectionToNonGenericAdapter<>).MakeGenericType(type), value);
				}
			}
			else
			{
				if (!typeof(IList).IsAssignableFrom(expectedType))
				{
					value = null;
					return false;
				}
				type = typeof(object);
				value = objectFactory.Create(expectedType);
				list = (IList)value;
			}
			DeserializeHelper(type, parser, nestedObjectDeserializer, list, canUpdate, enumNamingConvention, typeInspector);
			return true;
		}

		internal static void DeserializeHelper(Type tItem, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IList result, bool canUpdate, INamingConvention enumNamingConvention, ITypeInspector typeInspector, Action<int, object?>? promiseResolvedHandler = null)
		{
			Action<int, object?> promiseResolvedHandler2 = promiseResolvedHandler;
			IList result2 = result;
			Type tItem2 = tItem;
			INamingConvention enumNamingConvention2 = enumNamingConvention;
			ITypeInspector typeInspector2 = typeInspector;
			parser.Consume<SequenceStart>();
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem2);
				if (obj is IValuePromise valuePromise)
				{
					if (!canUpdate)
					{
						Mark start = current?.Start ?? Mark.Empty;
						Mark end = current?.End ?? Mark.Empty;
						throw new ForwardAnchorNotSupportedException(in start, in end, "Forward alias references are not allowed because this type does not implement IList<>");
					}
					int index = result2.Add(tItem2.IsValueType() ? Activator.CreateInstance(tItem2) : null);
					if (promiseResolvedHandler2 != null)
					{
						valuePromise.ValueAvailable += delegate(object? v)
						{
							promiseResolvedHandler2(index, v);
						};
					}
					else
					{
						valuePromise.ValueAvailable += delegate(object? v)
						{
							result2[index] = YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(v, tItem2, enumNamingConvention2, typeInspector2);
						};
					}
				}
				else
				{
					result2.Add(YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(obj, tItem2, enumNamingConvention2, typeInspector2));
				}
			}
		}
	}
	public abstract class DictionaryDeserializer
	{
		private readonly bool duplicateKeyChecking;

		public DictionaryDeserializer(bool duplicateKeyChecking)
		{
			this.duplicateKeyChecking = duplicateKeyChecking;
		}

		private void TryAssign(IDictionary result, object key, object value, MappingStart propertyName)
		{
			if (duplicateKeyChecking && result.Contains(key))
			{
				Mark start = propertyName.Start;
				Mark end = propertyName.End;
				throw new YamlException(in start, in end, $"Encountered duplicate key {key}");
			}
			result[key] = value;
		}

		protected virtual void Deserialize(Type tKey, Type tValue, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IDictionary result, ObjectDeserializer rootDeserializer)
		{
			IDictionary result2 = result;
			MappingStart property = parser.Consume<MappingStart>();
			MappingEnd @event;
			while (!parser.TryConsume<MappingEnd>(out @event))
			{
				object key = nestedObjectDeserializer(parser, tKey);
				object value = nestedObjectDeserializer(parser, tValue);
				IValuePromise valuePromise = value as IValuePromise;
				if (key is IValuePromise valuePromise2)
				{
					if (valuePromise == null)
					{
						valuePromise2.ValueAvailable += delegate(object? v)
						{
							result2[v] = value;
						};
						continue;
					}
					bool hasFirstPart = false;
					valuePromise2.ValueAvailable += delegate(object? v)
					{
						if (hasFirstPart)
						{
							TryAssign(result2, v, value, property);
						}
						else
						{
							key = v;
							hasFirstPart = true;
						}
					};
					valuePromise.ValueAvailable += delegate(object? v)
					{
						if (hasFirstPart)
						{
							TryAssign(result2, key, v, property);
						}
						else
						{
							value = v;
							hasFirstPart = true;
						}
					};
					continue;
				}
				if (key == null)
				{
					throw new ArgumentException("Empty key names are not supported yet.", "tKey");
				}
				if (valuePromise == null)
				{
					TryAssign(result2, key, value, property);
					continue;
				}
				valuePromise.ValueAvailable += delegate(object? v)
				{
					result2[key] = v;
				};
			}
		}
	}
	public class DictionaryNodeDeserializer : DictionaryDeserializer, INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public DictionaryNodeDeserializer(IObjectFactory objectFactory, bool duplicateKeyChecking)
			: base(duplicateKeyChecking)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			Type implementationOfOpenGenericInterface = expectedType.GetImplementationOfOpenGenericInterface(typeof(IDictionary<, >));
			Type type;
			Type type2;
			IDictionary dictionary;
			if (implementationOfOpenGenericInterface != null)
			{
				Type[] genericArguments = implementationOfOpenGenericInterface.GetGenericArguments();
				type = genericArguments[0];
				type2 = genericArguments[1];
				value = objectFactory.Create(expectedType);
				dictionary = value as IDictionary;
				if (dictionary == null)
				{
					dictionary = (IDictionary)Activator.CreateInstance(typeof(GenericDictionaryToNonGenericAdapter<, >).MakeGenericType(type, type2), value);
				}
			}
			else
			{
				if (!typeof(IDictionary).IsAssignableFrom(expectedType))
				{
					value = null;
					return false;
				}
				type = typeof(object);
				type2 = typeof(object);
				value = objectFactory.Create(expectedType);
				dictionary = (IDictionary)value;
			}
			Deserialize(type, type2, parser, nestedObjectDeserializer, dictionary, rootDeserializer);
			return true;
		}
	}
	public sealed class EnumerableNodeDeserializer : INodeDeserializer
	{
		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			Type type;
			if (expectedType == typeof(IEnumerable))
			{
				type = typeof(object);
			}
			else
			{
				Type implementationOfOpenGenericInterface = expectedType.GetImplementationOfOpenGenericInterface(typeof(IEnumerable<>));
				if (implementationOfOpenGenericInterface != expectedType)
				{
					value = null;
					return false;
				}
				type = implementationOfOpenGenericInterface.GetGenericArguments()[0];
			}
			Type arg = typeof(List<>).MakeGenericType(type);
			value = nestedObjectDeserializer(parser, arg);
			return true;
		}
	}
	public sealed class FsharpListNodeDeserializer : INodeDeserializer
	{
		private readonly ITypeInspector typeInspector;

		private readonly INamingConvention enumNamingConvention;

		public FsharpListNodeDeserializer(ITypeInspector typeInspector, INamingConvention enumNamingConvention)
		{
			this.typeInspector = typeInspector;
			this.enumNamingConvention = enumNamingConvention;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!FsharpHelper.IsFsharpListType(expectedType))
			{
				value = false;
				return false;
			}
			Type type = expectedType.GetGenericArguments()[0];
			Type t = expectedType.GetGenericTypeDefinition().MakeGenericType(type);
			ArrayList arrayList = new ArrayList();
			CollectionNodeDeserializer.DeserializeHelper(type, parser, nestedObjectDeserializer, arrayList, canUpdate: true, enumNamingConvention, typeInspector);
			Array array = Array.CreateInstance(type, arrayList.Count);
			arrayList.CopyTo(array, 0);
			object obj = FsharpHelper.CreateFsharpListFromArray(t, type, array);
			value = obj;
			return true;
		}
	}
	public sealed class NullNodeDeserializer : INodeDeserializer
	{
		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			value = null;
			if (parser.Accept<NodeEvent>(out var @event) && NodeIsNull(@event))
			{
				parser.SkipThisAndNestedEvents();
				return true;
			}
			return false;
		}

		private static bool NodeIsNull(NodeEvent nodeEvent)
		{
			if (nodeEvent.Tag == "tag:yaml.org,2002:null")
			{
				return true;
			}
			if (nodeEvent is YamlDotNet.Core.Events.Scalar scalar && scalar.Style == ScalarStyle.Plain && !scalar.IsKey)
			{
				string value = scalar.Value;
				switch (value)
				{
				default:
					return value == "NULL";
				case "":
				case "~":
				case "null":
				case "Null":
					return true;
				}
			}
			return false;
		}
	}
	public sealed class ObjectNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		private readonly ITypeInspector typeInspector;

		private readonly bool ignoreUnmatched;

		private readonly bool duplicateKeyChecking;

		private readonly ITypeConverter typeConverter;

		private readonly INamingConvention enumNamingConvention;

		private readonly bool enforceNullability;

		private readonly bool caseInsensitivePropertyMatching;

		private readonly bool enforceRequiredProperties;

		private readonly TypeConverterCache typeConverters;

		public ObjectNodeDeserializer(IObjectFactory objectFactory, ITypeInspector typeInspector, bool ignoreUnmatched, bool duplicateKeyChecking, ITypeConverter typeConverter, INamingConvention enumNamingConvention, bool enforceNullability, bool caseInsensitivePropertyMatching, bool enforceRequiredProperties, IEnumerable<IYamlTypeConverter> typeConverters)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
			this.typeInspector = typeInspector ?? throw new ArgumentNullException("typeInspector");
			this.ignoreUnmatched = ignoreUnmatched;
			this.duplicateKeyChecking = duplicateKeyChecking;
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
			this.enumNamingConvention = enumNamingConvention ?? throw new ArgumentNullException("enumNamingConvention");
			this.enforceNullability = enforceNullability;
			this.caseInsensitivePropertyMatching = caseInsensitivePropertyMatching;
			this.enforceRequiredProperties = enforceRequiredProperties;
			this.typeConverters = new TypeConverterCache(typeConverters);
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!parser.TryConsume<MappingStart>(out var _))
			{
				value = null;
				return false;
			}
			Type type = Nullable.GetUnderlyingType(expectedType) ?? FsharpHelper.GetOptionUnderlyingType(expectedType) ?? expectedType;
			value = objectFactory.Create(type);
			objectFactory.ExecuteOnDeserializing(value);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
			Mark start = Mark.Empty;
			MappingEnd event2;
			while (!parser.TryConsume<MappingEnd>(out event2))
			{
				YamlDotNet.Core.Events.Scalar propertyName = parser.Consume<YamlDotNet.Core.Events.Scalar>();
				if (duplicateKeyChecking && !hashSet.Add(propertyName.Value))
				{
					Mark start2 = propertyName.Start;
					Mark end = propertyName.End;
					throw new YamlException(in start2, in end, "Encountered duplicate key " + propertyName.Value);
				}
				try
				{
					IPropertyDescriptor property = typeInspector.GetProperty(type, null, propertyName.Value, ignoreUnmatched, caseInsensitivePropertyMatching);
					if (property == null)
					{
						parser.SkipThisAndNestedEvents();
						continue;
					}
					hashSet2.Add(property.Name);
					object obj;
					if (property.ConverterType != null)
					{
						IYamlTypeConverter converterByType = typeConverters.GetConverterByType(property.ConverterType);
						obj = converterByType.ReadYaml(parser, property.Type, rootDeserializer);
					}
					else
					{
						obj = nestedObjectDeserializer(parser, property.Type);
					}
					if (obj is IValuePromise valuePromise)
					{
						object valueRef = value;
						valuePromise.ValueAvailable += delegate(object? v)
						{
							object value3 = typeConverter.ChangeType(v, property.Type, enumNamingConvention, typeInspector);
							NullCheck(value3, property, propertyName);
							property.Write(valueRef, value3);
						};
					}
					else
					{
						object value2 = typeConverter.ChangeType(obj, property.Type, enumNamingConvention, typeInspector);
						NullCheck(value2, property, propertyName);
						property.Write(value, value2);
					}
					goto IL_0267;
				}
				catch (SerializationException ex)
				{
					Mark start2 = propertyName.Start;
					Mark end = propertyName.End;
					throw new YamlException(in start2, in end, ex.Message);
				}
				catch (YamlException)
				{
					throw;
				}
				catch (Exception innerException)
				{
					Mark start2 = propertyName.Start;
					Mark end = propertyName.End;
					throw new YamlException(in start2, in end, "Exception during deserialization", innerException);
				}
				IL_0267:
				start = propertyName.End;
			}
			if (enforceRequiredProperties)
			{
				IEnumerable<IPropertyDescriptor> properties = typeInspector.GetProperties(type, value);
				List<string> list = new List<string>();
				foreach (IPropertyDescriptor item in properties)
				{
					if (item.Required && !hashSet2.Contains(item.Name))
					{
						list.Add(item.Name);
					}
				}
				if (list.Count > 0)
				{
					string text = string.Join(",", list);
					throw new YamlException(in start, in start, "Missing properties, '" + text + "' in source yaml.");
				}
			}
			objectFactory.ExecuteOnDeserialized(value);
			return true;
		}

		public void NullCheck(object value, IPropertyDescriptor property, YamlDotNet.Core.Events.Scalar propertyName)
		{
			if (enforceNullability && value == null && !property.AllowNulls)
			{
				Mark start = propertyName.Start;
				Mark end = propertyName.End;
				throw new YamlException(in start, in end, "Strict nullability enforcement error.", new NullReferenceException("Yaml value is null when target property requires non null values."));
			}
		}
	}
	public sealed class ScalarNodeDeserializer : INodeDeserializer
	{
		private const string BooleanTruePattern = "^(true|y|yes|on)$";

		private const string BooleanFalsePattern = "^(false|n|no|off)$";

		private readonly bool attemptUnknownTypeDeserialization;

		private readonly ITypeConverter typeConverter;

		private readonly ITypeInspector typeInspector;

		private readonly YamlFormatter formatter;

		private readonly INamingConvention enumNamingConvention;

		public ScalarNodeDeserializer(bool attemptUnknownTypeDeserialization, ITypeConverter typeConverter, ITypeInspector typeInspector, YamlFormatter formatter, INamingConvention enumNamingConvention)
		{
			this.attemptUnknownTypeDeserialization = attemptUnknownTypeDeserialization;
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
			this.typeInspector = typeInspector;
			this.formatter = formatter;
			this.enumNamingConvention = enumNamingConvention;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!parser.TryConsume<YamlDotNet.Core.Events.Scalar>(out var @event))
			{
				value = null;
				return false;
			}
			Type type = Nullable.GetUnderlyingType(expectedType) ?? FsharpHelper.GetOptionUnderlyingType(expectedType) ?? expectedType;
			if (type.IsEnum())
			{
				string name = enumNamingConvention.Reverse(@event.Value);
				name = typeInspector.GetEnumName(type, name);
				value = Enum.Parse(type, name, ignoreCase: true);
				return true;
			}
			TypeCode typeCode = type.GetTypeCode();
			switch (typeCode)
			{
			case TypeCode.Boolean:
				value = DeserializeBooleanHelper(@event.Value);
				break;
			case TypeCode.SByte:
			case TypeCode.Byte:
			case TypeCode.Int16:
			case TypeCode.UInt16:
			case TypeCode.Int32:
			case TypeCode.UInt32:
			case TypeCode.Int64:
			case TypeCode.UInt64:
				value = DeserializeIntegerHelper(typeCode, @event.Value);
				break;
			case TypeCode.Single:
				value = float.Parse(@event.Value, formatter.NumberFormat);
				break;
			case TypeCode.Double:
				value = double.Parse(@event.Value, formatter.NumberFormat);
				break;
			case TypeCode.Decimal:
				value = decimal.Parse(@event.Value, formatter.NumberFormat);
				break;
			case TypeCode.String:
				value = @event.Value;
				break;
			case TypeCode.Char:
				value = @event.Value[0];
				break;
			case TypeCode.DateTime:
				value = DateTime.Parse(@event.Value, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
				break;
			default:
				if (expectedType == typeof(object))
				{
					if (!@event.IsKey && attemptUnknownTypeDeserialization)
					{
						value = AttemptUnknownTypeDeserialization(@event);
					}
					else
					{
						value = @event.Value;
					}
				}
				else
				{
					value = typeConverter.ChangeType(@event.Value, expectedType, enumNamingConvention, typeInspector);
				}
				break;
			}
			return true;
		}

		private static bool DeserializeBooleanHelper(string value)
		{
			if (Regex.IsMatch(value, "^(true|y|yes|on)$", RegexOptions.IgnoreCase))
			{
				return true;
			}
			if (Regex.IsMatch(value, "^(false|n|no|off)$", RegexOptions.IgnoreCase))
			{
				return false;
			}
			throw new FormatException("The value \"" + value + "\" is not a valid YAML Boolean");
		}

		private object DeserializeIntegerHelper(TypeCode typeCode, string value)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				int i = 0;
				bool flag = false;
				ulong num = 0uL;
				if (value[0] == '-')
				{
					i++;
					flag = true;
				}
				else if (value[0] == '+')
				{
					i++;
				}
				if (value[i] == '0')
				{
					int num2;
					if (i == value.Length - 1)
					{
						num2 = 10;
						num = 0uL;
					}
					else
					{
						i++;
						if (value[i] == 'b')
						{
							num2 = 2;
							i++;
						}
						else if (value[i] == 'x')
						{
							num2 = 16;
							i++;
						}
						else
						{
							num2 = 8;
						}
					}
					for (; i < value.Length; i++)
					{
						if (value[i] != '_')
						{
							builder.Append(value[i]);
						}
					}
					switch (num2)
					{
					case 2:
					case 8:
						num = Convert.ToUInt64(builder.ToString(), num2);
						break;
					case 16:
						num = ulong.Parse(builder.ToString(), NumberStyles.HexNumber, formatter.NumberFormat);
						break;
					}
				}
				else
				{
					string[] array = value.Substring(i).Split(new char[1] { ':' });
					num = 0uL;
					for (int j = 0; j < array.Length; j++)
					{
						num *= 60;
						num += ulong.Parse(array[j].Replace("_", ""), CultureInfo.InvariantCulture);
					}
				}
				if (!flag)
				{
					return CastInteger(num, typeCode);
				}
				long number = ((num != 9223372036854775808uL) ? checked(-(long)num) : long.MinValue);
				return CastInteger(number, typeCode);
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private static object CastInteger(long number, TypeCode typeCode)
		{
			return checked(typeCode switch
			{
				TypeCode.Byte => (byte)number, 
				TypeCode.Int16 => (short)number, 
				TypeCode.Int32 => (int)number, 
				TypeCode.Int64 => number, 
				TypeCode.SByte => (sbyte)number, 
				TypeCode.UInt16 => (ushort)number, 
				TypeCode.UInt32 => (uint)number, 
				TypeCode.UInt64 => (ulong)number, 
				_ => number, 
			});
		}

		private static object CastInteger(ulong number, TypeCode typeCode)
		{
			return checked(typeCode switch
			{
				TypeCode.Byte => (byte)number, 
				TypeCode.Int16 => (short)number, 
				TypeCode.Int32 => (int)number, 
				TypeCode.Int64 => (long)number, 
				TypeCode.SByte => (sbyte)number, 
				TypeCode.UInt16 => (ushort)number, 
				TypeCode.UInt32 => (uint)number, 
				TypeCode.UInt64 => number, 
				_ => number, 
			});
		}

		private object? AttemptUnknownTypeDeserialization(YamlDotNet.Core.Events.Scalar value)
		{
			if (value.Style == ScalarStyle.SingleQuoted || value.Style == ScalarStyle.DoubleQuoted || value.Style == ScalarStyle.Folded)
			{
				return value.Value;
			}
			string v = value.Value;
			switch (v)
			{
			case "null":
			case "Null":
			case "NULL":
			case "~":
			case "":
				return null;
			case "true":
			case "True":
			case "TRUE":
				return true;
			case "False":
			case "FALSE":
			case "false":
				return false;
			default:
				if (Regex.IsMatch(v, "^0x[0-9a-fA-F]+$"))
				{
					v = v.Substring(2);
					if (byte.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result))
					{
						return result;
					}
					if (short.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result2))
					{
						return result2;
					}
					if (int.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result3))
					{
						return result3;
					}
					if (long.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result4))
					{
						return result4;
					}
					if (ulong.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result5))
					{
						return result5;
					}
					return v;
				}
				if (Regex.IsMatch(v, "^0o[0-9a-fA-F]+$"))
				{
					if (!TryAndSwallow(() => Convert.ToByte(v, 8), out object value2) && !TryAndSwallow(() => Convert.ToInt16(v, 8), out value2) && !TryAndSwallow(() => Convert.ToInt32(v, 8), out value2) && !TryAndSwallow(() => Convert.ToInt64(v, 8), out value2) && !TryAndSwallow(() => Convert.ToUInt64(v, 8), out value2))
					{
						return v;
					}
					return value2;
				}
				if (Regex.IsMatch(v, "^[-+]?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?$"))
				{
					if (byte.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result6))
					{
						return result6;
					}
					if (short.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result7))
					{
						return result7;
					}
					if (int.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result8))
					{
						return result8;
					}
					if (long.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result9))
					{
						return result9;
					}
					if (ulong.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result10))
					{
						return result10;
					}
					if (float.TryParse(v, NumberStyles.Float, formatter.NumberFormat, out var result11))
					{
						return result11;
					}
					if (double.TryParse(v, NumberStyles.Float, formatter.NumberFormat, out var result12))
					{
						return result12;
					}
					return v;
				}
				if (Regex.IsMatch(v, "^[-+]?(\\.inf|\\.Inf|\\.INF)$"))
				{
					if (Polyfills.StartsWith(v, '-'))
					{
						return float.NegativeInfinity;
					}
					return float.PositiveInfinity;
				}
				if (Regex.IsMatch(v, "^(\\.nan|\\.NaN|\\.NAN)$"))
				{
					return float.NaN;
				}
				return v;
			}
		}

		private static bool TryAndSwallow(Func<object> attempt, out object? value)
		{
			try
			{
				value = attempt();
				return true;
			}
			catch
			{
				value = null;
				return false;
			}
		}
	}
	public sealed class StaticArrayNodeDeserializer : INodeDeserializer
	{
		private sealed class ArrayList : IList, ICollection, IEnumerable
		{
			private object?[] data;

			public bool IsFixedSize => false;

			public bool IsReadOnly => false;

			public object? this[int index]
			{
				get
				{
					return data[index];
				}
				set
				{
					data[index] = value;
				}
			}

			public int Count { get; private set; }

			public bool IsSynchronized => false;

			public object SyncRoot => data;

			public ArrayList()
			{
				Clear();
			}

			public int Add(object? value)
			{
				if (Count == data.Length)
				{
					Array.Resize(ref data, data.Length * 2);
				}
				data[Count] = value;
				return Count++;
			}

			public void Clear()
			{
				data = new object[10];
				Count = 0;
			}

			bool IList.Contains(object? value)
			{
				throw new NotSupportedException();
			}

			int IList.IndexOf(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Insert(int index, object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Remove(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.RemoveAt(int index)
			{
				throw new NotSupportedException();
			}

			public void CopyTo(Array array, int index)
			{
				Array.Copy(data, 0, array, index, Count);
			}

			public IEnumerator GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return data[i];
					int num = i + 1;
					i = num;
				}
			}
		}

		private readonly StaticObjectFactory factory;

		public StaticArrayNodeDeserializer(StaticObjectFactory factory)
		{
			this.factory = factory ?? throw new ArgumentNullException("factory");
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!factory.IsArray(expectedType))
			{
				value = false;
				return false;
			}
			Type valueType = factory.GetValueType(expectedType);
			ArrayList arrayList = new ArrayList();
			StaticCollectionNodeDeserializer.DeserializeHelper(valueType, parser, nestedObjectDeserializer, arrayList, factory);
			Array array = factory.CreateArray(expectedType, arrayList.Count);
			arrayList.CopyTo(array, 0);
			value = array;
			return true;
		}
	}
	public sealed class StaticCollectionNodeDeserializer : INodeDeserializer
	{
		private readonly StaticObjectFactory factory;

		public StaticCollectionNodeDeserializer(StaticObjectFactory factory)
		{
			this.factory = factory ?? throw new ArgumentNullException("factory");
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!factory.IsList(expectedType))
			{
				value = null;
				return false;
			}
			DeserializeHelper(result: (IList)(value = factory.Create(expectedType) as IList), tItem: factory.GetValueType(expectedType), parser: parser, nestedObjectDeserializer: nestedObjectDeserializer, factory: factory);
			return true;
		}

		internal static void DeserializeHelper(Type tItem, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IList result, IObjectFactory factory)
		{
			IList result2 = result;
			parser.Consume<SequenceStart>();
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem);
				if (obj is IValuePromise valuePromise)
				{
					int index = result2.Add(factory.CreatePrimitive(tItem));
					valuePromise.ValueAvailable += delegate(object? v)
					{
						result2[index] = v;
					};
				}
				else
				{
					result2.Add(obj);
				}
			}
		}
	}
	public class StaticDictionaryNodeDeserializer : DictionaryDeserializer, INodeDeserializer
	{
		private readonly StaticObjectFactory objectFactory;

		public StaticDictionaryNodeDeserializer(StaticObjectFactory objectFactory, bool duplicateKeyChecking)
			: base(duplicateKeyChecking)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (objectFactory.IsDictionary(expectedType))
			{
				if (!(objectFactory.Create(expectedType) is IDictionary dictionary))
				{
					value = null;
					return false;
				}
				Type keyType = objectFactory.GetKeyType(expectedType);
				Type valueType = objectFactory.GetValueType(expectedType);
				value = dictionary;
				base.Deserialize(keyType, valueType, reader, nestedObjectDeserializer, dictionary, rootDeserializer);
				return true;
			}
			value = null;
			return false;
		}
	}
	public sealed class TypeConverterNodeDeserializer : INodeDeserializer
	{
		private readonly TypeConverterCache converters;

		public TypeConverterNodeDeserializer(IEnumerable<IYamlTypeConverter> converters)
		{
			this.converters = new TypeConverterCache(converters);
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!converters.TryGetConverterForType(expectedType, out IYamlTypeConverter typeConverter))
			{
				value = null;
				return false;
			}
			value = typeConverter.ReadYaml(parser, expectedType, rootDeserializer);
			return true;
		}
	}
	public sealed class YamlConvertibleNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public YamlConvertibleNodeDeserializer(IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			Func<IParser, Type, object?> nestedObjectDeserializer2 = nestedObjectDeserializer;
			IParser parser2 = parser;
			if (typeof(IYamlConvertible).IsAssignableFrom(expectedType))
			{
				IYamlConvertible yamlConvertible = (IYamlConvertible)objectFactory.Create(expectedType);
				yamlConvertible.Read(parser2, expectedType, (Type type) => nestedObjectDeserializer2(parser2, type));
				value = yamlConvertible;
				return true;
			}
			value = null;
			return false;
		}
	}
	public sealed class YamlSerializableNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public YamlSerializableNodeDeserializer(IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (typeof(IYamlSerializable).IsAssignableFrom(expectedType))
			{
				IYamlSerializable yamlSerializable = (IYamlSerializable)objectFactory.Create(expectedType);
				yamlSerializable.ReadYaml(parser);
				value = yamlSerializable;
				return true;
			}
			value = null;
			return false;
		}
	}
}
namespace YamlDotNet.Serialization.NamingConventions
{
	public sealed class CamelCaseNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new CamelCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public CamelCaseNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.ToCamelCase();
		}

		public string Reverse(string value)
		{
			return value.ToPascalCase();
		}
	}
	public sealed class HyphenatedNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new HyphenatedNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public HyphenatedNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.FromCamelCase("-");
		}

		public string Reverse(string value)
		{
			return value.ToPascalCase();
		}
	}
	public sealed class LowerCaseNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new LowerCaseNamingConvention();

		private LowerCaseNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.ToCamelCase().ToLower(CultureInfo.InvariantCulture);
		}

		public string Reverse(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return value;
			}
			return char.ToUpperInvariant(value[0]) + value.Substring(1);
		}
	}
	public sealed class NullNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new NullNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public NullNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value;
		}

		public string Reverse(string value)
		{
			return value;
		}
	}
	public sealed class PascalCaseNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new PascalCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public PascalCaseNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.ToPascalCase();
		}

		public string Reverse(string value)
		{
			return value.ToPascalCase();
		}
	}
	public sealed class UnderscoredNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new UnderscoredNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public UnderscoredNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.FromCamelCase("_");
		}

		public string Reverse(string value)
		{
			return value.ToPascalCase();
		}
	}
}
namespace YamlDotNet.Serialization.EventEmitters
{
	public abstract class ChainedEventEmitter : IEventEmitter
	{
		protected readonly IEventEmitter nextEmitter;

		protected ChainedEventEmitter(IEventEmitter nextEmitter)
		{
			this.nextEmitter = nextEmitter ?? throw new ArgumentNullException("nextEmitter");
		}

		public virtual void Emit(AliasEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(ScalarEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(MappingEndEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(SequenceEndEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}
	}
	public sealed class JsonEventEmitter : ChainedEventEmitter
	{
		private readonly YamlFormatter formatter;

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public JsonEventEmitter(IEventEmitter nextEmitter, YamlFormatter formatter, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
			: base(nextEmitter)
		{
			this.formatter = formatter;
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public override void Emit(AliasEventInfo eventInfo, IEmitter emitter)
		{
			eventInfo.NeedsExpansion = true;
		}

		public override void Emit(ScalarEventInfo eventInfo, IEmitter emitter)
		{
			eventInfo.IsPlainImplicit = true;
			eventInfo.Style = ScalarStyle.Plain;
			object value = eventInfo.Source.Value;
			if (value == null)
			{
				eventInfo.RenderedValue = "null";
			}
			else
			{
				TypeCode typeCode = eventInfo.Source.Type.GetTypeCode();
				switch (typeCode)
				{
				case TypeCode.Boolean:
					eventInfo.RenderedValue = formatter.FormatBoolean(value);
					break;
				case TypeCode.SByte:
				case TypeCode.Byte:
				case TypeCode.Int16:
				case TypeCode.UInt16:
				case TypeCode.Int32:
				case TypeCode.UInt32:
				case TypeCode.Int64:
				case TypeCode.UInt64:
					if (eventInfo.Source.Type.IsEnum())
					{
						eventInfo.RenderedValue = formatter.FormatEnum(value, typeInspector, enumNamingConvention);
						eventInfo.Style = ((!formatter.PotentiallyQuoteEnums(value)) ? ScalarStyle.Plain : ScalarStyle.DoubleQuoted);
					}
					else
					{
						eventInfo.RenderedValue = formatter.FormatNumber(value);
					}
					break;
				case TypeCode.Single:
				{
					float f = (float)value;
					eventInfo.RenderedValue = f.ToString("G", CultureInfo.InvariantCulture);
					if (float.IsNaN(f) || float.IsInfinity(f))
					{
						eventInfo.Style = ScalarStyle.DoubleQuoted;
					}
					break;
				}
				case TypeCode.Double:
				{
					double d = (double)value;
					eventInfo.RenderedValue = d.ToString("G", CultureInfo.InvariantCulture);
					if (double.IsNaN(d) || double.IsInfinity(d))
					{
						eventInfo.Style = ScalarStyle.DoubleQuoted;
					}
					break;
				}
				case TypeCode.Decimal:
					eventInfo.RenderedValue = ((decimal)value).ToString(CultureInfo.InvariantCulture);
					break;
				case TypeCode.Char:
				case TypeCode.String:
					eventInfo.RenderedValue = value.ToString();
					eventInfo.Style = ScalarStyle.DoubleQuoted;
					break;
				case TypeCode.DateTime:
					eventInfo.RenderedValue = formatter.FormatDateTime(value);
					break;
				case TypeCode.Empty:
					eventInfo.RenderedValue = "null";
					break;
				default:
					if (eventInfo.Source.Type == typeof(TimeSpan))
					{
						eventInfo.RenderedValue = formatter.FormatTimeSpan(value);
						break;
					}
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
			}
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			eventInfo.Style = MappingStyle.Flow;
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			eventInfo.Style = SequenceStyle.Flow;
			base.Emit(eventInfo, emitter);
		}
	}
	public sealed class TypeAssigningEventEmitter : ChainedEventEmitter
	{
		private readonly IDictionary<Type, TagName> tagMappings;

		private readonly bool quoteNecessaryStrings;

		private readonly Regex? isSpecialStringValue_Regex;

		private static readonly string SpecialStrings_Pattern = "^(null|Null|NULL|\\~|true|True|TRUE|false|False|FALSE|[-+]?[0-9]+|0o[0-7]+|0x[0-9a-fA-F]+|[-+]?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?|[-+]?(\\.inf|\\.Inf|\\.INF)|\\.nan|\\.NaN|\\.NAN|\\s.*)$";

		private static readonly string CombinedYaml1_1SpecialStrings_Pattern = "^(null|Null|NULL|\\~|true|True|TRUE|false|False|FALSE|y|Y|yes|Yes|YES|n|N|no|No|NO|on|On|ON|off|Off|OFF|[-+]?0b[0-1_]+|[-+]?0o?[0-7_]+|[-+]?(0|[1-9][0-9_]*)|[-+]?0x[0-9a-fA-F_]+|[-+]?[1-9][0-9_]*(:[0-5]?[0-9])+|[-+]?([0-9][0-9_]*)?\\.[0-9_]*([eE][-+][0-9]+)?|[-+]?[0-9][0-9_]*(:[0-5]?[0-9])+\\.[0-9_]*|[-+]?\\.(inf|Inf|INF)|\\.(nan|NaN|NAN))$";

		private readonly ScalarStyle defaultScalarStyle;

		private readonly YamlFormatter formatter;

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public TypeAssigningEventEmitter(IEventEmitter nextEmitter, IDictionary<Type, TagName> tagMappings, bool quoteNecessaryStrings, bool quoteYaml1_1Strings, ScalarStyle defaultScalarStyle, YamlFormatter formatter, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
			: base(nextEmitter)
		{
			this.defaultScalarStyle = defaultScalarStyle;
			this.formatter = formatter;
			this.tagMappings = tagMappings;
			this.quoteNecessaryStrings = quoteNecessaryStrings;
			isSpecialStringValue_Regex = new Regex(quoteYaml1_1Strings ? CombinedYaml1_1SpecialStrings_Pattern : SpecialStrings_Pattern, RegexOptions.Compiled);
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public override void Emit(ScalarEventInfo eventInfo, IEmitter emitter)
		{
			ScalarStyle style = ScalarStyle.Plain;
			object value = eventInfo.Source.Value;
			if (value == null)
			{
				eventInfo.Tag = JsonSchema.Tags.Null;
				eventInfo.RenderedValue = "";
			}
			else
			{
				TypeCode typeCode = eventInfo.Source.Type.GetTypeCode();
				switch (typeCode)
				{
				case TypeCode.Boolean:
					eventInfo.Tag = JsonSchema.Tags.Bool;
					eventInfo.RenderedValue = formatter.FormatBoolean(value);
					break;
				case TypeCode.SByte:
				case TypeCode.Byte:
				case TypeCode.Int16:
				case TypeCode.UInt16:
				case TypeCode.Int32:
				case TypeCode.UInt32:
				case TypeCode.Int64:
				case TypeCode.UInt64:
					if (eventInfo.Source.Type.IsEnum)
					{
						eventInfo.Tag = FailsafeSchema.Tags.Str;
						eventInfo.RenderedValue = formatter.FormatEnum(value, typeInspector, enumNamingConvention);
						style = ((!quoteNecessaryStrings || !IsSpecialStringValue(eventInfo.RenderedValue) || !formatter.PotentiallyQuoteEnums(value)) ? defaultScalarStyle : ScalarStyle.DoubleQuoted);
					}
					else
					{
						eventInfo.Tag = JsonSchema.Tags.Int;
						eventInfo.RenderedValue = formatter.FormatNumber(value);
					}
					break;
				case TypeCode.Single:
					eventInfo.Tag = JsonSchema.Tags.Float;
					eventInfo.RenderedValue = formatter.FormatNumber((float)value);
					break;
				case TypeCode.Double:
					eventInfo.Tag = JsonSchema.Tags.Float;
					eventInfo.RenderedValue = formatter.FormatNumber((double)value);
					break;
				case TypeCode.Decimal:
					eventInfo.Tag = JsonSchema.Tags.Float;
					eventInfo.RenderedValue = formatter.FormatNumber(value);
					break;
				case TypeCode.Char:
				case TypeCode.String:
					eventInfo.Tag = FailsafeSchema.Tags.Str;
					eventInfo.RenderedValue = value.ToString();
					style = ((!quoteNecessaryStrings || !IsSpecialStringValue(eventInfo.RenderedValue)) ? defaultScalarStyle : ScalarStyle.DoubleQuoted);
					break;
				case TypeCode.DateTime:
					eventInfo.Tag = DefaultSchema.Tags.Timestamp;
					eventInfo.RenderedValue = formatter.FormatDateTime(value);
					break;
				case TypeCode.Empty:
					eventInfo.Tag = JsonSchema.Tags.Null;
					eventInfo.RenderedValue = "";
					break;
				default:
					if (eventInfo.Source.Type == typeof(TimeSpan))
					{
						eventInfo.RenderedValue = formatter.FormatTimeSpan(value);
						break;
					}
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
			}
			eventInfo.IsPlainImplicit = true;
			if (eventInfo.Style == ScalarStyle.Any)
			{
				eventInfo.Style = style;
			}
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			AssignTypeIfNeeded(eventInfo);
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			AssignTypeIfNeeded(eventInfo);
			base.Emit(eventInfo, emitter);
		}

		private void AssignTypeIfNeeded(ObjectEventInfo eventInfo)
		{
			if (tagMappings.TryGetValue(eventInfo.Source.Type, out var value))
			{
				eventInfo.Tag = value;
			}
		}

		private bool IsSpecialStringValue(string value)
		{
			if (value.Trim() == string.Empty)
			{
				return true;
			}
			return isSpecialStringValue_Regex?.IsMatch(value) ?? false;
		}
	}
	public sealed class WriterEventEmitter : IEventEmitter
	{
		void IEventEmitter.Emit(AliasEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new YamlDotNet.Core.Events.AnchorAlias(eventInfo.Alias));
		}

		void IEventEmitter.Emit(ScalarEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(eventInfo.Anchor, eventInfo.Tag, eventInfo.RenderedValue, eventInfo.Style, eventInfo.IsPlainImplicit, eventInfo.IsQuotedImplicit));
		}

		void IEventEmitter.Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new MappingStart(eventInfo.Anchor, eventInfo.Tag, eventInfo.IsImplicit, eventInfo.Style));
		}

		void IEventEmitter.Emit(MappingEndEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new MappingEnd());
		}

		void IEventEmitter.Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new SequenceStart(eventInfo.Anchor, eventInfo.Tag, eventInfo.IsImplicit, eventInfo.Style));
		}

		void IEventEmitter.Emit(SequenceEndEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new SequenceEnd());
		}
	}
}
namespace YamlDotNet.Serialization.Converters
{
	public class DateTime8601Converter : IYamlTypeConverter
	{
		private readonly ScalarStyle scalarStyle;

		public DateTime8601Converter()
			: this(ScalarStyle.Any)
		{
		}

		public DateTime8601Converter(ScalarStyle scalarStyle)
		{
			this.scalarStyle = scalarStyle;
		}

		public bool Accepts(Type type)
		{
			return type == typeof(DateTime);
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			DateTime dateTime = DateTime.ParseExact(value, "O", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
			return dateTime;
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			string value2 = ((DateTime)value).ToString("O", CultureInfo.InvariantCulture);
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, value2, scalarStyle, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
	public class DateTimeConverter : IYamlTypeConverter
	{
		private readonly DateTimeKind kind;

		private readonly IFormatProvider provider;

		private readonly bool doubleQuotes;

		private readonly string[] formats;

		public DateTimeConverter(DateTimeKind kind = DateTimeKind.Utc, IFormatProvider? provider = null, bool doubleQuotes = false, params string[] formats)
		{
			this.kind = ((kind == DateTimeKind.Unspecified) ? DateTimeKind.Utc : kind);
			this.provider = provider ?? CultureInfo.InvariantCulture;
			this.doubleQuotes = doubleQuotes;
			this.formats = formats.DefaultIfEmpty("G").ToArray();
		}

		public bool Accepts(Type type)
		{
			return type == typeof(DateTime);
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			DateTimeStyles style = ((kind == DateTimeKind.Local) ? DateTimeStyles.AssumeLocal : DateTimeStyles.AssumeUniversal);
			DateTime dt = DateTime.ParseExact(value, formats, provider, style);
			dt = EnsureDateTimeKind(dt, kind);
			return dt;
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			DateTime dateTime = (DateTime)value;
			string value2 = ((kind == DateTimeKind.Local) ? dateTime.ToLocalTime() : dateTime.ToUniversalTime()).ToString(formats.First(), provider);
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, value2, doubleQuotes ? ScalarStyle.DoubleQuoted : ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
		}

		private static DateTime EnsureDateTimeKind(DateTime dt, DateTimeKind kind)
		{
			if (dt.Kind == DateTimeKind.Local && kind == DateTimeKind.Utc)
			{
				return dt.ToUniversalTime();
			}
			if (dt.Kind == DateTimeKind.Utc && kind == DateTimeKind.Local)
			{
				return dt.ToLocalTime();
			}
			return dt;
		}
	}
	public class DateTimeOffsetConverter : IYamlTypeConverter
	{
		private readonly IFormatProvider provider;

		private readonly ScalarStyle style;

		private readonly DateTimeStyles dateStyle;

		private readonly string[] formats;

		public DateTimeOffsetConverter(IFormatProvider? provider = null, ScalarStyle style = ScalarStyle.Any, DateTimeStyles dateStyle = DateTimeStyles.None, params string[] formats)
		{
			this.provider = provider ?? CultureInfo.InvariantCulture;
			this.style = style;
			this.dateStyle = dateStyle;
			this.formats = formats.DefaultIfEmpty("O").ToArray();
		}

		public bool Accepts(Type type)
		{
			return type == typeof(DateTimeOffset);
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			DateTimeOffset dateTimeOffset = DateTimeOffset.ParseExact(value, formats, provider, dateStyle);
			return dateTimeOffset;
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			string value2 = ((DateTimeOffset)value).ToString(formats.First(), provider);
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, value2, style, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
	public class GuidConverter : IYamlTypeConverter
	{
		private readonly bool jsonCompatible;

		public GuidConverter(bool jsonCompatible)
		{
			this.jsonCompatible = jsonCompatible;
		}

		public bool Accepts(Type type)
		{
			return type == typeof(Guid);
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			return new Guid(value);
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			Guid guid = (Guid)value;
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, guid.ToString("D"), jsonCompatible ? ScalarStyle.DoubleQuoted : ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
	public class SystemTypeConverter : IYamlTypeConverter
	{
		public bool Accepts(Type type)
		{
			return typeof(Type).IsAssignableFrom(type);
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			return Type.GetType(value, throwOnError: true);
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			Type type2 = (Type)value;
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, type2.AssemblyQualifiedName, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
}
namespace YamlDotNet.Serialization.Callbacks
{
	[AttributeUsage(AttributeTargets.Method)]
	public sealed class OnDeserializedAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	public sealed class OnDeserializingAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	public sealed class OnSerializedAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	public sealed class OnSerializingAttribute : Attribute
	{
	}
}
namespace YamlDotNet.Serialization.BufferedDeserialization
{
	public interface ITypeDiscriminatingNodeDeserializerOptions
	{
		void AddTypeDiscriminator(ITypeDiscriminator discriminator);

		void AddKeyValueTypeDiscriminator<T>(string discriminatorKey, IDictionary<string, Type> valueTypeMapping);

		void AddUniqueKeyTypeDiscriminator<T>(IDictionary<string, Type> uniqueKeyTypeMapping);
	}
	public class ParserBuffer : IParser
	{
		private readonly LinkedList<ParsingEvent> buffer;

		private LinkedListNode<ParsingEvent>? current;

		public ParsingEvent? Current => current?.Value;

		public ParserBuffer(IParser parserToBuffer, int maxDepth, int maxLength)
		{
			buffer = new LinkedList<ParsingEvent>();
			buffer.AddLast(parserToBuffer.Consume<MappingStart>());
			int num = 0;
			do
			{
				ParsingEvent parsingEvent = parserToBuffer.Consume<ParsingEvent>();
				num += parsingEvent.NestingIncrease;
				buffer.AddLast(parsingEvent);
				if (maxDepth > -1 && num > maxDepth)
				{
					throw new ArgumentOutOfRangeException("parserToBuffer", "Parser buffer exceeded max depth");
				}
				if (maxLength > -1 && buffer.Count > maxLength)
				{
					throw new ArgumentOutOfRangeException("parserToBuffer", "Parser buffer exceeded max length");
				}
			}
			while (num >= 0);
			current = buffer.First;
		}

		public bool MoveNext()
		{
			current = current?.Next;
			return current != null;
		}

		public void Reset()
		{
			current = buffer.First;
		}
	}
	public class TypeDiscriminatingNodeDeserializer : INodeDeserializer
	{
		private readonly IList<INodeDeserializer> innerDeserializers;

		private readonly IList<ITypeDiscriminator> typeDiscriminators;

		private readonly int maxDepthToBuffer;

		private readonly int maxLengthToBuffer;

		public TypeDiscriminatingNodeDeserializer(IList<INodeDeserializer> innerDeserializers, IList<ITypeDiscriminator> typeDiscriminators, int maxDepthToBuffer, int maxLengthToBuffer)
		{
			this.innerDeserializers = innerDeserializers;
			this.typeDiscriminators = typeDiscriminators;
			this.maxDepthToBuffer = maxDepthToBuffer;
			this.maxLengthToBuffer = maxLengthToBuffer;
		}

		public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			Type expectedType2 = expectedType;
			if (!reader.Accept<MappingStart>(out var _))
			{
				value = null;
				return false;
			}
			IEnumerable<ITypeDiscriminator> enumerable = typeDiscriminators.Where((ITypeDiscriminator t) => t.BaseType.IsAssignableFrom(expectedType2));
			if (!enumerable.Any())
			{
				value = null;
				return false;
			}
			Mark start = reader.Current.Start;
			Type expectedType3 = expectedType2;
			ParserBuffer parserBuffer;
			try
			{
				parserBuffer = new ParserBuffer(reader, maxDepthToBuffer, maxLengthToBuffer);
			}
			catch (Exception innerException)
			{
				Mark end = reader.Current.End;
				throw new YamlException(in start, in end, "Failed to buffer yaml node", innerException);
			}
			try
			{
				foreach (ITypeDiscriminator item in enumerable)
				{
					parserBuffer.Reset();
					if (item.TryDiscriminate(parserBuffer, out Type suggestedType))
					{
						expectedType3 = suggestedType;
						break;
					}
				}
			}
			catch (Exception innerException2)
			{
				Mark end = reader.Current.End;
				throw new YamlException(in start, in end, "Failed to discriminate type", innerException2);
			}
			parserBuffer.Reset();
			foreach (INodeDeserializer innerDeserializer in innerDeserializers)
			{
				if (innerDeserializer.Deserialize(parserBuffer, expectedType3, nestedObjectDeserializer, out value, rootDeserializer))
				{
					return true;
				}
			}
			value = null;
			return false;
		}
	}
	public class TypeDiscriminatingNodeDeserializerOptions : ITypeDiscriminatingNodeDeserializerOptions
	{
		internal readonly List<ITypeDiscriminator> discriminators = new List<ITypeDiscriminator>();

		public void AddTypeDiscriminator(ITypeDiscriminator discriminator)
		{
			discriminators.Add(discriminator);
		}

		public void AddKeyValueTypeDiscriminator<T>(string discriminatorKey, IDictionary<string, Type> valueTypeMapping)
		{
			discriminators.Add(new KeyValueTypeDiscriminator(typeof(T), discriminatorKey, valueTypeMapping));
		}

		public void AddUniqueKeyTypeDiscriminator<T>(IDictionary<string, Type> uniqueKeyTypeMapping)
		{
			discriminators.Add(new UniqueKeyTypeDiscriminator(typeof(T), uniqueKeyTypeMapping));
		}
	}
}
namespace YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators
{
	public interface ITypeDiscriminator
	{
		Type BaseType { get; }

		bool TryDiscriminate(IParser buffer, out Type? suggestedType);
	}
	public class KeyValueTypeDiscriminator : ITypeDiscriminator
	{
		private readonly string targetKey;

		private readonly IDictionary<string, Type> typeMapping;

		public Type BaseType { get; private set; }

		public KeyValueTypeDiscriminator(Type baseType, string targetKey, IDictionary<string, Type> typeMapping)
		{
			foreach (KeyValuePair<string, Type> item in typeMapping)
			{
				if (!baseType.IsAssignableFrom(item.Value))
				{
					throw new ArgumentOutOfRangeException("typeMapping", $"{item.Value} is not a assignable to {baseType}");
				}
			}
			BaseType = baseType;
			this.targetKey = targetKey;
			this.typeMapping = typeMapping;
		}

		public bool TryDiscriminate(IParser parser, out Type? suggestedType)
		{
			if (parser.TryFindMappingEntry((YamlDotNet.Core.Events.Scalar scalar) => targetKey == scalar.Value, out YamlDotNet.Core.Events.Scalar _, out ParsingEvent value) && value is YamlDotNet.Core.Events.Scalar scalar2 && typeMapping.TryGetValue(scalar2.Value, out Type value2))
			{
				suggestedType = value2;
				return true;
			}
			suggestedType = null;
			return false;
		}
	}
	public class UniqueKeyTypeDiscriminator : ITypeDiscriminator
	{
		private readonly IDictionary<string, Type> typeMapping;

		public Type BaseType { get; private set; }

		public UniqueKeyTypeDiscriminator(Type baseType, IDictionary<string, Type> typeMapping)
		{
			foreach (KeyValuePair<string, Type> item in typeMapping)
			{
				if (!baseType.IsAssignableFrom(item.Value))
				{
					throw new ArgumentOutOfRangeException("typeMapping", $"{item.Value} is not a assignable to {baseType}");
				}
			}
			BaseType = baseType;
			this.typeMapping = typeMapping;
		}

		public bool TryDiscriminate(IParser parser, out Type? suggestedType)
		{
			if (parser.TryFindMappingEntry((YamlDotNet.Core.Events.Scalar scalar) => typeMapping.ContainsKey(scalar.Value), out YamlDotNet.Core.Events.Scalar key, out ParsingEvent _))
			{
				suggestedType = typeMapping[key.Value];
				return true;
			}
			suggestedType = null;
			return false;
		}
	}
}
namespace YamlDotNet.RepresentationModel
{
	internal class DocumentLoadingState
	{
		private readonly Dictionary<AnchorName, YamlNode> anchors = new Dictionary<AnchorName, YamlNode>();

		private readonly List<YamlNode> nodesWithUnresolvedAliases = new List<YamlNode>();

		public void AddAnchor(YamlNode node)
		{
			if (node.Anchor.IsEmpty)
			{
				throw new ArgumentException("The specified node does not have an anchor");
			}
			anchors[node.Anchor] = node;
		}

		public YamlNode GetNode(AnchorName anchor, Mark start, Mark end)
		{
			if (anchors.TryGetValue(anchor, out YamlNode value))
			{
				return value;
			}
			throw new AnchorNotFoundException(in start, in end, $"The anchor '{anchor}' does not exists");
		}

		public bool TryGetNode(AnchorName anchor, [NotNullWhen(true)] out YamlNode? node)
		{
			return anchors.TryGetValue(anchor, out node);
		}

		public void AddNodeWithUnresolvedAliases(YamlNode node)
		{
			nodesWithUnresolvedAliases.Add(node);
		}

		public void ResolveAliases()
		{
			foreach (YamlNode nodesWithUnresolvedAlias in nodesWithUnresolvedAliases)
			{
				nodesWithUnresolvedAlias.ResolveAliases(this);
			}
		}
	}
	internal class EmitterState
	{
		public HashSet<AnchorName> EmittedAnchors { get; } = new HashSet<AnchorName>();

	}
	public interface IYamlVisitor
	{
		void Visit(YamlStream stream);

		void Visit(YamlDocument document);

		void Visit(YamlScalarNode scalar);

		void Visit(YamlSequenceNode sequence);

		void Visit(YamlMappingNode mapping);
	}
	public class LibYamlEventStream
	{
		private readonly IParser parser;

		public LibYamlEventStream(IParser iParser)
		{
			parser = iParser ?? throw new ArgumentNullException("iParser");
		}

		public void WriteTo(TextWriter textWriter)
		{
			while (parser.MoveNext())
			{
				ParsingEvent current = parser.Current;
				if (!(current is YamlDotNet.Core.Events.AnchorAlias anchorAlias))
				{
					if (!(current is YamlDotNet.Core.Events.DocumentEnd documentEnd))
					{
						if (!(current is YamlDotNet.Core.Events.DocumentStart documentStart))
						{
							if (!(current is MappingEnd))
							{
								if (!(current is MappingStart nodeEvent))
								{
									if (!(current is YamlDotNet.Core.Events.Scalar scalar))
									{
										if (!(current is SequenceEnd))
										{
											if (!(current is SequenceStart nodeEvent2))
											{
												if (!(current is YamlDotNet.Core.Events.StreamEnd))
												{
													if (current is YamlDotNet.Core.Events.StreamStart)
													{
														textWriter.Write("+STR");
													}
												}
												else
												{
													textWriter.Write("-STR");
												}
											}
											else
											{
												textWriter.Write("+SEQ");
												WriteAnchorAndTag(textWriter, nodeEvent2);
											}
										}
										else
										{
											textWriter.Write("-SEQ");
										}
									}
									else
									{
										textWriter.Write("=VAL");
										WriteAnchorAndTag(textWriter, scalar);
										switch (scalar.Style)
										{
										case ScalarStyle.DoubleQuoted:
											textWriter.Write(" \"");
											break;
										case ScalarStyle.SingleQuoted:
											textWriter.Write(" '");
											break;
										case ScalarStyle.Folded:
											textWriter.Write(" >");
											break;
										case ScalarStyle.Literal:
											textWriter.Write(" |");
											break;
										default:
											textWriter.Write(" :");
											break;
										}
										string value = scalar.Value;
										foreach (char c in value)
										{
											switch (c)
											{
											case '\b':
												textWriter.Write("\\b");
												break;
											case '\t':
												textWriter.Write("\\t");
												break;
											case '\n':
												textWriter.Write("\\n");
												break;
											case '\r':
												textWriter.Write("\\r");
												break;
											case '\\':
												textWriter.Write("\\\\");
												break;
											default:
												textWriter.Write(c);
												break;
											}
										}
									}
								}
								else
								{
									textWriter.Write("+MAP");
									WriteAnchorAndTag(textWriter, nodeEvent);
								}
							}
							else
							{
								textWriter.Write("-MAP");
							}
						}
						else
						{
							textWriter.Write("+DOC");
							if (!documentStart.IsImplicit)
							{
								textWriter.Write(" ---");
							}
						}
					}
					else
					{
						textWriter.Write("-DOC");
						if (!documentEnd.IsImplicit)
						{
							textWriter.Write(" ...");
						}
					}
				}
				else
				{
					textWriter.Write("=ALI *");
					textWriter.Write(anchorAlias.Value);
				}
				textWriter.WriteLine();
			}
		}

		private static void WriteAnchorAndTag(TextWriter textWriter, NodeEvent nodeEvent)
		{
			if (!nodeEvent.Anchor.IsEmpty)
			{
				textWriter.Write(" &");
				textWriter.Write(nodeEvent.Anchor);
			}
			if (!nodeEvent.Tag.IsEmpty)
			{
				textWriter.Write(" <");
				textWriter.Write(nodeEvent.Tag.Value);
				textWriter.Write(">");
			}
		}
	}
	internal class YamlAliasNode : YamlNode
	{
		public override YamlNodeType NodeType => YamlNodeType.Alias;

		internal YamlAliasNode(AnchorName anchor)
		{
			base.Anchor = anchor;
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			throw new NotSupportedException("Resolving an alias on an alias node does not make sense");
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			throw new NotSupportedException("A YamlAliasNode is an implementation detail and should never be saved.");
		}

		public override void Accept(IYamlVisitor visitor)
		{
			throw new NotSupportedException("A YamlAliasNode is an implementation detail and should never be visited.");
		}

		public override bool Equals(object? obj)
		{
			if (obj is YamlAliasNode yamlAliasNode && Equals(yamlAliasNode))
			{
				return object.Equals(base.Anchor, yamlAliasNode.Anchor);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		internal override string ToString(RecursionLevel level)
		{
			return "*" + base.Anchor;
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			yield return this;
		}
	}
	public class YamlDocument
	{
		private class AnchorAssigningVisitor : YamlVisitorBase
		{
			private readonly HashSet<AnchorName> existingAnchors = new HashSet<AnchorName>();

			private readonly Dictionary<YamlNode, bool> visitedNodes = new Dictionary<YamlNode, bool>();

			public void AssignAnchors(YamlDocument document)
			{
				existingAnchors.Clear();
				visitedNodes.Clear();
				document.Accept(this);
				Random random = new Random();
				foreach (KeyValuePair<YamlNode, bool> visitedNode in visitedNodes)
				{
					if (!visitedNode.Value)
					{
						continue;
					}
					AnchorName anchorName;
					if (!visitedNode.Key.Anchor.IsEmpty && !existingAnchors.Contains(visitedNode.Key.Anchor))
					{
						anchorName = visitedNode.Key.Anchor;
					}
					else
					{
						do
						{
							anchorName = new AnchorName(random.Next().ToString(CultureInfo.InvariantCulture));
						}
						while (existingAnchors.Contains(anchorName));
					}
					existingAnchors.Add(anchorName);
					visitedNode.Key.Anchor = anchorName;
				}
			}

			private bool VisitNodeAndFindDuplicates(YamlNode node)
			{
				if (visitedNodes.TryGetValue(node, out var value))
				{
					if (!value)
					{
						visitedNodes[node] = true;
					}
					return !value;
				}
				visitedNodes.Add(node, value: false);
				return false;
			}

			public override void Visit(YamlScalarNode scalar)
			{
				VisitNodeAndFindDuplicates(scalar);
			}

			public override void Visit(YamlMappingNode mapping)
			{
				if (!VisitNodeAndFindDuplicates(mapping))
				{
					base.Visit(mapping);
				}
			}

			public override void Visit(YamlSequenceNode sequence)
			{
				if (!VisitNodeAndFindDuplicates(sequence))
				{
					base.Visit(sequence);
				}
			}
		}

		public YamlNode RootNode { get; private set; }

		public IEnumerable<YamlNode> AllNodes => RootNode.AllNodes;

		public YamlDocument(YamlNode rootNode)
		{
			RootNode = rootNode;
		}

		public YamlDocument(string rootNode)
		{
			RootNode = new YamlScalarNode(rootNode);
		}

		internal YamlDocument(IParser parser)
		{
			DocumentLoadingState documentLoadingState = new DocumentLoadingState();
			parser.Consume<YamlDotNet.Core.Events.DocumentStart>();
			YamlDotNet.Core.Events.DocumentEnd @event;
			while (!parser.TryConsume<YamlDotNet.Core.Events.DocumentEnd>(out @event))
			{
				RootNode = YamlNode.ParseNode(parser, documentLoadingState);
				if (RootNode is YamlAliasNode)
				{
					throw new YamlException("A document cannot contain only an alias");
				}
			}
			documentLoadingState.ResolveAliases();
			if (RootNode == null)
			{
				throw new ArgumentException("Atempted to parse an empty document");
			}
		}

		private void AssignAnchors()
		{
			AnchorAssigningVisitor anchorAssigningVisitor = new AnchorAssigningVisitor();
			anchorAssigningVisitor.AssignAnchors(this);
		}

		internal void Save(IEmitter emitter, bool assignAnchors = true)
		{
			if (assignAnchors)
			{
				AssignAnchors();
			}
			emitter.Emit(new YamlDotNet.Core.Events.DocumentStart());
			RootNode.Save(emitter, new EmitterState());
			emitter.Emit(new YamlDotNet.Core.Events.DocumentEnd(isImplicit: false));
		}

		public void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	public sealed class YamlMappingNode : YamlNode, IEnumerable<KeyValuePair<YamlNode, YamlNode>>, IEnumerable, IYamlConvertible
	{
		private readonly OrderedDictionary<YamlNode, YamlNode> children = new OrderedDictionary<YamlNode, YamlNode>();

		public IOrderedDictionary<YamlNode, YamlNode> Children => children;

		public MappingStyle Style { get; set; }

		public override YamlNodeType NodeType => YamlNodeType.Mapping;

		internal YamlMappingNode(IParser parser, DocumentLoadingState state)
		{
			Load(parser, state);
		}

		private void Load(IParser parser, DocumentLoadingState state)
		{
			MappingStart mappingStart = parser.Consume<MappingStart>();
			Load(mappingStart, state);
			Style = mappingStart.Style;
			bool flag = false;
			MappingEnd @event;
			while (!parser.TryConsume<MappingEnd>(out @event))
			{
				YamlNode yamlNode = YamlNode.ParseNode(parser, state);
				YamlNode yamlNode2 = YamlNode.ParseNode(parser, state);
				if (!children.TryAdd(yamlNode, yamlNode2))
				{
					Mark start = yamlNode.Start;
					Mark end = yamlNode.End;
					throw new YamlException(in start, in end, $"Duplicate key {yamlNode}");
				}
				flag = flag || yamlNode is YamlAliasNode || yamlNode2 is YamlAliasNode;
			}
			if (flag)
			{
				state.AddNodeWithUnresolvedAliases(this);
			}
		}

		public YamlMappingNode()
		{
		}

		public YamlMappingNode(params KeyValuePair<YamlNode, YamlNode>[] children)
			: this((IEnumerable<KeyValuePair<YamlNode, YamlNode>>)children)
		{
		}

		public YamlMappingNode(IEnumerable<KeyValuePair<YamlNode, YamlNode>> children)
		{
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				this.children.Add(child);
			}
		}

		public YamlMappingNode(params YamlNode[] children)
			: this((IEnumerable<YamlNode>)children)
		{
		}

		public YamlMappingNode(IEnumerable<YamlNode> children)
		{
			using IEnumerator<YamlNode> enumerator = children.GetEnumerator();
			while (enumerator.MoveNext())
			{
				YamlNode current = enumerator.Current;
				if (!enumerator.MoveNext())
				{
					throw new ArgumentException("When constructing a mapping node with a sequence, the number of elements of the sequence must be even.");
				}
				Add(current, enumerator.Current);
			}
		}

		public void Add(YamlNode key, YamlNode value)
		{
			children.Add(key, value);
		}

		public void Add(string key, YamlNode value)
		{
			children.Add(new YamlScalarNode(key), value);
		}

		public void Add(YamlNode key, string value)
		{
			children.Add(key, new YamlScalarNode(value));
		}

		public void Add(string key, string value)
		{
			children.Add(new YamlScalarNode(key), new YamlScalarNode(value));
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			Dictionary<YamlNode, YamlNode> dictionary = null;
			Dictionary<YamlNode, YamlNode> dictionary2 = null;
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				if (child.Key is YamlAliasNode)
				{
					if (dictionary == null)
					{
						dictionary = new Dictionary<YamlNode, YamlNode>();
					}
					dictionary.Add(child.Key, state.GetNode(child.Key.Anchor, child.Key.Start, child.Key.End));
				}
				if (child.Value is YamlAliasNode)
				{
					if (dictionary2 == null)
					{
						dictionary2 = new Dictionary<YamlNode, YamlNode>();
					}
					dictionary2.Add(child.Key, state.GetNode(child.Value.Anchor, child.Value.Start, child.Value.End));
				}
			}
			if (dictionary2 != null)
			{
				foreach (KeyValuePair<YamlNode, YamlNode> item in dictionary2)
				{
					children[item.Key] = item.Value;
				}
			}
			if (dictionary == null)
			{
				return;
			}
			foreach (KeyValuePair<YamlNode, YamlNode> item2 in dictionary)
			{
				YamlNode value = children[item2.Key];
				children.Remove(item2.Key);
				children.Add(item2.Value, value);
			}
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			emitter.Emit(new MappingStart(base.Anchor, base.Tag, isImplicit: true, Style));
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				child.Key.Save(emitter, state);
				child.Value.Save(emitter, state);
			}
			emitter.Emit(new MappingEnd());
		}

		public override void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override bool Equals(object? obj)
		{
			if (!(obj is YamlMappingNode yamlMappingNode) || !object.Equals(base.Tag, yamlMappingNode.Tag) || children.Count != yamlMappingNode.children.Count)
			{
				return false;
			}
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				if (!yamlMappingNode.children.TryGetValue(child.Key, out YamlNode value) || !object.Equals(child.Value, value))
				{
					return false;
				}
			}
			return true;
		}

		public override int GetHashCode()
		{
			int num = base.GetHashCode();
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				num = YamlDotNet.Core.HashCode.CombineHashCodes(num, child.Key);
				num = (child.Value.Anchor.IsEmpty ? YamlDotNet.Core.HashCode.CombineHashCodes(num, child.Value) : YamlDotNet.Core.HashCode.CombineHashCodes(num, child.Value.Anchor));
			}
			return num;
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			level.Increment();
			yield return this;
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				foreach (YamlNode item in child.Key.SafeAllNodes(level))
				{
					yield return item;
				}
				foreach (YamlNode item2 in child.Value.SafeAllNodes(level))
				{
					yield return item2;
				}
			}
			level.Decrement();
		}

		internal override string ToString(RecursionLevel level)
		{
			if (!level.TryIncrement())
			{
				return "WARNING! INFINITE RECURSION!";
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				builder.Append("{ ");
				foreach (KeyValuePair<YamlNode, YamlNode> child in children)
				{
					if (builder.Length > 2)
					{
						builder.Append(", ");
					}
					builder.Append("{ ").Append(child.Key.ToString(level)).Append(", ")
						.Append(child.Value.ToString(level))
						.Append(" }");
				}
				builder.Append(" }");
				level.Decrement();
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		public IEnumerator<KeyValuePair<YamlNode, YamlNode>> GetEnumerator()
		{
			return children.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new DocumentLoadingState());
		}

		void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new EmitterState());
		}

		public static YamlMappingNode FromObject(object mapping)
		{
			if (mapping == null)
			{
				throw new ArgumentNullException("mapping");
			}
			YamlMappingNode yamlMappingNode = new YamlMappingNode();
			foreach (PropertyInfo publicProperty in mapping.GetType().GetPublicProperties())
			{
				if (publicProperty.CanRead && publicProperty.GetGetMethod(nonPublic: false).GetParameters().Length == 0)
				{
					object value = publicProperty.GetValue(mapping, null);
					YamlNode yamlNode = value as YamlNode;
					if (yamlNode == null)
					{
						string text = Convert.ToString(value, CultureInfo.InvariantCulture);
						yamlNode = text ?? string.Empty;
					}
					yamlMappingNode.Add(publicProperty.Name, yamlNode);
				}
			}
			return yamlMappingNode;
		}
	}
	public abstract class YamlNode
	{
		private const int MaximumRecursionLevel = 1000;

		internal const string MaximumRecursionLevelReachedToStringValue = "WARNING! INFINITE RECURSION!";

		public AnchorName Anchor { get; set; }

		public TagName Tag { get; set; }

		public Mark Start { get; private set; } = Mark.Empty;


		public Mark End { get; private set; } = Mark.Empty;


		public IEnumerable<YamlNode> AllNodes
		{
			get
			{
				RecursionLevel level = new RecursionLevel(1000);
				return SafeAllNodes(level);
			}
		}

		public abstract YamlNodeType NodeType { get; }

		public YamlNode this[int index]
		{
			get
			{
				if (!(this is YamlSequenceNode yamlSequenceNode))
				{
					throw new ArgumentException($"Accessed '{NodeType}' with an invalid index: {index}. Only Sequences can be indexed by number.");
				}
				return yamlSequenceNode.Children[index];
			}
		}

		public YamlNode this[YamlNode key]
		{
			get
			{
				if (!(this is YamlMappingNode yamlMappingNode))
				{
					throw new ArgumentException($"Accessed '{NodeType}' with an invalid index: {key}. Only Mappings can be indexed by key.");
				}
				return yamlMappingNode.Children[key];
			}
		}

		internal void Load(NodeEvent yamlEvent, DocumentLoadingState state)
		{
			Tag = yamlEvent.Tag;
			if (!yamlEvent.Anchor.IsEmpty)
			{
				Anchor = yamlEvent.Anchor;
				state.AddAnchor(this);
			}
			Start = yamlEvent.Start;
			End = yamlEvent.End;
		}

		internal static YamlNode ParseNode(IParser parser, DocumentLoadingState state)
		{
			if (parser.Accept<YamlDotNet.Core.Events.Scalar>(out var _))
			{
				return new YamlScalarNode(parser, state);
			}
			if (parser.Accept<SequenceStart>(out var _))
			{
				return new YamlSequenceNode(parser, state);
			}
			if (parser.Accept<MappingStart>(out var _))
			{
				return new YamlMappingNode(parser, state);
			}
			if (parser.TryConsume<YamlDotNet.Core.Events.AnchorAlias>(out var event4))
			{
				if (!state.TryGetNode(event4.Value, out YamlNode node))
				{
					return new YamlAliasNode(event4.Value);
				}
				return node;
			}
			throw new ArgumentException("The current event is of an unsupported type.", "parser");
		}

		internal abstract void ResolveAliases(DocumentLoadingState state);

		internal void Save(IEmitter emitter, EmitterState state)
		{
			if (!Anchor.IsEmpty && !state.EmittedAnchors.Add(Anchor))
			{
				emitter.Emit(new YamlDotNet.Core.Events.AnchorAlias(Anchor));
			}
			else
			{
				Emit(emitter, state);
			}
		}

		internal abstract void Emit(IEmitter emitter, EmitterState state);

		public abstract void Accept(IYamlVisitor visitor);

		public override string ToString()
		{
			RecursionLevel recursionLevel = new RecursionLevel(1000);
			return ToString(recursionLevel);
		}

		internal abstract string ToString(RecursionLevel level);

		internal abstract IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level);

		public static implicit operator YamlNode(string value)
		{
			return new YamlScalarNode(value);
		}

		public static implicit operator YamlNode(string[] sequence)
		{
			return new YamlSequenceNode(((IEnumerable<string>)sequence).Select((Func<string, YamlNode>)((string i) => i)));
		}

		public static explicit operator string?(YamlNode node)
		{
			if (!(node is YamlScalarNode yamlScalarNode))
			{
				throw new ArgumentException($"Attempted to convert a '{node.NodeType}' to string. This conversion is valid only for Scalars.");
			}
			return yamlScalarNode.Value;
		}
	}
	public sealed class YamlNodeIdentityEqualityComparer : IEqualityComparer<YamlNode>
	{
		public bool Equals([AllowNull] YamlNode x, [AllowNull] YamlNode y)
		{
			return x == y;
		}

		public int GetHashCode(YamlNode obj)
		{
			return obj.GetHashCode();
		}
	}
	public enum YamlNodeType
	{
		Alias,
		Mapping,
		Scalar,
		Sequence
	}
	[DebuggerDisplay("{Value}")]
	public sealed class YamlScalarNode : YamlNode, IYamlConvertible
	{
		private bool forceImplicitPlain;

		private string? value;

		public string? Value
		{
			get
			{
				return value;
			}
			set
			{
				if (value == null)
				{
					forceImplicitPlain = true;
				}
				else
				{
					forceImplicitPlain = false;
				}
				this.value = value;
			}
		}

		public ScalarStyle Style { get; set; }

		public override YamlNodeType NodeType => YamlNodeType.Scalar;

		internal YamlScalarNode(IParser parser, DocumentLoadingState state)
		{
			Load(parser, state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void Load(IParser parser, DocumentLoadingState state)
		{
			YamlDotNet.Core.Events.Scalar scalar = parser.Consume<YamlDotNet.Core.Events.Scalar>();
			Load(scalar, state);
			string text = scalar.Value;
			if (scalar.Style == ScalarStyle.Plain && base.Tag.IsEmpty)
			{
				forceImplicitPlain = text.Length switch
				{
					0 => true, 
					1 => text == "~", 
					4 => text == "null" || text == "Null" || text == "NULL", 
					_ => false, 
				};
			}
			value = text;
			Style = scalar.Style;
		}

		public YamlScalarNode()
		{
		}

		public YamlScalarNode(string? value)
		{
			Value = value;
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			throw new NotSupportedException("Resolving an alias on a scalar node does not make sense");
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			TagName tag = base.Tag;
			bool isPlainImplicit = tag.IsEmpty;
			if (forceImplicitPlain && Style == ScalarStyle.Plain && (Value == null || Value == ""))
			{
				tag = JsonSchema.Tags.Null;
				isPlainImplicit = true;
			}
			else if (tag.IsEmpty && Value == null && (Style == ScalarStyle.Plain || Style == ScalarStyle.Any))
			{
				tag = JsonSchema.Tags.Null;
				isPlainImplicit = true;
			}
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(base.Anchor, tag, Value ?? string.Empty, Style, isPlainImplicit, isQuotedImplicit: false));
		}

		public override void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override bool Equals(object? obj)
		{
			if (obj is YamlScalarNode yamlScalarNode && object.Equals(base.Tag, yamlScalarNode.Tag))
			{
				return object.Equals(Value, yamlScalarNode.Value);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return YamlDotNet.Core.HashCode.CombineHashCodes(base.Tag.GetHashCode(), Value);
		}

		public static explicit operator string?(YamlScalarNode value)
		{
			return value.Value;
		}

		internal override string ToString(RecursionLevel level)
		{
			return Value ?? string.Empty;
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			yield return this;
		}

		void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new DocumentLoadingState());
		}

		void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new EmitterState());
		}
	}
	[DebuggerDisplay("Count = {children.Count}")]
	public sealed class YamlSequenceNode : YamlNode, IEnumerable<YamlNode>, IEnumerable, IYamlConvertible
	{
		private readonly List<YamlNode> children = new List<YamlNode>();

		public IList<YamlNode> Children => children;

		public SequenceStyle Style { get; set; }

		public override YamlNodeType NodeType => YamlNodeType.Sequence;

		internal YamlSequenceNode(IParser parser, DocumentLoadingState state)
		{
			Load(parser, state);
		}

		private void Load(IParser parser, DocumentLoadingState state)
		{
			SequenceStart sequenceStart = parser.Consume<SequenceStart>();
			Load(sequenceStart, state);
			Style = sequenceStart.Style;
			bool flag = false;
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				YamlNode yamlNode = YamlNode.ParseNode(parser, state);
				children.Add(yamlNode);
				flag = flag || yamlNode is YamlAliasNode;
			}
			if (flag)
			{
				state.AddNodeWithUnresolvedAliases(this);
			}
		}

		public YamlSequenceNode()
		{
		}

		public YamlSequenceNode(params YamlNode[] children)
			: this((IEnumerable<YamlNode>)children)
		{
		}

		public YamlSequenceNode(IEnumerable<YamlNode> children)
		{
			foreach (YamlNode child in children)
			{
				this.children.Add(child);
			}
		}

		public void Add(YamlNode child)
		{
			children.Add(child);
		}

		public void Add(string child)
		{
			children.Add(new YamlScalarNode(child));
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			for (int i = 0; i < children.Count; i++)
			{
				if (children[i] is YamlAliasNode)
				{
					children[i] = state.GetNode(children[i].Anchor, children[i].Start, children[i].End);
				}
			}
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			emitter.Emit(new SequenceStart(base.Anchor, base.Tag, base.Tag.IsEmpty, Style));
			foreach (YamlNode child in children)
			{
				child.Save(emitter, state);
			}
			emitter.Emit(new SequenceEnd());
		}

		public override void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override bool Equals(object? obj)
		{
			if (!(obj is YamlSequenceNode yamlSequenceNode) || !object.Equals(base.Tag, yamlSequenceNode.Tag) || children.Count != yamlSequenceNode.children.Count)
			{
				return false;
			}
			for (int i = 0; i < children.Count; i++)
			{
				if (!object.Equals(children[i], yamlSequenceNode.children[i]))
				{
					return false;
				}
			}
			return true;
		}

		public override int GetHashCode()
		{
			int h = 0;
			foreach (YamlNode child in children)
			{
				h = YamlDotNet.Core.HashCode.CombineHashCodes(h, child);
			}
			return YamlDotNet.Core.HashCode.CombineHashCodes(h, base.Tag);
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			level.Increment();
			yield return this;
			foreach (YamlNode child in children)
			{
				foreach (YamlNode item in child.SafeAllNodes(level))
				{
					yield return item;
				}
			}
			level.Decrement();
		}

		internal override string ToString(RecursionLevel level)
		{
			if (!level.TryIncrement())
			{
				return "WARNING! INFINITE RECURSION!";
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				builder.Append("[ ");
				foreach (YamlNode child in children)
				{
					if (builder.Length > 2)
					{
						builder.Append(", ");
					}
					builder.Append(child.ToString(level));
				}
				builder.Append(" ]");
				level.Decrement();
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		public IEnumerator<YamlNode> GetEnumerator()
		{
			return Children.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new DocumentLoadingState());
		}

		void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new EmitterState());
		}
	}
	public class YamlStream : IEnumerable<YamlDocument>, IEnumerable
	{
		private readonly List<YamlDocument> documents = new List<YamlDocument>();

		public IList<YamlDocument> Documents => documents;

		public YamlStream()
		{
		}

		public YamlStream(params YamlDocument[] documents)
			: this((IEnumerable<YamlDocument>)documents)
		{
		}

		public YamlStream(IEnumerable<YamlDocument> documents)
		{
			foreach (YamlDocument document in documents)
			{
				this.documents.Add(document);
			}
		}

		public void Add(YamlDocument document)
		{
			documents.Add(document);
		}

		public void Load(TextReader input)
		{
			Load(new Parser(input));
		}

		public void Load(IParser parser)
		{
			documents.Clear();
			parser.Consume<YamlDotNet.Core.Events.StreamStart>();
			YamlDotNet.Core.Events.StreamEnd @event;
			while (!parser.TryConsume<YamlDotNet.Core.Events.StreamEnd>(out @event))
			{
				YamlDocument item = new YamlDocument(parser);
				documents.Add(item);
			}
		}

		public void Save(TextWriter output)
		{
			Save(output, assignAnchors: true);
		}

		public void Save(TextWriter output, bool assignAnchors)
		{
			Save(new Emitter(output), assignAnchors);
		}

		public void Save(IEmitter emitter, bool assignAnchors)
		{
			emitter.Emit(new YamlDotNet.Core.Events.StreamStart());
			foreach (YamlDocument document in documents)
			{
				document.Save(emitter, assignAnchors);
			}
			emitter.Emit(new YamlDotNet.Core.Events.StreamEnd());
		}

		public void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public IEnumerator<YamlDocument> GetEnumerator()
		{
			return documents.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	[Obsolete("Use YamlVisitorBase")]
	public abstract class YamlVisitor : IYamlVisitor
	{
		protected virtual void Visit(YamlStream stream)
		{
		}

		protected virtual void Visited(YamlStream stream)
		{
		}

		protected virtual void Visit(YamlDocument document)
		{
		}

		protected virtual void Visited(YamlDocument document)
		{
		}

		protected virtual void Visit(YamlScalarNode scalar)
		{
		}

		protected virtual void Visited(YamlScalarNode scalar)
		{
		}

		protected virtual void Visit(YamlSequenceNode sequence)
		{
		}

		protected virtual void Visited(YamlSequenceNode sequence)
		{
		}

		protected virtual void Visit(YamlMappingNode mapping)
		{
		}

		protected virtual void Visited(YamlMappingNode mapping)
		{
		}

		protected virtual void VisitChildren(YamlStream stream)
		{
			foreach (YamlDocument document in stream.Documents)
			{
				document.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlDocument document)
		{
			if (document.RootNode != null)
			{
				document.RootNode.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlSequenceNode sequence)
		{
			foreach (YamlNode child in sequence.Children)
			{
				child.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlMappingNode mapping)
		{
			foreach (KeyValuePair<YamlNode, YamlNode> child in mapping.Children)
			{
				child.Key.Accept(this);
				child.Value.Accept(this);
			}
		}

		void IYamlVisitor.Visit(YamlStream stream)
		{
			Visit(stream);
			VisitChildren(stream);
			Visited(stream);
		}

		void IYamlVisitor.Visit(YamlDocument document)
		{
			Visit(document);
			VisitChildren(document);
			Visited(document);
		}

		void IYamlVisitor.Visit(YamlScalarNode scalar)
		{
			Visit(scalar);
			Visited(scalar);
		}

		void IYamlVisitor.Visit(YamlSequenceNode sequence)
		{
			Visit(sequence);
			VisitChildren(sequence);
			Visited(sequence);
		}

		void IYamlVisitor.Visit(YamlMappingNode mapping)
		{
			Visit(mapping);
			VisitChildren(mapping);
			Visited(mapping);
		}
	}
	public abstract class YamlVisitorBase : IYamlVisitor
	{
		public virtual void Visit(YamlStream stream)
		{
			VisitChildren(stream);
		}

		public virtual void Visit(YamlDocument document)
		{
			VisitChildren(document);
		}

		public virtual void Visit(YamlScalarNode scalar)
		{
		}

		public virtual void Visit(YamlSequenceNode sequence)
		{
			VisitChildren(sequence);
		}

		public virtual void Visit(YamlMappingNode mapping)
		{
			VisitChildren(mapping);
		}

		protected virtual void VisitPair(YamlNode key, YamlNode value)
		{
			key.Accept(this);
			value.Accept(this);
		}

		protected virtual void VisitChildren(YamlStream stream)
		{
			foreach (YamlDocument document in stream.Documents)
			{
				document.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlDocument document)
		{
			if (document.RootNode != null)
			{
				document.RootNode.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlSequenceNode sequence)
		{
			foreach (YamlNode child in sequence.Children)
			{
				child.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlMappingNode mapping)
		{
			foreach (KeyValuePair<YamlNode, YamlNode> child in mapping.Children)
			{
				VisitPair(child.Key, child.Value);
			}
		}
	}
}
namespace YamlDotNet.Helpers
{
	public class DefaultFsharpHelper : IFsharpHelper
	{
		private static bool IsFsharpCore(Type t)
		{
			return t.Namespace == "Microsoft.FSharp.Core";
		}

		public bool IsOptionType(Type t)
		{
			if (IsFsharpCore(t))
			{
				return t.Name == "FSharpOption`1";
			}
			return false;
		}

		public Type? GetOptionUnderlyingType(Type t)
		{
			if (!t.IsGenericType || !IsOptionType(t))
			{
				return null;
			}
			return t.GenericTypeArguments[0];
		}

		public object? GetValue(IObjectDescriptor objectDescriptor)
		{
			if (!IsOptionType(objectDescriptor.Type))
			{
				throw new InvalidOperationException("Should not be called on non-Option<> type");
			}
			if (objectDescriptor.Value == null)
			{
				return null;
			}
			return objectDescriptor.Type.GetProperty("Value").GetValue(objectDescriptor.Value);
		}

		public bool IsFsharpListType(Type t)
		{
			if (t.Namespace == "Microsoft.FSharp.Collections")
			{
				return t.Name == "FSharpList`1";
			}
			return false;
		}

		public object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr)
		{
			if (!IsFsharpListType(t))
			{
				return null;
			}
			return t.Assembly.GetType("Microsoft.FSharp.Collections.ListModule").GetMethod("OfArray").MakeGenericMethod(itemsType)
				.Invoke(null, new object[1] { arr });
		}
	}
	internal static class DictionaryExtensions
	{
		public static bool TryAdd<T, V>(this Dictionary<T, V> dictionary, T key, V value)
		{
			if (dictionary.ContainsKey(key))
			{
				return false;
			}
			dictionary.Add(key, value);
			return true;
		}

		public static TValue GetOrAdd<TKey, TValue, TArg>(this ConcurrentDictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TArg, TValue> valueFactory, TArg arg)
		{
			if (dictionary == null)
			{
				throw new ArgumentNullException("dictionary");
			}
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			if (valueFactory == null)
			{
				throw new ArgumentNullException("valueFactory");
			}
			TValue value;
			do
			{
				if (dictionary.TryGetValue(key, out value))
				{
					return value;
				}
				value = valueFactory(key, arg);
			}
			while (!dictionary.TryAdd(key, value));
			return value;
		}
	}
	public static class ExpressionExtensions
	{
		public static PropertyInfo AsProperty(this LambdaExpression propertyAccessor)
		{
			PropertyInfo propertyInfo = TryGetMemberExpression<PropertyInfo>(propertyAccessor);
			if (propertyInfo == null)
			{
				throw new ArgumentException("Expected a lambda expression in the form: x => x.SomeProperty", "propertyAccessor");
			}
			return propertyInfo;
		}

		[return: MaybeNull]
		private static TMemberInfo TryGetMemberExpression<TMemberInfo>(LambdaExpression lambdaExpression) where TMemberInfo : MemberInfo
		{
			if (lambdaExpression.Parameters.Count != 1)
			{
				return null;
			}
			Expression expression = lambdaExpression.Body;
			if (expression is UnaryExpression unaryExpression)
			{
				if (unaryExpression.NodeType != ExpressionType.Convert)
				{
					return null;
				}
				expression = unaryExpression.Operand;
			}
			if (expression is MemberExpression memberExpression)
			{
				if (memberExpression.Expression != lambdaExpression.Parameters[0])
				{
					return null;
				}
				return memberExpression.Member as TMemberInfo;
			}
			return null;
		}
	}
	public static class FsharpHelper
	{
		public static IFsharpHelper? Instance { get; set; }

		public static bool IsOptionType(Type t)
		{
			return Instance?.IsOptionType(t) ?? false;
		}

		public static Type? GetOptionUnderlyingType(Type t)
		{
			return Instance?.GetOptionUnderlyingType(t);
		}

		public static object? GetValue(IObjectDescriptor objectDescriptor)
		{
			return Instance?.GetValue(objectDescriptor);
		}

		public static bool IsFsharpListType(Type t)
		{
			return Instance?.IsFsharpListType(t) ?? false;
		}

		public static object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr)
		{
			return Instance?.CreateFsharpListFromArray(t, itemsType, arr);
		}
	}
	internal sealed class GenericCollectionToNonGenericAdapter<T> : IList, ICollection, IEnumerable
	{
		private readonly ICollection<T> genericCollection;

		public bool IsFixedSize
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsReadOnly
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object? this[int index]
		{
			get
			{
				throw new NotSupportedException();
			}
			set
			{
				((IList<T>)genericCollection)[index] = (T)value;
			}
		}

		public int Count
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsSynchronized
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object SyncRoot
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public GenericCollectionToNonGenericAdapter(ICollection<T> genericCollection)
		{
			this.genericCollection = genericCollection ?? throw new ArgumentNullException("genericCollection");
		}

		public int Add(object? value)
		{
			int count = genericCollection.Count;
			genericCollection.Add((T)value);
			return count;
		}

		public void Clear()
		{
			genericCollection.Clear();
		}

		public bool Contains(object? value)
		{
			throw new NotSupportedException();
		}

		public int IndexOf(object? value)
		{
			throw new NotSupportedException();
		}

		public void Insert(int index, object? value)
		{
			throw new NotSupportedException();
		}

		public void Remove(object? value)
		{
			throw new NotSupportedException();
		}

		public void RemoveAt(int index)
		{
			throw new NotSupportedException();
		}

		public void CopyTo(Array array, int index)
		{
			throw new NotSupportedException();
		}

		public IEnumerator GetEnumerator()
		{
			return genericCollection.GetEnumerator();
		}
	}
	internal sealed class GenericDictionaryToNonGenericAdapter<TKey, TValue> : IDictionary, ICollection, IEnumerable where TKey : notnull
	{
		private class DictionaryEnumerator : IDictionaryEnumerator, IEnumerator
		{
			private readonly IEnumerator<KeyValuePair<TKey, TValue>> enumerator;

			public DictionaryEntry Entry => new DictionaryEntry(Key, Value);

			public object Key => enumerator.Current.Key;

			public object? Value => enumerator.Current.Value;

			public object Current => Entry;

			public DictionaryEnumerator(IEnumerator<KeyValuePair<TKey, TValue>> enumerator)
			{
				this.enumerator = enumerator;
			}

			public bool MoveNext()
			{
				return enumerator.MoveNext();
			}

			public void Reset()
			{
				enumerator.Reset();
			}
		}

		private readonly IDictionary<TKey, TValue> genericDictionary;

		public bool IsFixedSize
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsReadOnly
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public ICollection Keys
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public ICollection Values
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object? this[object key]
		{
			get
			{
				throw new NotSupportedException();
			}
			set
			{
				genericDictionary[(TKey)key] = (TValue)value;
			}
		}

		public int Count
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsSynchronized
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object SyncRoot
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public GenericDictionaryToNonGenericAdapter(IDictionary<TKey, TValue> genericDictionary)
		{
			this.genericDictionary = genericDictionary ?? throw new ArgumentNullException("genericDictionary");
		}

		public void Add(object key, object? value)
		{
			throw new NotSupportedException();
		}

		public void Clear()
		{
			throw new NotSupportedException();
		}

		public bool Contains(object key)
		{
			throw new NotSupportedException();
		}

		public IDictionaryEnumerator GetEnumerator()
		{
			return new DictionaryEnumerator(genericDictionary.GetEnumerator());
		}

		public void Remove(object key)
		{
			throw new NotSupportedException();
		}

		public void CopyTo(Array array, int index)
		{
			throw new NotSupportedException();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public interface IFsharpHelper
	{
		bool IsOptionType(Type t);

		Type? GetOptionUnderlyingType(Type t);

		object? GetValue(IObjectDescriptor objectDescriptor);

		bool IsFsharpListType(Type t);

		object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr);
	}
	public interface IOrderedDictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable where TKey : notnull
	{
		KeyValuePair<TKey, TValue> this[int index] { get; set; }

		void Insert(int index, TKey key, TValue value);

		void RemoveAt(int index);
	}
	public class NullFsharpHelper : IFsharpHelper
	{
		public object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr)
		{
			return null;
		}

		public Type? GetOptionUnderlyingType(Type t)
		{
			return null;
		}

		public object? GetValue(IObjectDescriptor objectDescriptor)
		{
			return null;
		}

		public bool IsFsharpListType(Type t)
		{
			return false;
		}

		public bool IsOptionType(Type t)
		{
			return false;
		}
	}
	internal static class NumberExtensions
	{
		public static bool IsPowerOfTwo(this int value)
		{
			return (value & (value - 1)) == 0;
		}
	}
	[Serializable]
	internal sealed class OrderedDictionary<TKey, TValue> : IOrderedDictionary<TKey, TValue>, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable where TKey : notnull
	{
		private class KeyCollection : ICollection<TKey>, IEnumerable<TKey>, IEnumerable
		{
			private readonly OrderedDictionary<TKey, TValue> orderedDictionary;

			public int Count => orderedDictionary.list.Count;

			public bool IsReadOnly => true;

			public void Add(TKey item)
			{
				throw new NotSupportedException();
			}

			public void Clear()
			{
				throw new NotSupportedException();
			}

			public bool Contains(TKey item)
			{
				return orderedDictionary.dictionary.ContainsKey(item);
			}

			public KeyCollection(OrderedDictionary<TKey, TValue> orderedDictionary)
			{
				this.orderedDictionary = orderedDictionary;
			}

			public void CopyTo(TKey[] array, int arrayIndex)
			{
				for (int i = 0; i < orderedDictionary.list.Count; i++)
				{
					array[i] = orderedDictionary.list[i + arrayIndex].Key;
				}
			}

			public IEnumerator<TKey> GetEnumerator()
			{
				return orderedDictionary.list.Select((KeyValuePair<TKey, TValue> kvp) => kvp.Key).GetEnumerator();
			}

			public bool Remove(TKey item)
			{
				throw new NotSupportedException();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}
		}

		private class ValueCollection : ICollection<TValue>, IEnumerable<TValue>, IEnumerable
		{
			private readonly OrderedDictionary<TKey, TValue> orderedDictionary;

			public int Count => orderedDictionary.list.Count;

			public bool IsReadOnly => true;

			public void Add(TValue item)
			{
				throw new NotSupportedException();
			}

			public void Clear()
			{
				throw new NotSupportedException();
			}

			public bool Contains(TValue item)
			{
				return orderedDictionary.dictionary.ContainsValue(item);
			}

			public ValueCollection(OrderedDictionary<TKey, TValue> orderedDictionary)
			{
				this.orderedDictionary = orderedDictionary;
			}

			public void CopyTo(TValue[] array, int arrayIndex)
			{
				for (int i = 0; i < orderedDictionary.list.Count; i++)
				{
					array[i] = orderedDictionary.list[i + arrayIndex].Value;
				}
			}

			public IEnumerator<TValue> GetEnumerator()
			{
				return orderedDictionary.list.Select((KeyValuePair<TKey, TValue> kvp) => kvp.Value).GetEnumerator();
			}

			public bool Remove(TValue item)
			{
				throw new NotSupportedException();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}
		}

		[NonSerialized]
		private Dictionary<TKey, TValue> dictionary;

		private readonly List<KeyValuePair<TKey, TValue>> list;

		private readonly IEqualityComparer<TKey> comparer;

		public TValue this[TKey key]
		{
			get
			{
				return dictionary[key];
			}
			set
			{
				TKey key2 = key;
				if (dictionary.ContainsKey(key2))
				{
					int index = list.FindIndex((KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key2));
					dictionary[key2] = value;
					list[index] = new KeyValuePair<TKey, TValue>(key2, value);
				}
				else
				{
					Add(key2, value);
				}
			}
		}

		public ICollection<TKey> Keys => new KeyCollection(this);

		public ICollection<TValue> Values => new ValueCollection(this);

		public int Count => dictionary.Count;

		public bool IsReadOnly => false;

		public KeyValuePair<TKey, TValue> this[int index]
		{
			get
			{
				return list[index];
			}
			set
			{
				list[index] = value;
			}
		}

		public OrderedDictionary()
			: this((IEqualityComparer<TKey>)EqualityComparer<TKey>.Default)
		{
		}

		public OrderedDictionary(IEqualityComparer<TKey> comparer)
		{
			list = new List<KeyValuePair<TKey, TValue>>();
			dictionary = new Dictionary<TKey, TValue>(comparer);
			this.comparer = comparer;
		}

		public void Add(KeyValuePair<TKey, TValue> item)
		{
			if (!TryAdd(item))
			{
				ThrowDuplicateKeyException(item.Key);
			}
		}

		public void Add(TKey key, TValue value)
		{
			if (!TryAdd(key, value))
			{
				ThrowDuplicateKeyException(key);
			}
		}

		private static void ThrowDuplicateKeyException(TKey key)
		{
			throw new ArgumentException($"An item with the same key {key} has already been added.");
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryAdd(TKey key, TValue value)
		{
			if (DictionaryExtensions.TryAdd(dictionary, key, value))
			{
				list.Add(new KeyValuePair<TKey, TValue>(key, value));
				return true;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryAdd(KeyValuePair<TKey, TValue> item)
		{
			if (DictionaryExtensions.TryAdd(dictionary, item.Key, item.Value))
			{
				list.Add(item);
				return true;
			}
			return false;
		}

		public void Clear()
		{
			dictionary.Clear();
			list.Clear();
		}

		public bool Contains(KeyValuePair<TKey, TValue> item)
		{
			return dictionary.Contains(item);
		}

		public bool ContainsKey(TKey key)
		{
			return dictionary.ContainsKey(key);
		}

		public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			list.CopyTo(array, arrayIndex);
		}

		public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
		{
			return list.GetEnumerator();
		}

		public void Insert(int index, TKey key, TValue value)
		{
			dictionary.Add(key, value);
			list.Insert(index, new KeyValuePair<TKey, TValue>(key, value));
		}

		public bool Remove(TKey key)
		{
			TKey key2 = key;
			if (dictionary.ContainsKey(key2))
			{
				int index = list.FindIndex((KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key2));
				list.RemoveAt(index);
				if (!dictionary.Remove(key2))
				{
					throw new InvalidOperationException();
				}
				return true;
			}
			return false;
		}

		public bool Remove(KeyValuePair<TKey, TValue> item)
		{
			return Remove(item.Key);
		}

		public void RemoveAt(int index)
		{
			TKey key = list[index].Key;
			dictionary.Remove(key);
			list.RemoveAt(index);
		}

		public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
		{
			return dictionary.TryGetValue(key, out value);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return list.GetEnumerator();
		}

		[System.Runtime.Serialization.OnDeserialized]
		internal void OnDeserializedMethod(StreamingContext context)
		{
			dictionary = new Dictionary<TKey, TValue>();
			foreach (KeyValuePair<TKey, TValue> item in list)
			{
				dictionary[item.Key] = item.Value;
			}
		}
	}
	internal static class ReadOnlyCollectionExtensions
	{
		public static IReadOnlyList<T> AsReadonlyList<T>(this List<T> list)
		{
			return list;
		}

		public static IReadOnlyDictionary<TKey, TValue> AsReadonlyDictionary<TKey, TValue>(this Dictionary<TKey, TValue> dictionary) where TKey : notnull
		{
			return dictionary;
		}
	}
	internal static class ThrowHelper
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void ThrowArgumentOutOfRangeException(string paramName, string message)
		{
			throw new ArgumentOutOfRangeException(paramName, message);
		}
	}
}
namespace YamlDotNet.Core
{
	public readonly struct AnchorName : IEquatable<AnchorName>
	{
		public static readonly AnchorName Empty;

		private static readonly Regex AnchorPattern = new Regex("^[^\\[\\]\\{\\},]+$", RegexOptions.Compiled);

		private readonly string? value;

		public string Value => value ?? throw new InvalidOperationException("Cannot read the Value of an empty anchor");

		public bool IsEmpty => value == null;

		public AnchorName(string value)
		{
			this.value = value ?? throw new ArgumentNullException("value");
			if (!AnchorPattern.IsMatch(value))
			{
				throw new ArgumentException("Anchor cannot be empty or contain disallowed characters: []{},\nThe value was '" + value + "'.", "value");
			}
		}

		public override string ToString()
		{
			return value ?? "[empty]";
		}

		public bool Equals(AnchorName other)
		{
			return object.Equals(value, other.value);
		}

		public override bool Equals(object? obj)
		{
			if (obj is AnchorName other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return value?.GetHashCode() ?? 0;
		}

		public static bool operator ==(AnchorName left, AnchorName right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(AnchorName left, AnchorName right)
		{
			return !(left == right);
		}

		public static implicit operator AnchorName(string? value)
		{
			if (value != null)
			{
				return new AnchorName(value);
			}
			return Empty;
		}
	}
	public class AnchorNotFoundException : YamlException
	{
		public AnchorNotFoundException(string message)
			: base(message)
		{
		}

		public AnchorNotFoundException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public AnchorNotFoundException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[DebuggerStepThrough]
	internal readonly struct CharacterAnalyzer<TBuffer> where TBuffer : ILookAheadBuffer
	{
		public TBuffer Buffer { get; }

		public bool EndOfInput => Buffer.EndOfInput;

		public CharacterAnalyzer(TBuffer buffer)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer");
			}
			Buffer = buffer;
		}

		public char Peek(int offset)
		{
			return Buffer.Peek(offset);
		}

		public void Skip(int length)
		{
			Buffer.Skip(length);
		}

		public bool IsAlphaNumericDashOrUnderscore(int offset = 0)
		{
			char c = Buffer.Peek(offset);
			if ((c < '0' || c > '9') && (c < 'A' || c > 'Z') && (c < 'a' || c > 'z') && c != '_')
			{
				return c == '-';
			}
			return true;
		}

		public bool IsAscii(int offset = 0)
		{
			return Buffer.Peek(offset) <= '\u007f';
		}

		public bool IsPrintable(int offset = 0)
		{
			char c = Buffer.Peek(offset);
			switch (c)
			{
			default:
				if (c != '\u0085' && (c < '\u00a0' || c > '\ud7ff'))
				{
					if (c >= '\ue000')
					{
						return c <= '\ufffd';
					}
					return false;
				}
				break;
			case '\t':
			case '\n':
			case '\r':
			case ' ':
			case '!':
			case '"':
			case '#':
			case '$':
			case '%':
			case '&':
			case '\'':
			case '(':
			case ')':
			case '*':
			case '+':
			case ',':
			case '-':
			case '.':
			case '/':
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			case ':':
			case ';':
			case '<':
			case '=':
			case '>':
			case '?':
			case '@':
			case 'A':
			case 'B':
			case 'C':
			case 'D':
			case 'E':
			case 'F':
			case 'G':
			case 'H':
			case 'I':
			case 'J':
			case 'K':
			case 'L':
			case 'M':
			case 'N':
			case 'O':
			case 'P':
			case 'Q':
			case 'R':
			case 'S':
			case 'T':
			case 'U':
			case 'V':
			case 'W':
			case 'X':
			case 'Y':
			case 'Z':
			case '[':
			case '\\':
			case ']':
			case '^':
			case '_':
			case '`':
			case 'a':
			case 'b':
			case 'c':
			case 'd':
			case 'e':
			case 'f':
			case 'g':
			case 'h':
			case 'i':
			case 'j':
			case 'k':
			case 'l':
			case 'm':
			case 'n':
			case 'o':
			case 'p':
			case 'q':
			case 'r':
			case 's':
			case 't':
			case 'u':
			case 'v':
			case 'w':
			case 'x':
			case 'y':
			case 'z':
			case '{':
			case '|':
			case '}':
			case '~':
				break;
			}
			return true;
		}

		public bool IsDigit(int offset = 0)
		{
			char c = Buffer.Peek(offset);
			if (c >= '0')
			{
				return c <= '9';
			}
			return false;
		}

		public int AsDigit(int offset = 0)
		{
			return Buffer.Peek(offset) - 48;
		}

		public bool IsHex(int offset)
		{
			char c = Buffer.Peek(offset);
			if ((c < '0' || c > '9') && (c < 'A' || c > 'F'))
			{
				if (c >= 'a')
				{
					return c <= 'f';
				}
				return false;
			}
			return true;
		}

		public int AsHex(int offset)
		{
			char c = Buffer.Peek(offset);
			if (c <= '9')
			{
				return c - 48;
			}
			if (c <= 'F')
			{
				return c - 65 + 10;
			}
			return c - 97 + 10;
		}

		public bool IsSpace(int offset = 0)
		{
			return Check(' ', offset);
		}

		public bool IsZero(int offset = 0)
		{
			return Check('\0', offset);
		}

		public bool IsTab(int offset = 0)
		{
			return Check('\t', offset);
		}

		public bool IsWhite(int offset = 0)
		{
			if (!IsSpace(offset))
			{
				return IsTab(offset);
			}
			return true;
		}

		public bool IsBreak(int offset = 0)
		{
			return Check("\r\n\u0085\u2028\u2029", offset);
		}

		public bool IsCrLf(int offset = 0)
		{
			if (Check('\r', offset))
			{
				return Check('\n', offset + 1);
			}
			return false;
		}

		public bool IsBreakOrZero(int offset = 0)
		{
			if (!IsBreak(offset))
			{
				return IsZero(offset);
			}
			return true;
		}

		public bool IsWhiteBreakOrZero(int offset = 0)
		{
			if (!IsWhite(offset))
			{
				return IsBreakOrZero(offset);
			}
			return true;
		}

		public bool Check(char expected, int offset = 0)
		{
			return Buffer.Peek(offset) == expected;
		}

		public bool Check(string expectedCharacters, int offset = 0)
		{
			char c = Buffer.Peek(offset);
			return Polyfills.Contains(expectedCharacters, c);
		}
	}
	public static class Constants
	{
		public static readonly TagDirective[] DefaultTagDirectives = new TagDirective[2]
		{
			new TagDirective("!", "!"),
			new TagDirective("!!", "tag:yaml.org,2002:")
		};

		public const int MajorVersion = 1;

		public const int MinorVersion = 3;
	}
	[DebuggerStepThrough]
	public sealed class Cursor
	{
		public long Index { get; private set; }

		public long Line { get; private set; }

		public long LineOffset { get; private set; }

		public Cursor()
		{
			Line = 1L;
		}

		public Cursor(Cursor cursor)
		{
			Index = cursor.Index;
			Line = cursor.Line;
			LineOffset = cursor.LineOffset;
		}

		public Mark Mark()
		{
			return new Mark(Index, Line, LineOffset + 1);
		}

		public void Skip()
		{
			Index++;
			LineOffset++;
		}

		public void SkipLineByOffset(int offset)
		{
			Index += offset;
			Line++;
			LineOffset = 0L;
		}

		public void ForceSkipLineAfterNonBreak()
		{
			if (LineOffset != 0L)
			{
				Line++;
				LineOffset = 0L;
			}
		}
	}
	public class Emitter : IEmitter
	{
		private class AnchorData
		{
			public AnchorName Anchor;

			public bool IsAlias;
		}

		private class TagData
		{
			public string? Handle;

			public string? Suffix;
		}

		private class ScalarData
		{
			public string Value = string.Empty;

			public bool IsMultiline;

			public bool IsFlowPlainAllowed;

			public bool IsBlockPlainAllowed;

			public bool IsSingleQuotedAllowed;

			public bool IsBlockAllowed;

			public bool HasSingleQuotes;

			public ScalarStyle Style;
		}

		private static readonly Regex UriReplacer = new Regex("[^0-9A-Za-z_\\-;?@=$~\\\\\\)\\]/:&+,\\.\\*\\(\\[!]", RegexOptions.Compiled | RegexOptions.Singleline);

		private static readonly string[] NewLineSeparators = new string[3] { "\r\n", "\r", "\n" };

		private readonly TextWriter output;

		private readonly bool outputUsesUnicodeEncoding;

		private readonly int maxSimpleKeyLength;

		private readonly bool isCanonical;

		private readonly bool skipAnchorName;

		private readonly int bestIndent;

		private readonly int bestWidth;

		private EmitterState state;

		private readonly Stack<EmitterState> states = new Stack<EmitterState>();

		private readonly Queue<ParsingEvent> events = new Queue<ParsingEvent>();

		private readonly Stack<int> indents = new Stack<int>();

		private readonly TagDirectiveCollection tagDirectives = new TagDirectiveCollection();

		private int indent;

		private int flowLevel;

		private bool isMappingContext;

		private bool isSimpleKeyContext;

		private int column;

		private bool isWhitespace;

		private bool isIndentation;

		private readonly bool forceIndentLess;

		private readonly bool useUtf16SurrogatePair;

		private bool isDocumentEndWritten;

		private readonly AnchorData anchorData = new AnchorData();

		private readonly TagData tagData = new TagData();

		private readonly ScalarData scalarData = new ScalarData();

		public Emitter(TextWriter output)
			: this(output, EmitterSettings.Default)
		{
		}

		public Emitter(TextWriter output, int bestIndent)
			: this(output, bestIndent, int.MaxValue)
		{
		}

		public Emitter(TextWriter output, int bestIndent, int bestWidth)
			: this(output, bestIndent, bestWidth, isCanonical: false)
		{
		}

		public Emitter(TextWriter output, int bestIndent, int bestWidth, bool isCanonical)
			: this(output, new EmitterSettings(bestIndent, bestWidth, isCanonical, 1024))
		{
		}

		public Emitter(TextWriter output, EmitterSettings settings)
		{
			bestIndent = settings.BestIndent;
			bestWidth = settings.BestWidth;
			isCanonical = settings.IsCanonical;
			maxSimpleKeyLength = settings.MaxSimpleKeyLength;
			skipAnchorName = settings.SkipAnchorName;
			forceIndentLess = !settings.IndentSequences;
			useUtf16SurrogatePair = settings.UseUtf16SurrogatePairs;
			this.output = output;
			this.output.NewLine = settings.NewLine;
			outputUsesUnicodeEncoding = IsUnicode(output.Encoding);
		}

		public void Emit(ParsingEvent @event)
		{
			events.Enqueue(@event);
			while (!NeedMoreEvents())
			{
				ParsingEvent evt = events.Peek();
				try
				{
					AnalyzeEvent(evt);
					StateMachine(evt);
				}
				finally
				{
					events.Dequeue();
				}
			}
		}

		private bool NeedMoreEvents()
		{
			if (events.Count == 0)
			{
				return true;
			}
			int num;
			switch (events.Peek().Type)
			{
			case EventType.DocumentStart:
				num = 1;
				break;
			case EventType.SequenceStart:
				num = 2;
				break;
			case EventType.MappingStart:
				num = 3;
				break;
			default:
				return false;
			}
			if (events.Count > num)
			{
				return false;
			}
			int num2 = 0;
			foreach (ParsingEvent @event in events)
			{
				switch (@event.Type)
				{
				case EventType.DocumentStart:
				case EventType.SequenceStart:
				case EventType.MappingStart:
					num2++;
					break;
				case EventType.DocumentEnd:
				case EventType.SequenceEnd:
				case EventType.MappingEnd:
					num2--;
					break;
				}
				if (num2 == 0)
				{
					return false;
				}
			}
			return true;
		}

		private void AnalyzeEvent(ParsingEvent evt)
		{
			anchorData.Anchor = AnchorName.Empty;
			tagData.Handle = null;
			tagData.Suffix = null;
			if (evt is YamlDotNet.Core.Events.AnchorAlias anchorAlias)
			{
				AnalyzeAnchor(anchorAlias.Value, isAlias: true);
			}
			else if (evt is NodeEvent nodeEvent)
			{
				if (evt is YamlDotNet.Core.Events.Scalar scalar)
				{
					AnalyzeScalar(scalar);
				}
				AnalyzeAnchor(nodeEvent.Anchor, isAlias: false);
				if (!nodeEvent.Tag.IsEmpty && (isCanonical || nodeEvent.IsCanonical))
				{
					AnalyzeTag(nodeEvent.Tag);
				}
			}
		}

		private void AnalyzeAnchor(AnchorName anchor, bool isAlias)
		{
			anchorData.Anchor = anchor;
			anchorData.IsAlias = isAlias;
		}

		private void AnalyzeScalar(YamlDotNet.Core.Events.Scalar scalar)
		{
			string value = scalar.Value;
			scalarData.Value = value;
			if (value.Length == 0)
			{
				if (scalar.Tag == "tag:yaml.org,2002:null")
				{
					scalarData.IsMultiline = false;
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = true;
					scalarData.IsSingleQuotedAllowed = false;
					scalarData.IsBlockAllowed = false;
				}
				else
				{
					scalarData.IsMultiline = false;
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = false;
					scalarData.IsSingleQuotedAllowed = true;
					scalarData.IsBlockAllowed = false;
				}
				return;
			}
			bool flag = false;
			bool flag2 = false;
			if (value.StartsWith("---", StringComparison.Ordinal) || value.StartsWith("...", StringComparison.Ordinal))
			{
				flag = true;
				flag2 = true;
			}
			StringLookAheadBufferPool.BufferWrapper bufferWrapper = StringLookAheadBufferPool.Rent(value);
			try
			{
				CharacterAnalyzer<StringLookAheadBuffer> characterAnalyzer = new CharacterAnalyzer<StringLookAheadBuffer>(bufferWrapper.Buffer);
				bool flag3 = true;
				bool flag4 = characterAnalyzer.IsWhiteBreakOrZero(1);
				bool flag5 = false;
				bool flag6 = false;
				bool flag7 = false;
				bool flag8 = false;
				bool flag9 = false;
				bool flag10 = false;
				bool flag11 = false;
				bool flag12 = false;
				bool flag13 = false;
				bool flag14 = false;
				bool flag15 = false;
				bool flag16 = !ValueIsRepresentableInOutputEncoding(value);
				bool flag17 = false;
				bool flag18 = false;
				bool flag19 = true;
				while (!characterAnalyzer.EndOfInput)
				{
					if (flag19)
					{
						if (characterAnalyzer.Check("#,[]{}&*!|>\"%@`'"))
						{
							flag = true;
							flag2 = true;
							flag9 = characterAnalyzer.Check('\'');
							flag17 |= characterAnalyzer.Check('\'');
						}
						if (characterAnalyzer.Check("?:"))
						{
							flag = true;
							if (flag4)
							{
								flag2 = true;
							}
						}
						if (characterAnalyzer.Check('-') && flag4)
						{
							flag = true;
							flag2 = true;
						}
					}
					else
					{
						if (characterAnalyzer.Check(",?[]{}"))
						{
							flag = true;
						}
						if (characterAnalyzer.Check(':'))
						{
							flag = true;
							if (flag4)
							{
								flag2 = true;
							}
						}
						if (characterAnalyzer.Check('#') && flag3)
						{
							flag = true;
							flag2 = true;
						}
						flag17 |= characterAnalyzer.Check('\'');
					}
					if (!flag16 && !characterAnalyzer.IsPrintable())
					{
						flag16 = true;
					}
					if (characterAnalyzer.IsBreak())
					{
						flag15 = true;
					}
					if (characterAnalyzer.IsSpace())
					{
						if (flag19)
						{
							flag5 = true;
						}
						if (characterAnalyzer.Buffer.Position >= characterAnalyzer.Buffer.Length - 1)
						{
							flag7 = true;
						}
						if (flag13)
						{
							flag10 = true;
							flag14 = true;
						}
						flag12 = true;
						flag13 = false;
					}
					else if (characterAnalyzer.IsBreak())
					{
						if (flag19)
						{
							flag6 = true;
						}
						if (characterAnalyzer.Buffer.Position >= characterAnalyzer.Buffer.Length - 1)
						{
							flag8 = true;
						}
						if (flag12)
						{
							flag11 = true;
						}
						if (flag14)
						{
							flag18 = true;
						}
						flag12 = false;
						flag13 = true;
					}
					else
					{
						flag12 = false;
						flag13 = false;
						flag14 = false;
					}
					flag3 = characterAnalyzer.IsWhiteBreakOrZero();
					characterAnalyzer.Skip(1);
					if (!characterAnalyzer.EndOfInput)
					{
						flag4 = characterAnalyzer.IsWhiteBreakOrZero(1);
					}
					flag19 = false;
				}
				scalarData.IsFlowPlainAllowed = true;
				scalarData.IsBlockPlainAllowed = true;
				scalarData.IsSingleQuotedAllowed = true;
				scalarData.IsBlockAllowed = true;
				if (flag5 || flag6 || flag7 || flag8 || flag9)
				{
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = false;
				}
				if (flag7)
				{
					scalarData.IsBlockAllowed = false;
				}
				if (flag10)
				{
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = false;
					scalarData.IsSingleQuotedAllowed = false;
				}
				if (flag11 || flag16)
				{
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = false;
					scalarData.IsSingleQuotedAllowed = false;
				}
				if (flag18)
				{
					scalarData.IsBlockAllowed = false;
				}
				scalarData.IsMultiline = flag15;
				if (flag15)
				{
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = false;
				}
				if (flag)
				{
					scalarData.IsFlowPlainAllowed = false;
				}
				if (flag2)
				{
					scalarData.IsBlockPlainAllowed = false;
				}
				scalarData.HasSingleQuotes = flag17;
			}
			finally
			{
				((IDisposable)bufferWrapper).Dispose();
			}
		}

		private bool ValueIsRepresentableInOutputEncoding(string value)
		{
			if (outputUsesUnicodeEncoding)
			{
				return true;
			}
			try
			{
				byte[] bytes = output.Encoding.GetBytes(value);
				string @string = output.Encoding.GetString(bytes, 0, bytes.Length);
				return @string.Equals(value);
			}
			catch (EncoderFallbackException)
			{
				return false;
			}
			catch (ArgumentOutOfRangeException)
			{
				return false;
			}
		}

		private static bool IsUnicode(Encoding encoding)
		{
			if (!(encoding is UTF8Encoding) && !(encoding is UnicodeEncoding))
			{
				return encoding is UTF7Encoding;
			}
			return true;
		}

		private void AnalyzeTag(TagName tag)
		{
			tagData.Handle = tag.Value;
			foreach (TagDirective tagDirective in tagDirectives)
			{
				if (tag.Value.StartsWith(tagDirective.Prefix, StringComparison.Ordinal))
				{
					tagData.Handle = tagDirective.Handle;
					tagData.Suffix = tag.Value.Substring(tagDirective.Prefix.Length);
					break;
				}
			}
		}

		private void StateMachine(ParsingEvent evt)
		{
			if (evt is YamlDotNet.Core.Events.Comment comment)
			{
				EmitComment(comment);
				return;
			}
			switch (state)
			{
			case EmitterState.StreamStart:
				EmitStreamStart(evt);
				break;
			case EmitterState.FirstDocumentStart:
				EmitDocumentStart(evt, isFirst: true);
				break;
			case EmitterState.DocumentStart:
				EmitDocumentStart(evt, isFirst: false);
				break;
			case EmitterState.DocumentContent:
				EmitDocumentContent(evt);
				break;
			case EmitterState.DocumentEnd:
				EmitDocumentEnd(evt);
				break;
			case EmitterState.FlowSequenceFirstItem:
				EmitFlowSequenceItem(evt, isFirst: true);
				break;
			case EmitterState.FlowSequenceItem:
				EmitFlowSequenceItem(evt, isFirst: false);
				break;
			case EmitterState.FlowMappingFirstKey:
				EmitFlowMappingKey(evt, isFirst: true);
				break;
			case EmitterState.FlowMappingKey:
				EmitFlowMappingKey(evt, isFirst: false);
				break;
			case EmitterState.FlowMappingSimpleValue:
				EmitFlowMappingValue(evt, isSimple: true);
				break;
			case EmitterState.FlowMappingValue:
				EmitFlowMappingValue(evt, isSimple: false);
				break;
			case EmitterState.BlockSequenceFirstItem:
				EmitBlockSequenceItem(evt, isFirst: true);
				break;
			case EmitterState.BlockSequenceItem:
				EmitBlockSequenceItem(evt, isFirst: false);
				break;
			case EmitterState.BlockMappingFirstKey:
				EmitBlockMappingKey(evt, isFirst: true);
				break;
			case EmitterState.BlockMappingKey:
				EmitBlockMappingKey(evt, isFirst: false);
				break;
			case EmitterState.BlockMappingSimpleValue:
				EmitBlockMappingValue(evt, isSimple: true);
				break;
			case EmitterState.BlockMappingValue:
				EmitBlockMappingValue(evt, isSimple: false);
				break;
			case EmitterState.StreamEnd:
				throw new YamlException("Expected nothing after STREAM-END");
			default:
				throw new InvalidOperationException();
			}
		}

		private void EmitComment(YamlDotNet.Core.Events.Comment comment)
		{
			if (flowLevel > 0 || state == EmitterState.FlowMappingFirstKey || state == EmitterState.FlowSequenceFirstItem)
			{
				return;
			}
			string[] array = comment.Value.Split(NewLineSeparators, StringSplitOptions.None);
			if (comment.IsInline)
			{
				Write(" # ");
				Write(string.Join(" ", array));
			}
			else
			{
				bool flag = state == EmitterState.BlockMappingFirstKey;
				if (flag)
				{
					IncreaseIndent(isFlow: false, isIndentless: false);
				}
				string[] array2 = array;
				foreach (string value in array2)
				{
					WriteIndent();
					Write("# ");
					Write(value);
					WriteBreak();
				}
				if (flag)
				{
					indent = indents.Pop();
				}
			}
			isIndentation = true;
		}

		private void EmitStreamStart(ParsingEvent evt)
		{
			if (!(evt is YamlDotNet.Core.Events.StreamStart))
			{
				throw new ArgumentException("Expected STREAM-START.", "evt");
			}
			indent = -1;
			column = 0;
			isWhitespace = true;
			isIndentation = true;
			state = EmitterState.FirstDocumentStart;
		}

		private void EmitDocumentStart(ParsingEvent evt, bool isFirst)
		{
			if (evt is YamlDotNet.Core.Events.DocumentStart documentStart)
			{
				bool flag = documentStart.IsImplicit && isFirst && !isCanonical;
				TagDirectiveCollection tagDirectiveCollection = NonDefaultTagsAmong(documentStart.Tags);
				if (!isFirst && !isDocumentEndWritten && (documentStart.Version != null || tagDirectiveCollection.Count > 0))
				{
					isDocumentEndWritten = false;
					WriteIndicator("...", needWhitespace: true, whitespace: false, indentation: false);
					WriteIndent();
				}
				if (documentStart.Version != null)
				{
					AnalyzeVersionDirective(documentStart.Version);
					Version version = documentStart.Version.Version;
					flag = false;
					WriteIndicator("%YAML", needWhitespace: true, whitespace: false, indentation: false);
					WriteIndicator(string.Format(CultureInfo.InvariantCulture, "{0}.{1}", version.Major, version.Minor), needWhitespace: true, whitespace: false, indentation: false);
					WriteIndent();
				}
				foreach (TagDirective item in tagDirectiveCollection)
				{
					AppendTagDirectiveTo(item, allowDuplicates: false, tagDirectives);
				}
				TagDirective[] defaultTagDirectives = Constants.DefaultTagDirectives;
				foreach (TagDirective value in defaultTagDirectives)
				{
					AppendTagDirectiveTo(value, allowDuplicates: true, tagDirectives);
				}
				if (tagDirectiveCollection.Count > 0)
				{
					flag = false;
					TagDirective[] defaultTagDirectives2 = Constants.DefaultTagDirectives;
					foreach (TagDirective value2 in defaultTagDirectives2)
					{
						AppendTagDirectiveTo(value2, allowDuplicates: true, tagDirectiveCollection);
					}
					foreach (TagDirective item2 in tagDirectiveCollection)
					{
						WriteIndicator("%TAG", needWhitespace: true, whitespace: false, indentation: false);
						WriteTagHandle(item2.Handle);
						WriteTagContent(item2.Prefix, needsWhitespace: true);
						WriteIndent();
					}
				}
				if (CheckEmptyDocument())
				{
					flag = false;
				}
				if (!flag)
				{
					WriteIndent();
					WriteIndicator("---", needWhitespace: true, whitespace: false, indentation: false);
					if (isCanonical)
					{
						WriteIndent();
					}
				}
				state = EmitterState.DocumentContent;
			}
			else
			{
				if (!(evt is YamlDotNet.Core.Events.StreamEnd))
				{
					throw new YamlException("Expected DOCUMENT-START or STREAM-END");
				}
				state = EmitterState.StreamEnd;
			}
		}

		private static TagDirectiveCollection NonDefaultTagsAmong(IEnumerable<TagDirective>? tagCollection)
		{
			TagDirectiveCollection tagDirectiveCollection = new TagDirectiveCollection();
			if (tagCollection == null)
			{
				return tagDirectiveCollection;
			}
			foreach (TagDirective item2 in tagCollection)
			{
				AppendTagDirectiveTo(item2, allowDuplicates: false, tagDirectiveCollection);
			}
			TagDirective[] defaultTagDirectives = Constants.DefaultTagDirectives;
			foreach (TagDirective item in defaultTagDirectives)
			{
				tagDirectiveCollection.Remove(item);
			}
			return tagDirectiveCollection;
		}

		private static void AnalyzeVersionDirective(VersionDirective versionDirective)
		{
			if (versionDirective.Version.Major != 1 || versionDirective.Version.Minor > 3)
			{
				throw new YamlException("Incompatible %YAML directive");
			}
		}

		private static void AppendTagDirectiveTo(TagDirective value, bool allowDuplicates, TagDirectiveCollection tagDirectives)
		{
			if (tagDirectives.Contains(value))
			{
				if (!allowDuplicates)
				{
					throw new YamlException("Duplicate %TAG directive.");
				}
			}
			else
			{
				tagDirectives.Add(value);
			}
		}

		private void EmitDocumentContent(ParsingEvent evt)
		{
			states.Push(EmitterState.DocumentEnd);
			EmitNode(evt, isMapping: false, isSimpleKey: false);
		}

		private void EmitNode(ParsingEvent evt, bool isMapping, bool isSimpleKey)
		{
			isMappingContext = isMapping;
			isSimpleKeyContext = isSimpleKey;
			switch (evt.Type)
			{
			case EventType.Alias:
				EmitAlias();
				break;
			case EventType.Scalar:
				EmitScalar(evt);
				break;
			case EventType.SequenceStart:
				EmitSequenceStart(evt);
				break;
			case EventType.MappingStart:
				EmitMappingStart(evt);
				break;
			default:
				throw new YamlException($"Expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS, got {evt.Type}");
			}
		}

		private void EmitAlias()
		{
			ProcessAnchor();
			state = states.Pop();
		}

		private void EmitScalar(ParsingEvent evt)
		{
			SelectScalarStyle(evt);
			ProcessAnchor();
			ProcessTag();
			IncreaseIndent(isFlow: true, isIndentless: false);
			ProcessScalar();
			indent = indents.Pop();
			state = states.Pop();
		}

		private void SelectScalarStyle(ParsingEvent evt)
		{
			YamlDotNet.Core.Events.Scalar scalar = (YamlDotNet.Core.Events.Scalar)evt;
			ScalarStyle scalarStyle = scalar.Style;
			bool flag = tagData.Handle == null && tagData.Suffix == null;
			if (flag && !scalar.IsPlainImplicit && !scalar.IsQuotedImplicit)
			{
				throw new YamlException("Neither tag nor isImplicit flags are specified.");
			}
			if (scalarStyle == ScalarStyle.Any)
			{
				scalarStyle = ((!scalarData.IsMultiline) ? ScalarStyle.Plain : ScalarStyle.Folded);
			}
			if (isCanonical)
			{
				scalarStyle = ScalarStyle.DoubleQuoted;
			}
			if (isSimpleKeyContext && scalarData.IsMultiline)
			{
				scalarStyle = ScalarStyle.DoubleQuoted;
			}
			if (scalarStyle == ScalarStyle.Plain)
			{
				if ((flowLevel != 0 && !scalarData.IsFlowPlainAllowed) || (flowLevel == 0 && !scalarData.IsBlockPlainAllowed))
				{
					scalarStyle = ((scalarData.IsSingleQuotedAllowed && !scalarData.HasSingleQuotes) ? ScalarStyle.SingleQuoted : ScalarStyle.DoubleQuoted);
				}
				if (string.IsNullOrEmpty(scalarData.Value) && (flowLevel != 0 || isSimpleKeyContext))
				{
					scalarStyle = ScalarStyle.SingleQuoted;
				}
				if (flag && !scalar.IsPlainImplicit)
				{
					scalarStyle = ScalarStyle.SingleQuoted;
				}
			}
			if (scalarStyle == ScalarStyle.SingleQuoted && !scalarData.IsSingleQuotedAllowed)
			{
				scalarStyle = ScalarStyle.DoubleQuoted;
			}
			if ((scalarStyle == ScalarStyle.Literal || scalarStyle == ScalarStyle.Folded) && (!scalarData.IsBlockAllowed || flowLevel != 0 || isSimpleKeyContext))
			{
				scalarStyle = ScalarStyle.DoubleQuoted;
			}
			if (scalarStyle == ScalarStyle.ForcePlain)
			{
				scalarStyle = ScalarStyle.Plain;
			}
			scalarData.Style = scalarStyle;
		}

		private void ProcessScalar()
		{
			switch (scalarData.Style)
			{
			case ScalarStyle.Plain:
				WritePlainScalar(scalarData.Value, !isSimpleKeyContext);
				break;
			case ScalarStyle.SingleQuoted:
				WriteSingleQuotedScalar(scalarData.Value, !isSimpleKeyContext);
				break;
			case ScalarStyle.DoubleQuoted:
				WriteDoubleQuotedScalar(scalarData.Value, !isSimpleKeyContext);
				break;
			case ScalarStyle.Literal:
				WriteLiteralScalar(scalarData.Value);
				break;
			case ScalarStyle.Folded:
				WriteFoldedScalar(scalarData.Value);
				break;
			default:
				throw new InvalidOperationException();
			}
		}

		private void WritePlainScalar(string value, bool allowBreaks)
		{
			if (!isWhitespace)
			{
				Write(' ');
			}
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (IsSpace(c))
				{
					if (allowBreaks && !flag && column > bestWidth && i + 1 < value.Length && value[i + 1] != ' ')
					{
						WriteIndent();
					}
					else
					{
						Write(c);
					}
					flag = true;
					continue;
				}
				if (IsBreak(c, out var breakChar))
				{
					if (!flag2 && c == '\n')
					{
						WriteBreak();
					}
					WriteBreak(breakChar);
					isIndentation = true;
					flag2 = true;
					continue;
				}
				if (flag2)
				{
					WriteIndent();
				}
				Write(c);
				isIndentation = false;
				flag = false;
				flag2 = false;
			}
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteSingleQuotedScalar(string value, bool allowBreaks)
		{
			WriteIndicator("'", needWhitespace: true, whitespace: false, indentation: false);
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (c == ' ')
				{
					if (allowBreaks && !flag && column > bestWidth && i != 0 && i + 1 < value.Length && value[i + 1] != ' ')
					{
						WriteIndent();
					}
					else
					{
						Write(c);
					}
					flag = true;
					continue;
				}
				if (IsBreak(c, out var breakChar))
				{
					if (!flag2 && c == '\n')
					{
						WriteBreak();
					}
					WriteBreak(breakChar);
					isIndentation = true;
					flag2 = true;
					continue;
				}
				if (flag2)
				{
					WriteIndent();
				}
				if (c == '\'')
				{
					Write(c);
				}
				Write(c);
				isIndentation = false;
				flag = false;
				flag2 = false;
			}
			WriteIndicator("'", needWhitespace: false, whitespace: false, indentation: false);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteDoubleQuotedScalar(string value, bool allowBreaks)
		{
			WriteIndicator("\"", needWhitespace: true, whitespace: false, indentation: false);
			bool flag = false;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (IsPrintable(c) && !IsBreak(c, out var _))
				{
					switch (c)
					{
					case '"':
					case '\\':
						break;
					case ' ':
						if (allowBreaks && !flag && column > bestWidth && i > 0 && i + 1 < value.Length)
						{
							WriteIndent();
							if (value[i + 1] == ' ')
							{
								Write('\\');
							}
						}
						else
						{
							Write(c);
						}
						flag = true;
						continue;
					default:
						Write(c);
						flag = false;
						continue;
					}
				}
				Write('\\');
				switch (c)
				{
				case '\0':
					Write('0');
					break;
				case '\a':
					Write('a');
					break;
				case '\b':
					Write('b');
					break;
				case '\t':
					Write('t');
					break;
				case '\n':
					Write('n');
					break;
				case '\v':
					Write('v');
					break;
				case '\f':
					Write('f');
					break;
				case '\r':
					Write('r');
					break;
				case '\u001b':
					Write('e');
					break;
				case '"':
					Write('"');
					break;
				case '\\':
					Write('\\');
					break;
				case '\u0085':
					Write('N');
					break;
				case '\u00a0':
					Write('_');
					break;
				case '\u2028':
					Write('L');
					break;
				case '\u2029':
					Write('P');
					break;
				default:
				{
					ushort num = c;
					if (num <= 255)
					{
						Write('x');
						Write(num.ToString("X02", CultureInfo.InvariantCulture));
					}
					else if (IsHighSurrogate(c))
					{
						if (i + 1 >= value.Length || !IsLowSurrogate(value[i + 1]))
						{
							throw new SyntaxErrorException("While writing a quoted scalar, found an orphaned high surrogate.");
						}
						if (useUtf16SurrogatePair)
						{
							Write('u');
							Write(num.ToString("X04", CultureInfo.InvariantCulture));
							Write('\\');
							Write('u');
							Write(((ushort)value[i + 1]).ToString("X04", CultureInfo.InvariantCulture));
						}
						else
						{
							Write('U');
							Write(char.ConvertToUtf32(c, value[i + 1]).ToString("X08", CultureInfo.InvariantCulture));
						}
						i++;
					}
					else
					{
						Write('u');
						Write(num.ToString("X04", CultureInfo.InvariantCulture));
					}
					break;
				}
				}
				flag = false;
			}
			WriteIndicator("\"", needWhitespace: false, whitespace: false, indentation: false);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteLiteralScalar(string value)
		{
			bool flag = true;
			WriteIndicator("|", needWhitespace: true, whitespace: false, indentation: false);
			WriteBlockScalarHints(value);
			WriteBreak();
			isIndentation = true;
			isWhitespace = true;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (c == '\r' && i + 1 < value.Length && value[i + 1] == '\n')
				{
					continue;
				}
				if (IsBreak(c, out var breakChar))
				{
					WriteBreak(breakChar);
					isIndentation = true;
					flag = true;
					continue;
				}
				if (flag)
				{
					WriteIndent();
				}
				Write(c);
				isIndentation = false;
				flag = false;
			}
		}

		private void WriteFoldedScalar(string value)
		{
			bool flag = true;
			bool flag2 = true;
			WriteIndicator(">", needWhitespace: true, whitespace: false, indentation: false);
			WriteBlockScalarHints(value);
			WriteBreak();
			isIndentation = true;
			isWhitespace = true;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (IsBreak(c, out var breakChar))
				{
					if (c == '\r' && i + 1 < value.Length && value[i + 1] == '\n')
					{
						continue;
					}
					if (!flag && !flag2 && breakChar == '\n')
					{
						int j;
						char breakChar2;
						for (j = 0; i + j < value.Length && IsBreak(value[i + j], out breakChar2); j++)
						{
						}
						if (i + j < value.Length && !IsBlank(value[i + j]) && !IsBreak(value[i + j], out breakChar2))
						{
							WriteBreak();
						}
					}
					WriteBreak(breakChar);
					isIndentation = true;
					flag = true;
				}
				else
				{
					if (flag)
					{
						WriteIndent();
						flag2 = IsBlank(c);
					}
					if (!flag && c == ' ' && i + 1 < value.Length && value[i + 1] != ' ' && column > bestWidth)
					{
						WriteIndent();
					}
					else
					{
						Write(c);
					}
					isIndentation = false;
					flag = false;
				}
			}
		}

		private static bool IsSpace(char character)
		{
			return character == ' ';
		}

		private static bool IsBreak(char character, out char breakChar)
		{
			switch (character)
			{
			case '\n':
			case '\r':
			case '\u0085':
				breakChar = '\n';
				return true;
			case '\u2028':
			case '\u2029':
				breakChar = character;
				return true;
			default:
				breakChar = '\0';
				return false;
			}
		}

		private static bool IsBlank(char character)
		{
			if (character != ' ')
			{
				return character == '\t';
			}
			return true;
		}

		private static bool IsPrintable(char character)
		{
			switch (character)
			{
			default:
				if (character != '\u0085' && (character < '\u00a0' || character > '\ud7ff'))
				{
					if (character >= '\ue000')
					{
						return character <= '\ufffd';
					}
					return false;
				}
				break;
			case '\t':
			case '\n':
			case '\r':
			case ' ':
			case '!':
			case '"':
			case '#':
			case '$':
			case '%':
			case '&':
			case '\'':
			case '(':
			case ')':
			case '*':
			case '+':
			case ',':
			case '-':
			case '.':
			case '/':
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			case ':':
			case ';':
			case '<':
			case '=':
			case '>':
			case '?':
			case '@':
			case 'A':
			case 'B':
			case 'C':
			case 'D':
			case 'E':
			case 'F':
			case 'G':
			case 'H':
			case 'I':
			case 'J':
			case 'K':
			case 'L':
			case 'M':
			case 'N':
			case 'O':
			case 'P':
			case 'Q':
			case 'R':
			case 'S':
			case 'T':
			case 'U':
			case 'V':
			case 'W':
			case 'X':
			case 'Y':
			case 'Z':
			case '[':
			case '\\':
			case ']':
			case '^':
			case '_':
			case '`':
			case 'a':
			case 'b':
			case 'c':
			case 'd':
			case 'e':
			case 'f':
			case 'g':
			case 'h':
			case 'i':
			case 'j':
			case 'k':
			case 'l':
			case 'm':
			case 'n':
			case 'o':
			case 'p':
			case 'q':
			case 'r':
			case 's':
			case 't':
			case 'u':
			case 'v':
			case 'w':
			case 'x':
			case 'y':
			case 'z':
			case '{':
			case '|':
			case '}':
			case '~':
				break;
			}
			return true;
		}

		private static bool IsHighSurrogate(char c)
		{
			if ('\ud800' <= c)
			{
				return c <= '\udbff';
			}
			return false;
		}

		private static bool IsLowSurrogate(char c)
		{
			if ('\udc00' <= c)
			{
				return c <= '\udfff';
			}
			return false;
		}

		private void EmitSequenceStart(ParsingEvent evt)
		{
			ProcessAnchor();
			ProcessTag();
			SequenceStart sequenceStart = (SequenceStart)evt;
			if (flowLevel != 0 || isCanonical || sequenceStart.Style == SequenceStyle.Flow || CheckEmptySequence())
			{
				state = EmitterState.FlowSequenceFirstItem;
			}
			else
			{
				state = EmitterState.BlockSequenceFirstItem;
			}
		}

		private void EmitMappingStart(ParsingEvent evt)
		{
			ProcessAnchor();
			ProcessTag();
			MappingStart mappingStart = (MappingStart)evt;
			if (flowLevel != 0 || isCanonical || mappingStart.Style == MappingStyle.Flow || CheckEmptyMapping())
			{
				state = EmitterState.FlowMappingFirstKey;
			}
			else
			{
				state = EmitterState.BlockMappingFirstKey;
			}
		}

		private void ProcessAnchor()
		{
			if (!anchorData.Anchor.IsEmpty && !skipAnchorName)
			{
				WriteIndicator(anchorData.IsAlias ? "*" : "&", needWhitespace: true, whitespace: false, indentation: false);
				WriteAnchor(anchorData.Anchor);
			}
		}

		private void ProcessTag()
		{
			if (tagData.Handle == null && tagData.Suffix == null)
			{
				return;
			}
			if (tagData.Handle != null)
			{
				WriteTagHandle(tagData.Handle);
				if (tagData.Suffix != null)
				{
					WriteTagContent(tagData.Suffix, needsWhitespace: false);
				}
			}
			else
			{
				WriteIndicator("!<", needWhitespace: true, whitespace: false, indentation: false);
				WriteTagContent(tagData.Suffix, needsWhitespace: false);
				WriteIndicator(">", needWhitespace: false, whitespace: false, indentation: false);
			}
		}

		private void EmitDocumentEnd(ParsingEvent evt)
		{
			if (evt is YamlDotNet.Core.Events.DocumentEnd documentEnd)
			{
				WriteIndent();
				if (!documentEnd.IsImplicit)
				{
					WriteIndicator("...", needWhitespace: true, whitespace: false, indentation: false);
					WriteIndent();
					isDocumentEndWritten = true;
				}
				state = EmitterState.DocumentStart;
				tagDirectives.Clear();
				return;
			}
			throw new YamlException("Expected DOCUMENT-END.");
		}

		private void EmitFlowSequenceItem(ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				WriteIndicator("[", needWhitespace: true, whitespace: true, indentation: false);
				IncreaseIndent(isFlow: true, isIndentless: false);
				flowLevel++;
			}
			if (evt is SequenceEnd)
			{
				flowLevel--;
				indent = indents.Pop();
				if (isCanonical && !isFirst)
				{
					WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
					WriteIndent();
				}
				WriteIndicator("]", needWhitespace: false, whitespace: false, indentation: false);
				state = states.Pop();
			}
			else
			{
				if (!isFirst)
				{
					WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
				}
				if (isCanonical || column > bestWidth)
				{
					WriteIndent();
				}
				states.Push(EmitterState.FlowSequenceItem);
				EmitNode(evt, isMapping: false, isSimpleKey: false);
			}
		}

		private void EmitFlowMappingKey(ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				WriteIndicator("{", needWhitespace: true, whitespace: true, indentation: false);
				IncreaseIndent(isFlow: true, isIndentless: false);
				flowLevel++;
			}
			if (evt is MappingEnd)
			{
				flowLevel--;
				indent = indents.Pop();
				if (isCanonical && !isFirst)
				{
					WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
					WriteIndent();
				}
				WriteIndicator("}", needWhitespace: false, whitespace: false, indentation: false);
				state = states.Pop();
				return;
			}
			if (!isFirst)
			{
				WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
			}
			if (isCanonical || column > bestWidth)
			{
				WriteIndent();
			}
			if (!isCanonical && CheckSimpleKey())
			{
				states.Push(EmitterState.FlowMappingSimpleValue);
				EmitNode(evt, isMapping: true, isSimpleKey: true);
			}
			else
			{
				WriteIndicator("?", needWhitespace: true, whitespace: false, indentation: false);
				states.Push(EmitterState.FlowMappingValue);
				EmitNode(evt, isMapping: true, isSimpleKey: false);
			}
		}

		private void EmitFlowMappingValue(ParsingEvent evt, bool isSimple)
		{
			if (isSimple)
			{
				WriteIndicator(":", needWhitespace: false, whitespace: false, indentation: false);
			}
			else
			{
				if (isCanonical || column > bestWidth)
				{
					WriteIndent();
				}
				WriteIndicator(":", needWhitespace: true, whitespace: false, indentation: false);
			}
			states.Push(EmitterState.FlowMappingKey);
			EmitNode(evt, isMapping: true, isSimpleKey: false);
		}

		private void EmitBlockSequenceItem(ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				IncreaseIndent(isFlow: false, isMappingContext && !isIndentation);
			}
			if (evt is SequenceEnd)
			{
				indent = indents.Pop();
				state = states.Pop();
				return;
			}
			WriteIndent();
			WriteIndicator("-", needWhitespace: true, whitespace: false, indentation: true);
			states.Push(EmitterState.BlockSequenceItem);
			EmitNode(evt, isMapping: false, isSimpleKey: false);
		}

		private void EmitBlockMappingKey(ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				IncreaseIndent(isFlow: false, isIndentless: false);
			}
			if (evt is MappingEnd)
			{
				indent = indents.Pop();
				state = states.Pop();
				return;
			}
			WriteIndent();
			if (CheckSimpleKey())
			{
				states.Push(EmitterState.BlockMappingSimpleValue);
				EmitNode(evt, isMapping: true, isSimpleKey: true);
				WriteIndicator(":", needWhitespace: false, whitespace: false, indentation: false);
			}
			else
			{
				WriteIndicator("?", needWhitespace: true, whitespace: false, indentation: true);
				states.Push(EmitterState.BlockMappingValue);
				EmitNode(evt, isMapping: true, isSimpleKey: false);
			}
		}

		private void EmitBlockMappingValue(ParsingEvent evt, bool isSimple)
		{
			if (!isSimple)
			{
				WriteIndent();
				WriteIndicator(":", needWhitespace: true, whitespace: false, indentation: true);
			}
			states.Push(EmitterState.BlockMappingKey);
			EmitNode(evt, isMapping: true, isSimpleKey: false);
		}

		private void IncreaseIndent(bool isFlow, bool isIndentless)
		{
			indents.Push(indent);
			if (indent < 0)
			{
				indent = (isFlow ? bestIndent : 0);
			}
			else if (!isIndentless || !forceIndentLess)
			{
				indent += bestIndent;
			}
		}

		private bool CheckEmptyDocument()
		{
			int num = 0;
			foreach (ParsingEvent @event in events)
			{
				num++;
				if (num == 2)
				{
					if (@event is YamlDotNet.Core.Events.Scalar scalar)
					{
						return string.IsNullOrEmpty(scalar.Value);
					}
					break;
				}
			}
			return false;
		}

		private bool CheckSimpleKey()
		{
			if (events.Count < 1)
			{
				return false;
			}
			int num;
			switch (events.Peek().Type)
			{
			case EventType.Alias:
				num = AnchorNameLength(anchorData.Anchor);
				break;
			case EventType.Scalar:
				if (scalarData.IsMultiline)
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix) + SafeStringLength(scalarData.Value);
				break;
			case EventType.SequenceStart:
				if (!CheckEmptySequence())
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix);
				break;
			case EventType.MappingStart:
				if (!CheckEmptySequence())
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix);
				break;
			default:
				return false;
			}
			return num <= maxSimpleKeyLength;
		}

		private static int AnchorNameLength(AnchorName value)
		{
			if (!value.IsEmpty)
			{
				return value.Value.Length;
			}
			return 0;
		}

		private static int SafeStringLength(string? value)
		{
			return value?.Length ?? 0;
		}

		private bool CheckEmptySequence()
		{
			return CheckEmptyStructure<SequenceStart, SequenceEnd>();
		}

		private bool CheckEmptyMapping()
		{
			return CheckEmptyStructure<MappingStart, MappingEnd>();
		}

		private bool CheckEmptyStructure<TStart, TEnd>() where TStart : NodeEvent where TEnd : ParsingEvent
		{
			if (events.Count < 2)
			{
				return false;
			}
			using Queue<ParsingEvent>.Enumerator enumerator = events.GetEnumerator();
			return enumerator.MoveNext() && enumerator.Current is TStart && enumerator.MoveNext() && enumerator.Current is TEnd;
		}

		private void WriteBlockScalarHints(string value)
		{
			StringLookAheadBufferPool.BufferWrapper bufferWrapper = StringLookAheadBufferPool.Rent(value);
			try
			{
				CharacterAnalyzer<StringLookAheadBuffer> characterAnalyzer = new CharacterAnalyzer<StringLookAheadBuffer>(bufferWrapper.Buffer);
				if (characterAnalyzer.IsSpace() || characterAnalyzer.IsBreak())
				{
					int num = bestIndent;
					string indicator = num.ToString(CultureInfo.InvariantCulture);
					WriteIndicator(indicator, needWhitespace: false, whitespace: false, indentation: false);
				}
				string text = null;
				if (value.Length == 0 || !characterAnalyzer.IsBreak(value.Length - 1))
				{
					text = "-";
				}
				else if (value.Length >= 2 && characterAnalyzer.IsBreak(value.Length - 2))
				{
					text = "+";
				}
				if (text != null)
				{
					WriteIndicator(text, needWhitespace: false, whitespace: false, indentation: false);
				}
			}
			finally
			{
				((IDisposable)bufferWrapper).Dispose();
			}
		}

		private void WriteIndicator(string indicator, bool needWhitespace, bool whitespace, bool indentation)
		{
			if (needWhitespace && !isWhitespace)
			{
				Write(' ');
			}
			Write(indicator);
			isWhitespace = whitespace;
			isIndentation &= indentation;
		}

		private void WriteIndent()
		{
			int num = Math.Max(indent, 0);
			if (!isIndentation || column > num || (column == num && !isWhitespace))
			{
				WriteBreak();
			}
			while (column < num)
			{
				Write(' ');
			}
			isWhitespace = true;
			isIndentation = true;
		}

		private void WriteAnchor(AnchorName value)
		{
			Write(value.Value);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteTagHandle(string value)
		{
			if (!isWhitespace)
			{
				Write(' ');
			}
			Write(value);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteTagContent(string value, bool needsWhitespace)
		{
			if (needsWhitespace && !isWhitespace)
			{
				Write(' ');
			}
			Write(UrlEncode(value));
			isWhitespace = false;
			isIndentation = false;
		}

		private static string UrlEncode(string text)
		{
			return UriReplacer.Replace(text, delegate(Match match)
			{
				StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder = builderWrapper.Builder;
					byte[] bytes = Encoding.UTF8.GetBytes(match.Value);
					foreach (byte b in bytes)
					{
						builder.AppendFormat(CultureInfo.InvariantCulture, "%{0:X02}", b);
					}
					return builder.ToString();
				}
				finally
				{
					((IDisposable)builderWrapper).Dispose();
				}
			});
		}

		private void Write(char value)
		{
			output.Write(value);
			column++;
		}

		private void Write(string value)
		{
			output.Write(value);
			column += value.Length;
		}

		private void WriteBreak(char breakCharacter = '\n')
		{
			if (breakCharacter == '\n')
			{
				output.WriteLine();
			}
			else
			{
				output.Write(breakCharacter);
			}
			column = 0;
		}
	}
	public sealed class EmitterSettings
	{
		public static readonly EmitterSettings Default = new EmitterSettings();

		public int BestIndent { get; } = 2;


		public int BestWidth { get; } = int.MaxValue;


		public string NewLine { get; } = Environment.NewLine;


		public bool IsCanonical { get; }

		public bool SkipAnchorName { get; private set; }

		public int MaxSimpleKeyLength { get; } = 1024;


		public bool IndentSequences { get; }

		public bool UseUtf16SurrogatePairs { get; }

		public EmitterSettings()
		{
		}

		public EmitterSettings(int bestIndent, int bestWidth, bool isCanonical, int maxSimpleKeyLength, bool skipAnchorName = false, bool indentSequences = false, string? newLine = null, bool useUtf16SurrogatePairs = false)
		{
			if (bestIndent < 2 || bestIndent > 9)
			{
				throw new ArgumentOutOfRangeException("bestIndent", "BestIndent must be between 2 and 9, inclusive");
			}
			if (bestWidth <= bestIndent * 2)
			{
				throw new ArgumentOutOfRangeException("bestWidth", "BestWidth must be greater than BestIndent x 2.");
			}
			if (maxSimpleKeyLength < 0)
			{
				throw new ArgumentOutOfRangeException("maxSimpleKeyLength", "MaxSimpleKeyLength must be >= 0");
			}
			BestIndent = bestIndent;
			BestWidth = bestWidth;
			IsCanonical = isCanonical;
			MaxSimpleKeyLength = maxSimpleKeyLength;
			SkipAnchorName = skipAnchorName;
			IndentSequences = indentSequences;
			NewLine = newLine ?? Environment.NewLine;
			UseUtf16SurrogatePairs = useUtf16SurrogatePairs;
		}

		public EmitterSettings WithBestIndent(int bestIndent)
		{
			return new EmitterSettings(bestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithBestWidth(int bestWidth)
		{
			return new EmitterSettings(BestIndent, bestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithMaxSimpleKeyLength(int maxSimpleKeyLength)
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, maxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithNewLine(string newLine)
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, newLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings Canonical()
		{
			return new EmitterSettings(BestIndent, BestWidth, isCanonical: true, MaxSimpleKeyLength, SkipAnchorName);
		}

		public EmitterSettings WithoutAnchorName()
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, skipAnchorName: true, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithIndentedSequences()
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, indentSequences: true, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithUtf16SurrogatePairs()
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, useUtf16SurrogatePairs: true);
		}
	}
	internal enum EmitterState
	{
		StreamStart,
		StreamEnd,
		FirstDocumentStart,
		DocumentStart,
		DocumentContent,
		DocumentEnd,
		FlowSequenceFirstItem,
		FlowSequenceItem,
		FlowMappingFirstKey,
		FlowMappingKey,
		FlowMappingSimpleValue,
		FlowMappingValue,
		BlockSequenceFirstItem,
		BlockSequenceItem,
		BlockMappingFirstKey,
		BlockMappingKey,
		BlockMappingSimpleValue,
		BlockMappingValue
	}
	public sealed class ForwardAnchorNotSupportedException : YamlException
	{
		public ForwardAnchorNotSupportedException(string message)
			: base(message)
		{
		}

		public ForwardAnchorNotSupportedException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public ForwardAnchorNotSupportedException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	internal static class HashCode
	{
		public static int CombineHashCodes(int h1, int h2)
		{
			return ((h1 << 5) + h1) ^ h2;
		}

		public static int CombineHashCodes(int h1, object? o2)
		{
			return CombineHashCodes(h1, GetHashCode(o2));
		}

		private static int GetHashCode(object? obj)
		{
			return obj?.GetHashCode() ?? 0;
		}
	}
	public interface IEmitter
	{
		void Emit(ParsingEvent @event);
	}
	internal interface ILookAheadBuffer
	{
		bool EndOfInput { get; }

		char Peek(int offset);

		void Skip(int length);
	}
	public sealed class InsertionQueue<T> : IEnumerable<T>, IEnumerable
	{
		private const int DefaultInitialCapacity = 128;

		private T[] items;

		private int readPtr;

		private int writePtr;

		private int mask;

		private int count;

		public int Count => count;

		public int Capacity => items.Length;

		public InsertionQueue(int initialCapacity = 128)
		{
			if (initialCapacity <= 0)
			{
				throw new ArgumentOutOfRangeException("initialCapacity", "The initial capacity must be a positive number.");
			}
			if (!initialCapacity.IsPowerOfTwo())
			{
				throw new ArgumentException("The initial capacity must be a power of 2.", "initialCapacity");
			}
			items = new T[initialCapacity];
			readPtr = initialCapacity / 2;
			writePtr = initialCapacity / 2;
			mask = initialCapacity - 1;
		}

		public void Enqueue(T item)
		{
			ResizeIfNeeded();
			items[writePtr] = item;
			writePtr = (writePtr - 1) & mask;
			count++;
		}

		public T Dequeue()
		{
			if (count == 0)
			{
				throw new InvalidOperationException("The queue is empty");
			}
			T result = items[readPtr];
			readPtr = (readPtr - 1) & mask;
			count--;
			return result;
		}

		public void Insert(int index, T item)
		{
			if (index > count)
			{
				throw new InvalidOperationException("Cannot insert outside of the bounds of the queue");
			}
			ResizeIfNeeded();
			CalculateInsertionParameters(mask, count, index, ref readPtr, ref writePtr, out var insertPtr, out var copyIndex, out var copyOffset, out var copyLength);
			if (copyLength != 0)
			{
				Array.Copy(items, copyIndex, items, copyIndex + copyOffset, copyLength);
			}
			items[insertPtr] = item;
			count++;
		}

		private void ResizeIfNeeded()
		{
			int num = items.Length;
			if (count == num)
			{
				T[] destinationArray = new T[num * 2];
				int num2 = readPtr + 1;
				if (num2 > 0)
				{
					Array.Copy(items, 0, destinationArray, 0, num2);
				}
				writePtr += num;
				int num3 = num - num2;
				if (num3 > 0)
				{
					Array.Copy(items, readPtr + 1, destinationArray, writePtr + 1, num3);
				}
				items = destinationArray;
				mask = mask * 2 + 1;
			}
		}

		internal static void CalculateInsertionParameters(int mask, int count, int index, ref int readPtr, ref int writePtr, out int insertPtr, out int copyIndex, out int copyOffset, out int copyLength)
		{
			int num = (readPtr + 1) & mask;
			if (index == 0)
			{
				insertPtr = (readPtr = num);
				copyIndex = 0;
				copyOffset = 0;
				copyLength = 0;
				return;
			}
			insertPtr = (readPtr - index) & mask;
			if (index == count)
			{
				writePtr = (writePtr - 1) & mask;
				copyIndex = 0;
				copyOffset = 0;
				copyLength = 0;
				return;
			}
			int num2 = ((num >= insertPtr) ? (readPtr - insertPtr) : int.MaxValue);
			int num3 = ((writePtr <= insertPtr) ? (insertPtr - writePtr) : int.MaxValue);
			if (num2 <= num3)
			{
				insertPtr++;
				readPtr++;
				copyIndex = insertPtr;
				copyOffset = 1;
				copyLength = num2;
			}
			else
			{
				copyIndex = writePtr + 1;
				copyOffset = -1;
				copyLength = num3;
				writePtr = (writePtr - 1) & mask;
			}
		}

		public IEnumerator<T> GetEnumerator()
		{
			int ptr = readPtr;
			for (int i = 0; i < Count; i++)
			{
				yield return items[ptr];
				ptr = (ptr - 1) & mask;
			}
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public interface IParser
	{
		ParsingEvent? Current { get; }

		bool MoveNext();
	}
	public interface IScanner
	{
		Mark CurrentPosition { get; }

		Token? Current { get; }

		bool MoveNext();

		bool MoveNextWithoutConsuming();

		void ConsumeCurrent();
	}
	[DebuggerStepThrough]
	public sealed class LookAheadBuffer : ILookAheadBuffer
	{
		private readonly TextReader input;

		private readonly char[] buffer;

		private readonly int blockSize;

		private readonly int mask;

		private int firstIndex;

		private int writeOffset;

		private int count;

		private bool endOfInput;

		public bool EndOfInput
		{
			get
			{
				if (endOfInput)
				{
					return count == 0;
				}
				return false;
			}
		}

		public LookAheadBuffer(TextReader input, int capacity)
		{
			if (capacity < 1)
			{
				throw new ArgumentOutOfRangeException("capacity", "The capacity must be positive.");
			}
			if (!capacity.IsPowerOfTwo())
			{
				throw new ArgumentException("The capacity must be a power of 2.", "capacity");
			}
			this.input = input ?? throw new ArgumentNullException("input");
			blockSize = capacity;
			buffer = new char[capacity * 2];
			mask = capacity * 2 - 1;
		}

		private int GetIndexForOffset(int offset)
		{
			return (firstIndex + offset) & mask;
		}

		public char Peek(int offset)
		{
			if (offset >= count)
			{
				FillBuffer();
			}
			if (offset < count)
			{
				return buffer[(firstIndex + offset) & mask];
			}
			return '\0';
		}

		public void Cache(int length)
		{
			if (length >= count)
			{
				FillBuffer();
			}
		}

		private void FillBuffer()
		{
			if (endOfInput)
			{
				return;
			}
			int num = blockSize;
			do
			{
				int num2 = input.Read(buffer, writeOffset, num);
				if (num2 == 0)
				{
					endOfInput = true;
					return;
				}
				num -= num2;
				writeOffset += num2;
				count += num2;
			}
			while (num > 0);
			if (writeOffset == buffer.Length)
			{
				writeOffset = 0;
			}
		}

		public void Skip(int length)
		{
			if (length < 1 || length > blockSize)
			{
				throw new ArgumentOutOfRangeException("length", "The length must be between 1 and the number of characters in the buffer. Use the Peek() and / or Cache() methods to fill the buffer.");
			}
			firstIndex = GetIndexForOffset(length);
			count -= length;
		}
	}
	public readonly struct Mark : IEquatable<Mark>, IComparable<Mark>, IComparable
	{
		public static readonly Mark Empty = new Mark(0L, 1L, 1L);

		public long Index { get; }

		public long Line { get; }

		public long Column { get; }

		public Mark(long index, long line, long column)
		{
			if (index < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("index", "Index must be greater than or equal to zero.");
			}
			if (line < 1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("line", "Line must be greater than or equal to 1.");
			}
			if (column < 1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("column", "Column must be greater than or equal to 1.");
			}
			Index = index;
			Line = line;
			Column = column;
		}

		public override string ToString()
		{
			return $"Line: {Line}, Col: {Column}, Idx: {Index}";
		}

		public override bool Equals(object? obj)
		{
			return Equals((Mark)(obj ?? ((object)Empty)));
		}

		public bool Equals(Mark other)
		{
			if (Index == other.Index && Line == other.Line)
			{
				return Column == other.Column;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return HashCode.CombineHashCodes(Index.GetHashCode(), HashCode.CombineHashCodes(Line.GetHashCode(), Column.GetHashCode()));
		}

		public int CompareTo(object? obj)
		{
			return CompareTo((Mark)(obj ?? ((object)Empty)));
		}

		public int CompareTo(Mark other)
		{
			int num = Line.CompareTo(other.Line);
			if (num == 0)
			{
				num = Column.CompareTo(other.Column);
			}
			return num;
		}

		public static bool operator ==(Mark left, Mark right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(Mark left, Mark right)
		{
			return !(left == right);
		}

		public static bool operator <(Mark left, Mark right)
		{
			return left.CompareTo(right) < 0;
		}

		public static bool operator <=(Mark left, Mark right)
		{
			return left.CompareTo(right) <= 0;
		}

		public static bool operator >(Mark left, Mark right)
		{
			return left.CompareTo(right) > 0;
		}

		public static bool operator >=(Mark left, Mark right)
		{
			return left.CompareTo(right) >= 0;
		}
	}
	public sealed class MaximumRecursionLevelReachedException : YamlException
	{
		public MaximumRecursionLevelReachedException(string message)
			: base(message)
		{
		}

		public MaximumRecursionLevelReachedException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public MaximumRecursionLevelReachedException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	public sealed class MergingParser : IParser
	{
		private sealed class ParsingEventCollection : IEnumerable<LinkedListNode<ParsingEvent>>, IEnumerable
		{
			private readonly LinkedList<ParsingEvent> events;

			private readonly HashSet<LinkedListNode<ParsingEvent>> deleted;

			private readonly Dictionary<AnchorName, LinkedListNode<ParsingEvent>> references;

			public ParsingEventCollection()
			{
				events = new LinkedList<ParsingEvent>();
				deleted = new HashSet<LinkedListNode<ParsingEvent>>();
				references = new Dictionary<AnchorName, LinkedListNode<ParsingEvent>>();
			}

			public void AddAfter(LinkedListNode<ParsingEvent> node, IEnumerable<ParsingEvent> items)
			{
				foreach (ParsingEvent item in items)
				{
					node = events.AddAfter(node, item);
				}
			}

			public void Add(ParsingEvent item)
			{
				LinkedListNode<ParsingEvent> node = events.AddLast(item);
				AddReference(item, node);
			}

			public void MarkDeleted(LinkedListNode<ParsingEvent> node)
			{
				deleted.Add(node);
			}

			public bool IsDeleted(LinkedListNode<ParsingEvent> node)
			{
				return deleted.Contains(node);
			}

			public void CleanMarked()
			{
				foreach (LinkedListNode<ParsingEvent> item in deleted)
				{
					events.Remove(item);
				}
			}

			public IEnumerable<LinkedListNode<ParsingEvent>> FromAnchor(AnchorName anchor)
			{
				LinkedListNode<ParsingEvent> next = references[anchor].Next;
				return Enumerate(next);
			}

			public IEnumerator<LinkedListNode<ParsingEvent>> GetEnumerator()
			{
				return Enumerate(events.First).GetEnumerator();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			private static IEnumerable<LinkedListNode<ParsingEvent>> Enumerate(LinkedListNode<ParsingEvent>? node)
			{
				while (node != null)
				{
					yield return node;
					node = node.Next;
				}
			}

			private void AddReference(ParsingEvent item, LinkedListNode<ParsingEvent> node)
			{
				if (item is MappingStart mappingStart)
				{
					AnchorName anchor = mappingStart.Anchor;
					if (!anchor.IsEmpty)
					{
						references[anchor] = node;
					}
				}
			}
		}

		private sealed class ParsingEventCloner : IParsingEventVisitor
		{
			private ParsingEvent? clonedEvent;

			public ParsingEvent Clone(ParsingEvent e)
			{
				e.Accept(this);
				if (clonedEvent == null)
				{
					throw new InvalidOperationException($"Could not clone event of type '{e.Type}'");
				}
				return clonedEvent;
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.AnchorAlias e)
			{
				clonedEvent = new YamlDotNet.Core.Events.AnchorAlias(e.Value, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.StreamStart e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.StreamEnd e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.DocumentStart e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.DocumentEnd e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.Scalar e)
			{
				clonedEvent = new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, e.Tag, e.Value, e.Style, e.IsPlainImplicit, e.IsQuotedImplicit, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(SequenceStart e)
			{
				clonedEvent = new SequenceStart(AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(SequenceEnd e)
			{
				Mark start = e.Start;
				Mark end = e.End;
				clonedEvent = new SequenceEnd(in start, in end);
			}

			void IParsingEventVisitor.Visit(MappingStart e)
			{
				clonedEvent = new MappingStart(AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(MappingEnd e)
			{
				Mark start = e.Start;
				Mark end = e.End;
				clonedEvent = new MappingEnd(in start, in end);
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.Comment e)
			{
				throw new NotSupportedException();
			}
		}

		private readonly ParsingEventCollection events;

		private readonly IParser innerParser;

		private IEnumerator<LinkedListNode<ParsingEvent>> iterator;

		private bool merged;

		public ParsingEvent? Current => iterator.Current?.Value;

		public MergingParser(IParser innerParser)
		{
			events = new ParsingEventCollection();
			merged = false;
			iterator = events.GetEnumerator();
			this.innerParser = innerParser;
		}

		public bool MoveNext()
		{
			if (!merged)
			{
				Merge();
				events.CleanMarked();
				iterator = events.GetEnumerator();
				merged = true;
			}
			return iterator.MoveNext();
		}

		private void Merge()
		{
			while (innerParser.MoveNext())
			{
				events.Add(innerParser.Current);
			}
			foreach (LinkedListNode<ParsingEvent> @event in events)
			{
				if (IsMergeToken(@event))
				{
					events.MarkDeleted(@event);
					if (!HandleMerge(@event.Next))
					{
						Mark start = @event.Value.Start;
						Mark end = @event.Value.End;
						throw new SemanticErrorException(in start, in end, "Unrecognized merge key pattern");
					}
				}
			}
		}

		private bool HandleMerge(LinkedListNode<ParsingEvent>? node)
		{
			if (node == null)
			{
				return false;
			}
			if (node.Value is YamlDotNet.Core.Events.AnchorAlias anchorAlias)
			{
				return HandleAnchorAlias(node, node, anchorAlias);
			}
			if (node.Value is SequenceStart)
			{
				return HandleSequence(node);
			}
			return false;
		}

		private bool HandleMergeSequence(LinkedListNode<ParsingEvent> sequenceStart, LinkedListNode<ParsingEvent>? node)
		{
			if (node == null)
			{
				return false;
			}
			if (node.Value is YamlDotNet.Core.Events.AnchorAlias anchorAlias)
			{
				return HandleAnchorAlias(sequenceStart, node, anchorAlias);
			}
			if (node.Value is SequenceStart)
			{
				return HandleSequence(node);
			}
			return false;
		}

		private static bool IsMergeToken(LinkedListNode<ParsingEvent> node)
		{
			if (node.Value is YamlDotNet.Core.Events.Scalar scalar)
			{
				return scalar.Value == "<<";
			}
			return false;
		}

		private bool HandleAnchorAlias(LinkedListNode<ParsingEvent> node, LinkedListNode<ParsingEvent> anchorNode, YamlDotNet.Core.Events.AnchorAlias anchorAlias)
		{
			IEnumerable<ParsingEvent> mappingEvents = GetMappingEvents(anchorAlias.Value);
			events.AddAfter(node, mappingEvents);
			events.MarkDeleted(anchorNode);
			return true;
		}

		private bool HandleSequence(LinkedListNode<ParsingEvent> node)
		{
			events.MarkDeleted(node);
			LinkedListNode<ParsingEvent> linkedListNode = node;
			while (linkedListNode != null)
			{
				if (linkedListNode.Value is SequenceEnd)
				{
					events.MarkDeleted(linkedListNode);
					return true;
				}
				LinkedListNode<ParsingEvent> next = linkedListNode.Next;
				HandleMergeSequence(node, next);
				linkedListNode = next;
			}
			return true;
		}

		private IEnumerable<ParsingEvent> GetMappingEvents(AnchorName anchor)
		{
			ParsingEventCloner @object = new ParsingEventCloner();
			int nesting = 0;
			return (from e in events.FromAnchor(anchor)
				where !events.IsDeleted(e)
				select e.Value).TakeWhile((ParsingEvent e) => (nesting += e.NestingIncrease) >= 0).Select(@object.Clone);
		}
	}
	public class Parser : IParser
	{
		private class EventQueue
		{
			private readonly Queue<ParsingEvent> highPriorityEvents = new Queue<ParsingEvent>();

			private readonly Queue<ParsingEvent> normalPriorityEvents = new Queue<ParsingEvent>();

			public int Count => highPriorityEvents.Count + normalPriorityEvents.Count;

			public void Enqueue(ParsingEvent @event)
			{
				EventType type = @event.Type;
				if (type == EventType.StreamStart || type == EventType.DocumentStart)
				{
					highPriorityEvents.Enqueue(@event);
				}
				else
				{
					normalPriorityEvents.Enqueue(@event);
				}
			}

			public ParsingEvent Dequeue()
			{
				if (highPriorityEvents.Count <= 0)
				{
					return normalPriorityEvents.Dequeue();
				}
				return highPriorityEvents.Dequeue();
			}
		}

		private readonly Stack<ParserState> states = new Stack<ParserState>();

		private readonly TagDirectiveCollection tagDirectives = new TagDirectiveCollection();

		private ParserState state;

		private readonly IScanner scanner;

		private Token? currentToken;

		private VersionDirective? version;

		private readonly EventQueue pendingEvents = new EventQueue();

		public ParsingEvent? Current { get; private set; }

		private Token? GetCurrentToken()
		{
			if (currentToken == null)
			{
				while (scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (!(currentToken is YamlDotNet.Core.Tokens.Comment comment))
					{
						break;
					}
					pendingEvents.Enqueue(new YamlDotNet.Core.Events.Comment(comment.Value, comment.IsInline, comment.Start, comment.End));
					scanner.ConsumeCurrent();
				}
			}
			return currentToken;
		}

		public Parser(TextReader input)
			: this(new Scanner(input))
		{
		}

		public Parser(IScanner scanner)
		{
			this.scanner = scanner;
		}

		public bool MoveNext()
		{
			if (state == ParserState.StreamEnd)
			{
				Current = null;
				return false;
			}
			if (pendingEvents.Count == 0)
			{
				pendingEvents.Enqueue(StateMachine());
			}
			Current = pendingEvents.Dequeue();
			return true;
		}

		private ParsingEvent StateMachine()
		{
			return state switch
			{
				ParserState.StreamStart => ParseStreamStart(), 
				ParserState.ImplicitDocumentStart => ParseDocumentStart(isImplicit: true), 
				ParserState.DocumentStart => ParseDocumentStart(isImplicit: false), 
				ParserState.DocumentContent => ParseDocumentContent(), 
				ParserState.DocumentEnd => ParseDocumentEnd(), 
				ParserState.BlockNode => ParseNode(isBlock: true, isIndentlessSequence: false), 
				ParserState.BlockNodeOrIndentlessSequence => ParseNode(isBlock: true, isIndentlessSequence: true), 
				ParserState.FlowNode => ParseNode(isBlock: false, isIndentlessSequence: false), 
				ParserState.BlockSequenceFirstEntry => ParseBlockSequenceEntry(isFirst: true), 
				ParserState.BlockSequenceEntry => ParseBlockSequenceEntry(isFirst: false), 
				ParserState.IndentlessSequenceEntry => ParseIndentlessSequenceEntry(), 
				ParserState.BlockMappingFirstKey => ParseBlockMappingKey(isFirst: true), 
				ParserState.BlockMappingKey => ParseBlockMappingKey(isFirst: false), 
				ParserState.BlockMappingValue => ParseBlockMappingValue(), 
				ParserState.FlowSequenceFirstEntry => ParseFlowSequenceEntry(isFirst: true), 
				ParserState.FlowSequenceEntry => ParseFlowSequenceEntry(isFirst: false), 
				ParserState.FlowSequenceEntryMappingKey => ParseFlowSequenceEntryMappingKey(), 
				ParserState.FlowSequenceEntryMappingValue => ParseFlowSequenceEntryMappingValue(), 
				ParserState.FlowSequenceEntryMappingEnd => ParseFlowSequenceEntryMappingEnd(), 
				ParserState.FlowMappingFirstKey => ParseFlowMappingKey(isFirst: true), 
				ParserState.FlowMappingKey => ParseFlowMappingKey(isFirst: false), 
				ParserState.FlowMappingValue => ParseFlowMappingValue(isEmpty: false), 
				ParserState.FlowMappingEmptyValue => ParseFlowMappingValue(isEmpty: true), 
				_ => throw new InvalidOperationException(), 
			};
		}

		private void Skip()
		{
			if (currentToken != null)
			{
				currentToken = null;
				scanner.ConsumeCurrent();
			}
		}

		private YamlDotNet.Core.Events.StreamStart ParseStreamStart()
		{
			Token token = GetCurrentToken();
			Mark start;
			Mark end;
			if (!(token is YamlDotNet.Core.Tokens.StreamStart streamStart))
			{
				start = token?.Start ?? Mark.Empty;
				end = token?.End ?? Mark.Empty;
				throw new SemanticErrorException(in start, in end, "Did not find expected <stream-start>.");
			}
			Skip();
			state = ParserState.ImplicitDocumentStart;
			start = streamStart.Start;
			end = streamStart.End;
			return new YamlDotNet.Core.Events.StreamStart(in start, in end);
		}

		private ParsingEvent ParseDocumentStart(bool isImplicit)
		{
			if (currentToken is VersionDirective)
			{
				throw new SyntaxErrorException("While parsing a document start node, could not find document end marker before version directive.");
			}
			Token token = GetCurrentToken();
			if (!isImplicit)
			{
				while (token is YamlDotNet.Core.Tokens.DocumentEnd)
				{
					Skip();
					token = GetCurrentToken();
				}
			}
			if (token == null)
			{
				throw new SyntaxErrorException("Reached the end of the stream while parsing a document start.");
			}
			if (token is YamlDotNet.Core.Tokens.Scalar && (state == ParserState.ImplicitDocumentStart || state == ParserState.DocumentStart))
			{
				isImplicit = true;
			}
			if ((isImplicit && !(token is VersionDirective) && !(token is TagDirective) && !(token is YamlDotNet.Core.Tokens.DocumentStart) && !(token is YamlDotNet.Core.Tokens.StreamEnd) && !(token is YamlDotNet.Core.Tokens.DocumentEnd)) || token is BlockMappingStart)
			{
				TagDirectiveCollection tags = new TagDirectiveCollection();
				ProcessDirectives(tags);
				states.Push(ParserState.DocumentEnd);
				state = ParserState.BlockNode;
				return new YamlDotNet.Core.Events.DocumentStart(null, tags, isImplicit: true, token.Start, token.End);
			}
			Mark start2;
			Mark end;
			if (!(token is YamlDotNet.Core.Tokens.StreamEnd) && !(token is YamlDotNet.Core.Tokens.DocumentEnd))
			{
				Mark start = token.Start;
				TagDirectiveCollection tags2 = new TagDirectiveCollection();
				VersionDirective versionDirective = ProcessDirectives(tags2);
				token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a document start");
				if (!(token is YamlDotNet.Core.Tokens.DocumentStart))
				{
					start2 = token.Start;
					end = token.End;
					throw new SemanticErrorException(in start2, in end, "Did not find expected <document start>.");
				}
				states.Push(ParserState.DocumentEnd);
				state = ParserState.DocumentContent;
				Mark end2 = token.End;
				Skip();
				return new YamlDotNet.Core.Events.DocumentStart(versionDirective, tags2, isImplicit: false, start, end2);
			}
			if (token is YamlDotNet.Core.Tokens.DocumentEnd)
			{
				Skip();
			}
			state = ParserState.StreamEnd;
			token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a document start");
			start2 = token.Start;
			end = token.End;
			YamlDotNet.Core.Events.StreamEnd result = new YamlDotNet.Core.Events.StreamEnd(in start2, in end);
			if (scanner.MoveNextWithoutConsuming())
			{
				throw new InvalidOperationException("The scanner should contain no more tokens.");
			}
			return result;
		}

		private VersionDirective? ProcessDirectives(TagDirectiveCollection tags)
		{
			bool flag = false;
			VersionDirective result = null;
			while (true)
			{
				if (GetCurrentToken() is VersionDirective versionDirective)
				{
					if (version != null)
					{
						Mark start = versionDirective.Start;
						Mark end = versionDirective.End;
						throw new SemanticErrorException(in start, in end, "Found duplicate %YAML directive.");
					}
					if (versionDirective.Version.Major != 1 || versionDirective.Version.Minor > 3)
					{
						Mark start = versionDirective.Start;
						Mark end = versionDirective.End;
						throw new SemanticErrorException(in start, in end, "Found incompatible YAML document.");
					}
					result = (version = versionDirective);
					flag = true;
				}
				else
				{
					if (!(GetCurrentToken() is TagDirective tagDirective))
					{
						break;
					}
					if (tags.Contains(tagDirective.Handle))
					{
						Mark start = tagDirective.Start;
						Mark end = tagDirective.End;
						throw new SemanticErrorException(in start, in end, "Found duplicate %TAG directive.");
					}
					tags.Add(tagDirective);
					flag = true;
				}
				Skip();
			}
			if (GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentStart && (version == null || (version.Version.Major == 1 && version.Version.Minor > 1)))
			{
				if (GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentStart && version == null)
				{
					version = new VersionDirective(new Version(1, 2));
				}
				flag = true;
			}
			AddTagDirectives(tags, Constants.DefaultTagDirectives);
			if (flag)
			{
				tagDirectives.Clear();
			}
			AddTagDirectives(tagDirectives, tags);
			return result;
		}

		private static void AddTagDirectives(TagDirectiveCollection directives, IEnumerable<TagDirective> source)
		{
			foreach (TagDirective item in source)
			{
				if (!directives.Contains(item))
				{
					directives.Add(item);
				}
			}
		}

		private ParsingEvent ParseDocumentContent()
		{
			if (GetCurrentToken() is VersionDirective || GetCurrentToken() is TagDirective || GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentStart || GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentEnd || GetCurrentToken() is YamlDotNet.Core.Tokens.StreamEnd)
			{
				state = states.Pop();
				Mark position = scanner.CurrentPosition;
				return ProcessEmptyScalar(in position);
			}
			return ParseNode(isBlock: true, isIndentlessSequence: false);
		}

		private static YamlDotNet.Core.Events.Scalar ProcessEmptyScalar(in Mark position)
		{
			return new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, string.Empty, ScalarStyle.Plain, isPlainImplicit: true, isQuotedImplicit: false, position, position);
		}

		private ParsingEvent ParseNode(bool isBlock, bool isIndentlessSequence)
		{
			Mark start;
			Mark end;
			if (GetCurrentToken() is Error error)
			{
				start = error.Start;
				end = error.End;
				throw new SemanticErrorException(in start, in end, error.Value);
			}
			Token token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a node");
			if (token is YamlDotNet.Core.Tokens.AnchorAlias anchorAlias)
			{
				state = states.Pop();
				ParsingEvent result = new YamlDotNet.Core.Events.AnchorAlias(anchorAlias.Value, anchorAlias.Start, anchorAlias.End);
				Skip();
				return result;
			}
			Mark start2 = token.Start;
			AnchorName anchor = AnchorName.Empty;
			TagName tag = TagName.Empty;
			Anchor anchor2 = null;
			Tag tag2 = null;
			while (true)
			{
				if (anchor.IsEmpty && token is Anchor anchor3)
				{
					anchor2 = anchor3;
					anchor = anchor3.Value;
					Skip();
				}
				else
				{
					if (!tag.IsEmpty || !(token is Tag tag3))
					{
						if (token is Anchor anchor4)
						{
							start = anchor4.Start;
							end = anchor4.End;
							throw new SemanticErrorException(in start, in end, "While parsing a node, found more than one anchor.");
						}
						if (token is YamlDotNet.Core.Tokens.AnchorAlias anchorAlias2)
						{
							start = anchorAlias2.Start;
							end = anchorAlias2.End;
							throw new SemanticErrorException(in start, in end, "While parsing a node, did not find expected token.");
						}
						if (!(token is Error error2))
						{
							break;
						}
						if (tag2 != null && anchor2 != null && !anchor.IsEmpty)
						{
							return new YamlDotNet.Core.Events.Scalar(anchor, default(TagName), string.Empty, ScalarStyle.Any, isPlainImplicit: false, isQuotedImplicit: false, anchor2.Start, anchor2.End);
						}
						start = error2.Start;
						end = error2.End;
						throw new SemanticErrorException(in start, in end, error2.Value);
					}
					tag2 = tag3;
					if (string.IsNullOrEmpty(tag3.Handle))
					{
						tag = new TagName(tag3.Suffix);
					}
					else
					{
						if (!tagDirectives.Contains(tag3.Handle))
						{
							start = tag3.Start;
							end = tag3.End;
							throw new SemanticErrorException(in start, in end, "While parsing a node, found undefined tag handle.");
						}
						tag = new TagName(tagDirectives[tag3.Handle].Prefix + tag3.Suffix);
					}
					Skip();
				}
				token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a node");
			}
			bool isEmpty = tag.IsEmpty;
			if (isIndentlessSequence && GetCurrentToken() is BlockEntry)
			{
				state = ParserState.IndentlessSequenceEntry;
				return new SequenceStart(anchor, tag, isEmpty, SequenceStyle.Block, start2, token.End);
			}
			if (token is YamlDotNet.Core.Tokens.Scalar scalar)
			{
				bool isPlainImplicit = false;
				bool isQuotedImplicit = false;
				if ((scalar.Style == ScalarStyle.Plain && tag.IsEmpty) || tag.IsNonSpecific)
				{
					isPlainImplicit = true;
				}
				else if (tag.IsEmpty)
				{
					isQuotedImplicit = true;
				}
				state = states.Pop();
				Skip();
				ParsingEvent result2 = new YamlDotNet.Core.Events.Scalar(anchor, tag, scalar.Value, scalar.Style, isPlainImplicit, isQuotedImplicit, start2, scalar.End, scalar.IsKey);
				if (!anchor.IsEmpty && scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (currentToken is Error)
					{
						Error error3 = currentToken as Error;
						start = error3.Start;
						end = error3.End;
						throw new SemanticErrorException(in start, in end, error3.Value);
					}
				}
				if (state == ParserState.FlowMappingKey && !(scanner.Current is FlowMappingEnd) && scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (currentToken != null && !(currentToken is FlowEntry) && !(currentToken is FlowMappingEnd))
					{
						start = currentToken.Start;
						end = currentToken.End;
						throw new SemanticErrorException(in start, in end, "While parsing a flow mapping, did not find expected ',' or '}'.");
					}
				}
				return result2;
			}
			if (token is FlowSequenceStart flowSequenceStart)
			{
				state = ParserState.FlowSequenceFirstEntry;
				return new SequenceStart(anchor, tag, isEmpty, SequenceStyle.Flow, start2, flowSequenceStart.End);
			}
			if (token is FlowMappingStart flowMappingStart)
			{
				state = ParserState.FlowMappingFirstKey;
				return new MappingStart(anchor, tag, isEmpty, MappingStyle.Flow, start2, flowMappingStart.End);
			}
			if (isBlock)
			{
				if (token is BlockSequenceStart blockSequenceStart)
				{
					state = ParserState.BlockSequenceFirstEntry;
					return new SequenceStart(anchor, tag, isEmpty, SequenceStyle.Block, start2, blockSequenceStart.End);
				}
				if (token is BlockMappingStart blockMappingStart)
				{
					state = ParserState.BlockMappingFirstKey;
					return new MappingStart(anchor, tag, isEmpty, MappingStyle.Block, start2, blockMappingStart.End);
				}
			}
			if (!anchor.IsEmpty || !tag.IsEmpty)
			{
				state = states.Pop();
				return new YamlDotNet.Core.Events.Scalar(anchor, tag, string.Empty, ScalarStyle.Plain, isEmpty, isQuotedImplicit: false, start2, token.End);
			}
			start = token.Start;
			end = token.End;
			throw new SemanticErrorException(in start, in end, "While parsing a node, did not find expected node content.");
		}

		private YamlDotNet.Core.Events.DocumentEnd ParseDocumentEnd()
		{
			Token token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a document end");
			bool isImplicit = true;
			Mark start = token.Start;
			Mark end = start;
			if (token is YamlDotNet.Core.Tokens.DocumentEnd)
			{
				end = token.End;
				Skip();
				isImplicit = false;
			}
			else if (!(currentToken is YamlDotNet.Core.Tokens.StreamEnd) && !(currentToken is YamlDotNet.Core.Tokens.DocumentStart) && !(currentToken is FlowSequenceEnd) && !(currentToken is VersionDirective) && (!(Current is YamlDotNet.Core.Events.Scalar) || !(currentToken is Error)))
			{
				throw new SemanticErrorException(in start, in end, "Did not find expected <document end>.");
			}
			if (version != null && version.Version.Major == 1 && version.Version.Minor > 1)
			{
				version = null;
			}
			state = ParserState.DocumentStart;
			return new YamlDotNet.Core.Events.DocumentEnd(isImplicit, start, end);
		}

		private ParsingEvent ParseBlockSequenceEntry(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			if (token is BlockEntry blockEntry)
			{
				Mark position = blockEntry.End;
				Skip();
				token = GetCurrentToken();
				if (!(token is BlockEntry) && !(token is BlockEnd))
				{
					states.Push(ParserState.BlockSequenceEntry);
					return ParseNode(isBlock: true, isIndentlessSequence: false);
				}
				state = ParserState.BlockSequenceEntry;
				return ProcessEmptyScalar(in position);
			}
			Mark start;
			Mark end;
			if (token is BlockEnd blockEnd)
			{
				state = states.Pop();
				start = blockEnd.Start;
				end = blockEnd.End;
				ParsingEvent result = new SequenceEnd(in start, in end);
				Skip();
				return result;
			}
			start = token?.Start ?? Mark.Empty;
			end = token?.End ?? Mark.Empty;
			throw new SemanticErrorException(in start, in end, "While parsing a block collection, did not find expected '-' indicator.");
		}

		private ParsingEvent ParseIndentlessSequenceEntry()
		{
			Token token = GetCurrentToken();
			if (token is BlockEntry blockEntry)
			{
				Mark position = blockEntry.End;
				Skip();
				token = GetCurrentToken();
				if (!(token is BlockEntry) && !(token is Key) && !(token is Value) && !(token is BlockEnd))
				{
					states.Push(ParserState.IndentlessSequenceEntry);
					return ParseNode(isBlock: true, isIndentlessSequence: false);
				}
				state = ParserState.IndentlessSequenceEntry;
				return ProcessEmptyScalar(in position);
			}
			state = states.Pop();
			Mark start = token?.Start ?? Mark.Empty;
			Mark end = token?.End ?? Mark.Empty;
			return new SequenceEnd(in start, in end);
		}

		private ParsingEvent ParseBlockMappingKey(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			if (token is Key key)
			{
				Mark position = key.End;
				Skip();
				token = GetCurrentToken();
				if (!(token is Key) && !(token is Value) && !(token is BlockEnd))
				{
					states.Push(ParserState.BlockMappingValue);
					return ParseNode(isBlock: true, isIndentlessSequence: true);
				}
				state = ParserState.BlockMappingValue;
				return ProcessEmptyScalar(in position);
			}
			Mark position2;
			if (token is Value value)
			{
				Skip();
				position2 = value.End;
				return ProcessEmptyScalar(in position2);
			}
			if (token is YamlDotNet.Core.Tokens.AnchorAlias anchorAlias)
			{
				Skip();
				return new YamlDotNet.Core.Events.AnchorAlias(anchorAlias.Value, anchorAlias.Start, anchorAlias.End);
			}
			Mark end;
			if (token is BlockEnd blockEnd)
			{
				state = states.Pop();
				position2 = blockEnd.Start;
				end = blockEnd.End;
				ParsingEvent result = new MappingEnd(in position2, in end);
				Skip();
				return result;
			}
			if (GetCurrentToken() is Error error)
			{
				position2 = error.Start;
				end = error.End;
				throw new SyntaxErrorException(in position2, in end, error.Value);
			}
			position2 = token?.Start ?? Mark.Empty;
			end = token?.End ?? Mark.Empty;
			throw new SemanticErrorException(in position2, in end, "While parsing a block mapping, did not find expected key.");
		}

		private ParsingEvent ParseBlockMappingValue()
		{
			Token token = GetCurrentToken();
			if (token is Value value)
			{
				Mark position = value.End;
				Skip();
				token = GetCurrentToken();
				if (!(token is Key) && !(token is Value) && !(token is BlockEnd))
				{
					states.Push(ParserState.BlockMappingKey);
					return ParseNode(isBlock: true, isIndentlessSequence: true);
				}
				state = ParserState.BlockMappingKey;
				return ProcessEmptyScalar(in position);
			}
			Mark start;
			if (token is Error error)
			{
				start = error.Start;
				Mark end = error.End;
				throw new SemanticErrorException(in start, in end, error.Value);
			}
			state = ParserState.BlockMappingKey;
			start = token?.Start ?? Mark.Empty;
			return ProcessEmptyScalar(in start);
		}

		private ParsingEvent ParseFlowSequenceEntry(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			Mark start;
			Mark end;
			ParsingEvent result;
			if (!(token is FlowSequenceEnd))
			{
				if (!isFirst)
				{
					if (!(token is FlowEntry))
					{
						start = token?.Start ?? Mark.Empty;
						end = token?.End ?? Mark.Empty;
						throw new SemanticErrorException(in start, in end, "While parsing a flow sequence, did not find expected ',' or ']'.");
					}
					Skip();
					token = GetCurrentToken();
				}
				if (token is Key)
				{
					state = ParserState.FlowSequenceEntryMappingKey;
					result = new MappingStart(AnchorName.Empty, TagName.Empty, isImplicit: true, MappingStyle.Flow);
					Skip();
					return result;
				}
				if (!(token is FlowSequenceEnd))
				{
					states.Push(ParserState.FlowSequenceEntry);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = states.Pop();
			start = token?.Start ?? Mark.Empty;
			end = token?.End ?? Mark.Empty;
			result = new SequenceEnd(in start, in end);
			Skip();
			return result;
		}

		private ParsingEvent ParseFlowSequenceEntryMappingKey()
		{
			Token token = GetCurrentToken();
			if (!(token is Value) && !(token is FlowEntry) && !(token is FlowSequenceEnd))
			{
				states.Push(ParserState.FlowSequenceEntryMappingValue);
				return ParseNode(isBlock: false, isIndentlessSequence: false);
			}
			Mark position = token?.End ?? Mark.Empty;
			Skip();
			state = ParserState.FlowSequenceEntryMappingValue;
			return ProcessEmptyScalar(in position);
		}

		private ParsingEvent ParseFlowSequenceEntryMappingValue()
		{
			Token token = GetCurrentToken();
			if (token is Value)
			{
				Skip();
				token = GetCurrentToken();
				if (!(token is FlowEntry) && !(token is FlowSequenceEnd))
				{
					states.Push(ParserState.FlowSequenceEntryMappingEnd);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = ParserState.FlowSequenceEntryMappingEnd;
			Mark position = token?.Start ?? Mark.Empty;
			return ProcessEmptyScalar(in position);
		}

		private MappingEnd ParseFlowSequenceEntryMappingEnd()
		{
			state = ParserState.FlowSequenceEntry;
			Token token = GetCurrentToken();
			Mark start = token?.Start ?? Mark.Empty;
			Mark end = token?.End ?? Mark.Empty;
			return new MappingEnd(in start, in end);
		}

		private ParsingEvent ParseFlowMappingKey(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			Mark start;
			Mark end;
			if (!(token is FlowMappingEnd))
			{
				if (!isFirst)
				{
					if (token is FlowEntry)
					{
						Skip();
						token = GetCurrentToken();
					}
					else if (!(token is YamlDotNet.Core.Tokens.Scalar))
					{
						start = token?.Start ?? Mark.Empty;
						end = token?.End ?? Mark.Empty;
						throw new SemanticErrorException(in start, in end, "While parsing a flow mapping,  did not find expected ',' or '}'.");
					}
				}
				if (token is Key)
				{
					Skip();
					token = GetCurrentToken();
					if (!(token is Value) && !(token is FlowEntry) && !(token is FlowMappingEnd))
					{
						states.Push(ParserState.FlowMappingValue);
						return ParseNode(isBlock: false, isIndentlessSequence: false);
					}
					state = ParserState.FlowMappingValue;
					start = token?.Start ?? Mark.Empty;
					return ProcessEmptyScalar(in start);
				}
				if (token is YamlDotNet.Core.Tokens.Scalar)
				{
					states.Push(ParserState.FlowMappingValue);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
				if (!(token is FlowMappingEnd))
				{
					states.Push(ParserState.FlowMappingEmptyValue);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = states.Pop();
			Skip();
			start = token?.Start ?? Mark.Empty;
			end = token?.End ?? Mark.Empty;
			return new MappingEnd(in start, in end);
		}

		private ParsingEvent ParseFlowMappingValue(bool isEmpty)
		{
			Token token = GetCurrentToken();
			if (!isEmpty && token is Value)
			{
				Skip();
				token = GetCurrentToken();
				if (!(token is FlowEntry) && !(token is FlowMappingEnd))
				{
					states.Push(ParserState.FlowMappingKey);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = ParserState.FlowMappingKey;
			if (!isEmpty && token is YamlDotNet.Core.Tokens.Scalar scalar)
			{
				Skip();
				return new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, scalar.Value, scalar.Style, isPlainImplicit: false, isQuotedImplicit: false, token.Start, scalar.End);
			}
			Mark position = token?.Start ?? Mark.Empty;
			return ProcessEmptyScalar(in position);
		}
	}
	public static class ParserExtensions
	{
		public static T Consume<T>(this IParser parser) where T : ParsingEvent
		{
			T result = parser.Require<T>();
			parser.MoveNext();
			return result;
		}

		public static bool TryConsume<T>(this IParser parser, [MaybeNullWhen(false)] out T @event) where T : ParsingEvent
		{
			if (parser.Accept<T>(out @event))
			{
				parser.MoveNext();
				return true;
			}
			return false;
		}

		public static T Require<T>(this IParser parser) where T : ParsingEvent
		{
			if (!parser.Accept<T>(out var @event))
			{
				ParsingEvent current = parser.Current;
				if (current == null)
				{
					throw new YamlException("Expected '" + typeof(T).Name + "', got nothing.");
				}
				Mark start = current.Start;
				Mark end = current.End;
				throw new YamlException(in start, in end, $"Expected '{typeof(T).Name}', got '{current.GetType().Name}' (at {current.Start}).");
			}
			return @event;
		}

		public static bool Accept<T>(this IParser parser, [MaybeNullWhen(false)] out T @event) where T : ParsingEvent
		{
			if (parser.Current == null && !parser.MoveNext())
			{
				throw new EndOfStreamException();
			}
			if (parser.Current is T val)
			{
				@event = val;
				return true;
			}
			@event = null;
			return false;
		}

		public static void SkipThisAndNestedEvents(this IParser parser)
		{
			int num = 0;
			do
			{
				ParsingEvent parsingEvent = parser.Consume<ParsingEvent>();
				num += parsingEvent.NestingIncrease;
			}
			while (num > 0);
		}

		[Obsolete("Please use Consume<T>() instead")]
		public static T Expect<T>(this IParser parser) where T : ParsingEvent
		{
			return parser.Consume<T>();
		}

		[Obsolete("Please use TryConsume<T>(out var evt) instead")]
		[return: MaybeNull]
		public static T? Allow<T>(this IParser parser) where T : ParsingEvent
		{
			if (!parser.TryConsume<T>(out var @event))
			{
				return null;
			}
			return @event;
		}

		[Obsolete("Please use Accept<T>(out var evt) instead")]
		[return: MaybeNull]
		public static T? Peek<T>(this IParser parser) where T : ParsingEvent
		{
			if (!parser.Accept<T>(out var @event))
			{
				return null;
			}
			return @event;
		}

		[Obsolete("Please use TryConsume<T>(out var evt) or Accept<T>(out var evt) instead")]
		public static bool Accept<T>(this IParser parser) where T : ParsingEvent
		{
			T @event;
			return parser.Accept<T>(out @event);
		}

		public static bool TryFindMappingEntry(this IParser parser, Func<YamlDotNet.Core.Events.Scalar, bool> selector, [MaybeNullWhen(false)] out YamlDotNet.Core.Events.Scalar? key, [MaybeNullWhen(false)] out ParsingEvent? value)
		{
			if (parser.TryConsume<MappingStart>(out var _))
			{
				while (parser.Current != null)
				{
					ParsingEvent current = parser.Current;
					if (!(current is YamlDotNet.Core.Events.Scalar scalar))
					{
						if (current is MappingStart || current is SequenceStart)
						{
							parser.SkipThisAndNestedEvents();
						}
						else
						{
							parser.MoveNext();
						}
						continue;
					}
					bool flag = selector(scalar);
					parser.MoveNext();
					if (flag)
					{
						value = parser.Current;
						key = scalar;
						return true;
					}
					parser.SkipThisAndNestedEvents();
				}
			}
			key = null;
			value = null;
			return false;
		}
	}
	internal enum ParserState
	{
		StreamStart,
		StreamEnd,
		ImplicitDocumentStart,
		DocumentStart,
		DocumentContent,
		DocumentEnd,
		BlockNode,
		BlockNodeOrIndentlessSequence,
		FlowNode,
		BlockSequenceFirstEntry,
		BlockSequenceEntry,
		IndentlessSequenceEntry,
		BlockMappingFirstKey,
		BlockMappingKey,
		BlockMappingValue,
		FlowSequenceFirstEntry,
		FlowSequenceEntry,
		FlowSequenceEntryMappingKey,
		FlowSequenceEntryMappingValue,
		FlowSequenceEntryMappingEnd,
		FlowMappingFirstKey,
		FlowMappingKey,
		FlowMappingValue,
		FlowMappingEmptyValue
	}
	internal sealed class RecursionLevel
	{
		private int current;

		public int Maximum { get; }

		public RecursionLevel(int maximum)
		{
			Maximum = maximum;
		}

		public void Increment()
		{
			if (!TryIncrement())
			{
				throw new MaximumRecursionLevelReachedException("Maximum level of recursion reached");
			}
		}

		public bool TryIncrement()
		{
			if (current < Maximum)
			{
				current++;
				return true;
			}
			return false;
		}

		public void Decrement()
		{
			if (current == 0)
			{
				throw new InvalidOperationException("Attempted to decrement RecursionLevel to a negative value");
			}
			current--;
		}
	}
	public enum ScalarStyle
	{
		Any,
		Plain,
		SingleQuoted,
		DoubleQuoted,
		Literal,
		Folded,
		ForcePlain
	}
	public class Scanner : IScanner
	{
		private const int MaxVersionNumberLength = 9;

		private static readonly SortedDictionary<char, char> SimpleEscapeCodes = new SortedDictionary<char, char>
		{
			{ '0', '\0' },
			{ 'a', '\a' },
			{ 'b', '\b' },
			{ 't', '\t' },
			{ '\t', '\t' },
			{ 'n', '\n' },
			{ 'v', '\v' },
			{ 'f', '\f' },
			{ 'r', '\r' },
			{ 'e', '\u001b' },
			{ ' ', ' ' },
			{ '"', '"' },
			{ '\\', '\\' },
			{ '/', '/' },
			{ 'N', '\u0085' },
			{ '_', '\u00a0' },
			{ 'L', '\u2028' },
			{ 'P', '\u2029' }
		};

		private readonly Stack<long> indents = new Stack<long>();

		private readonly InsertionQueue<Token> tokens = new InsertionQueue<Token>();

		private readonly Stack<SimpleKey> simpleKeys = new Stack<SimpleKey>();

		private readonly CharacterAnalyzer<LookAheadBuffer> analyzer;

		private readonly Cursor cursor;

		private bool streamStartProduced;

		private bool streamEndProduced;

		private bool plainScalarFollowedByComment;

		private bool flowCollectionFetched;

		private bool startFlowCollectionFetched;

		private long indent = -1L;

		private bool flowScalarFetched;

		private bool simpleKeyAllowed;

		private int flowLevel;

		private int tokensParsed;

		private bool tokenAvailable;

		private Token? previous;

		private Anchor? previousAnchor;

		private YamlDotNet.Core.Tokens.Scalar? lastScalar;

		private readonly int maxKeySize;

		private static readonly byte[] EmptyBytes = Array.Empty<byte>();

		public bool SkipComments { get; private set; }

		public Token? Current { get; private set; }

		public Mark CurrentPosition => cursor.Mark();

		private bool IsDocumentStart()
		{
			if (!analyzer.EndOfInput && cursor.LineOffset == 0L && analyzer.Check('-') && analyzer.Check('-', 1) && analyzer.Check('-', 2))
			{
				return analyzer.IsWhiteBreakOrZero(3);
			}
			return false;
		}

		private bool IsDocumentEnd()
		{
			if (!analyzer.EndOfInput && cursor.LineOffset == 0L && analyzer.Check('.') && analyzer.Check('.', 1) && analyzer.Check('.', 2))
			{
				return analyzer.IsWhiteBreakOrZero(3);
			}
			return false;
		}

		private bool IsDocumentIndicator()
		{
			if (!IsDocumentStart())
			{
				return IsDocumentEnd();
			}
			return true;
		}

		public Scanner(TextReader input, bool skipComments = true)
			: this(input, skipComments, 1024)
		{
		}

		public Scanner(TextReader input, bool skipComments, int maxKeySize)
		{
			analyzer = new CharacterAnalyzer<LookAheadBuffer>(new LookAheadBuffer(input, 1024));
			cursor = new Cursor();
			SkipComments = skipComments;
			this.maxKeySize = maxKeySize;
		}

		public bool MoveNext()
		{
			if (Current != null)
			{
				ConsumeCurrent();
			}
			return MoveNextWithoutConsuming();
		}

		public bool MoveNextWithoutConsuming()
		{
			if (!tokenAvailable && !streamEndProduced)
			{
				FetchMoreTokens();
			}
			if (tokens.Count > 0)
			{
				Current = tokens.Dequeue();
				tokenAvailable = false;
				return true;
			}
			Current = null;
			return false;
		}

		public void ConsumeCurrent()
		{
			tokensParsed++;
			tokenAvailable = false;
			previous = Current;
			Current = null;
		}

		private char ReadCurrentCharacter()
		{
			char result = analyzer.Peek(0);
			Skip();
			return result;
		}

		private char ReadLine()
		{
			if (analyzer.Check("\r\n\u0085"))
			{
				SkipLine();
				return '\n';
			}
			char result = analyzer.Peek(0);
			SkipLine();
			return result;
		}

		private void FetchMoreTokens()
		{
			while (true)
			{
				bool flag = false;
				if (tokens.Count == 0)
				{
					flag = true;
				}
				else
				{
					foreach (SimpleKey simpleKey in simpleKeys)
					{
						if (simpleKey.IsPossible && simpleKey.TokenNumber == tokensParsed)
						{
							flag = true;
							break;
						}
					}
				}
				if (!flag)
				{
					break;
				}
				FetchNextToken();
			}
			tokenAvailable = true;
		}

		private static bool StartsWith(StringBuilder what, char start)
		{
			if (what.Length > 0)
			{
				return what[0] == start;
			}
			return false;
		}

		private void StaleSimpleKeys()
		{
			foreach (SimpleKey simpleKey in simpleKeys)
			{
				if (simpleKey.IsPossible && (simpleKey.Line < cursor.Line || simpleKey.Index + maxKeySize < cursor.Index))
				{
					if (simpleKey.IsRequired)
					{
						Mark mark = cursor.Mark();
						tokens.Enqueue(new Error("While scanning a simple key, could not find expected ':'.", mark, mark));
					}
					simpleKey.MarkAsImpossible();
				}
			}
		}

		private void FetchNextToken()
		{
			if (!streamStartProduced)
			{
				FetchStreamStart();
				return;
			}
			ScanToNextToken();
			StaleSimpleKeys();
			UnrollIndent(cursor.LineOffset);
			analyzer.Buffer.Cache(4);
			if (analyzer.Buffer.EndOfInput)
			{
				lastScalar = null;
				FetchStreamEnd();
			}
			if (cursor.LineOffset == 0L && analyzer.Check('%'))
			{
				lastScalar = null;
				FetchDirective();
				return;
			}
			if (IsDocumentStart())
			{
				lastScalar = null;
				FetchDocumentIndicator(isStartToken: true);
				return;
			}
			if (IsDocumentEnd())
			{
				lastScalar = null;
				FetchDocumentIndicator(isStartToken: false);
				return;
			}
			if (analyzer.Check('['))
			{
				lastScalar = null;
				FetchFlowCollectionStart(isSequenceToken: true);
				return;
			}
			if (analyzer.Check('{'))
			{
				lastScalar = null;
				FetchFlowCollectionStart(isSequenceToken: false);
				return;
			}
			if (analyzer.Check(']'))
			{
				lastScalar = null;
				FetchFlowCollectionEnd(isSequenceToken: true);
				return;
			}
			if (analyzer.Check('}'))
			{
				lastScalar = null;
				FetchFlowCollectionEnd(isSequenceToken: false);
				return;
			}
			if (analyzer.Check(','))
			{
				lastScalar = null;
				FetchFlowEntry();
				return;
			}
			if (analyzer.Check('-'))
			{
				if (analyzer.IsWhiteBreakOrZero(1))
				{
					FetchBlockEntry();
					return;
				}
				if (flowLevel > 0 && analyzer.Check(",[]{}", 1))
				{
					tokens.Enqueue(new Error("Invalid key indicator format.", cursor.Mark(), cursor.Mark()));
				}
			}
			if (analyzer.Check('?') && (flowLevel > 0 || analyzer.IsWhiteBreakOrZero(1)) && analyzer.IsWhiteBreakOrZero(1))
			{
				FetchKey();
			}
			else if (analyzer.Check(':') && (flowLevel > 0 || analyzer.IsWhiteBreakOrZero(1)) && (!simpleKeyAllowed || flowLevel <= 0) && (!flowScalarFetched || !analyzer.Check(':', 1)) && (analyzer.IsWhiteBreakOrZero(1) || analyzer.Check(',', 1) || flowScalarFetched || flowCollectionFetched || startFlowCollectionFetched))
			{
				if (lastScalar != null)
				{
					lastScalar.IsKey = true;
					lastScalar = null;
				}
				FetchValue();
			}
			else if (analyzer.Check('*'))
			{
				FetchAnchor(isAlias: true);
			}
			else if (analyzer.Check('&'))
			{
				FetchAnchor(isAlias: false);
			}
			else if (analyzer.Check('!'))
			{
				FetchTag();
			}
			else if (analyzer.Check('|') && flowLevel == 0)
			{
				FetchBlockScalar(isLiteral: true);
			}
			else if (analyzer.Check('>') && flowLevel == 0)
			{
				FetchBlockScalar(isLiteral: false);
			}
			else if (analyzer.Check('\''))
			{
				FetchQuotedScalar(isSingleQuoted: true);
			}
			else if (analyzer.Check('"'))
			{
				FetchQuotedScalar(isSingleQuoted: false);
			}
			else if ((!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("-?:,[]{}#&*!|>'\"%@`")) || (analyzer.Check('-') && !analyzer.IsWhite(1)) || (analyzer.Check("?:") && !analyzer.IsWhiteBreakOrZero(1)) || (simpleKeyAllowed && flowLevel > 0))
			{
				if (plainScalarFollowedByComment)
				{
					Mark mark = cursor.Mark();
					tokens.Enqueue(new Error("While scanning plain scalar, found a comment between adjacent scalars.", mark, mark));
				}
				if ((flowScalarFetched || (flowCollectionFetched && !startFlowCollectionFetched)) && analyzer.Check(':'))
				{
					Skip();
				}
				flowScalarFetched = false;
				flowCollectionFetched = false;
				startFlowCollectionFetched = false;
				plainScalarFollowedByComment = false;
				FetchPlainScalar();
			}
			else
			{
				if (simpleKeyAllowed && indent >= cursor.LineOffset && analyzer.IsTab())
				{
					throw new SyntaxErrorException("While scanning a mapping, found invalid tab as indentation.");
				}
				if (!analyzer.IsWhiteBreakOrZero())
				{
					Mark start = cursor.Mark();
					Skip();
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning for the next token, found character that cannot start any token.");
				}
				Skip();
			}
		}

		private bool CheckWhiteSpace()
		{
			if (!analyzer.Check(' '))
			{
				if (flowLevel > 0 || !simpleKeyAllowed)
				{
					return analyzer.Check('\t');
				}
				return false;
			}
			return true;
		}

		private void Skip()
		{
			cursor.Skip();
			analyzer.Buffer.Skip(1);
		}

		private void SkipLine()
		{
			if (analyzer.IsCrLf())
			{
				cursor.SkipLineByOffset(2);
				analyzer.Buffer.Skip(2);
			}
			else if (analyzer.IsBreak())
			{
				cursor.SkipLineByOffset(1);
				analyzer.Buffer.Skip(1);
			}
			else if (!analyzer.IsZero())
			{
				throw new InvalidOperationException("Not at a break.");
			}
		}

		private void ScanToNextToken()
		{
			while (true)
			{
				if (CheckWhiteSpace())
				{
					Skip();
					continue;
				}
				ProcessComment();
				if (analyzer.IsBreak())
				{
					SkipLine();
					if (flowLevel == 0)
					{
						simpleKeyAllowed = true;
					}
					continue;
				}
				break;
			}
		}

		private void ProcessComment()
		{
			if (!analyzer.Check('#'))
			{
				return;
			}
			Mark start = cursor.Mark();
			Skip();
			while (analyzer.IsSpace())
			{
				Skip();
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				while (!analyzer.IsBreakOrZero())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (!SkipComments)
				{
					bool isInline = previous != null && previous.End.Line == start.Line && previous.End.Column != 1 && !(previous is YamlDotNet.Core.Tokens.StreamStart);
					tokens.Enqueue(new YamlDotNet.Core.Tokens.Comment(builder.ToString(), isInline, start, cursor.Mark()));
				}
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void FetchStreamStart()
		{
			simpleKeys.Push(new SimpleKey());
			simpleKeyAllowed = true;
			streamStartProduced = true;
			Mark start = cursor.Mark();
			tokens.Enqueue(new YamlDotNet.Core.Tokens.StreamStart(in start, in start));
		}

		private void UnrollIndent(long column)
		{
			if (flowLevel == 0)
			{
				while (indent > column)
				{
					Mark start = cursor.Mark();
					tokens.Enqueue(new BlockEnd(in start, in start));
					indent = indents.Pop();
				}
			}
		}

		private void FetchStreamEnd()
		{
			cursor.ForceSkipLineAfterNonBreak();
			UnrollIndent(-1L);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			streamEndProduced = true;
			Mark start = cursor.Mark();
			tokens.Enqueue(new YamlDotNet.Core.Tokens.StreamEnd(in start, in start));
		}

		private void FetchDirective()
		{
			UnrollIndent(-1L);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			Token token = ScanDirective();
			if (token != null)
			{
				tokens.Enqueue(token);
			}
		}

		private Token? ScanDirective()
		{
			Mark start = cursor.Mark();
			Skip();
			string text = ScanDirectiveName(in start);
			Token result;
			if (!(text == "YAML"))
			{
				if (!(text == "TAG"))
				{
					while (!analyzer.EndOfInput && !analyzer.Check('#') && !analyzer.IsBreak())
					{
						Skip();
					}
					return null;
				}
				result = ScanTagDirectiveValue(in start);
			}
			else
			{
				if (!(previous is YamlDotNet.Core.Tokens.DocumentStart) && !(previous is YamlDotNet.Core.Tokens.StreamStart) && !(previous is YamlDotNet.Core.Tokens.DocumentEnd))
				{
					Mark end = cursor.Mark();
					throw new SemanticErrorException(in start, in end, "While scanning a version directive, did not find preceding <document end>.");
				}
				result = ScanVersionDirectiveValue(in start);
			}
			while (analyzer.IsWhite())
			{
				Skip();
			}
			ProcessComment();
			if (!analyzer.IsBreakOrZero())
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "While scanning a directive, did not find expected comment or line break.");
			}
			if (analyzer.IsBreak())
			{
				SkipLine();
			}
			return result;
		}

		private void FetchDocumentIndicator(bool isStartToken)
		{
			UnrollIndent(-1L);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			Mark end = cursor.Mark();
			Skip();
			Skip();
			Skip();
			if (isStartToken)
			{
				InsertionQueue<Token> insertionQueue = tokens;
				Mark end2 = cursor.Mark();
				insertionQueue.Enqueue(new YamlDotNet.Core.Tokens.DocumentStart(in end, in end2));
				return;
			}
			Token token = null;
			while (!analyzer.EndOfInput && !analyzer.IsBreak() && !analyzer.Check('#'))
			{
				if (!analyzer.IsWhite())
				{
					token = new Error("While scanning a document end, found invalid content after '...' marker.", end, cursor.Mark());
					break;
				}
				Skip();
			}
			tokens.Enqueue(new YamlDotNet.Core.Tokens.DocumentEnd(in end, in end));
			if (token != null)
			{
				tokens.Enqueue(token);
			}
		}

		private void FetchFlowCollectionStart(bool isSequenceToken)
		{
			SaveSimpleKey();
			IncreaseFlowLevel();
			simpleKeyAllowed = true;
			Mark start = cursor.Mark();
			Skip();
			Token item = ((!isSequenceToken) ? ((Token)new FlowMappingStart(in start, in start)) : ((Token)new FlowSequenceStart(in start, in start)));
			tokens.Enqueue(item);
			startFlowCollectionFetched = true;
		}

		private void IncreaseFlowLevel()
		{
			simpleKeys.Push(new SimpleKey());
			flowLevel++;
		}

		private void FetchFlowCollectionEnd(bool isSequenceToken)
		{
			RemoveSimpleKey();
			DecreaseFlowLevel();
			simpleKeyAllowed = false;
			Mark start = cursor.Mark();
			Skip();
			Token token = null;
			Token item;
			if (isSequenceToken)
			{
				if (analyzer.Check('#'))
				{
					token = new Error("While scanning a flow sequence end, found invalid comment after ']'.", start, start);
				}
				item = new FlowSequenceEnd(in start, in start);
			}
			else
			{
				item = new FlowMappingEnd(in start, in start);
			}
			tokens.Enqueue(item);
			if (token != null)
			{
				tokens.Enqueue(token);
			}
			flowCollectionFetched = true;
		}

		private void DecreaseFlowLevel()
		{
			if (flowLevel > 0)
			{
				flowLevel--;
				simpleKeys.Pop();
			}
		}

		private void FetchFlowEntry()
		{
			RemoveSimpleKey();
			simpleKeyAllowed = true;
			Mark start = cursor.Mark();
			Skip();
			Mark end = cursor.Mark();
			if (analyzer.Check('#'))
			{
				tokens.Enqueue(new Error("While scanning a flow entry, found invalid comment after comma.", start, end));
			}
			else
			{
				tokens.Enqueue(new FlowEntry(in start, in end));
			}
		}

		private void FetchBlockEntry()
		{
			Mark start;
			if (flowLevel == 0)
			{
				if (!simpleKeyAllowed)
				{
					if (previousAnchor != null && previousAnchor.End.Line == cursor.Line)
					{
						start = previousAnchor.Start;
						Mark end = previousAnchor.End;
						throw new SemanticErrorException(in start, in end, "Anchor before sequence entry on same line is not allowed.");
					}
					Mark mark = cursor.Mark();
					tokens.Enqueue(new Error("Block sequence entries are not allowed in this context.", mark, mark));
				}
				RollIndent(cursor.LineOffset, -1, isSequence: true, cursor.Mark());
			}
			RemoveSimpleKey();
			simpleKeyAllowed = true;
			Mark start2 = cursor.Mark();
			Skip();
			InsertionQueue<Token> insertionQueue = tokens;
			start = cursor.Mark();
			insertionQueue.Enqueue(new BlockEntry(in start2, in start));
		}

		private void FetchKey()
		{
			if (flowLevel == 0)
			{
				if (!simpleKeyAllowed)
				{
					Mark start = cursor.Mark();
					throw new SyntaxErrorException(in start, in start, "Mapping keys are not allowed in this context.");
				}
				RollIndent(cursor.LineOffset, -1, isSequence: false, cursor.Mark());
			}
			RemoveSimpleKey();
			simpleKeyAllowed = flowLevel == 0;
			Mark start2 = cursor.Mark();
			Skip();
			InsertionQueue<Token> insertionQueue = tokens;
			Mark end = cursor.Mark();
			insertionQueue.Enqueue(new Key(in start2, in end));
		}

		private void FetchValue()
		{
			SimpleKey simpleKey = simpleKeys.Peek();
			Mark start;
			if (simpleKey.IsPossible)
			{
				InsertionQueue<Token> insertionQueue = tokens;
				int index = simpleKey.TokenNumber - tokensParsed;
				start = simpleKey.Mark;
				Mark end = simpleKey.Mark;
				insertionQueue.Insert(index, new Key(in start, in end));
				RollIndent(simpleKey.LineOffset, simpleKey.TokenNumber, isSequence: false, simpleKey.Mark);
				simpleKey.MarkAsImpossible();
				simpleKeyAllowed = false;
			}
			else
			{
				bool flag = flowLevel == 0;
				if (flag)
				{
					if (!simpleKeyAllowed)
					{
						Mark mark = cursor.Mark();
						tokens.Enqueue(new Error("Mapping values are not allowed in this context.", mark, mark));
						return;
					}
					RollIndent(cursor.LineOffset, -1, isSequence: false, cursor.Mark());
					if (cursor.LineOffset == 0L && simpleKey.LineOffset == 0L)
					{
						InsertionQueue<Token> insertionQueue2 = tokens;
						int count = tokens.Count;
						start = simpleKey.Mark;
						Mark end = simpleKey.Mark;
						insertionQueue2.Insert(count, new Key(in start, in end));
						flag = false;
					}
				}
				simpleKeyAllowed = flag;
			}
			Mark start2 = cursor.Mark();
			Skip();
			InsertionQueue<Token> insertionQueue3 = tokens;
			start = cursor.Mark();
			insertionQueue3.Enqueue(new Value(in start2, in start));
		}

		private void RollIndent(long column, int number, bool isSequence, Mark position)
		{
			if (flowLevel <= 0 && indent < column)
			{
				indents.Push(indent);
				indent = column;
				Token item = ((!isSequence) ? ((Token)new BlockMappingStart(in position, in position)) : ((Token)new BlockSequenceStart(in position, in position)));
				if (number == -1)
				{
					tokens.Enqueue(item);
				}
				else
				{
					tokens.Insert(number - tokensParsed, item);
				}
			}
		}

		private void FetchAnchor(bool isAlias)
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			tokens.Enqueue(ScanAnchor(isAlias));
		}

		private Token ScanAnchor(bool isAlias)
		{
			Mark start = cursor.Mark();
			Skip();
			bool flag = false;
			if (isAlias)
			{
				SimpleKey simpleKey = simpleKeys.Peek();
				flag = simpleKey.IsRequired && simpleKey.IsPossible;
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				while (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("[]{},") && (!flag || !analyzer.Check(':') || !analyzer.IsWhiteBreakOrZero(1)))
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (builder.Length == 0 || (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("?:,]}%@`")))
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning an anchor or alias, found value containing disallowed: []{},");
				}
				AnchorName value = new AnchorName(builder.ToString());
				if (isAlias)
				{
					return new YamlDotNet.Core.Tokens.AnchorAlias(value, start, cursor.Mark());
				}
				return previousAnchor = new Anchor(value, start, cursor.Mark());
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void FetchTag()
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			tokens.Enqueue(ScanTag());
		}

		private Tag ScanTag()
		{
			Mark start = cursor.Mark();
			string text;
			string text2;
			if (analyzer.Check('<', 1))
			{
				text = string.Empty;
				Skip();
				Skip();
				text2 = ScanTagUri(null, start);
				if (!analyzer.Check('>'))
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a tag, did not find the expected '>'.");
				}
				Skip();
			}
			else
			{
				string text3 = ScanTagHandle(isDirective: false, start);
				if (text3.Length > 1 && text3[0] == '!' && text3[text3.Length - 1] == '!')
				{
					text = text3;
					text2 = ScanTagUri(null, start);
				}
				else
				{
					text2 = ScanTagUri(text3, start);
					text = "!";
					if (text2.Length == 0)
					{
						text2 = text;
						text = string.Empty;
					}
				}
			}
			if (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check(','))
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "While scanning a tag, did not find expected whitespace, comma or line break.");
			}
			return new Tag(text, text2, start, cursor.Mark());
		}

		private void FetchBlockScalar(bool isLiteral)
		{
			SaveSimpleKey();
			simpleKeyAllowed = true;
			tokens.Enqueue(ScanBlockScalar(isLiteral));
		}

		private YamlDotNet.Core.Tokens.Scalar ScanBlockScalar(bool isLiteral)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				StringBuilderPool.BuilderWrapper builderWrapper2 = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder2 = builderWrapper2.Builder;
					StringBuilderPool.BuilderWrapper builderWrapper3 = StringBuilderPool.Rent();
					try
					{
						StringBuilder builder3 = builderWrapper3.Builder;
						int num = 0;
						int num2 = 0;
						long currentIndent = 0L;
						bool flag = false;
						bool? isFirstLine = null;
						Mark start = cursor.Mark();
						Skip();
						if (analyzer.Check("+-"))
						{
							num = (analyzer.Check('+') ? 1 : (-1));
							Skip();
							if (analyzer.IsDigit())
							{
								if (analyzer.Check('0'))
								{
									Mark end = cursor.Mark();
									throw new SyntaxErrorException(in start, in end, "While scanning a block scalar, found an indentation indicator equal to 0.");
								}
								num2 = analyzer.AsDigit();
								Skip();
							}
						}
						else if (analyzer.IsDigit())
						{
							if (analyzer.Check('0'))
							{
								Mark end = cursor.Mark();
								throw new SyntaxErrorException(in start, in end, "While scanning a block scalar, found an indentation indicator equal to 0.");
							}
							num2 = analyzer.AsDigit();
							Skip();
							if (analyzer.Check("+-"))
							{
								num = (analyzer.Check('+') ? 1 : (-1));
								Skip();
							}
						}
						if (analyzer.Check('#'))
						{
							Mark end = cursor.Mark();
							throw new SyntaxErrorException(in start, in end, "While scanning a block scalar, found a comment without whtespace after '>' indicator.");
						}
						while (analyzer.IsWhite())
						{
							Skip();
						}
						ProcessComment();
						if (!analyzer.IsBreakOrZero())
						{
							Mark end = cursor.Mark();
							throw new SyntaxErrorException(in start, in end, "While scanning a block scalar, did not find expected comment or line break.");
						}
						if (analyzer.IsBreak())
						{
							SkipLine();
							if (!isFirstLine.HasValue)
							{
								isFirstLine = true;
							}
							else if (isFirstLine.GetValueOrDefault())
							{
								isFirstLine = false;
							}
						}
						Mark end2 = cursor.Mark();
						if (num2 != 0)
						{
							currentIndent = ((indent >= 0) ? (indent + num2) : num2);
						}
						currentIndent = ScanBlockScalarBreaks(currentIndent, builder3, isLiteral, ref end2, ref isFirstLine);
						isFirstLine = false;
						while (cursor.LineOffset == currentIndent && !analyzer.IsZero() && !IsDocumentEnd())
						{
							bool flag2 = analyzer.IsWhite();
							if (!isLiteral && StartsWith(builder2, '\n') && !flag && !flag2)
							{
								if (builder3.Length == 0)
								{
									builder.Append(' ');
								}
								builder2.Length = 0;
							}
							else
							{
								builder.Append((object?)builder2);
								builder2.Length = 0;
							}
							builder.Append((object?)builder3);
							builder3.Length = 0;
							flag = analyzer.IsWhite();
							while (!analyzer.IsBreakOrZero())
							{
								builder.Append(ReadCurrentCharacter());
							}
							char c = ReadLine();
							if (c != 0)
							{
								builder2.Append(c);
							}
							currentIndent = ScanBlockScalarBreaks(currentIndent, builder3, isLiteral, ref end2, ref isFirstLine);
						}
						if (num != -1)
						{
							builder.Append((object?)builder2);
						}
						if (num == 1)
						{
							builder.Append((object?)builder3);
						}
						ScalarStyle style = (isLiteral ? ScalarStyle.Literal : ScalarStyle.Folded);
						return new YamlDotNet.Core.Tokens.Scalar(builder.ToString(), style, start, end2);
					}
					finally
					{
						((IDisposable)builderWrapper3).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private long ScanBlockScalarBreaks(long currentIndent, StringBuilder breaks, bool isLiteral, ref Mark end, ref bool? isFirstLine)
		{
			long num = 0L;
			long num2 = -1L;
			end = cursor.Mark();
			while (true)
			{
				if ((currentIndent == 0L || cursor.LineOffset < currentIndent) && analyzer.IsSpace())
				{
					Skip();
					continue;
				}
				if (cursor.LineOffset > num)
				{
					num = cursor.LineOffset;
				}
				if (!analyzer.IsBreak())
				{
					break;
				}
				if (isFirstLine.GetValueOrDefault())
				{
					isFirstLine = false;
					num2 = cursor.LineOffset;
				}
				breaks.Append(ReadLine());
				end = cursor.Mark();
			}
			if (isLiteral && isFirstLine.GetValueOrDefault())
			{
				long num3 = cursor.LineOffset;
				int num4 = 0;
				while (!analyzer.IsBreak(num4) && analyzer.IsSpace(num4))
				{
					num4++;
					num3++;
				}
				if (analyzer.IsBreak(num4) && num3 > cursor.LineOffset)
				{
					isFirstLine = false;
					num2 = num3;
				}
			}
			if (isLiteral && num2 > 1 && currentIndent < num2 - 1)
			{
				Mark end2 = cursor.Mark();
				throw new SemanticErrorException(in end, in end2, "While scanning a literal block scalar, found extra spaces in first line.");
			}
			if (!isLiteral && num > cursor.LineOffset && num2 > -1)
			{
				Mark end2 = cursor.Mark();
				throw new SemanticErrorException(in end, in end2, "While scanning a literal block scalar, found more spaces in lines above first content line.");
			}
			if (currentIndent == 0L && (cursor.LineOffset > 0 || indent > -1))
			{
				currentIndent = Math.Max(num, Math.Max(indent + 1, 1L));
			}
			return currentIndent;
		}

		private void FetchQuotedScalar(bool isSingleQuoted)
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			flowScalarFetched = flowLevel > 0;
			YamlDotNet.Core.Tokens.Scalar item = ScanFlowScalar(isSingleQuoted);
			tokens.Enqueue(item);
			lastScalar = item;
			if (!isSingleQuoted && analyzer.Check('#'))
			{
				Mark mark = cursor.Mark();
				tokens.Enqueue(new Error("While scanning a flow sequence end, found invalid comment after double-quoted scalar.", mark, mark));
			}
		}

		private YamlDotNet.Core.Tokens.Scalar ScanFlowScalar(bool isSingleQuoted)
		{
			Mark start = cursor.Mark();
			Skip();
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				StringBuilderPool.BuilderWrapper builderWrapper2 = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder2 = builderWrapper2.Builder;
					StringBuilderPool.BuilderWrapper builderWrapper3 = StringBuilderPool.Rent();
					try
					{
						StringBuilder builder3 = builderWrapper3.Builder;
						StringBuilderPool.BuilderWrapper builderWrapper4 = StringBuilderPool.Rent();
						try
						{
							StringBuilder builder4 = builderWrapper4.Builder;
							bool flag = false;
							while (true)
							{
								if (IsDocumentIndicator())
								{
									Mark end = cursor.Mark();
									throw new SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found unexpected document indicator.");
								}
								if (analyzer.IsZero())
								{
									Mark end = cursor.Mark();
									throw new SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found unexpected end of stream.");
								}
								if (flag && !isSingleQuoted && indent >= cursor.LineOffset)
								{
									Mark end = cursor.Mark();
									throw new SyntaxErrorException(in start, in end, "While scanning a multi-line double-quoted scalar, found wrong indentation.");
								}
								flag = false;
								while (!analyzer.IsWhiteBreakOrZero())
								{
									if (isSingleQuoted && analyzer.Check('\'') && analyzer.Check('\'', 1))
									{
										builder.Append('\'');
										Skip();
										Skip();
										continue;
									}
									if (analyzer.Check(isSingleQuoted ? '\'' : '"'))
									{
										break;
									}
									if (!isSingleQuoted && analyzer.Check('\\') && analyzer.IsBreak(1))
									{
										Skip();
										SkipLine();
										flag = true;
										break;
									}
									if (!isSingleQuoted && analyzer.Check('\\'))
									{
										int num = 0;
										char c = analyzer.Peek(1);
										switch (c)
										{
										case 'x':
											num = 2;
											break;
										case 'u':
											num = 4;
											break;
										case 'U':
											num = 8;
											break;
										default:
										{
											if (SimpleEscapeCodes.TryGetValue(c, out var value))
											{
												builder.Append(value);
												break;
											}
											Mark end = cursor.Mark();
											throw new SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found unknown escape character.");
										}
										}
										Skip();
										Skip();
										if (num <= 0)
										{
											continue;
										}
										int num2 = 0;
										for (int i = 0; i < num; i++)
										{
											if (!analyzer.IsHex(i))
											{
												Mark end = cursor.Mark();
												throw new SyntaxErrorException(in start, in end, "While scanning a quoted scalar, did not find expected hexadecimal number.");
											}
											num2 = (num2 << 4) + analyzer.AsHex(i);
										}
										if (num2 >= 55296 && num2 <= 57343)
										{
											for (int j = 0; j < num; j++)
											{
												Skip();
											}
											if (analyzer.Peek(0) != '\\' || (analyzer.Peek(1) != 'u' && analyzer.Peek(1) != 'U'))
											{
												Mark end = cursor.Mark();
												throw new SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found invalid Unicode surrogates.");
											}
											Skip();
											num = ((analyzer.Peek(0) != 'u') ? 8 : 4);
											Skip();
											int num3 = 0;
											for (int k = 0; k < num; k++)
											{
												if (!analyzer.IsHex(0))
												{
													Mark end = cursor.Mark();
													throw new SyntaxErrorException(in start, in end, "While scanning a quoted scalar, did not find expected hexadecimal number.");
												}
												num3 = (num3 << 4) + analyzer.AsHex(k);
											}
											for (int l = 0; l < num; l++)
											{
												Skip();
											}
											num2 = char.ConvertToUtf32((char)num2, (char)num3);
										}
										else
										{
											if (num2 > 1114111)
											{
												Mark end = cursor.Mark();
												throw new SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found invalid Unicode character escape code.");
											}
											for (int m = 0; m < num; m++)
											{
												Skip();
											}
										}
										builder.Append(char.ConvertFromUtf32(num2));
									}
									else
									{
										builder.Append(ReadCurrentCharacter());
									}
								}
								if (analyzer.Check(isSingleQuoted ? '\'' : '"'))
								{
									break;
								}
								while (analyzer.IsWhite() || analyzer.IsBreak())
								{
									if (analyzer.IsWhite())
									{
										if (!flag)
										{
											builder2.Append(ReadCurrentCharacter());
										}
										else
										{
											Skip();
										}
									}
									else if (!flag)
									{
										builder2.Length = 0;
										builder3.Append(ReadLine());
										flag = true;
									}
									else
									{
										builder4.Append(ReadLine());
									}
								}
								if (flag)
								{
									if (StartsWith(builder3, '\n'))
									{
										if (builder4.Length == 0)
										{
											builder.Append(' ');
										}
										else
										{
											builder.Append((object?)builder4);
										}
									}
									else
									{
										builder.Append((object?)builder3);
										builder.Append((object?)builder4);
									}
									builder3.Length = 0;
									builder4.Length = 0;
								}
								else
								{
									builder.Append((object?)builder2);
									builder2.Length = 0;
								}
							}
							Skip();
							return new YamlDotNet.Core.Tokens.Scalar(builder.ToString(), isSingleQuoted ? ScalarStyle.SingleQuoted : ScalarStyle.DoubleQuoted, start, cursor.Mark());
						}
						finally
						{
							((IDisposable)builderWrapper4).Dispose();
						}
					}
					finally
					{
						((IDisposable)builderWrapper3).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void FetchPlainScalar()
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			bool isMultiline = false;
			YamlDotNet.Core.Tokens.Scalar item = (lastScalar = ScanPlainScalar(ref isMultiline));
			if (isMultiline && analyzer.Check(':') && flowLevel == 0 && indent < cursor.LineOffset)
			{
				tokens.Enqueue(new Error("While scanning a multiline plain scalar, found invalid mapping.", cursor.Mark(), cursor.Mark()));
			}
			tokens.Enqueue(item);
		}

		private YamlDotNet.Core.Tokens.Scalar ScanPlainScalar(ref bool isMultiline)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				StringBuilderPool.BuilderWrapper builderWrapper2 = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder2 = builderWrapper2.Builder;
					StringBuilderPool.BuilderWrapper builderWrapper3 = StringBuilderPool.Rent();
					try
					{
						StringBuilder builder3 = builderWrapper3.Builder;
						StringBuilderPool.BuilderWrapper builderWrapper4 = StringBuilderPool.Rent();
						try
						{
							StringBuilder builder4 = builderWrapper4.Builder;
							bool flag = false;
							long num = indent + 1;
							Mark start = cursor.Mark();
							Mark end = start;
							SimpleKey simpleKey = simpleKeys.Peek();
							while (!IsDocumentIndicator())
							{
								if (analyzer.Check('#'))
								{
									if (indent < 0 && flowLevel == 0)
									{
										plainScalarFollowedByComment = true;
									}
									break;
								}
								bool flag2 = analyzer.Check('*') && (!simpleKey.IsPossible || !simpleKey.IsRequired);
								while (!analyzer.IsWhiteBreakOrZero())
								{
									if ((analyzer.Check(':') && !flag2 && (analyzer.IsWhiteBreakOrZero(1) || (flowLevel > 0 && analyzer.Check(',', 1)))) || (flowLevel > 0 && analyzer.Check(",[]{}")))
									{
										if (flowLevel == 0 && !simpleKey.IsPossible)
										{
											tokens.Enqueue(new Error("While scanning a plain scalar value, found invalid mapping.", cursor.Mark(), cursor.Mark()));
										}
										break;
									}
									if (flag || builder2.Length > 0)
									{
										if (flag)
										{
											if (StartsWith(builder3, '\n'))
											{
												if (builder4.Length == 0)
												{
													builder.Append(' ');
												}
												else
												{
													builder.Append((object?)builder4);
												}
											}
											else
											{
												builder.Append((object?)builder3);
												builder.Append((object?)builder4);
											}
											builder3.Length = 0;
											builder4.Length = 0;
											flag = false;
										}
										else
										{
											builder.Append((object?)builder2);
											builder2.Length = 0;
										}
									}
									if (flowLevel > 0 && cursor.LineOffset < num)
									{
										throw new InvalidOperationException();
									}
									builder.Append(ReadCurrentCharacter());
									end = cursor.Mark();
								}
								if (!analyzer.IsWhite() && !analyzer.IsBreak())
								{
									break;
								}
								while (analyzer.IsWhite() || analyzer.IsBreak())
								{
									if (analyzer.IsWhite())
									{
										if (flag && cursor.LineOffset < num && analyzer.IsTab())
										{
											Mark end2 = cursor.Mark();
											throw new SyntaxErrorException(in start, in end2, "While scanning a plain scalar, found a tab character that violate indentation.");
										}
										if (!flag)
										{
											builder2.Append(ReadCurrentCharacter());
										}
										else
										{
											Skip();
										}
									}
									else
									{
										isMultiline = true;
										if (!flag)
										{
											builder2.Length = 0;
											builder3.Append(ReadLine());
											flag = true;
										}
										else
										{
											builder4.Append(ReadLine());
										}
									}
								}
								if (flowLevel == 0 && cursor.LineOffset < num)
								{
									break;
								}
							}
							if (flag)
							{
								simpleKeyAllowed = true;
							}
							return new YamlDotNet.Core.Tokens.Scalar(builder.ToString(), ScalarStyle.Plain, start, end);
						}
						finally
						{
							((IDisposable)builderWrapper4).Dispose();
						}
					}
					finally
					{
						((IDisposable)builderWrapper3).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void RemoveSimpleKey()
		{
			SimpleKey simpleKey = simpleKeys.Peek();
			if (simpleKey.IsPossible && simpleKey.IsRequired)
			{
				Mark start = simpleKey.Mark;
				Mark end = simpleKey.Mark;
				throw new SyntaxErrorException(in start, in end, "While scanning a simple key, could not find expected ':'.");
			}
			simpleKey.MarkAsImpossible();
		}

		private string ScanDirectiveName(in Mark start)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				while (analyzer.IsAlphaNumericDashOrUnderscore())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (builder.Length == 0)
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a directive, could not find expected directive name.");
				}
				if (analyzer.EndOfInput)
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a directive, found unexpected end of stream.");
				}
				if (!analyzer.IsWhiteBreakOrZero())
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a directive, found unexpected non-alphabetical character.");
				}
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void SkipWhitespaces()
		{
			while (analyzer.IsWhite())
			{
				Skip();
			}
		}

		private VersionDirective ScanVersionDirectiveValue(in Mark start)
		{
			SkipWhitespaces();
			int major = ScanVersionDirectiveNumber(in start);
			if (!analyzer.Check('.'))
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "While scanning a %YAML directive, did not find expected digit or '.' character.");
			}
			Skip();
			int minor = ScanVersionDirectiveNumber(in start);
			return new VersionDirective(new Version(major, minor), start, start);
		}

		private TagDirective ScanTagDirectiveValue(in Mark start)
		{
			SkipWhitespaces();
			string handle = ScanTagHandle(isDirective: true, start);
			if (!analyzer.IsWhite())
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "While scanning a %TAG directive, did not find expected whitespace.");
			}
			SkipWhitespaces();
			string prefix = ScanTagUri(null, start);
			if (!analyzer.IsWhiteBreakOrZero())
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "While scanning a %TAG directive, did not find expected whitespace or line break.");
			}
			return new TagDirective(handle, prefix, start, start);
		}

		private string ScanTagUri(string? head, Mark start)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				if (head != null && head.Length > 1)
				{
					builder.Append(head.Substring(1));
				}
				while (analyzer.IsAlphaNumericDashOrUnderscore() || analyzer.Check(";/?:@&=+$.!~*'()[]%") || (analyzer.Check(',') && !analyzer.IsBreak(1)))
				{
					if (analyzer.Check('%'))
					{
						builder.Append(ScanUriEscapes(in start));
					}
					else if (analyzer.Check('+'))
					{
						builder.Append(' ');
						Skip();
					}
					else
					{
						builder.Append(ReadCurrentCharacter());
					}
				}
				if (builder.Length == 0)
				{
					return string.Empty;
				}
				string text = builder.ToString();
				if (Polyfills.EndsWith(text, ','))
				{
					Mark start2 = cursor.Mark();
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start2, in end, "Unexpected comma at end of tag");
				}
				return text;
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private string ScanUriEscapes(in Mark start)
		{
			byte[] array = EmptyBytes;
			int count = 0;
			int num = 0;
			do
			{
				if (!analyzer.Check('%') || !analyzer.IsHex(1) || !analyzer.IsHex(2))
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a tag, did not find URI escaped octet.");
				}
				int num2 = (analyzer.AsHex(1) << 4) + analyzer.AsHex(2);
				if (num == 0)
				{
					num = (((num2 & 0x80) == 0) ? 1 : (((num2 & 0xE0) == 192) ? 2 : (((num2 & 0xF0) == 224) ? 3 : (((num2 & 0xF8) == 240) ? 4 : 0))));
					if (num == 0)
					{
						Mark end = cursor.Mark();
						throw new SyntaxErrorException(in start, in end, "While scanning a tag, found an incorrect leading UTF-8 octet.");
					}
					array = new byte[num];
				}
				else if ((num2 & 0xC0) != 128)
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a tag, found an incorrect trailing UTF-8 octet.");
				}
				array[count++] = (byte)num2;
				Skip();
				Skip();
				Skip();
			}
			while (--num > 0);
			string @string = Encoding.UTF8.GetString(array, 0, count);
			if (@string.Length == 0 || @string.Length > 2)
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "While scanning a tag, found an incorrect UTF-8 sequence.");
			}
			return @string;
		}

		private string ScanTagHandle(bool isDirective, Mark start)
		{
			if (!analyzer.Check('!'))
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "While scanning a tag, did not find expected '!'.");
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				builder.Append(ReadCurrentCharacter());
				while (analyzer.IsAlphaNumericDashOrUnderscore())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (analyzer.Check('!'))
				{
					builder.Append(ReadCurrentCharacter());
				}
				else if (isDirective && (builder.Length != 1 || builder[0] != '!'))
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a tag directive, did not find expected '!'.");
				}
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private int ScanVersionDirectiveNumber(in Mark start)
		{
			int num = 0;
			int num2 = 0;
			while (analyzer.IsDigit())
			{
				if (++num2 > 9)
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(in start, in end, "While scanning a %YAML directive, found extremely long version number.");
				}
				num = num * 10 + analyzer.AsDigit();
				Skip();
			}
			if (num2 == 0)
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(in start, in end, "While scanning a %YAML directive, did not find expected version number.");
			}
			return num;
		}

		private void SaveSimpleKey()
		{
			bool isRequired = flowLevel == 0 && indent == cursor.LineOffset;
			if (simpleKeyAllowed)
			{
				SimpleKey item = new SimpleKey(isRequired, tokensParsed + tokens.Count, cursor);
				RemoveSimpleKey();
				simpleKeys.Pop();
				simpleKeys.Push(item);
			}
		}
	}
	public class SemanticErrorException : YamlException
	{
		public SemanticErrorException(string message)
			: base(message)
		{
		}

		public SemanticErrorException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public SemanticErrorException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	internal sealed class SimpleKey
	{
		private readonly Cursor cursor;

		public bool IsPossible { get; private set; }

		public bool IsRequired { get; }

		public int TokenNumber { get; }

		public long Index => cursor.Index;

		public long Line => cursor.Line;

		public long LineOffset => cursor.LineOffset;

		public Mark Mark => cursor.Mark();

		public void MarkAsImpossible()
		{
			IsPossible = false;
		}

		public SimpleKey()
		{
			cursor = new Cursor();
		}

		public SimpleKey(bool isRequired, int tokenNumber, Cursor cursor)
		{
			IsPossible = true;
			IsRequired = isRequired;
			TokenNumber = tokenNumber;
			this.cursor = new Cursor(cursor);
		}
	}
	internal sealed class StringLookAheadBuffer : ILookAheadBuffer, IResettable
	{
		public string Value { get; set; } = string.Empty;


		public int Position { get; private set; }

		public int Length => Value.Length;

		public bool EndOfInput => IsOutside(Position);

		public char Peek(int offset)
		{
			int index = Position + offset;
			if (!IsOutside(index))
			{
				return Value[index];
			}
			return '\0';
		}

		private bool IsOutside(int index)
		{
			return index >= Value.Length;
		}

		public void Skip(int length)
		{
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", "The length must be positive.");
			}
			Position += length;
		}

		public bool TryReset()
		{
			Position = 0;
			Value = string.Empty;
			return true;
		}
	}
	public sealed class SyntaxErrorException : YamlException
	{
		public SyntaxErrorException(string message)
			: base(message)
		{
		}

		public SyntaxErrorException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public SyntaxErrorException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	public sealed class TagDirectiveCollection : KeyedCollection<string, TagDirective>
	{
		public TagDirectiveCollection()
		{
		}

		public TagDirectiveCollection(IEnumerable<TagDirective> tagDirectives)
		{
			foreach (TagDirective tagDirective in tagDirectives)
			{
				Add(tagDirective);
			}
		}

		protected override string GetKeyForItem(TagDirective item)
		{
			return item.Handle;
		}

		public new bool Contains(TagDirective directive)
		{
			return Contains(GetKeyForItem(directive));
		}
	}
	public readonly struct TagName : IEquatable<TagName>
	{
		public static readonly TagName Empty;

		private readonly string? value;

		public string Value => value ?? throw new InvalidOperationException("Cannot read the Value of a non-specific tag");

		public bool IsEmpty => value == null;

		public bool IsNonSpecific
		{
			get
			{
				if (!IsEmpty)
				{
					if (!(value == "!"))
					{
						return value == "?";
					}
					return true;
				}
				return false;
			}
		}

		public bool IsLocal
		{
			get
			{
				if (!IsEmpty)
				{
					return Value[0] == '!';
				}
				return false;
			}
		}

		public bool IsGlobal
		{
			get
			{
				if (!IsEmpty)
				{
					return !IsLocal;
				}
				return false;
			}
		}

		public TagName(string value)
		{
			this.value = value ?? throw new ArgumentNullException("value");
			if (value.Length == 0)
			{
				throw new ArgumentException("Tag value must not be empty.", "value");
			}
			if (IsGlobal && !Uri.IsWellFormedUriString(value, UriKind.RelativeOrAbsolute))
			{
				throw new ArgumentException("Global tags must be valid URIs.", "value");
			}
		}

		public override string ToString()
		{
			return value ?? "?";
		}

		public bool Equals(TagName other)
		{
			return object.Equals(value, other.value);
		}

		public override bool Equals(object? obj)
		{
			if (obj is TagName other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return value?.GetHashCode() ?? 0;
		}

		public static bool operator ==(TagName left, TagName right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(TagName left, TagName right)
		{
			return !(left == right);
		}

		public static bool operator ==(TagName left, string right)
		{
			return object.Equals(left.value, right);
		}

		public static bool operator !=(TagName left, string right)
		{
			return !(left == right);
		}

		public static implicit operator TagName(string? value)
		{
			if (value != null)
			{
				return new TagName(value);
			}
			return Empty;
		}
	}
	public sealed class Version
	{
		public int Major { get; }

		public int Minor { get; }

		public Version(int major, int minor)
		{
			if (major < 0)
			{
				throw new ArgumentOutOfRangeException("major", $"{major} should be >= 0");
			}
			Major = major;
			if (minor < 0)
			{
				throw new ArgumentOutOfRangeException("minor", $"{minor} should be >= 0");
			}
			Minor = minor;
		}

		public override bool Equals(object? obj)
		{
			if (obj is Version version && Major == version.Major)
			{
				return Minor == version.Minor;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return HashCode.CombineHashCodes(Major.GetHashCode(), Minor.GetHashCode());
		}
	}
	public class YamlException : Exception
	{
		public Mark Start { get; }

		public Mark End { get; }

		public YamlException(string message)
			: this(in Mark.Empty, in Mark.Empty, message)
		{
		}

		public YamlException(in Mark start, in Mark end, string message)
			: this(in start, in end, message, null)
		{
		}

		public YamlException(in Mark start, in Mark end, string message, Exception? innerException)
			: base(message, innerException)
		{
			Start = start;
			End = end;
		}

		public YamlException(string message, Exception inner)
			: this(in Mark.Empty, in Mark.Empty, message, inner)
		{
		}

		public override string ToString()
		{
			return $"({Start}) - ({End}): {Message}";
		}
	}
}
namespace YamlDotNet.Core.Tokens
{
	public class Anchor : Token
	{
		public AnchorName Value { get; }

		public Anchor(AnchorName value)
			: this(value, Mark.Empty, Mark.Empty)
		{
		}

		public Anchor(AnchorName value, Mark start, Mark end)
			: base(in start, in end)
		{
			if (value.IsEmpty)
			{
				throw new ArgumentNullException("value");
			}
			Value = value;
		}
	}
	public sealed class AnchorAlias : Token
	{
		public AnchorName Value { get; }

		public AnchorAlias(AnchorName value)
			: this(value, Mark.Empty, Mark.Empty)
		{
		}

		public AnchorAlias(AnchorName value, Mark start, Mark end)
			: base(in start, in end)
		{
			if (value.IsEmpty)
			{
				throw new ArgumentNullException("value");
			}
			Value = value;
		}
	}
	public sealed class BlockEnd : Token
	{
		public BlockEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public BlockEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	public sealed class BlockEntry : Token
	{
		public BlockEntry()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public BlockEntry(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	public sealed class BlockMappingStart : Token
	{
		public BlockMappingStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public BlockMappingStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	public sealed class BlockSequenceStart : Token
	{
		public BlockSequenceStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public BlockSequenceStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	public sealed class Comment : Token
	{
		public string Value { get; }

		public bool IsInline { get; }

		public Comment(string value, bool isInline)
			: this(value, isInline, Mark.Empty, Mark.Empty)
		{
		}

		public Comment(string value, bool isInline, Mark start, Mark end)
			: base(in start, in end)
		{
			Value = value ?? throw new ArgumentNullException("value");
			IsInline = isInline;
		}
	}
	public sealed class DocumentEnd : Token
	{
		public DocumentEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public DocumentEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	public sealed class DocumentStart : Token
	{
		public DocumentStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public DocumentStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	public class Error : Token
	{
		public string Value { get; }

		public Error(string value, Mark start, Mark end)
			: base(in start, in end)
		{
			Value = value;
		}
	}
	public sealed class FlowEntry : Token
	{
		public FlowEntry()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowEntry(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	public sealed class FlowMappingEnd : Token
	{
		public FlowMappingEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowMappingEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	public sealed class FlowMappingStart : Token
	{
		public FlowMappingStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowMappingStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	public sealed class FlowSequenceEnd : Token
	{
		public FlowSequenceEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowSequenceEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	public sealed class FlowSequenceStart : Token
	{
		public FlowSequenceStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowSequenceStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	public sealed class Key : Token
	{
		public Key()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public Key(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	public sealed class Scalar : Token
	{
		public bool IsKey { get; set; }

		public string Value { get; }

		public ScalarStyle Style { get; }

		public Scalar(string value)
			: this(value, ScalarStyle.Any)
		{
		}

		public Scalar(string value, ScalarStyle style)
			: this(value, style, Mark.Empty, Mark.Empty)
		{
		}

		public Scalar(string value, ScalarStyle style, Mark start, Mark end)
			: base(in start, in end)
		{
			Value = value ?? throw new ArgumentNullException("value");
			Style = style;
		}
	}
	public sealed class StreamEnd : Token
	{
		public StreamEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public StreamEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	public sealed class StreamStart : Token
	{
		public StreamStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public StreamStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	public sealed class Tag : Token
	{
		public string Handle { get; }

		public string Suffix { get; }

		public Tag(string handle, string suffix)
			: this(handle, suffix, Mark.Empty, Mark.Empty)
		{
		}

		public Tag(string handle, string suffix, Mark start, Mark end)
			: base(in start, in end)
		{
			Handle = handle ?? throw new ArgumentNullException("handle");
			Suffix = suffix ?? throw new ArgumentNullException("suffix");
		}
	}
	public class TagDirective : Token
	{
		private static readonly Regex TagHandlePattern = new Regex("^!([0-9A-Za-z_\\-]*!)?$", RegexOptions.Compiled);

		public string Handle { get; }

		public string Prefix { get; }

		public TagDirective(string handle, string prefix)
			: this(handle, prefix, Mark.Empty, Mark.Empty)
		{
		}

		public TagDirective(string handle, string prefix, Mark start, Mark end)
			: base(in start, in end)
		{
			if (string.IsNullOrEmpty(handle))
			{
				throw new ArgumentNullException("handle", "Tag handle must not be empty.");
			}
			if (!TagHandlePattern.IsMatch(handle))
			{
				throw new ArgumentException("Tag handle must start and end with '!' and contain alphanumerical characters only.", "handle");
			}
			Handle = handle;
			if (string.IsNullOrEmpty(prefix))
			{
				throw new ArgumentNullException("prefix", "Tag prefix must not be empty.");
			}
			Prefix = prefix;
		}

		public override bool Equals(object? obj)
		{
			if (obj is TagDirective tagDirective && Handle.Equals(tagDirective.Handle))
			{
				return Prefix.Equals(tagDirective.Prefix);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Handle.GetHashCode() ^ Prefix.GetHashCode();
		}

		public override string ToString()
		{
			return Handle + " => " + Prefix;
		}
	}
	public abstract class Token
	{
		public Mark Start { get; }

		public Mark End { get; }

		protected Token(in Mark start, in Mark end)
		{
			Start = start;
			End = end;
		}
	}
	public sealed class Value : Token
	{
		public Value()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public Value(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	public sealed class VersionDirective : Token
	{
		public Version Version { get; }

		public VersionDirective(Version version)
			: this(version, Mark.Empty, Mark.Empty)
		{
		}

		public VersionDirective(Version version, Mark start, Mark end)
			: base(in start, in end)
		{
			Version = version;
		}

		public override bool Equals(object? obj)
		{
			if (obj is VersionDirective versionDirective)
			{
				return Version.Equals(versionDirective.Version);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Version.GetHashCode();
		}
	}
}
namespace YamlDotNet.Core.ObjectPool
{
	internal class DefaultObjectPool<T> : ObjectPool<T> where T : class
	{
		private readonly Func<T> createFunc;

		private readonly Func<T, bool> returnFunc;

		private readonly int maxCapacity;

		private int numItems;

		private protected readonly ConcurrentQueue<T> items = new ConcurrentQueue<T>();

		private protected T? fastItem;

		public DefaultObjectPool(IPooledObjectPolicy<T> policy)
			: this(policy, Environment.ProcessorCount * 2)
		{
		}

		public DefaultObjectPool(IPooledObjectPolicy<T> policy, int maximumRetained)
		{
			createFunc = policy.Create;
			returnFunc = policy.Return;
			maxCapacity = maximumRetained - 1;
		}

		public override T Get()
		{
			T result = fastItem;
			if (result == null || Interlocked.CompareExchange(ref fastItem, null, result) != result)
			{
				if (items.TryDequeue(out result))
				{
					Interlocked.Decrement(ref numItems);
					return result;
				}
				return createFunc();
			}
			return result;
		}

		public override void Return(T obj)
		{
			ReturnCore(obj);
		}

		private protected bool ReturnCore(T obj)
		{
			if (!returnFunc(obj))
			{
				return false;
			}
			if (fastItem != null || Interlocked.CompareExchange(ref fastItem, obj, null) != null)
			{
				if (Interlocked.Increment(ref numItems) <= maxCapacity)
				{
					items.Enqueue(obj);
					return true;
				}
				Interlocked.Decrement(ref numItems);
				return false;
			}
			return true;
		}
	}
	internal class DefaultPooledObjectPolicy<T> : IPooledObjectPolicy<T> where T : class, new()
	{
		public T Create()
		{
			return new T();
		}

		public bool Return(T obj)
		{
			if (obj is IResettable resettable)
			{
				return resettable.TryReset();
			}
			return true;
		}
	}
	internal interface IPooledObjectPolicy<T> where T : notnull
	{
		T Create();

		bool Return(T obj);
	}
	internal interface IResettable
	{
		bool TryReset();
	}
	internal abstract class ObjectPool<T> where T : class
	{
		public abstract T Get();

		public abstract void Return(T obj);
	}
	internal static class ObjectPool
	{
		public static ObjectPool<T> Create<T>(IPooledObjectPolicy<T>? policy = null) where T : class, new()
		{
			return new DefaultObjectPool<T>(policy ?? new DefaultPooledObjectPolicy<T>());
		}

		public static ObjectPool<T> Create<T>(int maximumRetained, IPooledObjectPolicy<T>? policy = null) where T : class, new()
		{
			return new DefaultObjectPool<T>(policy ?? new DefaultPooledObjectPolicy<T>(), maximumRetained);
		}
	}
	[DebuggerStepThrough]
	internal static class StringBuilderPool
	{
		internal readonly struct BuilderWrapper : IDisposable
		{
			public readonly StringBuilder Builder;

			private readonly ObjectPool<StringBuilder> pool;

			public BuilderWrapper(StringBuilder builder, ObjectPool<StringBuilder> pool)
			{
				Builder = builder;
				this.pool = pool;
			}

			public override string ToString()
			{
				return Builder.ToString();
			}

			public void Dispose()
			{
				pool.Return(Builder);
			}
		}

		private static readonly ObjectPool<StringBuilder> Pool = ObjectPool.Create(new StringBuilderPooledObjectPolicy
		{
			InitialCapacity = 16,
			MaximumRetainedCapacity = 1024
		});

		public static BuilderWrapper Rent()
		{
			StringBuilder builder = Pool.Get();
			return new BuilderWrapper(builder, Pool);
		}
	}
	internal class StringBuilderPooledObjectPolicy : IPooledObjectPolicy<StringBuilder>
	{
		public int InitialCapacity { get; set; } = 100;


		public int MaximumRetainedCapacity { get; set; } = 4096;


		public StringBuilder Create()
		{
			return new StringBuilder(InitialCapacity);
		}

		public bool Return(StringBuilder obj)
		{
			if (obj.Capacity > MaximumRetainedCapacity)
			{
				return false;
			}
			obj.Clear();
			return true;
		}
	}
	internal static class StringLookAheadBufferPool
	{
		internal readonly struct BufferWrapper : IDisposable
		{
			public readonly StringLookAheadBuffer Buffer;

			private readonly ObjectPool<StringLookAheadBuffer> pool;

			public BufferWrapper(StringLookAheadBuffer buffer, ObjectPool<StringLookAheadBuffer> pool)
			{
				Buffer = buffer;
				this.pool = pool;
			}

			public override string ToString()
			{
				return Buffer.ToString();
			}

			public void Dispose()
			{
				pool.Return(Buffer);
			}
		}

		private static readonly ObjectPool<StringLookAheadBuffer> Pool = ObjectPool.Create(new DefaultPooledObjectPolicy<StringLookAheadBuffer>());

		public static BufferWrapper Rent(string value)
		{
			StringLookAheadBuffer stringLookAheadBuffer = Pool.Get();
			stringLookAheadBuffer.Value = value;
			return new BufferWrapper(stringLookAheadBuffer, Pool);
		}
	}
}
namespace YamlDotNet.Core.Events
{
	public sealed class AnchorAlias : ParsingEvent
	{
		internal override EventType Type => EventType.Alias;

		public AnchorName Value { get; }

		public AnchorAlias(AnchorName value, Mark start, Mark end)
			: base(in start, in end)
		{
			if (value.IsEmpty)
			{
				throw new YamlException(in start, in end, "Anchor value must not be empty.");
			}
			Value = value;
		}

		public AnchorAlias(AnchorName value)
			: this(value, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Alias [value = {Value}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	public sealed class Comment : ParsingEvent
	{
		public string Value { get; }

		public bool IsInline { get; }

		internal override EventType Type => EventType.Comment;

		public Comment(string value, bool isInline)
			: this(value, isInline, Mark.Empty, Mark.Empty)
		{
		}

		public Comment(string value, bool isInline, Mark start, Mark end)
			: base(in start, in end)
		{
			Value = value;
			IsInline = isInline;
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override string ToString()
		{
			return (IsInline ? "Inline" : "Block") + " Comment [" + Value + "]";
		}
	}
	public sealed class DocumentEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.DocumentEnd;

		public bool IsImplicit { get; }

		public DocumentEnd(bool isImplicit, Mark start, Mark end)
			: base(in start, in end)
		{
			IsImplicit = isImplicit;
		}

		public DocumentEnd(bool isImplicit)
			: this(isImplicit, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Document end [isImplicit = {IsImplicit}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	public sealed class DocumentStart : ParsingEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.DocumentStart;

		public TagDirectiveCollection? Tags { get; }

		public VersionDirective? Version { get; }

		public bool IsImplicit { get; }

		public DocumentStart(VersionDirective? version, TagDirectiveCollection? tags, bool isImplicit, Mark start, Mark end)
			: base(in start, in end)
		{
			Version = version;
			Tags = tags;
			IsImplicit = isImplicit;
		}

		public DocumentStart(VersionDirective? version, TagDirectiveCollection? tags, bool isImplicit)
			: this(version, tags, isImplicit, Mark.Empty, Mark.Empty)
		{
		}

		public DocumentStart(in Mark start, in Mark end)
			: this(null, null, isImplicit: true, start, end)
		{
		}

		public DocumentStart()
			: this(null, null, isImplicit: true, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Document start [isImplicit = {IsImplicit}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum EventType
	{
		None,
		StreamStart,
		StreamEnd,
		DocumentStart,
		DocumentEnd,
		Alias,
		Scalar,
		SequenceStart,
		SequenceEnd,
		MappingStart,
		MappingEnd,
		Comment
	}
	public interface IParsingEventVisitor
	{
		void Visit(AnchorAlias e);

		void Visit(StreamStart e);

		void Visit(StreamEnd e);

		void Visit(DocumentStart e);

		void Visit(DocumentEnd e);

		void Visit(Scalar e);

		void Visit(SequenceStart e);

		void Visit(SequenceEnd e);

		void Visit(MappingStart e);

		void Visit(MappingEnd e);

		void Visit(Comment e);
	}
	public class MappingEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.MappingEnd;

		public MappingEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}

		public MappingEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public override string ToString()
		{
			return "Mapping end";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	public sealed class MappingStart : NodeEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.MappingStart;

		public bool IsImplicit { get; }

		public override bool IsCanonical => !IsImplicit;

		public MappingStyle Style { get; }

		public MappingStart(AnchorName anchor, TagName tag, bool isImplicit, MappingStyle style, Mark start, Mark end)
			: base(anchor, tag, start, end)
		{
			IsImplicit = isImplicit;
			Style = style;
		}

		public MappingStart(AnchorName anchor, TagName tag, bool isImplicit, MappingStyle style)
			: this(anchor, tag, isImplicit, style, Mark.Empty, Mark.Empty)
		{
		}

		public MappingStart()
			: this(AnchorName.Empty, TagName.Empty, isImplicit: true, MappingStyle.Any, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Mapping start [anchor = {base.Anchor}, tag = {base.Tag}, isImplicit = {IsImplicit}, style = {Style}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	public enum MappingStyle
	{
		Any,
		Block,
		Flow
	}
	public abstract class NodeEvent : ParsingEvent
	{
		public AnchorName Anchor { get; }

		public TagName Tag { get; }

		public abstract bool IsCanonical { get; }

		protected NodeEvent(AnchorName anchor, TagName tag, Mark start, Mark end)
			: base(in start, in end)
		{
			Anchor = anchor;
			Tag = tag;
		}

		protected NodeEvent(AnchorName anchor, TagName tag)
			: this(anchor, tag, Mark.Empty, Mark.Empty)
		{
		}
	}
	public abstract class ParsingEvent
	{
		public virtual int NestingIncrease => 0;

		internal abstract EventType Type { get; }

		public Mark Start { get; }

		public Mark End { get; }

		public abstract void Accept(IParsingEventVisitor visitor);

		internal ParsingEvent(in Mark start, in Mark end)
		{
			Start = start;
			End = end;
		}
	}
	public sealed class Scalar : NodeEvent
	{
		internal override EventType Type => EventType.Scalar;

		public string Value { get; }

		public ScalarStyle Style { get; }

		public bool IsPlainImplicit { get; }

		public bool IsQuotedImplicit { get; }

		public override bool IsCanonical
		{
			get
			{
				if (!IsPlainImplicit)
				{
					return !IsQuotedImplicit;
				}
				return false;
			}
		}

		public bool IsKey { get; }

		public Scalar(AnchorName anchor, TagName tag, string value, ScalarStyle style, bool isPlainImplicit, bool isQuotedImplicit, Mark start, Mark end, bool isKey = false)
			: base(anchor, tag, start, end)
		{
			Value = value;
			Style = style;
			IsPlainImplicit = isPlainImplicit;
			IsQuotedImplicit = isQuotedImplicit;
			IsKey = isKey;
		}

		public Scalar(AnchorName anchor, TagName tag, string value, ScalarStyle style, bool isPlainImplicit, bool isQuotedImplicit)
			: this(anchor, tag, value, style, isPlainImplicit, isQuotedImplicit, Mark.Empty, Mark.Empty)
		{
		}

		public Scalar(string value)
			: this(AnchorName.Empty, TagName.Empty, value, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, Mark.Empty, Mark.Empty)
		{
		}

		public Scalar(TagName tag, string value)
			: this(AnchorName.Empty, tag, value, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, Mark.Empty, Mark.Empty)
		{
		}

		public Scalar(AnchorName anchor, TagName tag, string value)
			: this(anchor, tag, value, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Scalar [anchor = {base.Anchor}, tag = {base.Tag}, value = {Value}, style = {Style}, isPlainImplicit = {IsPlainImplicit}, isQuotedImplicit = {IsQuotedImplicit}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	public sealed class SequenceEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.SequenceEnd;

		public SequenceEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}

		public SequenceEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public override string ToString()
		{
			return "Sequence end";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	public sealed class SequenceStart : NodeEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.SequenceStart;

		public bool IsImplicit { get; }

		public override bool IsCanonical => !IsImplicit;

		public SequenceStyle Style { get; }

		public SequenceStart(AnchorName anchor, TagName tag, bool isImplicit, SequenceStyle style, Mark start, Mark end)
			: base(anchor, tag, start, end)
		{
			IsImplicit = isImplicit;
			Style = style;
		}

		public SequenceStart(AnchorName anchor, TagName tag, bool isImplicit, SequenceStyle style)
			: this(anchor, tag, isImplicit, style, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Sequence start [anchor = {base.Anchor}, tag = {base.Tag}, isImplicit = {IsImplicit}, style = {Style}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	public enum SequenceStyle
	{
		Any,
		Block,
		Flow
	}
	public sealed class StreamEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.StreamEnd;

		public StreamEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}

		public StreamEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public override string ToString()
		{
			return "Stream end";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	public sealed class StreamStart : ParsingEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.StreamStart;

		public StreamStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public StreamStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}

		public override string ToString()
		{
			return "Stream start";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class AllowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class DisallowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class DoesNotReturnAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class DoesNotReturnIfAttribute : Attribute
	{
		public bool ParameterValue { get; }

		public DoesNotReturnIfAttribute(bool parameterValue)
		{
			ParameterValue = parameterValue;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MaybeNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MaybeNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public MaybeNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class NotNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class NotNullIfNotNullAttribute : Attribute
	{
		public string ParameterName { get; }

		public NotNullIfNotNullAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class NotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public NotNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
}
namespace Jewelcrafting
{
	[PublicAPI]
	public static class API
	{
		[PublicAPI]
		public class GemInfo
		{
			public readonly string gemPrefab;

			public readonly Sprite gemSprite;

			public readonly Dictionary<string, float> gemEffects;

			public GemInfo(string gemPrefab, Sprite gemSprite, Dictionary<string, float> gemEffects)
			{
				this.gemPrefab = gemPrefab;
				this.gemSprite = gemSprite;
				this.gemEffects = gemEffects;
			}
		}

		public delegate bool GemBreakHandler(ItemData? container, ItemData gem, int count = 1);

		public delegate bool ItemBreakHandler(ItemData? container);

		public delegate bool ItemMirroredHandler(ItemData? item);

		public static event Action? OnEffectRecalc;

		public static bool IsLoaded()
		{
			return false;
		}

		internal static void InvokeEffectRecalc()
		{
			API.OnEffectRecalc?.Invoke();
		}

		public static GameObject CreateNecklaceFromTemplate(string colorName, Color color)
		{
			return null;
		}

		public static GameObject CreateNecklaceFromTemplate(string colorName, Material material)
		{
			return null;
		}

		public static GameObject CreateRingFromTemplate(string colorName, Color color)
		{
			return null;
		}

		public static GameObject CreateRingFromTemplate(string colorName, Material material)
		{
			return null;
		}

		public static void MarkJewelry(GameObject jewelry)
		{
		}

		public static void AddGems(string type, string colorName, Color color)
		{
		}

		public static List<GameObject> AddGems(string type, string colorName, Material material, Color color)
		{
			return null;
		}

		public static GameObject AddDestructibleFromTemplate(string type, string colorName, Color color)
		{
			return null;
		}

		public static GameObject AddDestructibleFromTemplate(string type, string colorName, Material material)
		{
			return null;
		}

		public static GameObject AddUncutFromTemplate(string type, string colorName, Color color)
		{
			return null;
		}

		public static GameObject AddUncutFromTemplate(string type, string colorName, Material material)
		{
			return null;
		}

		public static GameObject AddAndRegisterUncutFromTemplate(string type, string colorName, Color color)
		{
			return null;
		}

		public static GameObject AddAndRegisterUncutFromTemplate(string type, string colorName, Material material)
		{
			return null;
		}

		public static GameObject AddShardFromTemplate(string type, string colorName, Color color)
		{
			return null;
		}

		public static GameObject AddShardFromTemplate(string type, string colorName, Material material)
		{
			return null;
		}

		public static GameObject[] AddTieredGemFromTemplate(string type, string colorName, Color color)
		{
			return null;
		}

		public static GameObject[] AddTieredGemFromTemplate(string type, string colorName, Material material, Color color)
		{
			return null;
		}

		public static void AddGem(GameObject prefab, string colorName)
		{
		}

		public static void AddShard(GameObject prefab, string colorName)
		{
		}

		public static void AddDestructible(GameObject prefab, string colorName)
		{
		}

		public static void AddUncutGem(GameObject prefab, string colorName, ConfigEntry<float>? dropChance = null)
		{
		}

		public static void AddGemEffect<T>(string name, string? englishDescription = null, string? englishDescriptionDetailed = null) where T : struct
		{
		}

		public static void AddGemConfig(string yaml)
		{
		}

		public static T GetEffectPower<T>(this Player player, string name) where T : struct
		{
			return default(T);
		}

		public static List<GemInfo?> GetGems(ItemData item)
		{
			return new List<GemInfo>();
		}

		public static bool SetGems(ItemData item, List<GemInfo?> gems)
		{
			return false;
		}

		public static Sprite GetSocketBorder()
		{
			return null;
		}

		public static GameObject GetGemcuttersTable()
		{
			return null;
		}

		public static void AddParticleEffect(string prefabName, GameObject effect, VisualEffectCondition displayCondition)
		{
		}

		public static void SetSocketsLock(ItemData item, bool enabled)
		{
		}

		public static void OnGemBreak(GemBreakHandler callback)
		{
		}

		public static void OnItemBreak(ItemBreakHandler callback)
		{
		}

		public static void OnItemMirrored(ItemMirroredHandler callback)
		{
		}

		public static bool IsJewelryEquipped(Player player, string prefabName)
		{
			return false;
		}
	}
	[AttributeUsage(AttributeTargets.Field)]
	public abstract class PowerAttribute : Attribute
	{
		public abstract float Add(float a, float b);
	}
	public class AdditivePowerAttribute : PowerAttribute
	{
		public override float Add(float a, float b)
		{
			return a + b;
		}
	}
	public class MultiplicativePercentagePowerAttribute : PowerAttribute
	{
		public override float Add(float a, float b)
		{
			return ((1f + a / 100f) * (1f + b / 100f) - 1f) * 100f;
		}
	}
	public class InverseMultiplicativePercentagePowerAttribute : PowerAttribute
	{
		public override float Add(float a, float b)
		{
			return (1f - (1f - a / 100f) * (1f - b / 100f)) * 100f;
		}
	}
	public class MinPowerAttribute : PowerAttribute
	{
		public override float Add(float a, float b)
		{
			return Mathf.Min(a, b);
		}
	}
	public class MaxPowerAttribute : PowerAttribute
	{
		public override float Add(float a, float b)
		{
			return Mathf.Max(a, b);
		}
	}
	[AttributeUsage(AttributeTargets.Field)]
	public class OptionalPowerAttribute : Attribute
	{
		public readonly float DefaultValue;

		public OptionalPowerAttribute(float defaultValue)
		{
			DefaultValue = defaultValue;
		}
	}
	[Flags]
	public enum VisualEffectCondition : uint
	{
		IsSkill = 0xFFFu,
		Swords = 1u,
		Knives = 2u,
		Clubs = 3u,
		Polearms = 4u,
		Spears = 5u,
		Blocking = 6u,
		Axes = 7u,
		Bows = 8u,
		Unarmed = 0xBu,
		Pickaxes = 0xCu,
		WoodCutting = 0xDu,
		Crossbows = 0xEu,
		IsItem = 0xFF000u,
		Helmet = 0x6000u,
		Chest = 0x7000u,
		Legs = 0xB000u,
		Hands = 0xC000u,
		Shoulder = 0x11000u,
		Tool = 0x13000u,
		GenericExtraAttributes = 0xFF000000u,
		Blackmetal = 0x40000000u,
		TwoHanded = 0x80000000u,
		SpecificExtraAttributes = 0xF00000u,
		Hammer = 0x113000u,
		Hoe = 0x213000u,
		Buckler = 0x100006u,
		Towershield = 0x200006u,
		FineWoodBow = 0x100008u,
		BowHuntsman = 0x200008u,
		BowDraugrFang = 0x300008u,
		PickaxeIron = 0x10000Cu,
		Club = 0x100003u
	}
}