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.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.Xml.Serialization;
using API;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using EpicMMOSystem;
using EpicMMOSystem.Gui;
using EpicMMOSystem.MonoScripts;
using EpicMMOSystem.OtherApi;
using Groups;
using HarmonyLib;
using ItemManager;
using JetBrains.Annotations;
using LocalizationManager;
using Microsoft.CodeAnalysis;
using PieceManager;
using ServerSync;
using StatusEffectManager;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.UI;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Core.Tokens;
using YamlDotNet.Helpers;
using YamlDotNet.Serialization;
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;

[assembly: AssemblyFileVersion("1.9.60")]
[assembly: Guid("4358610B-F3F4-4843-B7AF-98B7BC60DCDE")]
[assembly: ComVisible(false)]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCopyright("Copyright ©  2022")]
[assembly: AssemblyProduct("EpicMMOSystem")]
[assembly: AssemblyCompany("WackyMoleWackyMole")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyTitle("EpicMMOSystem")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.9.60.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<8c1690b5-b1ae-44eb-a821-6cdcb4c5b120>Embedded]
	internal sealed class <8c1690b5-b1ae-44eb-a821-6cdcb4c5b120>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[<8c1690b5-b1ae-44eb-a821-6cdcb4c5b120>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class <3b2bd33d-f87e-4f02-816f-4bef815516a7>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <3b2bd33d-f87e-4f02-816f-4bef815516a7>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <3b2bd33d-f87e-4f02-816f-4bef815516a7>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[<8c1690b5-b1ae-44eb-a821-6cdcb4c5b120>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	internal sealed class <2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
public class ColorUtil
{
	public static Color GetColorFromHex(string hex)
	{
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		hex = hex.TrimStart(new char[1] { '#' });
		Color result = default(Color);
		((Color)(ref result))..ctor(255f, 0f, 0f);
		if (hex.Length >= 6)
		{
			result.r = int.Parse(hex.Substring(0, 2), NumberStyles.HexNumber);
			result.g = int.Parse(hex.Substring(2, 2), NumberStyles.HexNumber);
			result.b = int.Parse(hex.Substring(4, 2), NumberStyles.HexNumber);
			if (hex.Length == 8)
			{
				result.a = int.Parse(hex.Substring(6, 2), NumberStyles.HexNumber);
			}
		}
		return result;
	}

	public static string GetHexFromColor(Color color)
	{
		//IL_0005: 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_003d: 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)
		return $"#{(int)(color.r * 255f):X2}" + $"{(int)(color.g * 255f):X2}" + $"{(int)(color.b * 255f):X2}" + $"{(int)(color.a * 255f):X2}";
	}
}
namespace API
{
	[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
	[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
	public static class EpicMMOSystem_API
	{
		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		private enum API_State
		{
			NotReady,
			NotInstalled,
			Ready
		}

		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		public enum Attribut
		{
			Strength,
			Agility,
			Intellect,
			Body,
			Vigour,
			Special
		}

		private static API_State state;

		private static MethodInfo eGetLevel;

		private static MethodInfo eAddExp;

		private static MethodInfo eGetAttribute;

		private static MethodInfo eGetAttributeRusty;

		private static MethodInfo eSetSingleRate;

		public static int GetLevel()
		{
			int result = 0;
			Init();
			if (eGetLevel != null)
			{
				result = (int)eGetLevel.Invoke(null, null);
			}
			return result;
		}

		public static int GetAttribute(Attribut attribute)
		{
			int result = 0;
			Init();
			if (eGetAttribute != null)
			{
				result = (int)eGetAttribute.Invoke(null, new object[1] { attribute });
			}
			return result;
		}

		public static int GetAttributeRusty(string attribute)
		{
			int result = 0;
			Init();
			if (eGetAttributeRusty != null)
			{
				result = (int)eGetAttributeRusty.Invoke(null, new object[1] { attribute });
			}
			return result;
		}

		public static void AddExp(int value)
		{
			Init();
			eAddExp?.Invoke(null, new object[1] { value });
		}

		public static void SetSingleRate(float rate)
		{
			Init();
			eSetSingleRate?.Invoke(null, new object[1] { rate });
		}

		private static void Init()
		{
			API_State aPI_State = state;
			if ((uint)(aPI_State - 1) > 1u)
			{
				if (Type.GetType("EpicMMOSystem.EpicMMOSystem, EpicMMOSystem") == null)
				{
					state = API_State.NotInstalled;
					return;
				}
				state = API_State.Ready;
				Type? type = Type.GetType("API.EMMOS_API, EpicMMOSystem");
				eGetLevel = type.GetMethod("GetLevel", BindingFlags.Static | BindingFlags.Public);
				eAddExp = type.GetMethod("AddExp", BindingFlags.Static | BindingFlags.Public);
				eGetAttribute = type.GetMethod("GetAttribute", BindingFlags.Static | BindingFlags.Public);
				eGetAttributeRusty = type.GetMethod("GetAttribute", BindingFlags.Static | BindingFlags.Public);
				eSetSingleRate = type.GetMethod("SetSingleRate", BindingFlags.Static | BindingFlags.Public);
			}
		}
	}
	public static class EMMOS_API
	{
		public static int GetLevel()
		{
			return LevelSystem.Instance.getLevel();
		}

		public static void AddExp(int exp)
		{
			LevelSystem.Instance.AddExp(exp);
		}

		public static void SetSingleRate(float rate)
		{
			LevelSystem.Instance.SetSingleRate(rate);
		}

		public static int GetAttribute(EpicMMOSystem_API.Attribut attribute)
		{
			return LevelSystem.Instance.getParameter((Parameter)attribute);
		}

		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
		public static int GetAttributeRusty(string attribute)
		{
			if (!Enum.TryParse<EpicMMOSystem_API.Attribut>(attribute, ignoreCase: true, out var result))
			{
				return 0;
			}
			int parameter = (int)result;
			return LevelSystem.Instance.getParameter((Parameter)parameter);
		}
	}
	[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
	[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
	[PublicAPI]
	public static class Marketplace_API
	{
		[Flags]
		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		public enum TerritoryFlags
		{
			None = 0,
			PushAway = 1,
			NoBuild = 2,
			NoPickaxe = 4,
			NoInteract = 8,
			NoAttack = 0x10,
			PvpOnly = 0x20,
			PveOnly = 0x40,
			PeriodicHeal = 0x80,
			PeriodicDamage = 0x100,
			IncreasedPlayerDamage = 0x200,
			IncreasedMonsterDamage = 0x400,
			NoMonsters = 0x800,
			CustomEnvironment = 0x1000,
			MoveSpeedMultiplier = 0x2000,
			NoDeathPenalty = 0x4000,
			NoPortals = 0x8000,
			PeriodicHealALL = 0x10000,
			ForceGroundHeight = 0x20000,
			ForceBiome = 0x40000,
			AddGroundHeight = 0x80000,
			NoBuildDamage = 0x100000,
			MonstersAddStars = 0x200000,
			InfiniteFuel = 0x400000,
			NoInteractItems = 0x800000,
			NoInteractCraftingStation = 0x1000000,
			NoInteractItemStands = 0x2000000,
			NoInteractChests = 0x4000000,
			NoInteractDoors = 0x8000000,
			NoStructureSupport = 0x10000000,
			NoInteractPortals = 0x20000000,
			CustomPaint = 0x40000000,
			LimitZoneHeight = int.MinValue
		}

		[Flags]
		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		public enum AdditionalTerritoryFlags
		{
			None = 0,
			NoItemLoss = 1,
			SnowMask = 2,
			NoMist = 4,
			InfiniteEitr = 8,
			InfiniteStamina = 0x10,
			NoCreatureDrops = 0x20
		}

		private static readonly bool _IsInstalled;

		private static readonly MethodInfo MI_IsPlayerInsideTerritory;

		private static readonly MethodInfo MI_IsObjectInsideTerritoryWithFlag;

		private static readonly MethodInfo MI_IsObjectInsideTerritoryWithFlag_Additional;

		private static readonly MethodInfo MI_ResetTraderItems;

		private static readonly MethodInfo MI_AddTraderItem;

		private static readonly MethodInfo MI_OpenQuestJournal;

		public static bool IsInstalled()
		{
			return _IsInstalled;
		}

		public static bool IsPlayerInsideTerritory(out string name, out TerritoryFlags flags, out AdditionalTerritoryFlags additionalFlags)
		{
			flags = TerritoryFlags.None;
			additionalFlags = AdditionalTerritoryFlags.None;
			name = "";
			if (!_IsInstalled || MI_IsPlayerInsideTerritory == null)
			{
				return false;
			}
			object[] array = new object[3] { "", 0, 0 };
			bool result = (bool)MI_IsPlayerInsideTerritory.Invoke(null, array);
			name = (string)array[0];
			flags = (TerritoryFlags)array[1];
			additionalFlags = (AdditionalTerritoryFlags)array[2];
			return result;
		}

		public static bool IsObjectInsideTerritoryWithFlag(GameObject go, TerritoryFlags flag, out string name, out TerritoryFlags flags, out AdditionalTerritoryFlags additionalFlags)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return IsPointInsideTerritoryWithFlag(go.transform.position, flag, out name, out flags, out additionalFlags);
		}

		public static bool IsObjectInsideTerritoryWithFlag(GameObject go, AdditionalTerritoryFlags flag, out string name, out TerritoryFlags flags, out AdditionalTerritoryFlags additionalFlags)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return IsPointInsideTerritoryWithFlag(go.transform.position, flag, out name, out flags, out additionalFlags);
		}

		public static bool IsPointInsideTerritoryWithFlag(Vector3 pos, TerritoryFlags flag, out string name, out TerritoryFlags flags, out AdditionalTerritoryFlags additionalFlags)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			name = "";
			flags = TerritoryFlags.None;
			additionalFlags = AdditionalTerritoryFlags.None;
			if (!_IsInstalled || MI_IsObjectInsideTerritoryWithFlag == null)
			{
				return false;
			}
			object[] array = new object[5]
			{
				pos,
				(int)flag,
				"",
				0,
				0
			};
			bool result = (bool)MI_IsObjectInsideTerritoryWithFlag.Invoke(null, array);
			name = (string)array[2];
			flags = (TerritoryFlags)array[3];
			additionalFlags = (AdditionalTerritoryFlags)array[4];
			return result;
		}

		public static bool IsPointInsideTerritoryWithFlag(Vector3 pos, AdditionalTerritoryFlags flag, out string name, out TerritoryFlags flags, out AdditionalTerritoryFlags additionalFlags)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			name = "";
			flags = TerritoryFlags.None;
			additionalFlags = AdditionalTerritoryFlags.None;
			if (!_IsInstalled || MI_IsObjectInsideTerritoryWithFlag_Additional == null)
			{
				return false;
			}
			object[] array = new object[5]
			{
				pos,
				(int)flag,
				"",
				0,
				0
			};
			bool result = (bool)MI_IsObjectInsideTerritoryWithFlag_Additional.Invoke(null, array);
			name = (string)array[2];
			flags = (TerritoryFlags)array[3];
			additionalFlags = (AdditionalTerritoryFlags)array[4];
			return result;
		}

		public static void ResetTraderItems()
		{
			if (_IsInstalled && !(MI_ResetTraderItems == null))
			{
				MI_ResetTraderItems.Invoke(null, null);
			}
		}

		public static void OpenQuestJournal()
		{
			if (_IsInstalled && !(MI_OpenQuestJournal == null))
			{
				MI_OpenQuestJournal.Invoke(null, null);
			}
		}

		static Marketplace_API()
		{
			Type type = Type.GetType("API.ClientSide, kg.Marketplace");
			if ((object)type == null)
			{
				_IsInstalled = false;
				return;
			}
			_IsInstalled = true;
			MI_IsPlayerInsideTerritory = type.GetMethod("IsPlayerInsideTerritory", BindingFlags.Static | BindingFlags.Public);
			MI_IsObjectInsideTerritoryWithFlag = type.GetMethod("IsObjectInsideTerritoryWithFlag", BindingFlags.Static | BindingFlags.Public);
			MI_IsObjectInsideTerritoryWithFlag_Additional = type.GetMethod("IsObjectInsideTerritoryWithFlag_Additional", BindingFlags.Static | BindingFlags.Public);
			MI_ResetTraderItems = type.GetMethod("ResetTraderItems", BindingFlags.Static | BindingFlags.Public);
			MI_OpenQuestJournal = type.GetMethod("OpenQuestJournal", BindingFlags.Static | BindingFlags.Public);
		}
	}
}
namespace EpicMMOSystem
{
	[Serializable]
	public struct Monster
	{
		[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(1)]
		public string name;

		public int minExp;

		public int maxExp;

		public int level;
	}
	public struct MonsterOld
	{
		[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(1)]
		public string name;

		public int minExp;

		public int maxExp;
	}
	[Serializable]
	public class CustomLevel
	{
		[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(1)]
		private Dictionary<int, int> level;
	}
	public class CustomLevels
	{
		private void generateXPCustomFile()
		{
			new Dictionary<int, int>
			{
				{ 1, 500 },
				{ 2, 1020 },
				{ 3, 1561 },
				{ 4, 2123 },
				{ 5, 2708 },
				{ 6, 3316 },
				{ 7, 3949 },
				{ 8, 4607 },
				{ 9, 5291 },
				{ 10, 6003 },
				{ 11, 6743 },
				{ 12, 7513 },
				{ 13, 8313 },
				{ 14, 9146 },
				{ 15, 10012 },
				{ 16, 10912 },
				{ 17, 11849 },
				{ 18, 12823 },
				{ 19, 13836 },
				{ 20, 14889 },
				{ 21, 15985 },
				{ 22, 17124 },
				{ 23, 18309 },
				{ 24, 19541 },
				{ 25, 20823 },
				{ 26, 22156 },
				{ 27, 23542 },
				{ 28, 24984 },
				{ 29, 26483 },
				{ 30, 28042 },
				{ 31, 29664 },
				{ 32, 31351 },
				{ 33, 33105 },
				{ 34, 34929 },
				{ 35, 36826 },
				{ 36, 38799 },
				{ 37, 40851 },
				{ 38, 42985 },
				{ 39, 45205 },
				{ 40, 47513 },
				{ 41, 49913 },
				{ 42, 52410 },
				{ 43, 55006 },
				{ 44, 57706 },
				{ 45, 60515 },
				{ 46, 63435 },
				{ 47, 66473 },
				{ 48, 69632 },
				{ 49, 72917 },
				{ 50, 76334 },
				{ 51, 79887 },
				{ 52, 83582 },
				{ 53, 87426 },
				{ 54, 91423 },
				{ 55, 95580 },
				{ 56, 99903 },
				{ 57, 104399 },
				{ 58, 109075 },
				{ 59, 113938 },
				{ 60, 118995 },
				{ 61, 124255 },
				{ 62, 129725 },
				{ 63, 135414 },
				{ 64, 141331 },
				{ 65, 147484 },
				{ 66, 153884 },
				{ 67, 160539 },
				{ 68, 167460 },
				{ 69, 174659 },
				{ 70, 182145 },
				{ 71, 189931 },
				{ 72, 198028 },
				{ 73, 206449 },
				{ 74, 215207 },
				{ 75, 224316 },
				{ 76, 233788 },
				{ 77, 243640 },
				{ 78, 253885 },
				{ 79, 264541 },
				{ 80, 275622 },
				{ 81, 287147 },
				{ 82, 299133 },
				{ 83, 311599 },
				{ 84, 324563 },
				{ 85, 338045 },
				{ 86, 352067 },
				{ 87, 366650 },
				{ 88, 381816 },
				{ 89, 397588 },
				{ 90, 413992 },
				{ 91, 431051 },
				{ 92, 448793 },
				{ 93, 467245 },
				{ 94, 486435 },
				{ 95, 506392 },
				{ 96, 527148 },
				{ 97, 548734 },
				{ 98, 571183 },
				{ 99, 594531 },
				{ 100, 618812 }
			};
			Path.Combine(Paths.ConfigPath, "EpicMMOSystem", "If you want to stop from updating.txt");
		}

		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
		private string GenerateXPTableString(Dictionary<string, int> xpTable)
		{
			int num = 0;
			string text = "";
			foreach (KeyValuePair<string, int> item in xpTable)
			{
				text += ((num != 0) ? ", " : "");
				text = text + item.Key + ":" + item.Value;
				num++;
			}
			return text;
		}

		private void readXPCustomFile()
		{
		}
	}
	internal class LevelSystem_noncombat
	{
		[HarmonyPatch(typeof(Destructible), "RPC_Damage")]
		private static class Destructible_dmg_patch
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			private static void Postfix(Destructible __instance, HitData hit)
			{
				if (EpicMMOSystem.disableNonCombatObjects.Value || EpicMMOSystem.disableDestructablesXP.Value || !__instance.m_nview.IsOwner())
				{
					return;
				}
				if (EpicMMOSystem.debugNonCombatObjects.Value)
				{
					EpicMMOSystem.MLLogger.LogWarning((object)("Destructible name" + ((Object)((Component)__instance).gameObject).name));
				}
				if (__instance.m_destroyed && DataMonsters.contains(((Object)((Component)__instance).gameObject).name))
				{
					Character attacker = hit.GetAttacker();
					if (!((Object)(object)attacker == (Object)null) && attacker is Player && hit.CheckToolTier(__instance.m_minToolTier, false) && !(hit.GetTotalDamage() < 1f))
					{
						int exp = DataMonsters.getExp(((Object)((Component)__instance).gameObject).name);
						LevelSystem.Instance.AddExp(exp);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Pickable), "RPC_Pick")]
		private static class PickablePickMMOWacky
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			private static void Postfix(Pickable __instance)
			{
				if (!EpicMMOSystem.disableNonCombatObjects.Value && !EpicMMOSystem.disableMiningXP.Value && readytopick)
				{
					if (EpicMMOSystem.debugNonCombatObjects.Value)
					{
						EpicMMOSystem.MLLogger.LogWarning((object)("pickable name" + ((Object)__instance).name));
					}
					if (DataMonsters.contains(((Object)__instance).name))
					{
						int exp = DataMonsters.getExp(((Object)__instance).name);
						LevelSystem.Instance.AddExp(exp);
						readytopick = false;
						((MonoBehaviour)EpicMMOSystem.Instance).StartCoroutine(PickWaitme());
					}
				}
			}
		}

		[HarmonyPatch(typeof(MineRock), "RPC_Hit")]
		private static class MineRock_dmg_patch
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			private static void Postfix(MineRock __instance, HitData hit)
			{
				if (EpicMMOSystem.disableNonCombatObjects.Value || EpicMMOSystem.disableMiningXP.Value)
				{
					return;
				}
				if (EpicMMOSystem.debugNonCombatObjects.Value)
				{
					EpicMMOSystem.MLLogger.LogWarning((object)("MineRock name" + ((Object)((Component)__instance).gameObject).name));
				}
				if (DataMonsters.contains(((Object)((Component)__instance).gameObject).name))
				{
					Character attacker = hit.GetAttacker();
					if (!((Object)(object)attacker == (Object)null) && attacker is Player && hit.CheckToolTier(__instance.m_minToolTier, false) && !(hit.GetTotalDamage() < 1f))
					{
						int exp = DataMonsters.getExp(((Object)((Component)__instance).gameObject).name);
						LevelSystem.Instance.AddExp(exp);
					}
				}
			}
		}

		[HarmonyPatch(typeof(MineRock5), "RPC_Damage")]
		private static class MineRock5_dmg_patch
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			private static void Postfix(MineRock5 __instance, HitData hit)
			{
				if (EpicMMOSystem.disableNonCombatObjects.Value || EpicMMOSystem.disableMiningXP.Value)
				{
					return;
				}
				if (EpicMMOSystem.debugNonCombatObjects.Value)
				{
					EpicMMOSystem.MLLogger.LogWarning((object)("MineRock5 name" + ((Object)((Component)__instance).gameObject).name));
				}
				if (DataMonsters.contains(((Object)((Component)__instance).gameObject).name))
				{
					Character attacker = hit.GetAttacker();
					if (!((Object)(object)attacker == (Object)null) && attacker is Player && hit.CheckToolTier(__instance.m_minToolTier, false) && !(hit.GetTotalDamage() < 1f))
					{
						int exp = DataMonsters.getExp(((Object)((Component)__instance).gameObject).name);
						LevelSystem.Instance.AddExp(exp);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Game), "IncrementPlayerStat")]
		private static class CheckPlayerStats
		{
			private static void Postfix(PlayerStatType stat)
			{
				//IL_0005: 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_0010: Invalid comparison between Unknown and I4
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Invalid comparison between Unknown and I4
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Invalid comparison between Unknown and I4
				if (!SeeifDied.ContainsKey(stat))
				{
					return;
				}
				if ((int)stat != 28)
				{
					if ((int)stat != 35)
					{
						if ((int)stat == 36 && SeeifDied[(PlayerStatType)36] == 1)
						{
							SeeifDied[(PlayerStatType)36] = 2;
						}
					}
					else if (SeeifDied[(PlayerStatType)35] == 1)
					{
						SeeifDied[(PlayerStatType)35] = 2;
					}
				}
				else if (SeeifDied[(PlayerStatType)28] == 1)
				{
					SeeifDied[(PlayerStatType)28] = 2;
				}
			}
		}

		[HarmonyPatch(typeof(TreeBase), "RPC_Damage")]
		private static class TreeBase_dmg_patch
		{
			private static void Prefix()
			{
				SeeifDied[(PlayerStatType)28] = 1;
			}

			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			private static void Postfix(TreeBase __instance, HitData hit)
			{
				if (EpicMMOSystem.disableNonCombatObjects.Value || EpicMMOSystem.disableTreeXP.Value)
				{
					return;
				}
				if (EpicMMOSystem.debugNonCombatObjects.Value)
				{
					EpicMMOSystem.MLLogger.LogWarning((object)("Treebase name" + ((Object)((Component)__instance).gameObject).name));
				}
				if (SeeifDied[(PlayerStatType)28] == 1)
				{
					SeeifDied[(PlayerStatType)28] = 0;
					return;
				}
				SeeifDied[(PlayerStatType)28] = 0;
				if (DataMonsters.contains(((Object)((Component)__instance).gameObject).name))
				{
					Character attacker = hit.GetAttacker();
					if (!((Object)(object)attacker == (Object)null) && attacker is Player && hit.CheckToolTier(__instance.m_minToolTier, false) && !(hit.GetTotalDamage() < 1f))
					{
						int exp = DataMonsters.getExp(((Object)((Component)__instance).gameObject).name);
						LevelSystem.Instance.AddExp(exp);
					}
				}
			}
		}

		[HarmonyPatch(typeof(TreeLog), "RPC_Damage")]
		private static class TreeLog_dmg_patch
		{
			private static void Prefix()
			{
				SeeifDied[(PlayerStatType)36] = 1;
				SeeifDied[(PlayerStatType)35] = 1;
			}

			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			private static void Postfix(TreeLog __instance, HitData hit)
			{
				if (EpicMMOSystem.disableNonCombatObjects.Value || EpicMMOSystem.disableTreeXP.Value || !__instance.m_nview.IsOwner())
				{
					return;
				}
				if (EpicMMOSystem.debugNonCombatObjects.Value)
				{
					EpicMMOSystem.MLLogger.LogWarning((object)("TreeLog name" + ((Object)((Component)__instance).gameObject).name));
				}
				if (DataMonsters.contains(((Object)((Component)__instance).gameObject).name))
				{
					Character attacker = hit.GetAttacker();
					if (!((Object)(object)attacker == (Object)null) && attacker is Player && hit.CheckToolTier(__instance.m_minToolTier, false) && !(hit.GetTotalDamage() < 1f))
					{
						int exp = DataMonsters.getExp(((Object)((Component)__instance).gameObject).name);
						LevelSystem.Instance.AddExp(exp);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Tameable), "Tame")]
		private static class Tameable_give_xp_patch
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			private static void Postfix(Tameable __instance)
			{
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				if (__instance.m_nview.IsOwner() && !EpicMMOSystem.disableTameXP.Value && DataMonsters.contains(((Object)((Component)__instance).gameObject).name) && Object.op_Implicit((Object)(object)Player.GetClosestPlayer(((Component)__instance).transform.position, 30f)))
				{
					int exp = DataMonsters.getExp(((Object)((Component)__instance).gameObject).name);
					LevelSystem.Instance.AddExp(exp * EpicMMOSystem.MultiplierForXPTaming.Value);
				}
			}
		}

		[HarmonyPatch(typeof(Player), "PlacePiece")]
		private static class Player_placepiece_patch_epicmmoA
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			private static void Postfix(Player __instance, Piece piece)
			{
				if (EpicMMOSystem.disableNonCombatObjects.Value || EpicMMOSystem.disablePieceXP.Value)
				{
					return;
				}
				if (piece.m_cultivatedGroundOnly)
				{
					if (EpicMMOSystem.debugNonCombatObjects.Value)
					{
						EpicMMOSystem.MLLogger.LogWarning((object)("plant name" + ((Object)piece).name));
					}
					if (DataMonsters.contains(((Object)piece).name + "(Clone)"))
					{
						int exp = DataMonsters.getExp(((Object)piece).name + "(Clone)");
						LevelSystem.Instance.AddExp(exp);
					}
				}
				else if (!(lastpiece == ((Object)piece).name))
				{
					lastpiece = ((Object)piece).name;
					if (EpicMMOSystem.debugNonCombatObjects.Value)
					{
						EpicMMOSystem.MLLogger.LogWarning((object)("piece name" + ((Object)piece).name));
					}
					if (DataMonsters.contains(((Object)piece).name + "(Clone)"))
					{
						int exp2 = DataMonsters.getExp(((Object)piece).name + "(Clone)");
						LevelSystem.Instance.AddExp(exp2);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Fish), "OnHooked")]
		private static class Fish_Hook_patch
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			private static void Postfix(Fish __instance)
			{
				if ((Object)(object)__instance.m_fishingFloat == (Object)null)
				{
					return;
				}
				Character owner = __instance.m_fishingFloat.GetOwner();
				if (!((Object)(object)owner == (Object)null))
				{
					Player val = (Player)(object)((owner is Player) ? owner : null);
					if (val != null)
					{
						TryGiveFishExp(__instance, val, pickupOnly: false);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Fish), "Interact")]
		private static class Fish_Caught_patch_interact
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			private static void Postfix(Fish __instance, Humanoid character, bool repeat, bool alt)
			{
				if (Object.op_Implicit((Object)(object)__instance) && !(repeat || alt) && !((Object)(object)character == (Object)null))
				{
					Player val = (Player)(object)((character is Player) ? character : null);
					if (val != null)
					{
						TryGiveFishExp(__instance, val, pickupOnly: true);
					}
				}
			}
		}

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

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(3f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					readytopick = 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();
			}
		}

		[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(1)]
		private const string FishXpAwardedKey = "EpicMMOSystem_FishXpAwarded";

		[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(1)]
		private static readonly HashSet<int> FishXpAwardedFallback = new HashSet<int>();

		internal static bool readytopick = true;

		[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(1)]
		internal static Dictionary<PlayerStatType, int> SeeifDied = new Dictionary<PlayerStatType, int>();

		[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(1)]
		private static string lastpiece = "";

		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
		private static bool HasFishXpBeenAwarded(Fish fish)
		{
			if ((Object)(object)fish == (Object)null)
			{
				return true;
			}
			ZNetView nview = fish.m_nview;
			if ((Object)(object)nview != (Object)null && nview.IsValid())
			{
				return nview.GetZDO().GetBool("EpicMMOSystem_FishXpAwarded", false);
			}
			return FishXpAwardedFallback.Contains(((Object)fish).GetInstanceID());
		}

		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
		private static void MarkFishXpAwarded(Fish fish)
		{
			if (!((Object)(object)fish == (Object)null))
			{
				ZNetView nview = fish.m_nview;
				if ((Object)(object)nview != (Object)null && nview.IsValid())
				{
					nview.GetZDO().Set("EpicMMOSystem_FishXpAwarded", true);
				}
				else
				{
					FishXpAwardedFallback.Add(((Object)fish).GetInstanceID());
				}
			}
		}

		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
		private static void TryGiveFishExp(Fish fish, Player player, bool pickupOnly)
		{
			if (!EpicMMOSystem.disableNonCombatObjects.Value && (!pickupOnly || !EpicMMOSystem.disableFishPickupXP.Value) && !((Object)(object)fish == (Object)null) && !((Object)(object)player == (Object)null) && !((Object)(object)player != (Object)(object)Player.m_localPlayer) && DataMonsters.contains(((Object)((Component)fish).gameObject).name) && !HasFishXpBeenAwarded(fish))
			{
				if (EpicMMOSystem.debugNonCombatObjects.Value)
				{
					EpicMMOSystem.MLLogger.LogWarning((object)((pickupOnly ? "fish Interact name" : "fish name") + ((Object)((Component)fish).gameObject).name));
				}
				MarkFishXpAwarded(fish);
				int exp = DataMonsters.getExp(((Object)((Component)fish).gameObject).name);
				int maxExp = DataMonsters.getMaxExp(((Object)((Component)fish).gameObject).name);
				float value = EpicMMOSystem.expForLvlMonster.Value;
				int level = DataMonsters.getLevel(((Object)((Component)fish).gameObject).name);
				float value2 = (float)exp + (float)maxExp * value * (float)(level - 1);
				LevelSystem.Instance.AddExp(Convert.ToInt32(value2));
			}
		}

		[IteratorStateMachine(typeof(<PickWaitme>d__7))]
		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
		public static IEnumerator PickWaitme()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PickWaitme>d__7(0);
		}
	}
	public class LevelSystem
	{
		[HarmonyPatch(typeof(ItemData), "GetDamage", new Type[]
		{
			typeof(int),
			typeof(float)
		})]
		private static class MiningPostfix
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			private static void Postfix(ItemData __instance, ref DamageTypes __result)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Invalid comparison between Unknown and I4
				if (__instance != null && (int)__instance.m_shared.m_skillType == 12)
				{
					float num = 1f + Instance.getaddMiningDmg() / 100f;
					__result.m_pickaxe *= num;
				}
			}
		}

		[HarmonyPriority(600)]
		[HarmonyPatch(typeof(WearNTear), "OnPlaced")]
		internal static class Player_HealthChangeMMO
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			internal static void Prefix(ref WearNTear __instance)
			{
				float addPieceHealth = Instance.getAddPieceHealth();
				if (addPieceHealth > 0f)
				{
					WearNTear obj = __instance;
					obj.m_health += addPieceHealth;
					ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
					if (Object.op_Implicit((Object)(object)component) && component.IsValid())
					{
						component.GetZDO().Set("MMO_ExtraHealth", addPieceHealth);
					}
				}
			}
		}

		[HarmonyPriority(600)]
		[HarmonyPatch(typeof(WearNTear), "Awake")]
		internal static class WearNTear_Awake_HealthChangeMMO
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			internal static void Prefix(ref WearNTear __instance)
			{
				ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
				if (Object.op_Implicit((Object)(object)component) && component.IsValid())
				{
					float @float = component.GetZDO().GetFloat("MMO_ExtraHealth", 0f);
					if (@float > 0f)
					{
						WearNTear obj = __instance;
						obj.m_health += @float;
					}
				}
			}
		}

		[HarmonyPatch(typeof(ItemData), "GetDamage", new Type[]
		{
			typeof(int),
			typeof(float)
		})]
		private static class TreeCuttingPostfix
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			private static void Postfix(ItemData __instance, ref DamageTypes __result)
			{
				//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)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Invalid comparison between Unknown and I4
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Invalid comparison between Unknown and I4
				if (__instance == null)
				{
					return;
				}
				SkillType skillType = __instance.m_shared.m_skillType;
				if ((int)skillType == 7 || (int)skillType == 13)
				{
					float addTreeCuttingDmg = Instance.getAddTreeCuttingDmg();
					if (!(addTreeCuttingDmg <= 0f))
					{
						float num = 1f + addTreeCuttingDmg / 100f;
						__result.m_chop *= num;
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "GetTotalFoodValue")]
		public static class AddHp_Path
		{
			public static void Postfix(ref float hp)
			{
				float num = Instance.getAddHp() + EpicMMOSystem.addDefaultHealth.Value;
				hp += num;
			}
		}

		[HarmonyPatch(typeof(SEMan), "ModifyHealthRegen")]
		public static class RegenHp_Patch
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			public static void Postfix(SEMan __instance, ref float regenMultiplier)
			{
				if (__instance.m_character.IsPlayer())
				{
					float addRegenHp = Instance.getAddRegenHp();
					regenMultiplier += addRegenHp / 100f;
				}
			}
		}

		[HarmonyPatch(typeof(Character), "RPC_Damage")]
		public static class RPC_Damage
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			public static void Prefix(Character __instance, HitData hit)
			{
				if (__instance.IsPlayer() && !((Object)(object)hit.GetAttacker() == (Object)(object)__instance))
				{
					float addMagicArmor = Instance.getAddMagicArmor();
					float num = 1f - addMagicArmor / 100f;
					hit.m_damage.m_fire *= num;
					hit.m_damage.m_frost *= num;
					hit.m_damage.m_lightning *= num;
					hit.m_damage.m_poison *= num;
					hit.m_damage.m_spirit *= num;
				}
			}
		}

		[HarmonyPatch(typeof(Attack), "GetAttackStamina")]
		public static class StaminaAttack_Patch
		{
			public static void Postfix(ref float __result)
			{
				float num = 1f - Instance.getAttackStamina() / 100f;
				__result *= num;
			}
		}

		[HarmonyPatch(typeof(SEMan), "ModifyRunStaminaDrain")]
		public static class ModifyRun_Patch
		{
			public static void Postfix(ref float drain)
			{
				float num = 1f - Instance.getStaminaReduction() / 100f;
				drain *= num;
			}
		}

		[HarmonyPatch(typeof(SEMan), "ModifyJumpStaminaUsage")]
		public static class ModifyJump_Patch
		{
			public static void Postfix(ref float staminaUse)
			{
				float num = 1f - Instance.getStaminaReduction() / 100f;
				staminaUse *= num;
			}
		}

		[HarmonyPatch(typeof(SEMan), "ModifyStaminaRegen")]
		public static class RegenStamina_Patch
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			public static void Postfix(SEMan __instance, ref float staminaMultiplier)
			{
				if (__instance.m_character.IsPlayer())
				{
					float staminaRegen = Instance.getStaminaRegen();
					staminaMultiplier += staminaRegen / 100f;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "GetTotalFoodValue")]
		public static class AddStamina_Path
		{
			public static void Postfix(ref float stamina)
			{
				stamina += Instance.getAddStamina();
			}
		}

		[HarmonyPatch(typeof(Character), "RPC_Damage")]
		public static class PhysicArmor_Path
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			public static void Prefix(Character __instance, HitData hit)
			{
				if (__instance.IsPlayer() && !((Object)(object)hit.GetAttacker() == (Object)(object)__instance))
				{
					float addPhysicArmor = Instance.getAddPhysicArmor();
					float num = 1f - addPhysicArmor / 100f;
					hit.m_damage.m_blunt *= num;
					hit.m_damage.m_slash *= num;
					hit.m_damage.m_pierce *= num;
					hit.m_damage.m_chop *= num;
					hit.m_damage.m_pickaxe *= num;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "GetTotalFoodValue")]
		public static class AddEitrFood_Path
		{
			public static void Postfix(ref float eitr)
			{
				if (eitr > 2f || EpicMMOSystem.addDefaultEitr.Value > 0f)
				{
					float addEitr = Instance.getAddEitr();
					eitr += addEitr + EpicMMOSystem.addDefaultEitr.Value;
				}
			}
		}

		[HarmonyPatch(typeof(ItemData), "GetDamage", new Type[]
		{
			typeof(int),
			typeof(float)
		})]
		public class AddDamageIntellect_Path
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			public static void Postfix(ref ItemData __instance, ref DamageTypes __result)
			{
				if (!((Object)(object)Player.m_localPlayer == (Object)null) && ((Humanoid)Player.m_localPlayer).m_inventory.ContainsItem(__instance))
				{
					float num = Instance.getAddMagicDamage() / 100f + 1f;
					__result.m_fire *= num;
					__result.m_frost *= num;
					__result.m_lightning *= num;
					__result.m_poison *= num;
					__result.m_spirit *= num;
				}
			}
		}

		[HarmonyPatch(typeof(SEMan), "ModifyEitrRegen")]
		public static class RegenEitr_Patch
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			public static void Postfix(SEMan __instance, ref float eitrMultiplier)
			{
				if (__instance.m_character.IsPlayer())
				{
					float eitrRegen = Instance.getEitrRegen();
					eitrMultiplier += eitrRegen / 100f;
				}
			}
		}

		[HarmonyPatch(typeof(Game), "Start")]
		public static class RegisterRpcStrength
		{
			public static void Postfix()
			{
				ZRoutedRpc.instance.Register<ZPackage>("EpicMMOSystem GiveCritToPlayer", (Action<long, ZPackage>)RPC_GiveCritToPlayer);
			}
		}

		[HarmonyPatch(typeof(ItemData), "GetDamage", new Type[]
		{
			typeof(int),
			typeof(float)
		})]
		public class AddDamageStrength_Path
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			public static void Postfix(ref ItemData __instance, ref DamageTypes __result)
			{
				if (!((Object)(object)Player.m_localPlayer == (Object)null) && ((Humanoid)Player.m_localPlayer).m_inventory.ContainsItem(__instance))
				{
					float num = Instance.getAddPhysicDamage() / 100f + 1f;
					__result.m_blunt *= num;
					__result.m_slash *= num;
					__result.m_pierce *= num;
					__result.m_chop *= num;
					__result.m_pickaxe *= num;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "GetMaxCarryWeight")]
		public class AddWeight_Path
		{
			private static void Postfix(ref float __result)
			{
				float num = (float)Math.Round(Instance.getAddWeight() + EpicMMOSystem.addDefaultWeight.Value);
				__result += num;
			}
		}

		[HarmonyPatch(typeof(SEMan), "ModifyBlockStaminaUsage")]
		private static class ModifyBlockStaminaUsage_BlockAttack_Patch
		{
			private static void Postfix(float baseStaminaUse, ref float staminaUse)
			{
				staminaUse -= Instance.getReducedStaminaBlock() / 100f * staminaUse;
			}
		}

		[HarmonyPatch(typeof(Character), "ApplyDamage")]
		public class AddCritDmg
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			private static void Prefix(Character __instance, ref bool showDamageText, ref HitData hit)
			{
				//IL_0026: 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_0136: Unknown result type (might be due to invalid IL or missing references)
				//IL_017f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0186: Expected O, but got Unknown
				//IL_018a: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance == (Object)null || !hit.HaveAttacker())
				{
					return;
				}
				Character attacker = hit.GetAttacker();
				if ((Object)(object)attacker == (Object)null || (int)__instance.m_faction == 0 || (int)attacker.m_faction != 0 || Random.Range(0f, 100f) >= Instance.getAddCriticalChance())
				{
					return;
				}
				float num = 1f + Instance.getAddCriticalDmg() / 100f;
				hit.m_damage.m_blunt *= num;
				hit.m_damage.m_slash *= num;
				hit.m_damage.m_pierce *= num;
				hit.m_damage.m_chop *= num;
				hit.m_damage.m_pickaxe *= num;
				hit.m_damage.m_fire *= num;
				hit.m_damage.m_frost *= num;
				hit.m_damage.m_lightning *= num;
				hit.m_damage.m_poison *= num;
				hit.m_damage.m_spirit *= num;
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && (Object)(object)attacker == (Object)(object)Player.m_localPlayer)
				{
					new CritDmgVFX().CriticalVFX(hit.m_point, hit.GetTotalDamage());
					showDamageText = false;
					EpicMMOSystem.MLLogger.LogInfo((object)$"You got a Critical Hit: {hit.GetTotalDamage():0}");
					return;
				}
				Player val = (Player)(object)((attacker is Player) ? attacker : null);
				if (val != null && TryGetPeerId(val, out var peerId))
				{
					ZPackage val2 = new ZPackage();
					val2.Write(hit.m_point);
					val2.Write(hit.GetTotalDamage());
					ZRoutedRpc.instance.InvokeRoutedRPC(peerId, "EpicMMOSystem GiveCritToPlayer", new object[1] { val2 });
					EpicMMOSystem.MLLogger.LogInfo((object)$"Sent crit VFX to {((Character)val).GetHoverName()} for {hit.GetTotalDamage():0}");
				}
			}
		}

		[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(1)]
		private CultureInfo invC = CultureInfo.InvariantCulture;

		[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(1)]
		private static LevelSystem instance;

		[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(1)]
		private static Dictionary<int, long> levelsExp;

		[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(1)]
		private string pluginKey = "EpicMMOSystem";

		[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(1)]
		private const string midleKey = "LevelSystem";

		[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(1)]
		private int[] depositPoint = new int[6];

		private float singleRate;

		private static int HoldCarryWeightTimes;

		private static float HoldCarryWeight;

		[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(1)]
		public static LevelSystem Instance
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			get
			{
				if (instance == null)
				{
					instance = new LevelSystem();
					return instance;
				}
				return instance;
			}
		}

		public float getaddMiningDmg(int pointpending = 0)
		{
			int num = getParameter(Parameter.Special) + pointpending;
			float value = EpicMMOSystem.miningSpeed.Value;
			return (float)num * value;
		}

		public float getAddPieceHealth(int pointpending = 0)
		{
			int num = getParameter(Parameter.Special) + pointpending;
			float value = EpicMMOSystem.constructionPieceHealth.Value;
			return (float)num * value;
		}

		public float getAddTreeCuttingDmg(int pointpending = 0)
		{
			int num = getParameter(Parameter.Special) + pointpending;
			float value = EpicMMOSystem.treeCuttingSpeed.Value;
			return (float)num * value;
		}

		public float getAddHp(int pointpending = 0)
		{
			int num = getParameter(Parameter.Vigour) + pointpending;
			float value = EpicMMOSystem.addHp.Value;
			return (float)num * value;
		}

		public float getAddRegenHp(int pointpending = 0)
		{
			int num = getParameter(Parameter.Vigour) + pointpending;
			float value = EpicMMOSystem.regenHp.Value;
			return (float)num * value;
		}

		public float getAddMagicArmor(int pointpending = 0)
		{
			int num = getParameter(Parameter.Vigour) + pointpending;
			float value = EpicMMOSystem.magicArmor.Value;
			return (float)num * value;
		}

		public int getLevel()
		{
			if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return 1;
			}
			if (!Player.m_localPlayer.m_knownTexts.ContainsKey(pluginKey + "_LevelSystem_Level"))
			{
				return 1;
			}
			return int.Parse(Player.m_localPlayer.m_knownTexts[pluginKey + "_LevelSystem_Level"]);
		}

		private void setLevel(int value)
		{
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				Player.m_localPlayer.m_knownTexts[pluginKey + "_LevelSystem_Level"] = value.ToString();
			}
		}

		public void recalcLevel()
		{
			long num = getTotalExp();
			setLevel(1);
			FillLevelsExp();
			long needExp = getNeedExp();
			int num2 = 0;
			while (num > needExp)
			{
				num -= needExp;
				num2++;
				needExp = getNeedExp(num2);
			}
			setCurrentExp(num);
			setLevel(num2 + 1);
			MyUI.updateExpBar();
		}

		public long getCurrentExp()
		{
			if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return 0L;
			}
			if (!Player.m_localPlayer.m_knownTexts.ContainsKey(pluginKey + "_LevelSystem_CurrentExp"))
			{
				return 0L;
			}
			long num = 0L;
			try
			{
				num = int.Parse(Player.m_localPlayer.m_knownTexts[pluginKey + "_LevelSystem_CurrentExp"]);
			}
			catch
			{
				Player.m_localPlayer.m_knownTexts[pluginKey + "_LevelSystem_CurrentExp"] = "2";
				num = 2L;
				EpicMMOSystem.MLLogger.LogWarning((object)"Error in getting current exp, setting exp to 2.");
			}
			return num;
		}

		private void setCurrentExp(long value)
		{
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				Player.m_localPlayer.m_knownTexts[pluginKey + "_LevelSystem_CurrentExp"] = value.ToString(invC);
			}
		}

		public long getTotalExp()
		{
			if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return 0L;
			}
			if (!Player.m_localPlayer.m_knownTexts.ContainsKey(pluginKey + "_LevelSystem_TotalExp"))
			{
				return 0L;
			}
			if (long.TryParse(Player.m_localPlayer.m_knownTexts[pluginKey + "_LevelSystem_TotalExp"], out var result))
			{
				return result;
			}
			EpicMMOSystem.MLLogger.LogWarning((object)"error on TotalExp, returned 0");
			return 0L;
		}

		private void setTotalExp(long value)
		{
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				Player.m_localPlayer.m_knownTexts[pluginKey + "_LevelSystem_TotalExp"] = value.ToString(invC);
			}
		}

		public void addTotalExp(long value)
		{
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				if (!Player.m_localPlayer.m_knownTexts.ContainsKey(pluginKey + "_LevelSystem_TotalExp"))
				{
					Player.m_localPlayer.m_knownTexts[pluginKey + "_LevelSystem_TotalExp"] = "1";
				}
				long num = 1L;
				num = ((!long.TryParse(Player.m_localPlayer.m_knownTexts[pluginKey + "_LevelSystem_TotalExp"], out var result)) ? value : (result + value));
				Player.m_localPlayer.m_knownTexts[pluginKey + "_LevelSystem_TotalExp"] = num.ToString(invC);
			}
		}

		private void setParameter(Parameter parameter, int value)
		{
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				int num;
				int num2 = Mathf.Clamp(value, 0, parameter.ToString() switch
				{
					"Strength" => EpicMMOSystem.maxValueStrength.Value, 
					"Agility" => EpicMMOSystem.maxValueDexterity.Value, 
					"Dexterity" => EpicMMOSystem.maxValueDexterity.Value, 
					"Intellect" => EpicMMOSystem.maxValueIntelligence.Value, 
					"Body" => EpicMMOSystem.maxValueEndurance.Value, 
					"Endurance" => EpicMMOSystem.maxValueEndurance.Value, 
					"Vigour" => EpicMMOSystem.maxValueVigour.Value, 
					"Special" => EpicMMOSystem.maxValueSpecializing.Value, 
					"Specializing" => EpicMMOSystem.maxValueSpecializing.Value, 
					_ => num = 205, 
				});
				Player.m_localPlayer.m_knownTexts[pluginKey + "_LevelSystem_" + parameter] = num2.ToString();
			}
		}

		public int getParameter(Parameter parameter)
		{
			if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return 0;
			}
			if (!Player.m_localPlayer.m_knownTexts.ContainsKey(pluginKey + "_LevelSystem_" + parameter))
			{
				return 0;
			}
			int num = int.Parse(Player.m_localPlayer.m_knownTexts[pluginKey + "_LevelSystem_" + parameter]);
			int num2;
			return Mathf.Clamp(num, 0, parameter.ToString() switch
			{
				"Strength" => EpicMMOSystem.maxValueStrength.Value, 
				"Agility" => EpicMMOSystem.maxValueDexterity.Value, 
				"Dexterity" => EpicMMOSystem.maxValueDexterity.Value, 
				"Intellect" => EpicMMOSystem.maxValueIntelligence.Value, 
				"Body" => EpicMMOSystem.maxValueEndurance.Value, 
				"Endurance" => EpicMMOSystem.maxValueEndurance.Value, 
				"Vigour" => EpicMMOSystem.maxValueVigour.Value, 
				"Special" => EpicMMOSystem.maxValueSpecializing.Value, 
				"Specializing" => EpicMMOSystem.maxValueSpecializing.Value, 
				_ => num2 = 205, 
			});
		}

		public int getFreePoints()
		{
			int value = EpicMMOSystem.freePointForLevel.Value;
			int value2 = EpicMMOSystem.startFreePoint.Value;
			int level = getLevel();
			int num = 0;
			try
			{
				string value3 = EpicMMOSystem.levelsForBinusFreePoint.Value;
				if (!Utility.IsNullOrWhiteSpace(value3))
				{
					string[] array = value3.Split(new char[1] { ',' });
					for (int i = 0; i < array.Length; i++)
					{
						string[] array2 = array[i].Split(new char[1] { ':' });
						if (int.Parse(array2[0]) <= level)
						{
							num += int.Parse(array2[1]);
							continue;
						}
						break;
					}
				}
			}
			catch (Exception ex)
			{
				MonoBehaviour.print((object)("Free point, bonus error: " + ex.Message));
			}
			int num2 = level * value + value2 + num;
			int num3 = 0;
			for (int j = 0; j < EpicMMOSystem.numofCats; j++)
			{
				num3 += getParameter((Parameter)j);
			}
			int totalDepositPoints = getTotalDepositPoints();
			return num2 - num3 - totalDepositPoints;
		}

		public void addPointsParametr(Parameter parameter, int addPoint)
		{
			int freePoints = getFreePoints();
			if (freePoints > 0)
			{
				int num = Mathf.Clamp(addPoint, 1, freePoints);
				depositPoint[(int)parameter] += num;
			}
		}

		public long getNeedExp(int addLvl = 0)
		{
			int key = Mathf.Clamp(getLevel() + 1 + addLvl, 1, EpicMMOSystem.maxLevel.Value);
			return levelsExp[key];
		}

		public void ResetAllParameter()
		{
			for (int i = 0; i < EpicMMOSystem.numofCats; i++)
			{
				setParameter((Parameter)i, 0);
			}
			MyUI.UpdateParameterPanel();
		}

		public void ResetTotalPoints()
		{
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				Player.m_localPlayer.m_knownTexts[pluginKey + "_LevelSystem_CurrentExp"] = "1";
				Player.m_localPlayer.m_knownTexts[pluginKey + "_LevelSystem_TotalExp"] = "1";
				Player.m_localPlayer.m_knownTexts[pluginKey + "_LevelSystem_Level"] = "1";
				MyUI.UpdateParameterPanel();
				MyUI.updateExpBar();
			}
		}

		public void ResetAllParameterPayment()
		{
			string value = EpicMMOSystem.prefabNameCoins.Value;
			string name = ZNetScene.instance.GetPrefab(value).GetComponent<ItemDrop>().m_itemData.m_shared.m_name;
			int priceResetPoints = getPriceResetPoints();
			if (((Humanoid)Player.m_localPlayer).m_inventory.CountItems(name, -1, true) < priceResetPoints)
			{
				string name2 = ZNetScene.instance.GetPrefab("ResetTrophy").GetComponent<ItemDrop>().m_itemData.m_shared.m_name;
				if (((Humanoid)Player.m_localPlayer).m_inventory.CountItems(name2, -1, true) > 0)
				{
					((Humanoid)Player.m_localPlayer).m_inventory.RemoveItem(name2, 1, -1, true);
					ResetAllParameter();
				}
			}
			else
			{
				((Humanoid)Player.m_localPlayer).m_inventory.RemoveItem(name, priceResetPoints, -1, true);
				ResetAllParameter();
			}
		}

		public void SetSingleRate(float rate)
		{
			singleRate = rate;
		}

		public void AddExp(int exp, bool noxpMulti = false)
		{
			if (exp < 1)
			{
				if (exp == -2)
				{
					Util.FloatingText(EpicMMOSystem.noExpPastLVLPopup.Value);
				}
				return;
			}
			float value = EpicMMOSystem.rateExp.Value;
			float num = (float)exp * (value + singleRate);
			if (noxpMulti)
			{
				num = exp;
			}
			if (((Character)Player.m_localPlayer).m_seman.HaveStatusEffect(StringExtensionMethods.GetStableHashCode("Potion_MMO_Greater")))
			{
				num = EpicMMOSystem.XPforGreaterPotion.Value * num;
			}
			else if (((Character)Player.m_localPlayer).m_seman.HaveStatusEffect(StringExtensionMethods.GetStableHashCode("Potion_MMO_Medium")))
			{
				num = EpicMMOSystem.XPforMediumPotion.Value * num;
			}
			else if (((Character)Player.m_localPlayer).m_seman.HaveStatusEffect(StringExtensionMethods.GetStableHashCode("Potion_MMO_Minor")))
			{
				num = EpicMMOSystem.XPforMinorPotion.Value * num;
			}
			long currentExp = getCurrentExp();
			long needExp = getNeedExp();
			currentExp += (int)num;
			int num2 = 0;
			while (currentExp >= needExp)
			{
				currentExp -= needExp;
				num2++;
				needExp = getNeedExp(num2);
			}
			if (num2 > 0)
			{
				AddLevel(num2);
			}
			addTotalExp((int)num);
			setCurrentExp(currentExp);
			MyUI.updateExpBar();
			if (EpicMMOSystem.leftMessageXP.Value)
			{
				((Character)Player.m_localPlayer).Message((MessageType)1, string.Format("{0}: {1}", EpicMMOSystem.localizationold["$get_exp"], (int)num), 0, (Sprite)null);
			}
			num = (float)Math.Round(num);
			Util.FloatingText(EpicMMOSystem.XPstring.Value.Replace("@", num.ToString()) ?? "");
		}

		public void AddLevel(int count)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (count > 0)
			{
				int level = getLevel();
				level += count;
				setLevel(Mathf.Clamp(level, 1, EpicMMOSystem.maxLevel.Value));
				PlayerFVX.levelUp();
				ZDO zDO = ((Character)Player.m_localPlayer).m_nview.GetZDO();
				zDO.Set(pluginKey + "_level", level);
				ZDOMan.instance.ForceSendZDO(zDO.m_uid);
			}
		}

		public bool hasDepositPoints()
		{
			bool result = false;
			int[] array = depositPoint;
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i] > 0)
				{
					result = true;
					break;
				}
			}
			return result;
		}

		public void applyDepositPoints()
		{
			for (int i = 0; i < depositPoint.Length; i++)
			{
				if (depositPoint[i] != 0)
				{
					Parameter parameter = (Parameter)i;
					int num = depositPoint[i];
					int parameter2 = getParameter(parameter);
					setParameter(parameter, parameter2 + num);
					depositPoint[i] = 0;
				}
			}
			MyUI.UpdateParameterPanel();
		}

		public int getDepositPoint(Parameter parameter)
		{
			return depositPoint[(int)parameter];
		}

		public int getTotalDepositPoints()
		{
			int num = 0;
			for (int i = 0; i < depositPoint.Length; i++)
			{
				if (depositPoint[i] != 0)
				{
					num += depositPoint[i];
				}
			}
			return num;
		}

		public void cancelDepositPoints()
		{
			if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return;
			}
			for (int i = 0; i < depositPoint.Length; i++)
			{
				if (depositPoint[i] != 0)
				{
					depositPoint[i] = 0;
				}
			}
			MyUI.UpdateParameterPanel();
		}

		public int getPriceResetPoints()
		{
			int num = 0;
			for (int i = 0; i < EpicMMOSystem.numofCats; i++)
			{
				num += getParameter((Parameter)i);
			}
			return num * EpicMMOSystem.priceResetPoints.Value;
		}

		public void DeathPlayer()
		{
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			Player.m_localPlayer.m_customData[EpicMMOSystem.PlayerAliveString] = "0";
			ZDO zDO = ((Character)Player.m_localPlayer).m_nview.GetZDO();
			zDO.Set("EpicMMOSystem" + EpicMMOSystem.PlayerAliveString, 0);
			if (EpicMMOSystem.lossExp.Value && Player.m_localPlayer.HardDeath())
			{
				float value = EpicMMOSystem.minLossExp.Value;
				float value2 = EpicMMOSystem.maxLossExp.Value;
				float num = 1f - Random.Range(value, value2);
				long totalExp = getTotalExp();
				long currentExp = getCurrentExp();
				long currentExp2 = (long)((float)currentExp * num);
				setCurrentExp(currentExp2);
				setTotalExp(totalExp - (long)((float)currentExp * num));
				MyUI.updateExpBar();
				ZDOMan.instance.ForceSendZDO(zDO.m_uid);
			}
		}

		public void FillLevelsExp()
		{
			int value = EpicMMOSystem.levelExp.Value;
			float value2 = EpicMMOSystem.multiNextLevel.Value;
			int value3 = EpicMMOSystem.maxLevel.Value;
			levelsExp = new Dictionary<int, long>();
			if (EpicMMOSystem.levelexpforeachlevel.Value)
			{
				long num = 0L;
				for (int i = 1; i <= value3; i++)
				{
					num = (long)Math.Round((float)num * value2 + (float)value);
					levelsExp[i + 1] = num;
				}
			}
			else
			{
				long num2 = value;
				for (int j = 1; j <= value3; j++)
				{
					num2 = (long)Math.Round((float)num2 * value2);
					levelsExp[j + 1] = num2;
				}
			}
		}

		public void terminalSetLevel(int value)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Clamp(value, 1, EpicMMOSystem.maxLevel.Value);
			setLevel(num);
			setCurrentExp(1L);
			ResetAllParameter();
			PlayerFVX.levelUp();
			MyUI.updateExpBar();
			Player.m_localPlayer.m_customData["epicmmolevel"] = num.ToString();
			ZDO zDO = ((Character)Player.m_localPlayer).m_nview.GetZDO();
			zDO.Set(pluginKey + "_level", num);
			ZDOMan.instance.ForceSendZDO(zDO.m_uid);
		}

		public float getAddAttackSpeed(int pointpending = 0)
		{
			int num = getParameter(Parameter.Agility) + pointpending;
			float value = EpicMMOSystem.attackSpeed.Value;
			return (float)num * value;
		}

		public float getAttackStamina(int pointpending = 0)
		{
			int num = getParameter(Parameter.Agility) + pointpending;
			float value = EpicMMOSystem.attackStamina.Value;
			return (float)num * value;
		}

		public float getStaminaReduction(int pointpending = 0)
		{
			int num = getParameter(Parameter.Agility) + pointpending;
			float value = EpicMMOSystem.staminaReduction.Value;
			return (float)num * value;
		}

		public float getStaminaRegen(int pointpending = 0)
		{
			int num = getParameter(Parameter.Body) + pointpending;
			float value = EpicMMOSystem.staminaRegen.Value;
			return (float)num * value;
		}

		public float getAddStamina(int pointpending = 0)
		{
			int num = getParameter(Parameter.Body) + pointpending;
			float value = EpicMMOSystem.addStamina.Value;
			return (float)num * value;
		}

		public float getAddPhysicArmor(int pointpending = 0)
		{
			int num = getParameter(Parameter.Body) + pointpending;
			float value = EpicMMOSystem.physicArmor.Value;
			return (float)num * value;
		}

		public float getAddMagicDamage(int pointpending = 0)
		{
			int num = getParameter(Parameter.Intellect) + pointpending;
			float value = EpicMMOSystem.magicDamage.Value;
			return (float)num * value;
		}

		public float getEitrRegen(int pointpending = 0)
		{
			int num = getParameter(Parameter.Intellect) + pointpending;
			float value = EpicMMOSystem.magicEitrRegen.Value;
			return (float)num * value;
		}

		public float getAddEitr(int pointpending = 0)
		{
			int num = getParameter(Parameter.Intellect) + pointpending;
			float value = EpicMMOSystem.addEitr.Value;
			return (float)num * value;
		}

		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
		private static void RPC_GiveCritToPlayer(long sender, ZPackage pkg)
		{
			//IL_000f: 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_0021: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					Vector3 position = pkg.ReadVector3();
					float damage = pkg.ReadSingle();
					new CritDmgVFX().CriticalVFX(position, damage);
					EpicMMOSystem.MLLogger.LogInfo((object)"You recieved a Critical Hit from the combat owner: ");
				}
			}
			catch (Exception arg)
			{
				EpicMMOSystem.MLLogger.LogWarning((object)$"Bug catch RPC_GiveCritToPlayer: {arg}");
			}
		}

		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
		private static bool TryGetPeerId(Player p, out long peerId)
		{
			peerId = 0L;
			if (!Object.op_Implicit((Object)(object)p))
			{
				return false;
			}
			ZDO val = (Object.op_Implicit((Object)(object)((Character)p).m_nview) ? ((Character)p).m_nview.GetZDO() : null);
			if (val == null)
			{
				return false;
			}
			peerId = ((ZDOID)(ref val.m_uid)).UserID;
			return peerId != 0;
		}

		public float getAddPhysicDamage(int pointpending = 0)
		{
			int num = getParameter(Parameter.Strength) + pointpending;
			float value = EpicMMOSystem.physicDamage.Value;
			return (float)num * value;
		}

		public float getAddWeight(int pointpending = 0)
		{
			if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return 0f;
			}
			float num = 0f;
			if (HoldCarryWeightTimes == 0)
			{
				int num2 = getParameter(Parameter.Strength) + pointpending;
				float value = EpicMMOSystem.addWeight.Value;
				num = (HoldCarryWeight = (float)num2 * value);
			}
			else
			{
				num = HoldCarryWeight;
			}
			HoldCarryWeightTimes++;
			if (HoldCarryWeightTimes == 50)
			{
				HoldCarryWeightTimes = 0;
			}
			return num;
		}

		public float getReducedStaminaBlock(int pointpending = 0)
		{
			int num = getParameter(Parameter.Strength) + pointpending;
			float value = EpicMMOSystem.staminaBlock.Value;
			return (float)num * value;
		}

		public float getAddCriticalDmg(int pointpending = 0)
		{
			int num = getParameter(Parameter.Strength) + pointpending;
			float value = EpicMMOSystem.critDmg.Value;
			return (float)num * value + EpicMMOSystem.CriticalDefaultDamage.Value;
		}

		public float getAddCriticalChance(int pointpending = 0)
		{
			int num = getParameter(Parameter.Special) + pointpending;
			float value = EpicMMOSystem.critChance.Value;
			return (float)num * value + EpicMMOSystem.startCritChance.Value;
		}
	}
	[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
	[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
	public class FriendsData
	{
		private Dictionary<string, FriendInfo> friends = new Dictionary<string, FriendInfo>();

		public Dictionary<string, FriendInfo> getFriends()
		{
			if (friends.Count == 0)
			{
				LoadFriends();
			}
			return friends;
		}

		public void addFriends(FriendInfo friend)
		{
			if (!friends.ContainsKey(friend.name))
			{
				friends.Add(friend.name, friend);
				SaveFriends();
			}
		}

		public void updateFriends(FriendInfo friend)
		{
			friends[friend.name] = friend;
			SaveFriends();
		}

		public void deleteFriend(FriendInfo friend)
		{
			friends.Remove(friend.name);
			SaveFriends();
		}

		private void SaveFriends()
		{
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				string text = JSON.ToJSON(friends.Values.ToArray());
				Player.m_localPlayer.m_knownTexts["EpicMMOSystem_friend_list"] = text ?? "";
			}
		}

		private void LoadFriends()
		{
			if (!Object.op_Implicit((Object)(object)Player.m_localPlayer) || !Player.m_localPlayer.m_knownTexts.ContainsKey("EpicMMOSystem_friend_list"))
			{
				return;
			}
			friends.Clear();
			FriendInfo[] array = JSON.ToObject<FriendInfo[]>(Player.m_localPlayer.m_knownTexts["EpicMMOSystem_friend_list"] ?? "");
			if (array != null)
			{
				FriendInfo[] array2 = array;
				foreach (FriendInfo friendInfo in array2)
				{
					friends.Add(friendInfo.name, friendInfo);
				}
			}
		}

		public void ClearFriend()
		{
			friends.Clear();
		}
	}
	[Serializable]
	[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
	[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
	public class FriendInfo
	{
		public string name;

		public string host;

		public int level;

		public int moClass;
	}
	[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
	[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
	public static class FriendsSystem
	{
		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		private static class ZrouteMethodsServerFeedback
		{
			private static void Postfix()
			{
				if (!isServer)
				{
					ZRoutedRpc.instance.Register<int, int>(modName + " InviteFriend", (Action<long, int, int>)RPC_InviteFriend);
					ZRoutedRpc.instance.Register<int, int>(modName + " AcceptInviteFriend", (Action<long, int, int>)RPC_AcceptFriend);
					ZRoutedRpc.instance.Register<string>(modName + " RejectInviteFriend", (Action<long, string>)RPC_RejectFriend);
				}
			}
		}

		private static bool isServer => (int)SystemInfo.graphicsDeviceType == 4;

		private static string modName => "EpicMMOSystem";

		private static Localizationold local => EpicMMOSystem.localizationold;

		public static void Init()
		{
		}

		public static void inviteFriend(string name)
		{
			//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_001d: 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_003f: 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_009c: 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)
			foreach (PlayerInfo player in ZNet.instance.GetPlayerList())
			{
				if (player.m_name == name)
				{
					int level = LevelSystem.Instance.getLevel();
					ZRoutedRpc instance = ZRoutedRpc.instance;
					ZDOID characterID = player.m_characterID;
					instance.InvokeRoutedRPC(((ZDOID)(ref characterID)).UserID, modName + " InviteFriend", new object[2]
					{
						level,
						((Character)Player.m_localPlayer).m_nview.GetZDO().GetInt("MagicOverhaulClass", 0)
					});
					Chat.instance.RPC_ChatMessage(200L, Vector3.zero, 0, UserInfo.GetLocalUser(), string.Format(local["$send_invite"], name));
					return;
				}
			}
			Chat.instance.RPC_ChatMessage(200L, Vector3.zero, 0, UserInfo.GetLocalUser(), string.Format(local["$not_found"], name));
		}

		public static void acceptInvite(FriendInfo info, PlayerInfo player)
		{
			ZRoutedRpc.instance.InvokeRoutedRPC(((ZDOID)(ref player.m_characterID)).UserID, modName + " AcceptInviteFriend", new object[2]
			{
				info.level,
				((Character)Player.m_localPlayer).m_nview.GetZDO().GetInt("MagicOverhaulClass", 0)
			});
		}

		public static void rejectInvite(FriendInfo info, PlayerInfo player)
		{
			ZRoutedRpc.instance.InvokeRoutedRPC(((ZDOID)(ref player.m_characterID)).UserID, modName + " RejectInviteFriend", new object[1] { info.name });
		}

		private static void RPC_InviteFriend(long sender, int level, int moClass)
		{
			//IL_0023: 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_0054: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			PlayerInfo val = ZNet.instance.GetPlayerList().Find((PlayerInfo f) => ((ZDOID)(ref f.m_characterID)).UserID == sender);
			if (((ZDOID)(ref val.m_characterID)).UserID != sender)
			{
				EpicMMOSystem.MLLogger.LogWarning((object)"Friend invite sender was not found in player list.");
				return;
			}
			FriendInfo friendInfo = new FriendInfo();
			friendInfo.name = val.m_name;
			friendInfo.level = level;
			friendInfo.moClass = moClass;
			Chat.instance.RPC_ChatMessage(200L, Vector3.zero, 0, UserInfo.GetLocalUser(), string.Format(local["$get_invite"], friendInfo.name));
			MyUI.addInviteFriend(friendInfo, val);
		}

		private static void RPC_AcceptFriend(long sender, int level, int moClass)
		{
			//IL_0023: 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_0054: 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)
			PlayerInfo val = ZNet.instance.GetPlayerList().Find((PlayerInfo f) => ((ZDOID)(ref f.m_characterID)).UserID == sender);
			if (((ZDOID)(ref val.m_characterID)).UserID != sender)
			{
				EpicMMOSystem.MLLogger.LogWarning((object)"Accepted friend sender was not found in player list.");
				return;
			}
			FriendInfo friendInfo = new FriendInfo();
			friendInfo.name = val.m_name;
			friendInfo.level = level;
			friendInfo.moClass = moClass;
			Chat.instance.RPC_ChatMessage(200L, Vector3.zero, 0, UserInfo.GetLocalUser(), string.Format(local["$accept_invite"], friendInfo.name));
			MyUI.acceptInvited(friendInfo);
		}

		private static void RPC_RejectFriend(long sender, string name)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			Chat.instance.RPC_ChatMessage(200L, Vector3.zero, 0, UserInfo.GetLocalUser(), string.Format(local["$cancel_invite"]));
		}
	}
	[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
	[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
	public static class MyUI
	{
		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		[HarmonyPatch(typeof(InventoryGui), "Show")]
		public static class ShowPanel_Path
		{
			public static void Postfix()
			{
				Show();
			}
		}

		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		[HarmonyPatch(typeof(InventoryGui), "Hide")]
		public static class HidePanel_Path
		{
			public static void Postfix()
			{
				Hide();
			}
		}

		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		[HarmonyPatch(typeof(Menu), "IsVisible")]
		private static class BufferUIFix
		{
			private static void Postfix(ref bool __result)
			{
				if (textField.isFocused)
				{
					__result = true;
				}
			}
		}

		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		[HarmonyPatch(typeof(Hud), "SetVisible")]
		public static class Vis
		{
			private static void Postfix(bool visible)
			{
				if (visible && !UIToggle && !EpicMMOSystem.oldExpBar.Value)
				{
					((Component)expPanelRoot).gameObject.SetActive(true);
					UIToggle = true;
					DragControl.SaveWindowPositions(((Component)expPanel).gameObject, initialLoad: true);
					DragControl.SaveWindowPositions(((Component)hp).gameObject, initialLoad: true);
					DragControl.SaveWindowPositions(((Component)stamina).gameObject, initialLoad: true);
					EpicMMOSystemUI.coroutine = ((MonoBehaviour)EpicMMOSystemUI.Instance).StartCoroutine("Positionpanels");
				}
				if (!visible && UIToggle && !EpicMMOSystem.oldExpBar.Value)
				{
					((Component)expPanelRoot).gameObject.SetActive(false);
					UIToggle = false;
				}
			}
		}

		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		[HarmonyPatch(typeof(Hud), "Awake")]
		public static class InstantiateExpPanel
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			private static void Postfix(Hud __instance)
			{
				//IL_018f: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a8: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				if (EpicMMOSystem.oldExpBar.Value)
				{
					Transform transform = Object.Instantiate<GameObject>(EpicMMOSystem._asset.LoadAsset<GameObject>("ExpPanel"), __instance.m_rootObject.transform).transform;
					eLevelText = ((Component)transform.Find("Lvl")).GetComponent<Text>();
					eExpText = ((Component)transform.Find("Exp")).GetComponent<Text>();
					eBarImage = ((Component)transform.Find("Bar/Fill")).GetComponent<Image>();
					eOldBarImage = eBarImage;
					Color val = default(Color);
					if (ColorUtility.TryParseHtmlString(EpicMMOSystem.ExpColor.Value, ref val))
					{
						if (EpicMMOSystem.ExpColor.Value == "#FFFFFF")
						{
							((Graphic)eBarImage).color = val;
						}
						else
						{
							((Graphic)eBarImage).color = val * 2f;
						}
					}
					return;
				}
				expPanelRoot = Object.Instantiate<GameObject>(EpicMMOSystem._asset.LoadAsset<GameObject>("EpicHudPanelCanvas")).transform;
				((Component)expPanelRoot).gameObject.SetActive(false);
				InitHudPanel();
				DHpBar = ((Component)((Transform)__instance.m_healthPanel).Find("Health")).gameObject;
				IconHpBar = ((Component)((Transform)__instance.m_healthPanel).Find("healthicon")).gameObject;
				if (!EpicMMOSystem.oldExpBar.Value)
				{
					((Component)((Transform)__instance.m_healthPanel).Find("Health")).gameObject.SetActive(false);
					((Component)((Transform)__instance.m_healthPanel).Find("healthicon")).gameObject.SetActive(false);
				}
				Transform val2 = __instance.m_buildHud.transform.Find("SelectedInfo");
				if (Object.op_Implicit((Object)(object)val2))
				{
					val2.localPosition += new Vector3(0f, 45f, 0f);
				}
				EpicMMOSystem.MLLogger.LogInfo((object)"Call Awake");
			}
		}

		[HarmonyPatch(typeof(Hud), "UpdateHealth")]
		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		public static class UpdateHealth
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			private static bool Prefix(Player player)
			{
				if (EpicMMOSystem.oldExpBar.Value)
				{
					eLevelText.text = string.Format("{0} {1}", localization["$lvl"], currentLVL);
					return true;
				}
				if (!firstloadHP)
				{
					((Component)((Component)expPanelRoot).GetComponent<Canvas>()).gameObject.SetActive(true);
					firstloadHP = true;
				}
				if (DisableHPBar)
				{
					return true;
				}
				float health = ((Character)player).GetHealth();
				float maxHealth = ((Character)player).GetMaxHealth();
				hpImage.fillAmount = health / maxHealth;
				string text = "";
				text = ((!EpicMMOSystem.showMaxHp.Value) ? Mathf.CeilToInt(health).ToString() : (Mathf.CeilToInt(health) + " / " + Mathf.CeilToInt(maxHealth)));
				hpText.text = text;
				return false;
			}
		}

		[HarmonyPatch(typeof(Hud), "UpdateStamina")]
		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		public static class UpdateStamina
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			private static bool Prefix(Player player)
			{
				if (EpicMMOSystem.oldExpBar.Value)
				{
					return true;
				}
				if (DisableStaminaBar)
				{
					return true;
				}
				float stamina = player.GetStamina();
				float maxStamina = ((Character)player).GetMaxStamina();
				staminaImage.fillAmount = stamina / maxStamina;
				string text = "";
				text = ((!EpicMMOSystem.showMaxHp.Value) ? Mathf.CeilToInt(stamina).ToString() : (Mathf.CeilToInt(stamina) + " / " + Mathf.CeilToInt(maxStamina)));
				staminaText.text = text;
				return false;
			}
		}

		[HarmonyPatch(typeof(Hud), "UpdateEitr")]
		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		public static class UpdateEitr
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			private static bool Prefix(Player player)
			{
				if (EpicMMOSystem.oldExpBar.Value)
				{
					return true;
				}
				if (DisableEitrBar)
				{
					EitrGameObj.SetActive(false);
				}
				if (DisableEitrBar)
				{
					return true;
				}
				float eitr = player.GetEitr();
				float maxEitr = ((Character)player).GetMaxEitr();
				if (flagforMove > 0)
				{
					DragControl.RestoreWindow(((Component)hp).gameObject);
					DragControl.RestoreWindow(((Component)Exp).gameObject);
					DragControl.RestoreWindow(((Component)stamina).gameObject);
					if (flagforMove == 2)
					{
						DragControl.RestoreWindow(EitrGameObj);
					}
					flagforMove = 0;
				}
				if (maxEitr < 2f && EitrGameObj.activeSelf && !EpicMMOSystem.forceMagicBar.Value)
				{
					EitrGameObj.SetActive(false);
					((Component)expPanel).GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)0, 1050f);
					flagforMove = 1;
				}
				if ((maxEitr > 2f || EpicMMOSystem.forceMagicBar.Value) && !EitrGameObj.activeSelf)
				{
					EitrGameObj.SetActive(true);
					((Component)expPanel).GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)0, 1475f);
					flagforMove = 2;
				}
				EitrImage.fillAmount = eitr / maxEitr;
				string text = "";
				text = ((!EpicMMOSystem.showMaxHp.Value) ? Mathf.CeilToInt(eitr).ToString() : (Mathf.CeilToInt(eitr) + " / " + Mathf.CeilToInt(maxEitr)));
				Eitr.text = text;
				firstload = true;
				return false;
			}
		}

		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		[HarmonyPatch(typeof(Game), "SpawnPlayer")]
		public static class UpdateExpPanelForStart
		{
			private static void Postfix()
			{
				try
				{
					updateExpBar();
					if (!EpicMMOSystem.oldExpBar.Value)
					{
						((Component)expPanelRoot).gameObject.SetActive(true);
					}
				}
				catch (Exception ex)
				{
					MonoBehaviour.print((object)("Error set expbar: " + ex.Message));
					throw;
				}
			}
		}

		[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
		private class FriendsCell
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
			public enum StatusFriend
			{
				online,
				offline,
				invite
			}

			private GameObject cell;

			private FriendInfo friend;

			private Text nameText;

			private Text levelText;

			private Image icon;

			private PlayerInfo player;

			private StatusFriend status;

			public FriendsCell(GameObject cell, FriendInfo friend, PlayerInfo info, StatusFriend status)
			{
				//IL_0015: 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)
				//IL_0258: Unknown result type (might be due to invalid IL or missing references)
				//IL_012d: 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)
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0302: Unknown result type (might be due to invalid IL or missing references)
				//IL_030c: Expected O, but got Unknown
				//IL_032d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0337: Expected O, but got Unknown
				//IL_0358: Unknown result type (might be due to invalid IL or missing references)
				//IL_0362: Expected O, but got Unknown
				this.cell = cell;
				this.friend = friend;
				player = info;
				nameText = ((Component)cell.transform.Find("Name")).GetComponent<Text>();
				levelText = ((Component)cell.transform.Find("Level")).GetComponent<Text>();
				icon = ((Component)cell.transform.Find("IconClass")).GetComponent<Image>();
				nameText.text = friend.name;
				this.status = status;
				int num = friend.level;
				int num2 = friend.moClass;
				switch (status)
				{
				case StatusFriend.online:
					try
					{
						ZDO zDO = ZDOMan.instance.GetZDO(info.m_characterID);
						num = zDO.GetInt("EpicMMOSystem_level", 1);
						num2 = zDO.GetInt("MagicOverhaulClass", 0);
					}
					catch (Exception ex)
					{
						MonoBehaviour.print((object)("Ошибка в получении значений из здо: " + ex.Message));
					}
					((Component)cell.transform.Find("Status")).GetComponent<Text>().text = localization["$online"];
					((Graphic)((Component)cell.transform.Find("Status")).GetComponent<Text>()).color = Color.green;
					((Component)cell.transform.Find("Buttons/Accept")).gameObject.SetActive(false);
					if (!Groups.API.IsLoaded())
					{
						((Component)cell.transform.Find("Buttons/AddGroup")).gameObject.SetActive(false);
					}
					else if (Groups.API.GroupPlayers().Count > 0 && (Groups.API.GetLeader()?.name ?? "") != Player.m_localPlayer.GetPlayerName())
					{
						((Component)cell.transform.Find("Buttons/AddGroup")).gameObject.SetActive(false);
					}
					break;
				case StatusFriend.offline:
					((Component)cell.transform.Find("Buttons/AddGroup")).gameObject.SetActive(false);
					((Component)cell.transform.Find("Buttons/Accept")).gameObject.SetActive(false);
					((Component)cell.transform.Find("Status")).GetComponent<Text>().text = localization["$offline"];
					((Graphic)((Component)cell.transform.Find("Status")).GetComponent<Text>()).color = Color.red;
					break;
				case StatusFriend.invite:
					((Component)cell.transform.Find("Buttons/AddGroup")).gameObject.SetActive(false);
					((Component)cell.transform.Find("Status")).GetComponent<Text>().text = "";
					break;
				}
				levelText.text = string.Format("{0}: {1}", localization["$level"], num);
				if (num2 != 0)
				{
					icon.sprite = sprites[num2];
				}
				((UnityEvent)((Component)cell.transform.Find("Buttons/AddGroup")).GetComponent<Button>().onClick).AddListener(new UnityAction(inviteGroup));
				((UnityEvent)((Component)cell.transform.Find("Buttons/Accept")).GetComponent<Button>().onClick).AddListener(new UnityAction(acceptInvite));
				((UnityEvent)((Component)cell.transform.Find("Buttons/Delete")).GetComponent<Button>().onClick).AddListener(new UnityAction(deleteFriend));
				if (num > friend.level || num2 != friend.moClass)
				{
					friend.level = num;
					friend.moClass = num2;
					friendsData.updateFriends(friend);
				}
			}

			private void inviteGroup()
			{
				if (Groups.API.GroupPlayers().Count > 0)
				{
					foreach (PlayerReference item in Groups.API.GroupPlayers())
					{
						if (item.name == friend.name)
						{
							return;
						}
					}
					string playerName = Player.m_localPlayer.GetPlayerName();
					if ((Groups.API.GetLeader()?.name ?? "") == playerName)
					{
						ZRoutedRpc.instance.InvokeRoutedRPC(((ZDOID)(ref player.m_characterID)).UserID, "Groups InvitePlayer", new object[1] { playerName });
					}
				}
				else
				{
					Groups.API.CreateNewGroup();
					ZRoutedRpc.instance.InvokeRoutedRPC(((ZDOID)(ref player.m_characterID)).UserID, "Groups InvitePlayer", new object[1] { Player.m_localPlayer.GetPlayerName() });
				}
			}

			private void acceptInvite()
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				FriendsSystem.acceptInvite(friend, player);
				inviteList.Remove(friend);
				acceptInvited(friend);
				Destroy();
			}

			private void deleteFriend()
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				if (status == StatusFriend.invite)
				{
					inviteList.Remove(friend);
					FriendsSystem.rejectInvite(friend, player);
					updateInviteList();
				}
				else
				{
					friendsData.deleteFriend(friend);
					updateFriendsList();
				}
			}

			public void Destroy()
			{
				Object.Destroy((Object)(object)cell);
			}
		}

		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		[HarmonyPatch(typeof(Game), "Logout")]
		public static class DataFriendsClear
		{
			public static void Prefix()
			{
				inviteList.Clear();
				friendsData.ClearFriend();
			}
		}

		[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
		private class ParameterButton
		{
			private Parameter parameter;

			private Transform head;

			private GameObject buttons;

			private Text text;

			public ParameterButton(Transform head, Parameter parameter)
			{
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Expected O, but got Unknown
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Expected O, but got Unknown
				this.head = head;
				this.parameter = parameter;
				text = ((Component)head.Find("Text")).GetComponent<Text>();
				buttons = ((Component)head.Find("Buttons")).gameObject;
				((UnityEvent)((Component)buttons.transform.Find("Plus1")).GetComponent<Button>().onClick).AddListener(new UnityAction(ClickButton1));
				((UnityEvent)((Component)buttons.transform.Find("Plus5")).GetComponent<Button>().onClick).AddListener(new UnityAction(ClickButton5));
			}

			private void ClickButton1()
			{
				LevelSystem.Instance.addPointsParametr(parameter, 1);
				UpdateParameterPanel();
			}

			private void ClickButton5()
			{
				LevelSystem.Instance.addPointsParametr(parameter, 5);
				UpdateParameterPanel();
			}

			public void UpdateParameters(int freePoints)
			{
				int num = parameter.ToString() switch
				{
					"Strength" => EpicMMOSystem.maxValueStrength.Value, 
					"Agility" => EpicMMOSystem.maxValueDexterity.Value, 
					"Intellect" => EpicMMOSystem.maxValueIntelligence.Value, 
					"Body" => EpicMMOSystem.maxValueEndurance.Value, 
					"Vigour" => EpicMMOSystem.maxValueVigour.Value, 
					"Special" => EpicMMOSystem.maxValueSpecializing.Value, 
					_ => num = 205, 
				};
				int num2 = LevelSystem.Instance.getParameter(parameter);
				int depositPoint = LevelSystem.Instance.getDepositPoint(parameter);
				num2 += depositPoint;
				text.text = string.Format("{0}: {1}", localization["$parameter_" + parameter.ToString().ToLower()], num2);
				buttons.SetActive(freePoints > 0 && num2 < num);
			}
		}

		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		[HarmonyPatch(typeof(InventoryGui), "Awake")]
		private static class InventoryGui_Awake_Patch
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			private static void Postfix(InventoryGui __instance)
			{
				UITooltip[] componentsInChildren = levelSystemPanel.GetComponentsInChildren<UITooltip>(true);
				foreach (UITooltip val in componentsInChildren)
				{
					val.m_tooltipPrefab = __instance.m_playerGrid.m_elementPrefab.GetComponent<UITooltip>().m_tooltipPrefab;
					switch (val.m_topic)
					{
					case "Strength":
						val.m_text = localization["$strength_tooltip"];
						val.m_topic = localization["$parameter_strength"];
						break;
					case "Dexterity":
						val.m_text = localization["$dexterity_tooltip"];
						val.m_topic = localization["$parameter_agility"];
						break;
					case "Intelect":
						val.m_text = localization["$intelect_tooltip"];
						val.m_topic = localization["$parameter_intellect"];
						break;
					case "Endurance":
						val.m_text = localization["$endurance_tooltip"];
						val.m_topic = localization["$parameter_body"];
						break;
					case "Vigour":
						val.m_text = localization["$vigour_tooltip"];
						val.m_topic = localization["$parameter_vigour"];
						break;
					case "Special":
						val.m_text = localization["$special_tooltip"];
						val.m_topic = localization["$parameter_special"];
						break;
					}
				}
			}
		}

		private static GameObject UI;

		internal static Text eLevelText;

		internal static Text eExpText;

		internal static Image eBarImage;

		internal static Image eOldBarImage = null;

		internal static Transform Exp;

		internal static bool DisableExpBar = false;

		internal static Text hpText;

		internal static Image hpImage;

		internal static Transform hp;

		internal static Transform hpFill;

		internal static Color hpFillColor;

		internal static bool DisableHPBar = false;

		internal static GameObject DHpBar;

		internal static GameObject IconHpBar;

		internal static Text staminaText;

		internal static Image staminaImage;

		internal static Transform stamina;

		internal static Transform staminaBarFill;

		internal static Color staminaBarColor;

		internal static bool DisableStaminaBar = false;

		internal static Text Eitr;

		internal static Image EitrImage;

		internal static GameObject EitrGameObj;

		internal static Transform EitrTran;

		internal static Transform EitrFill;

		internal static Color EitrBarColor;

		internal static bool DisableEitrBar = false;

		internal static Transform expPanel;

		internal static Transform expPanelRoot;

		internal static Color expPanelBackgroundColor;

		internal static GameObject expPanelBackground;

		internal static int flagforMove = 0;

		internal static bool firstload = false;

		internal static bool firstloadHP = false;

		internal static int frameCount = 0;

		internal static int currentLVL = 1;

		internal static bool UIToggle = false;

		private static List<Sprite> sprites = new List<Sprite>();

		private static FriendsData friendsData = new FriendsData();

		private static GameObject friendsListPanel;

		private static GameObject friendsCell;

		private static GameObject headerInvited;

		private static GameObject contentInvited;

		private static GameObject headerFriends;

		private static GameObject contentFriends;

		private static GameObject addFriendAlert;

		private static InputField textField;

		private static List<FriendsCell> friendsCells = new List<FriendsCell>();

		private static List<FriendsCell> inviteCells = new List<FriendsCell>();

		private static Dictionary<FriendInfo, PlayerInfo> inviteList = new Dictionary<FriendInfo, PlayerInfo>();

		internal static GameObject levelSystemPanel;

		internal static GameObject levelSystemPanelRoot;

		private static GameObject alertResetPointPanel;

		private static Text alertResetPointText;

		private static List<ParameterButton> parameterButtons = new List<ParameterButton>();

		private static GameObject freePointsPanel;

		private static Text freePointsText;

		private static Text currentLevelText;

		private static Text expText;

		private static Text physicDamageText;

		private static Text addWeightText;

		private static Text criticalDmgMultText;

		private static Text attackSpeedMultiText;

		private static Text reducedStaminaText;

		private static Text attackStamina;

		private static Text magicDamageText;

		private static Text magicEitrRegText;

		private static Text eitrIncreaseText;

		private static Text addStaminaText;

		private static Text staminaRegen;

		private static Text reducedStaminaBlockText;

		private static Text physicArmorText;

		private static Text addHpText;

		private static Text regenHpText;

		private static Text magicArmorText;

		private static Text criticalChanceText;

		private static Text miningSpeedText;

		private static Text addpieceHealthText;

		private static Text treeCuttingSpeedText;

		internal static GameObject navigationPanel;

		private static Transform buttonLevelSystem;

		private static Transform buttonFriendsList;

		private static Transform buttonQuestPanel;

		private static Transform buttonProfessionsPanel;

		private static Transform ButtonGuildsPanel;

		private static Localizationold localization => EpicMMOSystem.localizationold;

		public static bool IsPanelVisible()
		{
			if (Object.op_Implicit((Object)(object)UI))
			{
				return UI.activeSelf;
			}
			return false;
		}

		public static void Init()
		{
			UI = Object.Instantiate<GameObject>(EpicMMOSystem._asset.LoadAsset<GameObject>("LevelHud"));
			Object.DontDestroyOnLoad((Object)(object)UI);
			UI.SetActive(false);
			InitNavigationPanel();
			InitLevelSystem();
			InitFriendsList();
			UI.GetComponentInChildren<Canvas>().sortingOrder = 1510;
		}

		public static void Hide()
		{
			navigationPanel.SetActive(false);
			levelSystemPanel.SetActive(false);
			levelSystemPanel.GetComponent<CanvasGroup>().interactable = true;
			alertResetPointPanel.SetActive(false);
			friendsListPanel.SetActive(false);
			friendsListPanel.GetComponent<CanvasGroup>().interactable = true;
			alertResetPointPanel.SetActive(false);
			addFriendAlert.SetActive(false);
			UI.SetActive(false);
			LevelSystem.Instance.cancelDepositPoints();
		}

		public static void Show()
		{
			ShowNavigationPanel();
			navigationPanel.SetActive(true);
			UI.SetActive(true);
		}

		public static void updateExpBar()
		{
			try
			{
				if (DisableExpBar)
				{
					((Component)Exp).gameObject.SetActive(false);
				}
				int level = LevelSystem.Instance.getLevel();
				long currentExp = LevelSystem.Instance.getCurrentExp();
				long needExp = LevelSystem.Instance.getNeedExp();
				if (!DisableExpBar || EpicMMOSystem.oldExpBar.Value)
				{
					string text = ((float)currentExp / (float)needExp * 100f).ToString("0.00");
					eLevelText.text = string.Format("{0} {1}", localization["$lvl"], level);
					eExpText.text = text.Replace(',', '.') + " %";
					eBarImage.fillAmount = (float)currentExp / (float)needExp;
					currentLVL = level;
				}
			}
			catch (Exception ex)
			{
				EpicMMOSystem.MLLogger.LogWarning((object)("ExpBar update failed " + ex));
			}
		}

		internal static void InitHudPanel()
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: 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_0145: 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_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: 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)
			expPanel = expPanelRoot.Find("EpicHudPanel");
			((Component)expPanelRoot).GetComponentInChildren<Canvas>().sortingOrder = 1511;
			expPanelBackground = ((Component)expPanel.Find("Background")).gameObject;
			expPanelBackgroundColor = ((Graphic)expPanelBackground.GetComponent<Image>()).color;
			((Component)expPanelRoot).GetComponent<CanvasScaler>().scaleFactor = EpicMMOSystem.HudBarScale.Value;
			if (EpicMMOSystem.HudExpBackgroundCol.Value == "none")
			{
				expPanelBackground.SetActive(false);
			}
			else
			{
				expPanelBackgroundColor = ColorUtil.GetColorFromHex(EpicMMOSystem.HudExpBackgroundCol.Value);
			}
			eLevelText = ((Component)expPanel.Find("Container/Exp/Lvl")).GetComponent<Text>();
			eExpText = ((Component)expPanel.Find("Container/Exp/Exp")).GetComponent<Text>();
			Exp = expPanel.Find("Container/Exp");
			eBarImage = ((Component)expPanel.Find("Container/Exp/Bar/Fill")).GetComponent<Image>();
			hpText = ((Component)expPanel.Find("Container/Hp/Text")).GetComponent<Text>();
			hpFill = expPanel.Find("Container/Hp/Bar/Fill");
			hpImage = ((Component)hpFill).GetComponent<Image>();
			hpFillColor = ((Graphic)hpImage).color;
			hp = expPanel.Find("Container/Hp");
			staminaText = ((Component)expPanel.Find("Container/Stamina/Text")).GetComponent<Text>();
			staminaBarFill = expPanel.Find("Container/Stamina/Bar/Fill");
			staminaImage = ((Component)staminaBarFill).GetComponent<Image>();
			staminaBarColor = ((Graphic)staminaImage).color;
			stamina = expPanel.Find("Container/Stamina");
			EitrTran = expPanel.Find("Container/Eitr");
			EitrGameObj = ((Component)expPanel.Find("Container/Eitr")).gameObject;
			Eitr = ((Component)expPanel.Find("Container/Eitr/Text")).GetComponent<Text>();
			EitrFill = expPanel.Find("Container/Eitr/Bar/Fill");
			EitrImage = ((Component)EitrFill).GetComponent<Image>();
			EitrBarColor = ((Graphic)EitrImage).color;
		}

		private static void InitFriendsList()
		{
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Expected O, but got Unknown
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Expected O, but got Unknown
			friendsListPanel = ((Component)UI.transform.Find("Canvas/FriendList")).gameObject;
			((Component)friendsListPanel.transform.Find("Background")).gameObject.AddComponent<DragMenu>().menu = friendsListPanel.transform;
			((Component)friendsListPanel.transform.Find("Header")).gameObject.AddComponent<DragMenu>().menu = friendsListPanel.transform;
			((Component)friendsListPanel.transform.Find("Header/Text")).GetComponent<Text>().text = localization["$friends_list"];
			friendsCell = EpicMMOSystem._asset.LoadAsset<GameObject>("FriendCell");
			((Graphic)((Component)friendsListPanel.transform.Find("Border")).GetComponent<Image>()).raycastTarget = false;
			((UnityEvent)((Component)friendsListPanel.transform.Find("Add")).GetComponent<Button>().onClick).AddListener(new UnityAction(clickButtonAdd));
			headerInvited = ((Component)friendsListPanel.transform.Find("Scroll View/Viewport/Content/HeaderInvited")).gameObject;
			headerInvited.SetActive(false);
			contentInvited = ((Component)friendsListPanel.transform.Find("Scroll View/Viewport/Content/Invited")).gameObject;
			headerFriends = ((Component)friendsListPanel.transform.Find("Scroll View/Viewport/Content/HeaderFriends")).gameObject;
			contentFriends = ((Component)friendsListPanel.transform.Find("Scroll View/Viewport/Content/Friends")).gameObject;
			((Component)headerInvited.transform.Find("Text")).GetComponent<Text>().text = localization["$invited"];
			((Component)headerFriends.transform.Find("Text")).GetComponent<Text>().text = localization["$friends"];
			addFriendAlert = ((Component)UI.transform.Find("Canvas/SendInvite")).gameObject;
			textField = ((Component)addFriendAlert.transform.Find("InputField")).GetComponent<InputField>();
			((Component)((Component)textField).transform.Find("Placeholder")).GetComponent<Text>().text = "";
			((UnityEvent)((Component)addFriendAlert.transform.Find("Buttons/Send")).GetComponent<Button>().onClick).AddListener(new UnityAction(clickButtonSend));
			((Component)addFriendAlert.transform.Find("Buttons/Send/Text")).GetComponent<Text>().text = localization["$send"];
			((UnityEvent)((Component)addFriendAlert.transform.Find("Buttons/Cancel")).GetComponent<Button>().onClick).AddListener(new UnityAction(clickButtonCancel));
			((Component)addFriendAlert.transform.Find("Buttons/Cancel/Text")).GetComponent<Text>().text = localization["$cancel"];
			sprites.Add(EpicMMOSystem._asset.LoadAsset<Sprite>("manIcon"));
			for (int i = 1; i < 15; i++)
			{
				sprites.Add(EpicMMOSystem._asset.LoadAsset<Sprite>($"Class{i}"));
			}
		}

		private static void updateList()
		{
			updateFriendsList();
			updateInviteList();
		}

		private static void updateFriendsList()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: 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_0069: 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)
			//IL_00e1: 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_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			if (friendsCells.Count > 0)
			{
				friendsCells.ForEach(delegate(FriendsCell f)
				{
					f.Destroy();
				});
				friendsCells.Clear();
			}
			Dictionary<string, PlayerInfo> dictionary = new Dictionary<string, PlayerInfo>();
			foreach (PlayerInfo player in ZNet.instance.GetPlayerList())
			{
				dictionary.Add(player.m_name, player);
			}
			Dictionary<string, FriendInfo> dictionary2 = new Dictionary<string, FriendInfo>(friendsData.getFriends());
			headerFriends.SetActive(dictionary2.Count > 0);
			List<FriendInfo> list = new List<FriendInfo>();
			foreach (KeyValuePair<string, FriendInfo> item3 in dictionary2)
			{
				if (dictionary.ContainsKey(item3.Key))
				{
					PlayerInfo info = dictionary[item3.Key];
					GameObject val = Object.Instantiate<GameObject>(friendsCell, contentFriends.transform);
					if (Object.op_Implicit((Object)(object)val))
					{
						FriendsCell item = new FriendsCell(val, item3.Value, info, FriendsCell.StatusFriend.online);
						friendsCells.Add(item);
					}
				}
				else
				{
					list.Add(item3.Value);
				}
			}
			foreach (FriendInfo item4 in list)
			{
				GameObject val2 = Object.Instantiate<GameObject>(friendsCell, contentFriends.transform);
				if (Object.op_Implicit((Object)(object)val2))
				{
					FriendsCell item2 = new FriendsCell(val2, item4, default(PlayerInfo), FriendsCell.StatusFriend.offline);
					friendsCells.Add(item2);
				}
			}
		}

		private static void updateInviteList()
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			if (inviteCells.Count > 0)
			{
				inviteCells.ForEach(delegate(FriendsCell f)
				{
					f.Destroy();
				});
				inviteCells.Clear();
			}
			headerInvited.SetActive(inviteList.Count > 0);
			foreach (KeyValuePair<FriendInfo, PlayerInfo> invite in inviteList)
			{
				GameObject val = Object.Instantiate<GameObject>(friendsCell, contentInvited.transform);
				if (Object.op_Implicit((Object)(object)val))
				{
					FriendsCell item = new FriendsCell(val, invite.Key, invite.Value, FriendsCell.StatusFriend.invite);
					inviteCells.Add(item);
				}
			}
		}

		public static void addInviteFriend(FriendInfo info, PlayerInfo playerInfo)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<FriendInfo, PlayerInfo> invite in inviteList)
			{
				if (invite.Key.name == info.name)
				{
					return;
				}
			}
			inviteList.Add(info, playerInfo);
			updateInviteList();
		}

		private static bool hasInvite()
		{
			return inviteList.Count > 0;
		}

		public static void acceptInvited(FriendInfo friendInfo)
		{
			friendsData.addFriends(friendInfo);
			if (friendsListPanel.activeSelf)
			{
				updateList();
			}
		}

		private static void clickButtonAdd()
		{
			friendsListPanel.GetComponent<CanvasGroup>().interactable = false;
			textField.SetTextWithoutNotify("");
			addFriendAlert.SetActive(true);
		}

		private static void clickButtonSend()
		{
			string text = textField.text ?? "";
			foreach (KeyValuePair<FriendInfo, PlayerInfo> invite in inviteList)
			{
				if (invite.Key.name == text)
				{
					return;
				}
			}
			if (!(text == Player.m_localPlayer.GetPlayerName()) && !friendsData.getFriends().ContainsKey(text))
			{
				FriendsSystem.inviteFriend(text);
				friendsListPanel.GetComponent<CanvasGroup>().interactable = true;
				addFriendAlert.SetActive(false);
			}
		}

		private static void clickButtonCancel()
		{
			friendsListPanel.GetComponent<CanvasGroup>().interactable = true;
			addFriendAlert.SetActive(false);
		}

		private static void InitLevelSystem()
		{
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Expected O, but got Unknown
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Expected O, but got Unknown
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Expected O, but got Unknown
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Expected O, but got Unknown
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Expected O, but got Unknown
			levelSystemPanel = ((Component)UI.transform.Find("Canvas/PointPanel")).gameObject;
			levelSystemPanelRoot = ((Component)UI.transform.Find("Canvas")).gameObject;
			levelSystemPanelRoot.GetComponent<CanvasScaler>().scaleFactor = EpicMMOSystem.LevelHudGroupScale.Value;
			((Component)levelSystemPanel.transform.Find("Header/Text")).GetComponent<Text>().text = localization["$attributes"];
			DragWindowCntrl.ApplyDragWindowCntrl(levelSystemPanel);
			alertResetPointPanel = ((Component)UI.transform.Find("Canvas/ApplyReset")).gameObject;
			alertResetPointText = ((Component)alertResetPointPanel.transform.Find("Text")).GetComponent<Text>();
			((UnityEvent)((Component)alertResetPointPanel.transform.Find("Buttons/Yes")).GetComponent<Button>().onClick).AddListener(new UnityAction(ResetYes));
			((Component)alertResetPointPanel.transform.Find("Buttons/Yes/Text")).GetComponent<Text>().text = localization["$yes"];
			((UnityEvent)((Component)alertResetPointPanel.transform.Find("Buttons/No")).GetComponent<Button>().onClick).AddListener(new UnityAction(ResetNo));
			((Component)alertResetPointPanel.transform.Find("Buttons/No/Text")).GetComponent<Text>().text = localization["$no"];
			Transform head = levelSystemPanel.transform.Find("Points/ListStat/Strength");
			parameterButtons.Add(new ParameterButton(head, Parameter.Strength));
			Transform head2 = levelSystemPanel.transform.Find("Points/ListStat/Dexterity");
			parameterButtons.Add(new ParameterButton(head2, Parameter.Agility));
			Transform head3 = levelSystemPanel.transform.Find("Points/ListStat/Intelect");
			parameterButtons.Add(new ParameterButton(head3, Parameter.Intellect));
			Transform head4 = levelSystemPanel.transform.Find("Points/ListStat/Endurance");
			parameterButtons.Add(new ParameterButton(head4, Parameter.Body));
			Transform head5 = levelSystemPanel.transform.Find("Points/ListStat/Vigour");
			parameterButtons.Add(new ParameterButton(head5, Parameter.Vigour));
			Transform head6 = levelSystemPanel.transform.Find("Points/ListStat/Specializing");
			parameterButtons.Add(new ParameterButton(head6, Parameter.Special));
			freePointsPanel = ((Component)levelSystemPanel.transform.Find("Points/FreePoints")).gameObject;
			freePointsText = ((Component)levelSystemPanel.transform.Find("Points/FreePoints/Text")).GetComponent<Text>();
			((UnityEvent)((Component)freePointsPanel.transform.Find("Cancel")).GetComponent<Button>().onClick).AddListener(new UnityAction(ClickCancel));
			((UnityEvent)((Component)levelSystemPanel.transform.Find("Close")).GetComponent<Button>().onClick).AddListener(new UnityAction(ClickCancel));
			((Component)freePointsPanel.transform.Find("Cancel/Text")).GetComponent<Text>().text = localization["$cancel"];
			((UnityEvent)((Component)freePointsPanel.transform.Find("Apply")).GetComponent<Button>().onClick).AddListener(new UnityAction(ClickApply));
			((Component)freePointsPanel.transform.Find("Apply/Text")).GetComponent<Text>().text = localization["$apply"];
			((UnityEvent)((Component)levelSystemPanel.transform.Find("Points/ResetButton/Button")).GetComponent<Button>().onClick).AddListener(new UnityAction(ResetParameters));
			((Component)levelSystemPanel.transform.Find("Points/ResetButton/Button/Text")).GetComponent<Text>().text = localization["$reset_parameters"];
			currentLevelText = ((Component)levelSystemPanel.transform.Find("CurrentLevel/Content/Lvl")).GetComponent<Text>();
			expText = ((Component)levelSystemPanel.transform.Find("CurrentLevel/Content/Exp")).GetComponent<Text>();
			Transform obj = levelSystemPanel.transform.Find("DescriptionStats/Scroll View/Viewport/Content");
			((Component)((Component)obj).transform.Find("HeaderDamage/Text")).GetComponent<Text>().text = localization["$damage"];
			((Component)((Component)obj).transform.Find("HeaderDefence/Text")).GetComponent<Text>().text = localization["$armor"];
			((Component)((Component)obj).transform.Find("HeaderSurv/Text")).GetComponent<Text>().text = localization["$survival"];
			((Component)((Component)obj).transform.Find("HeaderOther/Text")).GetComponent<Text>().text = localization["$specialother"];
			physicDamageText = ((Component)((Component)obj).transform.Find("PhysicDamage")).GetComponent<Text>();
			addWeightText = ((Component)((Component)obj).transform.Find("Weight")).GetComponent<Text>();
			reducedStaminaBlockText = ((Component)((Component)obj).transform.Find("StaminaBlock")).GetComponent<Text>();
			criticalDmgMultText = ((Component)((Component)obj).transform.Find("CriticalDmg")).GetComponent<Text>();
			attackSpeedMultiText = ((Component)((Component)obj).transform.Find("SpeedAttack")).GetComponent<Text>();
			attackStamina = ((Component)((Component)obj).transform.Find("AttackStamina")).GetComponent<Text>();
			reducedStaminaText = ((Component)((Component)obj).transform.Find("StaminaReduction")).GetComponent<Text>();
			magicDamageText = ((Component)((Component)obj).transform.Find("MagicDamage")).GetComponent<Text>();
			magicEitrRegText = ((Component)((Component)obj).transform.Find("EitrReg")).GetComponent<Text>();
			eitrIncreaseText = ((Component)((Component)obj).transform.Find("EitrIncr")).GetComponent<Text>();
			physicArmorText = ((Component)((Component)obj).transform.Find("DamageReduction")).GetComponent<Text>();
			staminaRegen = ((Component)((Component)obj).transform.Find("StaminaRegeneration")).GetComponent<Text>();
			addStaminaText = ((Component)((Component)obj).transform.Find("Stamina")).GetComponent<Text>();
			addHpText = ((Component)((Component)obj).transform.Find("Hp")).GetComponent<Text>();
			regenHpText = ((Component)((Component)obj).transform.Find("HpRegeneration")).GetComponent<Text>();
			magicArmorText = ((Component)((Component)obj).transform.Find("MagicDamageReduction")).GetComponent<Text>();
			criticalChanceText = ((Component)((Component)obj).transform.Find("CriticalChance")).GetComponent<Text>();
			miningSpeedText = ((Component)((Component)obj).transform.Find("MiningSpeed")).GetComponent<Text>();
			addpieceHealthText = ((Component)((Component)obj).transform.Find("ConstructionPieceHealth")).GetComponent<Text>();
			treeCuttingSpeedText = ((Component)((Component)obj).transform.Find("TreeCutting")).GetComponent<Text>();
		}

		private static void ClickCancel()
		{
			LevelSystem.Instance.cancelDepositPoints();
			levelSystemPanel.SetActive(false);
		}

		private static void ClickApply()
		{
			LevelSystem.Instance.applyDepositPoints();
			levelSystemPanel.SetActive(false);
		}

		private static void ResetParameters()
		{
			string value = EpicMMOSystem.viewTextCoins.Value;
			int priceResetPoints = LevelSystem.Instance.getPriceResetPoints();
			string format = localization["$reset_point_text"];
			alertResetPointText.text = string.Format(format, priceResetPoints, value);
			levelSystemPanel.GetComponent<CanvasGroup>().interactable = false;
			alertResetPointPanel.SetActive(true);
		}

		private static void ResetYes()
		{
			ResetNo();
			LevelSystem.Instance.ResetAllParameterPayment();
		}

		private static void ResetNo()
		{
			alertResetPointPanel.SetActive(false);
			levelSystemPanel.GetComponent<CanvasGroup>().interactable = true;
		}

		public static void UpdateParameterPanel()
		{
			int points = LevelSystem.Instance.getFreePoints();
			bool flag = LevelSystem.Instance.hasDepositPoints();
			parameterButtons.ForEach(delegate(ParameterButton p)
			{
				p.UpdateParameters(points);
			});
			freePointsPanel.SetActive(points > 0 || flag);
			freePointsText.text = string.Format("{0}: {1}", localization["$free_points"], points);
			currentLevelText.text = string.Format("{0}: {1}", localization["$level"], LevelSystem.Instance.getLevel());
			long currentExp = LevelSystem.Instance.getCurrentExp();
			long needExp = LevelSystem.Instance.getNeedExp();
			string arg = localization["$exp"];
			expText.text = $"{arg}: {currentExp} / {needExp}";
			physicDamageText.text = string.Format("{0}: +{1}%", localization["$physic_damage"], LevelSystem.Instance.getAddPhysicDamage(LevelSystem.Instance.getDepositPoint(Parameter.Strength)));
			addWeightText.text = string.Format("{0}: +{1}", localization["$add_weight"], LevelSystem.Instance.getAddWeight(LevelSystem.Instance.getDepositPoint(Parameter.Strength)));
			reducedStaminaBlockText.text = string.Format("{0}: -{1}%", localization["$reduced_stamina_block"], LevelSystem.Instance.getReducedStaminaBlock(LevelSystem.Instance.getDepositPoint(Parameter.Strength)));
			criticalDmgMultText.text = string.Format("{0}: +{1}%", localization["$crtcDmgMulti"], LevelSystem.Instance.getAddCriticalDmg(LevelSystem.Instance.getDepositPoint(Parameter.Strength)));
			attackSpeedMultiText.text = string.Format("{0}: +{1}%", localization["$attack_speed"], LevelSystem.Instance.getAddAttackSpeed(LevelSystem.Instance.getDepositPoint(Parameter.Agility)));
			attackStamina.text = string.Format("{0}: -{1}%", localization["$attack_stamina"], LevelSystem.Instance.getAttackStamina(LevelSystem.Instance.getDepositPoint(Parameter.Agility)));
			reducedStaminaText.text = string.Format("{0}: -{1}%", localization["$reduced_stamina"], LevelSystem.Instance.getStaminaReduction(LevelSystem.Instance.getDepositPoint(Parameter.Agility)));
			magicDamageText.text = string.Format("{0}: +{1}%", localization["$magic_damage"], LevelSystem.Instance.getAddMagicDamage(LevelSystem.Instance.getDepositPoint(Parameter.Intellect)));
			eitrIncreaseText.text = string.Format("{0}: +{1}", localization["$add_eitr"], LevelSystem.Instance.getAddEitr(LevelSystem.Instance.getDepositPoint(Parameter.Intellect)));
			magicEitrRegText.text = string.Format("{0}: +{1}%", localization["$regen_eitr"], LevelSystem.Instance.getEitrRegen(LevelSystem.Instance.getDepositPoint(Parameter.Intellect)));
			physicArmorText.text = string.Format("{0}: +{1}%", localization["$physic_armor"], LevelSystem.Instance.getAddPhysicArmor(LevelSystem.Instance.getDepositPoint(Parameter.Body)));
			staminaRegen.text = string.Format("{0}: +{1}%", localization["$stamina_reg"], LevelSystem.Instance.getStaminaRegen(LevelSystem.Instance.getDepositPoint(Parameter.Body)));
			addStaminaText.text = string.Format("{0}: +{1}", localization["$add_stamina"], LevelSystem.Instance.getAddStamina(LevelSystem.Instance.getDepositPoint(Parameter.Body)));
			addHpText.text = string.Format("{0}: +{1}", localization["$add_hp"], LevelSystem.Instance.getAddHp(LevelSystem.Instance.getDepositPoint(Parameter.Vigour)));
			regenHpText.text = string.Format("{0}: +{1}%", localization["$regen_hp"], LevelSystem.Instance.getAddRegenHp(LevelSystem.Instance.getDepositPoint(Parameter.Vigour)));
			magicArmorText.text = string.Format("{0}: +{1}%", localization["$magic_armor"], LevelSystem.Instance.getAddMagicArmor(LevelSystem.Instance.getDepositPoint(Parameter.Vigour)));
			criticalChanceText.text = string.Format("{0}: +{1}%", localization["$crit_chance"], LevelSystem.Instance.getAddCriticalChance(LevelSystem.Instance.getDepositPoint(Parameter.Special)));
			miningSpeedText.text = string.Format("{0}: +{1}%", localization["$mining_speed"], LevelSystem.Instance.getaddMiningDmg(LevelSystem.Instance.getDepositPoint(Parameter.Special)));
			addpieceHealthText.text = string.Format("{0}: +{1}", localization["$piece_health"], LevelSystem.Instance.getAddPieceHealth(LevelSystem.Instance.getDepositPoint(Parameter.Special)));
			treeCuttingSpeedText.text = string.Format("{0}: +{1}%", localization["$tree_cutting"], LevelSystem.Instance.getAddTreeCuttingDmg(LevelSystem.Instance.getDepositPoint(Parameter.Special)));
		}

		private static void InitNavigationPanel()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Expected O, but got Unknown
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			navigationPanel = ((Component)UI.transform.Find("Canvas/NavigatePanel")).gameObject;
			buttonLevelSystem = navigationPanel.transform.Find("Buttons/ButtonLevelSystem");
			((UnityEvent)((Component)buttonLevelSystem).GetComponent<Button>().onClick).AddListener(new UnityAction(ClickButtonLevelSystem));
			DragWindowCntrl.ApplyDragWindowCntrl(navigationPanel);
			buttonFriendsList = navigationPanel.transform.Find("Buttons/ButtonFriends");
			((UnityEvent)((Component)buttonFriendsList).GetComponent<Button>().onClick).AddListener(new UnityAction(ClickButtonFriendsList));
			if (Marketplace_API.IsInstalled())
			{
				buttonQuestPanel = navigationPanel.transform.Find("Buttons/ButtonQuests");
				((UnityEvent)((Component)buttonQuestPanel).GetComponent<Button>().onClick).AddListener(new UnityAction(ClickQuestPanel));
				((Component)buttonQuestPanel).gameObject.SetActive(true);
			}
			if (Professions_API.IsInstalled())
			{
				buttonProfessionsPanel = navigationPanel.transform.Find("Buttons/ButtonProffesions");
				((UnityEvent)((Component)buttonProfessionsPanel).GetComponent<Button>().onClick).AddListener(new UnityAction(ClickProfessionsPanel));
				((Component)buttonProfessionsPanel).gameObject.SetActive(true);
			}
			if (Guilds_API.IsInstalled())
			{
				ButtonGuildsPanel = navigationPanel.transform.Find("Buttons/ButtonGuilds");
				((UnityEvent)((Component)ButtonGuildsPanel).GetComponent<Button>().onClick).AddListener(new UnityAction(ClickButtonButtonGuilds));
				((Component)ButtonGuildsPanel).gameObject.SetActive(true);
			}
		}

		private static void ClickButtonLevelSystem()
		{
			if (!levelSystemPanel.activeSelf)
			{
				UpdateParameterPanel();
			}
			levelSystemPanel.SetActive(!levelSystemPanel.activeSelf);
		}

		private static void ClickButtonFriendsList()
		{
			if (!friendsListPanel.activeSelf)
			{
				updateList();
			}
			friendsListPanel.SetActive(!friendsListPanel.activeSelf);
		}

		private static void ClickButtonButtonGuilds()
		{
			CloseAllUI();
			Guilds_API.ShowGuilds();
		}

		private static void ClickQuestPanel()
		{
			Marketplace_API.OpenQuestJournal();
		}

		private static void ClickProfessionsPanel()
		{
			Professions_API.showProfessions();
		}

		private static void ShowNavigationPanel()
		{
			int freePoints = LevelSystem.Instance.getFreePoints();
			((Component)buttonLevelSystem.GetChild(0)).gameObject.SetActive(freePoints > 0);
			((Component)buttonFriendsList.GetChild(0)).gameObject.SetActive(hasInvite());
		}

		private static void CloseAllUI()
		{
			navigationPanel.SetActive(false);
			InventoryGui.instance.Hide();
		}
	}
	public class DragMenu : MonoBehaviour, IDragHandler, IEventSystemHandler
	{
		[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(1)]
		public Transform menu;

		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
		public void OnDrag(PointerEventData eventData)
		{
			//IL_0007: 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_0017: Unknown result type (might be due to invalid IL or missing references)
			Transform obj = menu;
			obj.position += Vector2.op_Implicit(eventData.delta);
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("WackyMole.EpicMMOSystem", "EpicMMOSystem", "1.9.60")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
	[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
	public class EpicMMOSystem : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		private static class InitCustomItemsClass
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			private static void Postfix(ZNetScene __instance)
			{
				GameObject val = _asset.LoadAsset<GameObject>("LevelUpVFX");
				__instance.m_prefabs.Add(val);
				__instance.m_namedPrefabs.Add(StringExtensionMethods.GetStableHashCode(((Object)val).name), val);
				GameObject val2 = _asset.LoadAsset<GameObject>("LevelUpVFX2");
				__instance.m_prefabs.Add(val2);
				__instance.m_namedPrefabs.Add(StringExtensionMethods.GetStableHashCode(((Object)val2).name), val2);
			}
		}

		[HarmonyPatch(typeof(Player), "GetKnownTexts")]
		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		private static class FixCompendium
		{
			private static void Postfix([<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(new byte[] { 1, 0, 1, 1 })] ref List<KeyValuePair<string, string>> __result)
			{
				__result = __result.Where((KeyValuePair<string, string> p) => !p.Key.StartsWith("EpicMMOSystem")).ToList();
			}
		}

		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		[HarmonyPatch(typeof(ObjectDB), "Awake")]
		internal static class DBPatMMO
		{
			internal static void Postfix()
			{
				//IL_016d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0172: Unknown result type (might be due to invalid IL or missing references)
				//IL_0179: Unknown result type (might be due to invalid IL or missing references)
				//IL_0180: Unknown result type (might be due to invalid IL or missing references)
				//IL_0197: Expected O, but got Unknown
				//IL_0197: Unknown result type (might be due to invalid IL or missing references)
				//IL_019c: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c2: Expected O, but got Unknown
				//IL_0207: 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_0213: Unknown result type (might be due to invalid IL or missing references)
				//IL_021a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0232: Expected O, but got Unknown
				//IL_027a: Unknown result type (might be due to invalid IL or missing references)
				//IL_027f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0286: Unknown result type (might be due to invalid IL or missing references)
				//IL_028d: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a5: Expected O, but got Unknown
				ObjectDB instance = ObjectDB.m_instance;
				Localizer.AddPlaceholder("mmoxpdrink1_description", "power1", XPforMinorPotion, (float power1) => ((power1 - 1f) * 100f).ToString());
				Localizer.AddPlaceholder("mmoxpdrink2_description", "power2", XPforMediumPotion, (float power2) => ((power2 - 1f) * 100f).ToString());
				Localizer.AddPlaceholder("mmoxpdrink3_description", "power3", XPforGreaterPotion, (float power3) => ((power3 - 1f) * 100f).ToString());
				if ((Object)(object)instance.GetItemPrefab("Wood") == (Object)null)
				{
					return;
				}
				Mead1Alt = ScriptableObject.CreateInstance<Recipe>();
				Mead2Alt = ScriptableObject.CreateInstance<Recipe>();
				Mead3Alt = ScriptableObject.CreateInstance<Recipe>();
				((Object)Mead1Alt).name = "MMO_Recipe_Mead1Alt";
				((Object)Mead2Alt).name = "MMO_Recipe_Mead2Alt";
				((Object)Mead3Alt).name = "MMO_Recipe_Mead3Alt";
				CraftingStation[] array = Resources.FindObjectsOfTypeAll<CraftingStation>();
				CraftingStation craftingStation = null;
				CraftingStation[] array2 = array;
				foreach (CraftingStation val in array2)
				{
					if (((Object)val).name == "piece_MeadCauldron")
					{
						craftingStation = val;
					}
				}
				Mead1Alt.m_craftingStation = craftingStation;
				Mead2Alt.m_craftingStation = craftingStation;
				Mead3Alt.m_craftingStation = craftingStation;
				Mead1Alt.m_item = Mead1D;
				List<Requirement> list = new List<Requirement>();
				Requirement item = new Requirement
				{
					m_amount = 1,
					m_recover = true,
					m_resItem = instance.GetItemPrefab("Mob_chunks").GetComponent<ItemDrop>()
				};
				Requirement item2 = new Requirement
				{
					m_amount = 1,
					m_recover = true,
					m_resItem = instance.GetItemPrefab("mmo_orb2").GetComponent<ItemDrop>()
				};
				list.Add(item);
				list.Add(item2);
				Mead1Alt.m_resources = list.ToArray();
				instance.m_recipes.Add(Mead1Alt);
				Mead2Alt.m_item = Mead2D;
				List<Requirement> list2 = new List<Requirement>();
				Requirement item3 = new Requirement
				{
					m_amount = 1,
					m_recover = true,
					m_resItem = instance.GetItemPrefab("mmo_orb4").GetComponent<ItemDrop>()
				};
				list2.Add(item);
				list2.Add(item3);
				Mead2Alt.m_resources = list2.ToArray();
				instance.m_recipes.Add(Mead2Alt);
				Mead3Alt.m_item = Mead3D;
				List<Requirement> list3 = new List<Requirement>();
				Requirement item4 = new Requirement
				{
					m_amount = 1,
					m_recover = true,
					m_resItem = instance.GetItemPrefab("mmo_orb6").GetComponent<ItemDrop>()
				};
				list3.Add(item);
				list3.Add(item4);
				Mead3Alt.m_resources = list3.ToArray();
				instance.m_recipes.Add(Mead3Alt);
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		private static class ZRouteAwake
		{
			private static void Postfix()
			{
				NetisActive = true;
				GameObject[] array = Resources.FindObjectsOfTypeAll<GameObject>();
				foreach (GameObject val in array)
				{
					if (((Object)val).name.Contains("fx_seeker_hurt"))
					{
						fx_seeker_crit = val;
					}
				}
			}
		}

		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		[HarmonyPatch(typeof(EnvMan), "OnMorning")]
		private static class MorningAwakeMMO
		{
			private static void Postfix()
			{
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				int num = 0;
				if (Player.m_localPlayer.m_customData.ContainsKey(PlayerAliveString))
				{
					int.TryParse(Player.m_localPlayer.m_customData[PlayerAliveString], out var result);
					num = result;
				}
				num++;
				string value = num.ToString();
				Player.m_localPlayer.m_customData[PlayerAliveString] = value;
				ZDO zDO = ((Character)Player.m_localPlayer).m_nview.GetZDO();
				zDO.Set("EpicMMOSystem" + PlayerAliveString, num);
				ZDOMan.instance.ForceSendZDO(zDO.m_uid);
			}
		}

		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		private class ConfigurationManagerAttributes
		{
			public bool? Browsable = false;
		}

		internal const string ModName = "EpicMMOSystem";

		internal const string VERSION = "1.9.60";

		internal const string Author = "WackyMole";

		private const string ModGUID = "WackyMole.EpicMMOSystem";

		private static string ConfigFileName = "WackyMole.EpicMMOSystem.cfg";

		private static string ConfigFileFullPath;

		internal static string ConnectionError;

		internal static bool NetisActive;

		private readonly Harmony _harmony = new Harmony("WackyMole.EpicMMOSystem");

		public static readonly ManualLogSource MLLogger;

		public static readonly ConfigSync ConfigSync;

		public static AssetBundle _asset;

		public static string folderpath;

		public static string playerjson;

		public static string playerspath;

		internal static EpicMMOSystem Instance;

		public static bool CLLCLoaded;

		public static CustomSE MMOXP;

		internal static Recipe Mead1Alt;

		internal static Recipe Mead2Alt;

		internal static Recipe Mead3Alt;

		internal static ItemDrop Mead1D;

		internal static ItemDrop Mead2D;

		internal static ItemDrop Mead3D;

		internal static ItemDrop Drink1;

		internal static ItemDrop Drink2;

		internal static ItemDrop Drink3;

		internal static int numofCats;

		internal static GameObject fx_seeker_crit;

		public static string PlayerAliveString;

		public static Localizationold localizationold;

		public static ConfigEntry<bool> extraDebug;

		public static ConfigEntry<int> maxLevel;

		public static ConfigEntry<int> priceResetPoints;

		public static ConfigEntry<int> freePointForLevel;

		public static ConfigEntry<int> startFreePoint;

		public static ConfigEntry<bool> levelexpforeachlevel;

		public static ConfigEntry<int> levelExp;

		public static ConfigEntry<float> multiNextLevel;

		public static ConfigEntry<float> expForLvlMonster;

		public static ConfigEntry<float> rateExp;

		public static ConfigEntry<float> groupExp;

		public static ConfigEntry<float> groupRange;

		public static ConfigEntry<float> playerRange;

		public static ConfigEntry<bool> lossExp;

		public static ConfigEntry<float> minLossExp;

		public static ConfigEntry<float> maxLossExp;

		public static ConfigEntry<string> levelsForBinusFreePoint;

		public static ConfigEntry<bool> tamesGiveXP;

		public static ConfigEntry<bool> leftMessageXP;

		public static ConfigEntry<string> XPstring;

		public static ConfigEntry<bool> UseCustomXPTable;

		public static ConfigEntry<int> maxValueStrength;

		public static ConfigEntry<int> maxValueDexterity;

		public static ConfigEntry<int> maxValueIntelligence;

		public static ConfigEntry<int> maxValueEndurance;

		public static ConfigEntry<int> maxValueVigour;

		public static ConfigEntry<int> maxValueSpecializing;

		public static ConfigEntry<bool> altLevelUpSound;

		public static ConfigEntry<bool> debugNonCombatObjects;

		public static ConfigEntry<float> physicDamage;

		public static ConfigEntry<float> addWeight;

		public static ConfigEntry<float> staminaBlock;

		public static ConfigEntry<float> critDmg;

		public static ConfigEntry<float> attackSpeed;

		public static ConfigEntry<float> attackStamina;

		public static ConfigEntry<float> staminaReduction;

		public static ConfigEntry<float> addEitr;

		public static ConfigEntry<float> magicDamage;

		public static ConfigEntry<float> magicEitrRegen;

		public static ConfigEntry<float> addStamina;

		public static ConfigEntry<float> staminaRegen;

		public static ConfigEntry<float> physicArmor;

		public static ConfigEntry<float> addHp;

		public static ConfigEntry<float> regenHp;

		public static ConfigEntry<float> magicArmor;

		public static ConfigEntry<float> critChance;

		public static ConfigEntry<float> startCritChance;

		public static ConfigEntry<float> miningSpeed;

		public static ConfigEntry<float> constructionPieceHealth;

		public static ConfigEntry<float> treeCuttingSpeed;

		public static ConfigEntry<bool> enabledLevelControl;

		public static ConfigEntry<bool> removeDropMax;

		public static ConfigEntry<bool> removeDropMin;

		public static ConfigEntry<bool> removeBossDropMax;

		public static ConfigEntry<bool> removeBossDropMin;

		public static ConfigEntry<bool> mentor;

		public static ConfigEntry<bool> curveExp;

		public static ConfigEntry<bool> curveBossExp;

		public static ConfigEntry<bool> lowDamageLevel;

		public static ConfigEntry<int> lowDamageExtraConfig;

		public static ConfigEntry<int> maxLevelExp;

		public static ConfigEntry<int> minLevelExp;

		public static ConfigEntry<string> MobLVLChars;

		public static ConfigEntry<string> XPColor;

		public static ConfigEntry<bool> removeAllDropsFromNonPlayerKills;

		public static ConfigEntry<bool> noExpPastLVL;

		public static ConfigEntry<bool> mobLvlPerStar;

		public static ConfigEntry<string> noExpPastLVLPopup;

		public static ConfigEntry<string> prefabNameCoins;

		public static ConfigEntry<string> viewTextCoins;

		public static ConfigEntry<bool> oldExpBar;

		public static ConfigEntry<bool> showMaxHp;

		public static ConfigEntry<bool> forceMagicBar;

		public static ConfigEntry<float> HudBarScale;

		public static ConfigEntry<float> LevelHudGroupScale;

		public static ConfigEntry<string> HudExpBackgroundCol;

		public static ConfigEntry<string> HudPostionCords;

		public static ConfigEntry<bool> HealthIcons;

		internal static ConfigEntry<Vector2> HudPanelPosition;

		internal static ConfigEntry<Vector2> ExpPanelPosition;

		internal static ConfigEntry<Vector2> HpPanelPosition;

		internal static ConfigEntry<Vector2> StaminaPanelPosition;

		internal static ConfigEntry<Vector2> EitrPanelPosition;

		internal static ConfigEntry<Vector2> MobLevelPosition;

		internal static ConfigEntry<Vector2> BossLevelPosition;

		internal static ConfigEntry<Vector2> LevelPointPosition;

		internal static ConfigEntry<Vector2> LevelNavPosition;

		public static ConfigEntry<string> HpColor;

		public static ConfigEntry<string> StaminaColor;

		public static ConfigEntry<string> EitrColor;

		public static ConfigEntry<string> ExpColor;

		internal static ConfigEntry<Vector3> HudExpBackgroundScale;

		internal static ConfigEntry<Vector3> ExpScale;

		internal static ConfigEntry<Vector3> HPScale;

		internal static ConfigEntry<Vector3> EitrScale;

		internal static ConfigEntry<Vector3> StaminaScale;

		public static ConfigEntry<float> addDefaultHealth;

		public static ConfigEntry<float> addDefaultWeight;

		public static ConfigEntry<float> CriticalStartChance;

		public static ConfigEntry<float> CriticalDefaultDamage;

		public static ConfigEntry<float> addDefaultEitr;

		public static ConfigEntry<int> XPforOrb1;

		public static ConfigEntry<int> XPforOrb2;

		public static ConfigEntry<int> XPforOrb3;

		public static ConfigEntry<int> XPforOrb4;

		public static ConfigEntry<int> XPforOrb5;

		public static ConfigEntry<int> XPforOrb6;

		public static ConfigEntry<int> XPforOrb7;

		public static ConfigEntry<int> XPforOrb8;

		public static ConfigEntry<float> XPforMinorPotion;

		public static ConfigEntry<float> XPforMediumPotion;

		public static ConfigEntry<float> XPforGreaterPotion;

		public static ConfigEntry<int> OrbSEtime;

		public static ConfigEntry<int> PotionSEtime;

		public static ConfigEntry<float> OrbDropChance;

		public static ConfigEntry<float> OrbDropChancefromBoss;

		public static ConfigEntry<int> OrdDropMaxAmountFromBoss;

		public static ConfigEntry<bool> UseRegFerm;

		public static ConfigEntry<bool> UseMagicFerm;

		public static ConfigEntry<bool> disableNonCombatObjects;

		public static ConfigEntry<int> MultiplierForXPTaming;

		public static ConfigEntry<bool> disablePieceXP;

		public static ConfigEntry<bool> disableTameXP;

		public static ConfigEntry<bool> disableFishPickupXP;

		public static ConfigEntry<bool> disableMiningXP;

		public static ConfigEntry<bool> disablePickableXP;

		public static ConfigEntry<bool> disableTreeXP;

		public static ConfigEntry<bool> disableDestructablesXP;

		public static ConfigEntry<bool> displayUIString;

		public static ConfigEntry<int> displayUIStringYPosition;

		public static ConfigEntry<string> displayPlayerLevel;

		public static ConfigEntry<string> displayPlayerXP;

		public static ConfigEntry<string> displayDaysAlive;

		public static ConfigEntry<bool> enablePVPXP;

		public static ConfigEntry<int> xpPerLevelPVP;

		public static ConfigEntry<int> xpPerDayNotDead;

		public static ConfigEntry<int> pvpPlayerRange;

		[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(2)]
		private static ConfigEntry<bool> _serverConfigLocked;

		public static bool _isServer => (int)SystemInfo.graphicsDeviceType == 4;

		public void Awake()
		{
			//IL_0708: Unknown result type (might be due to invalid IL or missing references)
			//IL_072f: Unknown result type (might be due to invalid IL or missing references)
			Localizer.Load();
			Instance = this;
			MMOXP = new CustomSE("MMO_XP");
			string group = "0.General---------------";
			_serverConfigLocked = config(group, "Force Server Config", value: true, "Force Server Config");
			extraDebug = config(group, "EnableExtraDebug", value: false, "Enable Extra Debug mode for Debugging", synchronizedSetting: false);
			string group2 = "1.LevelSystem-----------";
			maxLevel = config(group2, "MaxLevel", 100, "Maximum level. Максимальный уровень");
			priceResetPoints = config(group2, "PriceResetPoints", 3, "Reset price per point. Цена сброса за один поинт");
			freePointForLevel = config(group2, "FreePointForLevel", 5, "Free points per level. Свободных поинтов за один уровень");
			startFreePoint = config(group2, "StartFreePoint", 5, "Additional free points start. Дополнительных свободных поинтов");
			levelExp = config(group2, "LevelExperience", 300, "Amount of experience needed per level. Количество опыта необходимого на 1 уровень");
			levelexpforeachlevel = config(group2, "Add LevelExperience on each level", value: true, "By default the calculations per level are (previous_amount * 1.05 + 300) disabled it will be (previous_amount * 1.05) per level ");
			multiNextLevel = config(group2, "MultiplyNextLevelExperience", 1.05f, "Experience multiplier for the next level - Should never go below 1.00. Умножитель опыта для следующего уровня");
			expForLvlMonster = config(group2, "ExpForLvlMonster", 0.25f, "Extra experience (from the sum of the basic experience) for the level of the monster. Доп опыт (из суммы основного опыта) за уровень монстра");
			rateExp = config(group2, "RateExp", 1f, "Experience multiplier. Множитель опыта");
			groupExp = config(group2, "GroupExp", 0.7f, "Experience multiplier that the other players in the group get. Множитель опыта который получают остальные игроки в группе");
			minLossExp = config(group2, "MinLossExp", 0.05f, "Minimum Loss Exp if player death, default 5% loss");
			maxLossExp = config(group2, "MaxLossExp", 0.25f, "Maximum Loss Exp if player death, default 25% loss");
			lossExp = config(group2, "LossExp", value: true, "Enabled exp loss");
			levelsForBinusFreePoint = config(group2, "BonusLevelPoints", "5:5,10:5", "Added bonus point for level. Example(level:points): 5:10,15:20 add all 30 points ");
			groupRange = config(group2, "Group EXP Range", 70f, "The range at which people in a group (Group MOD ONLY) get XP, relative to player who killed mob - only works if the killer gets xp. - Default 70f, a large number like 999999999999f, will probably cover map");
			playerRange = config(group2, "Player EXP Range", 70f, "The range at which a player gets XP");
			tamesGiveXP = config(group2, "Tames give XP on Mob kill", value: true, "Your tames give players in range XP");
			leftMessageXP = config(group2, "Display XP Received on Left", value: true, "Display XP Amount on Left Message when mob is killed");
			XPColor = config(group2, "XP death Color", "#fff708", "The Color of XP popup market on a mob death");
			XPstring = config(group2, "XP String", "+@ XP", "@ for XP Received, must include '@'");
			maxValueStrength = config(group2, "maxValueStrength", 200, "Maximum number of points you can put into Strength");
			maxValueDexterity = config(group2, "maxValueDexterity", 200, "Maximum number of points you can put into Dexterity");
			maxValueIntelligence = config(group2, "maxValueIntelligence", 200, "Maximum number of points you can put into Intelleigence");
			maxValueEndurance = config(group2, "maxValueEndurance", 200, "Maximum number of points you can put into Endurance");
			maxValueVigour = config(group2, "maxValueVigour", 200, "Maximum number of points you can put into Vigour");
			maxValueSpecializing = config(group2, "maxValueSpecializing", 200, "Maximum number of points you can put into Specializing");
			MultiplierForXPTaming = config(group2, "Taming XP Multiplier", 5, "You get normal xp amount, times this number for taming a creature");
			altLevelUpSound = config(group2, "altLevelUpSound", value: false, "It's Loud and Heart attack inducing");
			string group3 = "1.LevelSystem Strength-----";
			physicDamage = config(group3, "PhysicDamage", 0.2f, "Damage multiplier per point.");
			addWeight = config(group3, "AddWeight", 2f, "Adds carry weight per point. ");
			staminaBlock = config(group3, "StaminaBlock", 0.2f, "Decrease stamina consumption per unit per point.");
			critDmg = config(group3, "CriticalDmg", 1f, "Amount of Critical Dmg done per point");
			string group4 = "1.LevelSystem Dexterity---";
			attackSpeed = config(group4, "AttackSpeed", 0.2f, "Swing your blade faster with every point - OP warning-");
			attackStamina = config(group4, "StaminaAttack", 0.1f, "Reduces attack stamina consumption. ");
			staminaReduction = config(group4, "StaminaReduction", 0.15f, "Decrease stamina consumption for running, jumping for one point.");
			string group5 = "1.LevelSystem Intellect-----";
			magicDamage = config(group5, "MagicAttack", 0.2f, "Increase magic attack per point.");
			magicEitrRegen = config(group5, "MagicEitrReg", 0.3f, "Increase magical Eitr Regeneration per point.");
			addEitr = config(group5, "AddEitr", 0.3f, "Eitr Increase per point ONLY when player has above 1 base Eitr");
			string group6 = "1.LevelSystem Endurance------";
			addStamina = config(group6, "AddStamina", 1f, "One Point Stamina Increase.");
			staminaRegen = config(group6, "StaminaReg", 0.4f, "Increase stamina regeneration per point.");
			physicArmor = config(group6, "PhysicArmor", 0.15f, "Increase in physical protection per point.");
			string group7 = "1.LevelSystem Vigour------";
			addHp = config(group7, "AddHp", 1f, "One Point Health Increase. ");
			regenHp = config(group7, "RegenHp", 0.1f, "Increase health regeneration per point.");
			magicArmor = config(group7, "MagicArmor", 0.1f, "Increase magical protection per point. ");
			string group8 = "1.LevelSystem Specializing------";
			startCritChance = config(group8, "Critical Start Chance", 1f, "Critical Chance Starts at (1%) after 1 point assigned ");
			critChance = config(group8, "Critical Chance", 0.2f, "Critical Chance, Starts with Critical Start Chance, increment per point - default 0.1% ");
			miningSpeed = config(group8, "MiningSpeed", 0.4f, "Mining Dmg Multiplier per point");
			constructionPieceHealth = config(group8, "PieceHealth", 2f, "Increase max health of new pieces built per point");
			treeCuttingSpeed = config(group8, "TreeCuttingSpeed", 0.4f, "Increase tree cutting speed per point.");
			string group9 = "2.Creature level control";
			mentor = config(group9, "Mentor", value: true, "Give full eXP for low level members in Groups");
			enabledLevelControl = config(group9, "Enabled_creature_level", value: true, "Enable creature Level control - Disable this to remove levels, but still get eXP gain");
			removeDropMax = config(group9, "Remove_creature_drop_max", value: false, "Monsters after death do not give items if their level is higher than player level + MaxLevel");
			removeDropMin = config(group9, "Remove_creature_drop_min", value: false, "Monsters after death do not give items if their level is lower than player level - MinLevel");
			removeBossDropMax = config(group9, "Remove_boss_drop_max", value: false, "Bosses after death do not give items if their level is higher than player level + MaxLevel");
			removeBossDropMin = config(group9, "Remove_boss_drop_min", value: false, "Bosses after death do not give items if their level is lower than player level - Minlevel");
			curveExp = config(group9, "Curve_creature_exp", value: false, "Monsters after death will give less exp if player is outside Max or Min Level Range");
			curveBossExp = config(group9, "Curve_Boss_exp", value: false, "Bosses after death will give less exp if player is outside Max or Min Level Range");
			lowDamageLevel = config(group9, "Low_damage_level", value: false, "Decreased damage to the monster if the level is insufficient");
			lowDamageExtraConfig = config(group9, "Low_damage_config", 0, "Extra paramater to low damage config - for reference(float)(playerLevel + lowDamageConfig) / monsterLevel; when player is below lvl");
			minLevelExp = config(group9, "MinLevelRange", 10, "Character level - MinLevelRange is less than the level of the monster, then you will receive reduced experience. Уровень персонажа - MinLevelRange меньше уровня монстра, то вы будете получать урезанный опыт");
			maxLevelExp = config(group9, "MaxLevelRange", 10, "Character level + MaxLevelRange is less than the level of the monster, then you will not receive experience. Уровень персонажа + MaxLevelRange меньше уровня монстра, то вы не будете получать опыт");
			MobLevelPosition = config<Vector2>(group9, "LevelBar Position", new Vector2(40f, -30f), "LevelBar Position for regular mobs - synced");
			BossLevelPosition = config<Vector2>(group9, "Boss LevelBar Position", new Vector2(0f, 30f), "LevelBar Position for Boss Bars - synced");
			MobLVLChars = config(group9, "Mob Level UI String", "[@]", "[@] uses @ for moblevel, must include '@', but you coudl do 'Level @' or something similar");
			removeAllDropsFromNonPlayerKills = config(group9, "RemoveAllDrops From NonPlayer Kills", value: true, "Remove all drops from mobs that were not killed by a player or tame -ie no drops from mobs attacking each other");
			noExpPastLVL = config(group9, "U Jerk, NoExpOn Red/Blue", value: false, "You are a jerk admin if you enable this, this removes all exp on creatures that are above level (RED) or Below (Blue)");
			mobLvlPerStar = config(group9, "Mob Lvl increase per star", value: true, "By default a mob lvl goes up per star, change to false to disable this.");
			noExpPastLVLPopup = config(group9, "Popup Message For noExpPastLVL", "No XP for red/blue creatures :(", "This message displays when you enable U Jerk, NoExpOn Red/Blue and Kill a Red or blue mob");
			string group10 = "3.Reset attributes items";
			prefabNameCoins = config(group10, "prefabName", "Coins", "Name prefab item");
			viewTextCoins = config(group10, "viewText", "coins or 1 Reset Trophy", "Name item");
			string group11 = "5.Optional perk---------";
			addDefaultHealth = config(group11, "AddDefaultHealth", 0f, "Add health by default");
			addDefaultWeight = config(group11, "AddDefaultWeight", 0f, "Add weight by default");
			CriticalStartChance = config(group11, "CriticalStartChance", 0f, "Add Critical Chance by default");
			CriticalDefaultDamage = config(group11, "DefaultCriticalDamage", 50f, "Add Critical Damage by default");
			addDefaultEitr = config(group11, "addDefaultEitr", 0f, "Add Eitr by default");
			string group12 = "6.Orbs and Potions-------";
			XPforOrb1 = config(group12, "XP for Orb 1", 300, "Consuming Orb grants how much exp?");
			XPforOrb2 = config(group12, "XP for Orb 2", 600, "Consuming Orb grants how much exp?");
			XPforOrb3 = config(group12, "XP for Orb 3", 1000, "Consuming Orb grants how much exp?");
			XPforOrb4 = config(group12, "XP for Orb 4", 2000, "Consuming Orb grants how much exp?");
			XPforOrb5 = config(group12, "XP for Orb 5", 4000, "Consuming Orb grants how much exp?");
			XPforOrb6 = config(group12, "XP for Orb 6", 8000, "Consuming Orb grants how much exp?");
			XPforOrb7 = config(group12, "XP for Orb 7", 16000, "Consuming Orb grants how much exp?");
			XPforOrb8 = config(group12, "XP for Orb 8", 32000, "Consuming Orb grants how much exp?");
			XPforMinorPotion = config(group12, "Minor Potion", 1.3f, "XP Multiplier for XP Potion Minor");
			XPforMediumPotion = config(group12, "Medium Potion", 1.6f, "XP Multiplier for XP Potion Medium");
			XPforGreaterPotion = config(group12, "Greater Potion", 2f, "XP Multiplier for XP Potion Greater");
			OrbSEtime = config(group12, "Orb SE time", 10, "Orb Consumption SE Icon lasts for default 10 seconds - dont set to 0");
			PotionSEtime = config(group12, "Potion SE time", 600, "Potion SE timer last for default of 10 minutes");
			OrbDropChance = config(group12, "Orb Drop Chance", 1f, "Chance for Magic Orb to drop from a monster - default 1%");
			OrbDropChancefromBoss = config(group12, "Ord Drop Boss", 100f, "Drop Chance for Orbs to drop from a boss - default 100%");
			OrdDropMaxAmountFromBoss = config(group12, "Orb Boss Max Amount", 3, "Max Amount of Orbs to drop from Boss if any orbs drop. So there is a chance 1-3 will drop on default");
			UseRegFerm = config(group12, "Use Regular Fermentor", value: false, "For the people that can't handle a little fireworks in their bases, you can use the regular fermentor instead.");
			UseMagicFerm = config(group12, "MMO Fermentor Can Ferment all Meads", value: false, " Give the mmo_fermentor all the recipes. Duplicates the conversions from regular fermentor.");
			string group13 = "7.Non Combat XP------";
			disableNonCombatObjects = config(group13, "1.Disable All NonCombat XP", value: false, "Disables all non combat xp.");
			disablePieceXP = config(group13, "Disable Piece XP", value: false, "Disables Piece XP. You only get xp for once per building, then you have to change to another piece. It still could be abused.");
			disableTameXP = config(group13, "Disable Tame XP", value: false, "Disables XP for tames.");
			disableFishPickupXP = config(group13, "Disable Fish Pickup XP", value: false, "Disable Fish pickup XP, you still get xp for catching fish.");
			disableMiningXP = config(group13, "Disable Mining XP", value: false, "Disable XP for mining.");
			disablePickableXP = config(group13, "Disable Pickup XP", value: false, "Disable XP for pickables.");
			disableTreeXP = config(group13, "Disable Tree XP", value: false, "Disable XP for Chopping Trees.");
			disableDestructablesXP = config(group13, "Disable Destructables XP", value: false, "Disable XP Destructables.");
			debugNonCombatObjects = config(group13, "2.Debug NonCombat Objects", value: false, "Gives a Warning log for various objects names. Don't forgot that (Clone) is added to everything in the jsons.", synchronizedSetting: false);
			string group14 = "8.PVP Combat XP------";
			displayUIString = config(group14, "Display Player Info", value: true, "Display Player Info above head for other players, Saves performance if you never use it.");
			displayUIStringYPosition = config(group14, "Display Player Info Y-Axis", -110, "Y-Axis of the player info, will not change right away. ");
			displayPlayerLevel = config(group14, "Display Player Level", "(Lvl<color=blue> @ </color>) ", " Use @, to display player Level next to name. Blank for nothing.");
			displayPlayerXP = config(group14, "Display Players XP Worth", " [@ XP]", "Use @, to display the current XP a player is worth next to name. Blank for nothing.");
			displayDaysAlive = config(group14, "Display Days Alive", " <color=red>(@ Days Alive)</color>", "Use @, to display the how long the player has been alive in days. Blank for nothing.");
			enablePVPXP = config(group14, "Enable PVP XP", value: true, "Enable PVP XP, victor gets XP of fallen player.");
			xpPerLevelPVP = config(group14, "XP Per Level", 50, "How much XP is a player worth on defeat by another player per level.");
			xpPerDayNotDead = config(group14, "XP Per Day Alive", 10, "How much extra a player is worth if they haven't died, per day.");
			pvpPlayerRange = config(group14, "Player PVP Range", 15, "How close in level, do the players have to be in order to recieve damage in PVP?");
			AnimationSpeedManager.Add(delegate(Character character, double speed)
			{
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Invalid comparison between Unknown and I4
				Player val = (Player)(object)((character is Player) ? character : null);
				return (val == null || !((Character)val).InAttack() || ((Humanoid)val).m_currentAttack == null || LevelSystem.Instance.getParameter(Parameter.Agility) == 0 || (int)((Humanoid)val).GetCurrentWeapon().m_shared.m_skillType == 8) ? speed : (speed * (double)(1f + LevelSystem.Instance.getAddAttackSpeed() / 100f));
			});
			ConfigSync.AddLockingConfigEntry<bool>(_serverConfigLocked);
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			_harmony.PatchAll(executingAssembly);
			_asset = GetAssetBundle("epicasset");
			itemassets();
			if (Chainloader.PluginInfos.ContainsKey("org.bepinex.plugins.creaturelevelcontrol"))
			{
				CLLCLoaded = true;
			}
		}

		private static void itemassets()
		{
			Item item = new Item("mmo_xp", "mmo_xp_drink1", "asset");
			item.ToggleConfigurationVisibility(Configurability.Drop);
			Item item2 = new Item("mmo_xp", "mmo_xp_drink2", "asset");
			item2.ToggleConfigurationVisibility(Configurability.Drop);
			Item item3 = new Item("mmo_xp", "mmo_xp_drink3", "asset");
			item3.ToggleConfigurationVisibility(Configurability.Drop);
			Drink1 = item.Prefab.GetComponent<ItemDrop>();
			Drink2 = item2.Prefab.GetComponent<ItemDrop>();
			Drink3 = item3.Prefab.GetComponent<ItemDrop>();
			DataMonsters.InitItems();
			Item item4 = new Item("mmo_xp", "mmo_mead_minor", "asset");
			item4.ToggleConfigurationVisibility(Configurability.Recipe);
			Item item5 = new Item("mmo_xp", "mmo_mead_med", "asset");
			item5.ToggleConfigurationVisibility(Configurability.Recipe);
			Item item6 = new Item("mmo_xp", "mmo_mead_greater", "asset");
			item6.ToggleConfigurationVisibility(Configurability.Recipe);
			Item item7 = new Item("mmo_xp", "Mob_chunks", "asset");
			item7.RequireOnlyOneIngredient = true;
			item7.Crafting.Add(ItemManager.CraftingTable.Cauldron, 1);
			item7.RequiredItems.Add("TrophyBoar", 4);
			item7.RequiredItems.Add("TrophyNeck", 4);
			item7.RequiredItems.Add("TrophyDeer", 4);
			item7.RequiredItems.Add("TrophyFrostTroll", 2);
			item7.RequiredItems.Add("TrophyEikthyr", 2);
			item7.RequiredItems.Add("TrophyGreydwarfBrute", 2);
			item7.RequiredItems.Add("TrophyGreydwarfShaman", 3);
			item7.RequiredItems.Add("TrophyBlob", 3);
			item7.RequiredItems.Add("TrophyGreydwarf", 4);
			item7.RequiredItems.Add("TrophyDraugr", 3);
			item7.RequiredItems.Add("TrophySkeleton", 4);
			item7.RequiredItems.Add("TrophySerpent", 2);
			item7.RequiredItems.Add("TrophyWolf", 4);
			item4.Crafting.Add(ItemManager.CraftingTable.MeadCauldron, 1);
			item4.RequiredItems.Add("Mob_chunks", 1);
			item4.RequiredItems.Add("mmo_orb1", 2);
			item5.Crafting.Add(ItemManager.CraftingTable.MeadCauldron, 1);
			item5.RequiredItems.Add("Mob_chunks", 1);
			item5.RequiredItems.Add("mmo_orb3", 2);
			item6.Crafting.Add(ItemManager.CraftingTable.MeadCauldron, 1);
			item6.RequiredItems.Add("Mob_chunks", 1);
			item6.RequiredItems.Add("mmo_orb5", 2);
			Mead1D = item4.Prefab.GetComponent<ItemDrop>();
			Mead2D = item5.Prefab.GetComponent<ItemDrop>();
			Mead3D = item6.Prefab.GetComponent<ItemDrop>();
			BuildPiece buildPiece = new BuildPiece("mmo_xp", "mmo_fermenter", "asset");
			buildPiece.Category.Set(BuildPieceCategory.Crafting);
			buildPiece.Crafting.Set(PieceManager.CraftingTable.Forge);
			buildPiece.RequiredItems.Add("FineWood", 30, recover: true);
			buildPiece.RequiredItems.Add("Bronze", 5, recover: true);
			buildPiece.RequiredItems.Add("Coins", 200, recover: true);
			new Item("epicmmoitems", "ResetTrophy", "asset").ToggleConfigurationVisibility(Configurability.Drop | Configurability.Trader);
		}

		internal static void runSSvalues()
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Expected O, but got Unknown
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			if (!UseRegFerm.Value && !UseMagicFerm.Value)
			{
				return;
			}
			List<Fermenter> list = new List<Fermenter>();
			List<Fermenter> list2 = new List<Fermenter>();
			Fermenter[] array = Resources.FindObjectsOfTypeAll<Fermenter>();
			foreach (Fermenter val in array)
			{
				if (((Object)val).name == "fermenter")
				{
					list.Add(val);
				}
				if (((Object)val).name == "mmo_fermenter")
				{
					list2.Add(val);
				}
			}
			if (list == null)
			{
				return;
			}
			bool flag = false;
			foreach (ItemConversion item in list[0].m_conversion)
			{
				if ((Object)(object)item.m_from == (Object)(object)Mead1D)
				{
					flag = true;
				}
			}
			ItemConversion val2 = new ItemConversion();
			ItemConversion val3 = new ItemConversion();
			ItemConversion val4 = new ItemConversion();
			val2.m_from = Mead1D;
			val2.m_to = Drink1;
			val2.m_producedItems = 3;
			val3.m_from = Mead2D;
			val3.m_to = Drink2;
			val3.m_producedItems = 3;
			val4.m_from = Mead3D;
			val4.m_to = Drink3;
			val4.m_producedItems = 3;
			if (!flag && UseRegFerm.Value)
			{
				foreach (Fermenter item2 in list)
				{
					item2.m_conversion.Add(val2);
					item2.m_conversion.Add(val3);
					item2.m_conversion.Add(val4);
				}
			}
			if (!UseMagicFerm.Value)
			{
				return;
			}
			if (list2 == null)
			{
				MLLogger.LogWarning((object)"mmo ferm is null");
				return;
			}
			foreach (Fermenter item3 in list2)
			{
				item3.m_conversion = list[0].m_conversion;
			}
			if (flag)
			{
				return;
			}
			foreach (Fermenter item4 in list2)
			{
				item4.m_conversion.Add(val2);
				item4.m_conversion.Add(val3);
				item4.m_conversion.Add(val4);
			}
		}

		private void Start()
		{
			localizationold = new Localizationold();
			MyUI.Init();
			DataMonsters.Init();
			FriendsSystem.Init();
			SetupWatcher();
		}

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

		private void SetupWatcher()
		{
			if (!Directory.Exists(folderpath))
			{
				Directory.CreateDirectory(folderpath);
			}
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(folderpath);
			fileSystemWatcher.Changed += ReadJsonValues;
			fileSystemWatcher.Created += ReadJsonValues;
			fileSystemWatcher.Renamed += ReadJsonValues;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
			FileSystemWatcher fileSystemWatcher2 = new FileSystemWatcher(Paths.ConfigPath, ConfigFileName);
			fileSystemWatcher2.Changed += ReadConfigValues;
			fileSystemWatcher2.IncludeSubdirectories = false;
			fileSystemWatcher2.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher2.EnableRaisingEvents = true;
		}

		private void ReadJsonValues(object sender, FileSystemEventArgs e)
		{
			if (!NetisActive || !ZNet.instance.IsServer())
			{
				return;
			}
			List<string> list = new List<string>();
			string[] files = Directory.GetFiles(folderpath, "*.json", SearchOption.AllDirectories);
			foreach (string path in files)
			{
				string fileName = Path.GetFileName(path);
				if (extraDebug.Value)
				{
					MLLogger.LogInfo((object)(fileName + " read"));
				}
				string item = File.ReadAllText(path);
				list.Add(item);
			}
			DataMonsters.MonsterDBL = list;
			DataMonsters.createNewDataMonsters(list);
			if (extraDebug.Value)
			{
				MLLogger.LogInfo((object)"Mobs Updated on Server");
			}
			foreach (ZNetPeer peer in ZNet.instance.GetPeers())
			{
				if (peer == null)
				{
					break;
				}
				ZRoutedRpc.instance.InvokeRoutedRPC(peer.m_uid, "EpicMMOSystem SetMonsterDB", new object[1] { list });
			}
		}

		internal void ReadConfigValues(object sender = null, FileSystemEventArgs e = null)
		{
			if (File.Exists(ConfigFileFullPath))
			{
				LevelSystem.Instance.FillLevelsExp();
				if ((Object)(object)ObjectDB.m_instance != (Object)null)
				{
					ObjectDB.m_instance.GetStatusEffect(StringExtensionMethods.GetStableHashCode("MMO_XP")).m_ttl = OrbSEtime.Value;
					ObjectDB.m_instance.GetStatusEffect(StringExtensionMethods.GetStableHashCode("Potion_MMO_Greater")).m_ttl = PotionSEtime.Value;
					ObjectDB.m_instance.GetStatusEffect(StringExtensionMethods.GetStableHashCode("Potion_MMO_Medium")).m_ttl = PotionSEtime.Value;
					ObjectDB.m_instance.GetStatusEffect(StringExtensionMethods.GetStableHashCode("Potion_MMO_Minor")).m_ttl = PotionSEtime.Value;
				}
			}
		}

		private ConfigEntry<T> config<[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(2)] T>(string group, string name, T value, ConfigDescription description, bool synchronizedSetting = true)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			ConfigDescription val = new ConfigDescription(description.Description + (synchronizedSetting ? " [Synced with Server]" : " [Not Synced with Server]"), description.AcceptableValues, description.Tags);
			ConfigEntry<T> val2 = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, val);
			ConfigSync.AddConfigEntry<T>(val2).SynchronizedConfig = synchronizedSetting;
			return val2;
		}

		private ConfigEntry<T> config<[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(2)] T>(string group, string name, T value, string description, bool synchronizedSetting = true)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting);
		}

		public static AssetBundle GetAssetBundle(string filename)
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string name = executingAssembly.GetManifestResourceNames().Single([<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)] (string str) => str.EndsWith(filename));
			using Stream stream = executingAssembly.GetManifestResourceStream(name);
			return AssetBundle.LoadFromStream(stream);
		}

		static EpicMMOSystem()
		{
			string configPath = Paths.ConfigPath;
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			ConfigFileFullPath = configPath + directorySeparatorChar + ConfigFileName;
			ConnectionError = "";
			NetisActive = false;
			MLLogger = Logger.CreateLogSource("EpicMMOSystem");
			ConfigSync = new ConfigSync("WackyMole.EpicMMOSystem")
			{
				DisplayName = "EpicMMOSystem",
				CurrentVersion = "1.9.60",
				MinimumRequiredVersion = "1.9.60"
			};
			folderpath = Path.Combine(Paths.ConfigPath, "EpicMMOSystem");
			playerjson = "Players.json";
			playerspath = Path.Combine(Paths.ConfigPath, "EpicMMOSystem", playerjson);
			CLLCLoaded = false;
			Mead1D = null;
			Mead2D = null;
			Mead3D = null;
			Drink1 = null;
			Drink2 = null;
			Drink3 = null;
			numofCats = 6;
			fx_seeker_crit = null;
			PlayerAliveString = "_playeralivedays";
			HudPanelPosition = null;
			ExpPanelPosition = null;
			HpPanelPosition = null;
			StaminaPanelPosition = null;
			EitrPanelPosition = null;
			MobLevelPosition = null;
			BossLevelPosition = null;
			LevelPointPosition = null;
			LevelNavPosition = null;
			HudExpBackgroundScale = null;
			ExpScale = null;
			HPScale = null;
			EitrScale = null;
			StaminaScale = null;
		}
	}
	[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
	[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
	public static class DataMonsters
	{
		[HarmonyPatch(typeof(ItemData), "GetTooltip", new Type[] { typeof(int) })]
		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		public class GetTooltipPatch
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			public static void Postfix(ItemData __instance, int stackOverride, ref string __result)
			{
				if (__instance != null && Object.op_Implicit((Object)(object)__instance.m_dropPrefab) && MagicOrbDictionary.TryGetValue(__instance.m_dropPrefab, out var value))
				{
					__result += $" Right Mouse Button click to get <color=yellow>{value}</color> EXP";
				}
			}
		}

		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		private static class ZrouteMethodsServerFeedback
		{
			private static void Postfix()
			{
				if (EpicMMOSystem._isServer)
				{
					ZRoutedRpc.instance.Register<bool>("EpicMMOSystem ReloadJsons", (Action<long, bool>)ReloadJsons);
				}
				else
				{
					ZRoutedRpc.instance.Register<List<string>>("EpicMMOSystem SetMonsterDB", (Action<long, List<string>>)SetMonsterDB);
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		private static class ZnetSyncServerInfo
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			private static void Postfix(ZRpc rpc)
			{
				if (EpicMMOSystem._isServer)
				{
					ZNetPeer peer = ZNet.instance.GetPeer(rpc);
					if (peer != null)
					{
						ZRoutedRpc.instance.InvokeRoutedRPC(peer.m_uid, "EpicMMOSystem SetMonsterDB", new object[1] { MonsterDBL });
					}
				}
			}
		}

		[HarmonyPriority(1)]
		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		[HarmonyPatch(typeof(EnemyHud), "ShowHud")]
		public static class MonsterColorTexts
		{
			[HarmonyPatch(typeof(EnemyHud), "UpdateHuds")]
			public static class StarVisibilityMMO
			{
				[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
				private static void Postfix(Dictionary<Character, HudData> ___m_huds)
				{
					//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
					//IL_00db: 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_00ef: 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_010f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0114: Unknown result type (might be due to invalid IL or missing references)
					//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
					//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
					//IL_0210: Unknown result type (might be due to invalid IL or missing references)
					//IL_0268: Unknown result type (might be due to invalid IL or missing references)
					if (___m_huds == null)
					{
						return;
					}
					TextMeshProUGUI val2 = default(TextMeshProUGUI);
					foreach (KeyValuePair<Character, HudData> ___m_hud in ___m_huds)
					{
						if (!EpicMMOSystem.enabledLevelControl.Value)
						{
							continue;
						}
						Character key = ___m_hud.Key;
						if (key.IsTamed())
						{
							break;
						}
						if (!((Object)(object)key != (Object)null) || !Object.op_Implicit((Object)(object)___m_hud.Value.m_gui))
						{
							continue;
						}
						if (!contains(((Object)((Component)key).gameObject).name))
						{
							break;
						}
						int num = LevelSystem.Instance.getLevel() + EpicMMOSystem.maxLevelExp.Value;
						int num2 = LevelSystem.Instance.getLevel() - EpicMMOSystem.minLevelExp.Value;
						int num3 = getLevel(((Object)((Component)key).gameObject).name);
						if (EpicMMOSystem.mobLvlPerStar.Value)
						{
							num3 = num3 + key.m_level - 1;
						}
						string text = num3.ToString();
						Color color = ((num3 > num) ? Color.red : Color.white);
						if (num3 < num2)
						{
							color = Color.cyan;
						}
						if (getLevel(((Object)((Component)key).gameObject).name) == 0)
						{
							text = "???";
							color = Color.yellow;
						}
						Transform val = ___m_hud.Value.m_gui.transform.Find("Name/Name(Clone)");
						if ((Object)(object)val != (Object)null)
						{
							((Component)val).gameObject.SetActive(true);
						}
						else
						{
							GameObject gameObject = ((Component)___m_hud.Value.m_gui.transform.Find("Name")).gameObject;
							val = Object.Instantiate<GameObject>(gameObject, gameObject.transform).transform;
							EnsureHudFont(((Component)val).GetComponent<TextMeshProUGUI>(), gameObject.GetComponent<TextMeshProUGUI>());
							((Component)val).GetComponent<RectTransform>().anchoredPosition = new Vector2(37f, -30f);
							((TMP_Text)((Component)val).GetComponent<TextMeshProUGUI>()).fontSize = 13f;
							((TMP_Text)((Component)val).GetComponent<TextMeshProUGUI>()).text = "[" + text + "]";
						}
						((Graphic)((Component)val).GetComponent<TextMeshProUGUI>()).color = color;
						((Graphic)((Component)___m_hud.Value.m_gui.transform.Find("Name")).GetComponent<TextMeshProUGUI>()).color = color;
						if (Object.op_Implicit((Object)(object)___m_hud.Value.m_gui.transform.Find("extraeffecttext")))
						{
							((Component)___m_hud.Value.m_gui.transform.Find("extraeffecttext")).TryGetComponent<TextMeshProUGUI>(ref val2);
							if ((Object)(object)val2 != (Object)null)
							{
								((Graphic)val2).color = color;
							}
						}
					}
				}
			}

			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			public static void Postfix(EnemyHud __instance, Character c, Dictionary<Character, HudData> ___m_huds, bool __state)
			{
				//IL_03eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0409: Unknown result type (might be due to invalid IL or missing references)
				//IL_0147: Unknown result type (might be due to invalid IL or missing references)
				//IL_014c: 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_00ae: Expected O, but got Unknown
				//IL_00c9: 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_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_0124: Unknown result type (might be due to invalid IL or missing references)
				//IL_0433: Unknown result type (might be due to invalid IL or missing references)
				//IL_042c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0438: Unknown result type (might be due to invalid IL or missing references)
				//IL_043e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0443: Unknown result type (might be due to invalid IL or missing references)
				//IL_04a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_04b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_045e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0463: Unknown result type (might be due to invalid IL or missing references)
				//IL_0236: Unknown result type (might be due to invalid IL or missing references)
				//IL_022e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0508: Unknown result type (might be due to invalid IL or missing references)
				//IL_0300: Unknown result type (might be due to invalid IL or missing references)
				//IL_0240: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					if (c.m_tamed)
					{
						return;
					}
				}
				catch
				{
				}
				if (c.IsPlayer() && (Object)(object)___m_huds[c].m_gui != (Object)null && EpicMMOSystem.displayUIString.Value)
				{
					GameObject gui = ___m_huds[c].m_gui;
					TextMeshProUGUI component = ((Component)gui.transform.Find("Name")).GetComponent<TextMeshProUGUI>();
					Transform obj2 = gui.transform.Find("mmoname");
					GameObject val = ((obj2 != null) ? ((Component)obj2).gameObject : null);
					if (val == null)
					{
						val = new GameObject("mmoname", new Type[1] { typeof(RectTransform) });
						val.transform.SetParent(gui.transform, false);
						((RectTransform)val.transform).sizeDelta = ((Component)gui.transform.Find("Name")).GetComponent<RectTransform>().sizeDelta + new Vector2(0f, (float)EpicMMOSystem.displayUIStringYPosition.Value);
						TextMeshProUGUI obj3 = val.AddComponent<TextMeshProUGUI>();
						EnsureHudFont(obj3, component);
						((TMP_Text)obj3).fontSize = 16f;
						((TMP_Text)obj3).alignment = ((TMP_Text)component).alignment;
					}
					EnsureHudFont(val.GetComponent<TextMeshProUGUI>(), component);
					RectTransform component2 = ((Component)component).GetComponent<RectTransform>();
					Vector2 pivot = component2.pivot;
					int num = 1;
					int num2 = 0;
					int num3 = LevelSystem.Instance.getLevel() + EpicMMOSystem.maxLevelExp.Value;
					int num4 = LevelSystem.Instance.getLevel() - EpicMMOSystem.minLevelExp.Value;
					string hoverName = c.GetHoverName();
					foreach (Player allPlayer in Player.GetAllPlayers())
					{
						if (allPlayer.GetPlayerName() == hoverName)
						{
							ZDO zDO = ((Character)allPlayer).m_nview.GetZDO();
							num2 = zDO.GetInt("EpicMMOSystem" + EpicMMOSystem.PlayerAliveString, -1);
							if (num2 == -1)
							{
								EpicMMOSystem.MLLogger.LogWarning((object)("Days alive not found" + num2 + " for player " + hoverName));
								num2 = 0;
							}
							num = zDO.GetInt("EpicMMOSystem_level", 1);
							break;
						}
					}
					int num5 = num;
					if (num5 <= num3)
					{
						_ = Color.white;
					}
					else
					{
						_ = Color.red;
					}
					if (num5 < num4)
					{
						_ = Color.cyan;
					}
					string text = "";
					string text2 = "";
					string text3 = "";
					int num6 = num * EpicMMOSystem.xpPerLevelPVP.Value + num2 * EpicMMOSystem.xpPerDayNotDead.Value;
					text = EpicMMOSystem.displayPlayerLevel.Value;
					text = text.Replace("@", num.ToString());
					text2 = EpicMMOSystem.displayPlayerXP.Value;
					text2 = text2.Replace("@", num6.ToString());
					text3 = EpicMMOSystem.displayDaysAlive.Value;
					text3 = text3.Replace("@", num2.ToString());
					pivot.y = 0.2f;
					((TMP_Text)val.GetComponent<TextMeshProUGUI>()).text = text + text2 + text3;
					component2.pivot = pivot;
				}
				if (!EpicMMOSystem.enabledLevelControl.Value || !contains(((Object)((Component)c).gameObject).name) || Object.op_Implicit((Object)(object)___m_huds[c].m_gui.transform.Find("Name/Name(Clone)")))
				{
					return;
				}
				int num7 = LevelSystem.Instance.getLevel() + EpicMMOSystem.maxLevelExp.Value;
				int num8 = LevelSystem.Instance.getLevel() - EpicMMOSystem.minLevelExp.Value;
				int num9 = getLevel(((Object)((Component)c).gameObject).name);
				if (EpicMMOSystem.mobLvlPerStar.Value)
				{
					num9 = num9 + c.m_level - 1;
				}
				GameObject gameObject = ((Component)___m_huds[c].m_gui.transform.Find("Name")).gameObject;
				GameObject val2 = Object.Instantiate<GameObject>(gameObject, gameObject.transform);
				EnsureHudFont(val2.GetComponent<TextMeshProUGUI>(), gameObject.GetComponent<TextMeshProUGUI>());
				val2.GetComponent<RectTransform>().anchoredPosition = EpicMMOSystem.MobLevelPosition.Value;
				if (c.m_boss)
				{
					val2.GetComponent<RectTransform>().anchoredPosition = EpicMMOSystem.BossLevelPosition.Value;
				}
				string value = EpicMMOSystem.MobLVLChars.Value;
				string newValue = num9.ToString();
				Color color = ((num9 > num7) ? Color.red : Color.white);
				if (num9 < num8)
				{
					color = Color.cyan;
				}
				if (getLevel(((Object)((Component)c).gameObject).name) == 0)
				{
					newValue = "???";
					color = Color.yellow;
				}
				value = value.Replace("@", newValue);
				((TMP_Text)val2.GetComponent<TextMeshProUGUI>()).overflowMode = (TextOverflowModes)0;
				val2.AddComponent<ContentSizeFitter>().SetLayoutHorizontal();
				((TMP_Text)val2.GetComponent<TextMeshProUGUI>()).text = value;
				((Graphic)gameObject.GetComponent<TextMeshProUGUI>()).color = color;
				((Graphic)val2.GetComponent<TextMeshProUGUI>()).color = color;
				if (Object.op_Implicit((Object)(object)___m_huds[c].m_gui.transform.Find("extraeffecttext")))
				{
					TextMeshProUGUI val3 = default(TextMeshProUGUI);
					((Component)___m_huds[c].m_gui.transform.Find("extraeffecttext")).TryGetComponent<TextMeshProUGUI>(ref val3);
					if ((Object)(object)val3 != (Object)null)
					{
						((Graphic)val3).color = color;
					}
				}
			}
		}

		[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
		[HarmonyPatch(typeof(CharacterDrop), "GenerateDropList")]
		public static class MonsterDropGenerate
		{
			[HarmonyPriority(1)]
			private static void DropItem(GameObject prefab, Vector3 centerPos, float dropArea)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: 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_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: 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_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: 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_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: 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)
				Quaternion val = Quaternion.Euler(0f, (float)Random.Range(0, 360), 0f);
				Vector3 val2 = Random.insideUnitSphere * dropArea;
				Rigidbody component = Object.Instantiate<GameObject>(prefab, centerPos + val2, val).GetComponent<Rigidbody>();
				if (Object.op_Implicit((Object)(object)component))
				{
					Vector3 insideUnitSphere = Random.insideUnitSphere;
					if (insideUnitSphere.y < 0f)
					{
						insideUnitSphere.y = 0f - insideUnitSphere.y;
					}
					component.AddForce(insideUnitSphere * 5f, (ForceMode)2);
				}
			}

			public static void Postfix(CharacterDrop __instance, [<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(new byte[] { 1, 0, 1 })] ref List<KeyValuePair<GameObject, int>> __result)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: 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)
				if (__instance.m_character.IsTamed())
				{
					return;
				}
				Biome currentBiome = EnvMan.instance.m_currentBiome;
				float value = Random.value;
				float num = (__instance.m_character.IsBoss() ? EpicMMOSystem.OrbDropChancefromBoss.Value : EpicMMOSystem.OrbDropChance.Value);
				bool flag = __instance.m_character.IsBoss();
				if (OrbsByBiomes.TryGetValue(currentBiome, out var value2) && value <= num / 100f)
				{
					if (flag)
					{
						for (int i = 0; i < Random.Range(1, EpicMMOSystem.OrdDropMaxAmountFromBoss.Value); i++)
						{
							DropItem(value2, ((Component)__instance).transform.position + Vector3.up * 0.75f, 0.5f);
						}
					}
					else
					{
						DropItem(value2, ((Component)__instance).transform.position + Vector3.up * 0.75f, 0.5f);
					}
				}
				if (!EpicMMOSystem.enabledLevelControl.Value || (!EpicMMOSystem.removeDropMax.Value && !EpicMMOSystem.removeDropMin.Value && !EpicMMOSystem.removeBossDropMax.Value && !EpicMMOSystem.removeBossDropMin.Value && !EpicMMOSystem.removeAllDropsFromNonPlayerKills.Value))
				{
					return;
				}
				int num2 = __instance.m_character.m_nview.GetZDO().GetInt("epic playerLevel", 0);
				if (num2 == 1000512)
				{
					if (EpicMMOSystem.removeAllDropsFromNonPlayerKills.Value && contains(((Object)((Component)__instance.m_character).gameObject).name))
					{
						__result = new List<KeyValuePair<GameObject, int>>();
					}
					num2 = 0;
				}
				if (!contains(((Object)((Component)__instance.m_character).gameObject).name) || num2 == 0)
				{
					return;
				}
				bool flag2 = true;
				if (EpicMMOSystem.extraDebug.Value)
				{
					EpicMMOSystem.MLLogger.LogInfo((object)("Player level " + num2));
				}
				if (num2 > 0)
				{
					flag2 = false;
				}
				else
				{
					flag2 = true;
					num2 = -num2;
				}
				int num3 = num2 + EpicMMOSystem.maxLevelExp.Value;
				int num4 = num2 - EpicMMOSystem.minLevelExp.Value;
				int num5 = getLevel(((Object)((Component)__instance.m_character).gameObject).name);
				if (EpicMMOSystem.mobLvlPerStar.Value)
				{
					num5 = num5 + __instance.m_character.m_level - 1;
				}
				if (getLevel(((Object)((Component)__instance.m_character).gameObject).name) != 0)
				{
					if (num5 > num3 && ((EpicMMOSystem.removeBossDropMax.Value && !flag2) || (EpicMMOSystem.removeDropMax.Value && flag2)))
					{
						__result = new List<KeyValuePair<GameObject, int>>();
					}
					else if (num5 < num4 && ((EpicMMOSystem.removeBossDropMin.Value && !flag2) || (EpicMMOSystem.removeDropMin.Value && flag2)))
					{
						__result = new List<KeyValuePair<GameObject, int>>();
					}
				}
			}
		}

		private static Dictionary<string, Monster> dictionary = new Dictionary<string, Monster>();

		private static string MonsterDB = "";

		public static List<string> MonsterDBL;

		public static string PlayerDBL;

		private static readonly Dictionary<Biome, GameObject> OrbsByBiomes = new Dictionary<Biome, GameObject>(10);

		public static readonly Dictionary<GameObject, int> MagicOrbDictionary = new Dictionary<GameObject, int>(10);

		private static TMP_FontAsset ResolveHudFont(TextMeshProUGUI referenceText = null)
		{
			if ((Object)(object)referenceText != (Object)null && (Object)(object)((TMP_Text)referenceText).font != (Object)null)
			{
				return ((TMP_Text)referenceText).font;
			}
			if ((Object)(object)TMP_Settings.defaultFontAsset != (Object)null)
			{
				return TMP_Settings.defaultFontAsset;
			}
			return Resources.FindObjectsOfTypeAll<TMP_FontAsset>().FirstOrDefault();
		}

		private static void EnsureHudFont(TextMeshProUGUI text, TextMeshProUGUI referenceText = null)
		{
			if (!((Object)(object)text == (Object)null))
			{
				TMP_FontAsset val = ResolveHudFont(referenceText ?? text);
				if ((Object)(object)val != (Object)null)
				{
					((TMP_Text)text).font = val;
				}
			}
		}

		public static void InitItems()
		{
			Item item = new Item("mmo_xp", "mmo_orb1", "asset");
			item.ToggleConfigurationVisibility(Configurability.Disabled);
			Item item2 = new Item("mmo_xp", "mmo_orb2", "asset");
			item2.ToggleConfigurationVisibility(Configurability.Disabled);
			Item item3 = new Item("mmo_xp", "mmo_orb3", "asset");
			item3.ToggleConfigurationVisibility(Configurability.Disabled);
			Item item4 = new Item("mmo_xp", "mmo_orb4", "asset");
			item4.ToggleConfigurationVisibility(Configurability.Disabled);
			Item item5 = new Item("mmo_xp", "mmo_orb5", "asset");
			item5.ToggleConfigurationVisibility(Configurability.Disabled);
			Item item6 = new Item("mmo_xp", "mmo_orb6", "asset");
			item6.ToggleConfigurationVisibility(Configurability.Disabled);
			Item item7 = new Item("mmo_xp", "mmo_orb7", "asset");
			item7.ToggleConfigurationVisibility(Configurability.Disabled);
			Item item8 = new Item("mmo_xp", "mmo_orb8", "asset");
			item8.ToggleConfigurationVisibility(Configurability.Disabled);
			MagicOrbDictionary.Add(item.Prefab, EpicMMOSystem.XPforOrb1.Value);
			MagicOrbDictionary.Add(item2.Prefab, EpicMMOSystem.XPforOrb2.Value);
			MagicOrbDictionary.Add(item3.Prefab, EpicMMOSystem.XPforOrb3.Value);
			MagicOrbDictionary.Add(item4.Prefab, EpicMMOSystem.XPforOrb4.Value);
			MagicOrbDictionary.Add(item5.Prefab, EpicMMOSystem.XPforOrb5.Value);
			MagicOrbDictionary.Add(item6.Prefab, EpicMMOSystem.XPforOrb6.Value);
			MagicOrbDictionary.Add(item7.Prefab, EpicMMOSystem.XPforOrb7.Value);
			MagicOrbDictionary.Add(item8.Prefab, EpicMMOSystem.XPforOrb8.Value);
			OrbsByBiomes.Add((Biome)1, item.Prefab);
			OrbsByBiomes.Add((Biome)8, item2.Prefab);
			OrbsByBiomes.Add((Biome)2, item3.Prefab);
			OrbsByBiomes.Add((Biome)4, item4.Prefab);
			OrbsByBiomes.Add((Biome)16, item5.Prefab);
			OrbsByBiomes.Add((Biome)64, item8.Prefab);
			OrbsByBiomes.Add((Biome)32, item7.Prefab);
			OrbsByBiomes.Add((Biome)256, item3.Prefab);
			OrbsByBiomes.Add((Biome)0, item2.Prefab);
			OrbsByBiomes.Add((Biome)512, item6.Prefab);
		}

		public static bool contains(string name)
		{
			return dictionary.ContainsKey(name);
		}

		public static int getExp(string name)
		{
			Monster monster = dictionary[name];
			return Random.Range(monster.minExp, monster.maxExp);
		}

		public static int getMaxExp(string name)
		{
			return dictionary[name].maxExp;
		}

		public static int getLevel(string name)
		{
			return dictionary[name].level;
		}

		public static void createNewDataMonsters(List<string> json)
		{
			createNewDataMonsters(json, null);
		}

		public static void createNewDataMonsters(List<string> json, List<string> sources)
		{
			dictionary.Clear();
			if (json == null)
			{
				EpicMMOSystem.MLLogger.LogWarning((object)"Monster database payload was null.");
				return;
			}
			int num = 0;
			foreach (string item in json)
			{
				num++;
				string text = ((sources != null && num - 1 < sources.Count && !string.IsNullOrWhiteSpace(sources[num - 1])) ? sources[num - 1] : $"payload #{num}");
				if (string.IsNullOrWhiteSpace(item))
				{
					EpicMMOSystem.MLLogger.LogWarning((object)("Monster database " + text + " was empty and has been skipped."));
					continue;
				}
				if (EpicMMOSystem.extraDebug.Value)
				{
					EpicMMOSystem.MLLogger.LogInfo((object)("Loading monster json " + text));
				}
				Monster[] array;
				try
				{
					array = JSON.ToObject<Monster[]>(item);
				}
				catch (Exception ex)
				{
					string text2 = ((item.Length > 200) ? (item.Substring(0, 200) + "...") : item);
					EpicMMOSystem.MLLogger.LogWarning((object)("Failed to parse monster database " + text + ". Expected a JSON array of Monster objects. Preview: " + text2));
					EpicMMOSystem.MLLogger.LogWarning((object)ex.ToString());
					continue;
				}
				if (array == null || array.Length == 0)
				{
					EpicMMOSystem.MLLogger.LogWarning((object)("Monster database " + text + " did not contain any monsters and has been skipped."));
					continue;
				}
				Monster[] array2 = array;
				for (int i = 0; i < array2.Length; i++)
				{
					Monster value = array2[i];
					if (string.IsNullOrWhiteSpace(value.name))
					{
						EpicMMOSystem.MLLogger.LogWarning((object)("Monster database " + text + " contains an entry with no name and it has been skipped."));
						continue;
					}
					if (EpicMMOSystem.extraDebug.Value)
					{
						EpicMMOSystem.MLLogger.LogInfo((object)(value.name ?? ""));
					}
					string key = value.name + "(Clone)";
					if (dictionary.ContainsKey(key))
					{
						EpicMMOSystem.MLLogger.LogWarning((object)(value.name + " from " + text + " is already entered"));
					}
					else
					{
						dictionary.Add(key, value);
					}
				}
			}
		}

		public static void setplayeralivetoZero(string playerset)
		{
		}

		public static void createUpdateDataPlayer(List<string> json)
		{
		}

		public static void Init()
		{
			string path = Path.Combine(Paths.ConfigPath, "EpicMMOSystem", "Version.txt");
			string text = Path.Combine(Paths.ConfigPath, "EpicMMOSystem");
			string path2 = Path.Combine(Paths.ConfigPath, "EpicMMOSystem", "If you want to stop from updating.txt");
			string text2 = "Default.json";
			string text3 = "AirAnimals.json";
			string text4 = "LandAnimals.json";
			string text5 = "Fantasy_Creatures.json";
			string text6 = "SeaAnimals.json";
			string text7 = "MMO_MonsterLabZ.json";
			string text8 = "Outsiders.json";
			string text9 = "DoorDieMonsters.json";
			string text10 = "MajesticChickens.json";
			string text11 = "Therzie_Monstrum.json";
			string text12 = "Reforge_Krumpac.json";
			string text13 = "TeddyBears.json";
			string text14 = "PungusSouls.json";
			string text15 = "Jewelcrafting.json";
			string text16 = "RtDMonsters.json";
			string text17 = "Therzie_Wizardry.json";
			string text18 = "NonCombat.json";
			string text19 = "Monstrum_DeepNorth.json";
			string text20 = "RtDHorrors.json";
			string text21 = "RtDMonstrum.json";
			string text22 = "RtDSea.json";
			string text23 = "RtDFairyTale.json";
			string text24 = "RtDAdditions.json";
			string text25 = "RtDSouls.json";
			string text26 = "Bestiary.json";
			string text27 = "NonCombat_RtD.json";
			string path3 = "MonsterLabZ.json";
			string path4 = Path.Combine(text, path3);
			if (!Directory.Exists(text))
			{
				Directory.CreateDirectory(text);
			}
			bool flag = true;
			if (File.Exists(path))
			{
				string text28 = File.ReadAllText(path);
				flag = false;
				if (text28 == "1.7.3")
				{
					flag = true;
				}
				if (text28 == "1.7.4")
				{
					flag = true;
				}
				if (text28 == "1.7.5")
				{
					flag = true;
				}
				if (text28 == "1.7.6")
				{
					flag = true;
				}
				if (text28 == "1.7.7")
				{
					flag = true;
				}
				if (text28 == "1.7.8")
				{
					flag = true;
				}
				if (text28 == "1.7.9")
				{
					flag = true;
				}
				if (text28 == "1.8.7")
				{
					flag = true;
				}
				if (text28 == "1.8.8")
				{
					flag = true;
				}
				if (text28 == "1.8.97")
				{
					flag = true;
				}
				if (text28 == "1.9.02")
				{
					flag = true;
				}
				if (text28 == "1.9.12")
				{
					flag = true;
				}
				if (text28 == "1.9.20")
				{
					flag = true;
				}
				if (text28 == "1.9.21")
				{
					flag = true;
				}
				if (text28 == "1.9.23")
				{
					flag = true;
				}
				if (text28 == "1.9.30")
				{
					flag = true;
				}
				if (text28 == "1.9.32")
				{
					flag = true;
				}
				if (text28 == "1.9.35")
				{
					flag = true;
				}
				if (text28 == "1.9.38")
				{
					flag = true;
				}
				if (text28 == "1.9.47")
				{
					flag = true;
				}
				if (text28 == "1.9.49")
				{
					flag = true;
				}
				if (text28 == "1.9.51")
				{
					flag = true;
				}
				if (text28 == "1.9.55")
				{
					flag = true;
				}
				if (File.Exists(path4))
				{
					File.Delete(path4);
				}
				if (text28 == "1.9.60")
				{
					flag = false;
				}
				switch (text28)
				{
				case "NO":
				case "no":
				case "No":
				case "STOP":
				case "stop":
				case "Stop":
					flag = false;
					break;
				}
			}
			if (flag)
			{
				File.WriteAllText(path, "1.9.60");
				File.WriteAllText(path2, "Erase numbers in Version.txt and write NO or stop in file. This should stop DB json files from updating on an update. If you make your own custom json file, then that one should never be updated.");
				File.WriteAllText(Path.Combine(text, text2), getDefaultJsonMonster(text2));
				File.WriteAllText(Path.Combine(text, text3), getDefaultJsonMonster(text3));
				File.WriteAllText(Path.Combine(text, text4), getDefaultJsonMonster(text4));
				File.WriteAllText(Path.Combine(text, text5), getDefaultJsonMonster(text5));
				File.WriteAllText(Path.Combine(text, text6), getDefaultJsonMonster(text6));
				File.WriteAllText(Path.Combine(text, text7), getDefaultJsonMonster(text7));
				File.WriteAllText(Path.Combine(text, text8), getDefaultJsonMonster(text8));
				File.WriteAllText(Path.Combine(text, text9), getDefaultJsonMonster(text9));
				File.WriteAllText(Path.Combine(text, text10), getDefaultJsonMonster(text10));
				File.WriteAllText(Path.Combine(text, text11), getDefaultJsonMonster(text11));
				File.WriteAllText(Path.Combine(text, text12), getDefaultJsonMonster(text12));
				File.WriteAllText(Path.Combine(text, text13), getDefaultJsonMonster(text13));
				File.WriteAllText(Path.Combine(text, text14), getDefaultJsonMonster(text14));
				File.WriteAllText(Path.Combine(text, text15), getDefaultJsonMonster(text15));
				File.WriteAllText(Path.Combine(text, text16), getDefaultJsonMonster(text16));
				File.WriteAllText(Path.Combine(text, text17), getDefaultJsonMonster(text17));
				File.WriteAllText(Path.Combine(text, text18), getDefaultJsonMonster(text18));
				File.WriteAllText(Path.Combine(text, text19), getDefaultJsonMonster(text19));
				File.WriteAllText(Path.Combine(text, text20), getDefaultJsonMonster(text20));
				File.WriteAllText(Path.Combine(text, text21), getDefaultJsonMonster(text21));
				File.WriteAllText(Path.Combine(text, text22), getDefaultJsonMonster(text22));
				File.WriteAllText(Path.Combine(text, text23), getDefaultJsonMonster(text23));
				File.WriteAllText(Path.Combine(text, text24), getDefaultJsonMonster(text24));
				File.WriteAllText(Path.Combine(text, text25), getDefaultJsonMonster(text25));
				File.WriteAllText(Path.Combine(text, text26), getDefaultJsonMonster(text26));
				File.WriteAllText(Path.Combine(text, text27), getDefaultJsonMonster(text27));
				if (EpicMMOSystem.extraDebug.Value)
				{
					EpicMMOSystem.MLLogger.LogInfo((object)"Mobs Jsons Written");
				}
			}
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			string[] files = Directory.GetFiles(text, "*.json", SearchOption.AllDirectories);
			foreach (string path5 in files)
			{
				string fileName = Path.GetFileName(path5);
				if (!(fileName == EpicMMOSystem.playerjson))
				{
					if (EpicMMOSystem.extraDebug.Value)
					{
						EpicMMOSystem.MLLogger.LogInfo((object)(fileName + " read"));
					}
					string text29 = File.ReadAllText(path5);
					list.Add(text29);
					list2.Add(fileName);
					MonsterDB += text29;
				}
			}
			if (EpicMMOSystem.extraDebug.Value)
			{
				EpicMMOSystem.MLLogger.LogInfo((object)"Mobs Read");
			}
			MonsterDBL = list;
			createNewDataMonsters(list, list2);
		}

		private static string getDefaultJsonMonster(string jsonname)
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string name = executingAssembly.GetManifestResourceNames().Single([<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)] (string str) => str.EndsWith(jsonname));
			using Stream stream = executingAssembly.GetManifestResourceStream(name);
			using StreamReader streamReader = new StreamReader(stream);
			return streamReader.ReadToEnd();
		}

		public static void ReloadJsons(long peer, bool reload)
		{
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			string[] files = Directory.GetFiles(EpicMMOSystem.folderpath, "*.json", SearchOption.AllDirectories);
			foreach (string path in files)
			{
				string fileName = Path.GetFileName(path);
				if (!(fileName == EpicMMOSystem.playerjson))
				{
					if (EpicMMOSystem.extraDebug.Value)
					{
						EpicMMOSystem.MLLogger.LogInfo((object)(fileName + " read"));
					}
					string item = File.ReadAllText(path);
					list.Add(item);
					list2.Add(fileName);
				}
			}
			if (EpicMMOSystem.extraDebug.Value)
			{
				EpicMMOSystem.MLLogger.LogInfo((object)"Mobs Updated on Server");
			}
			MonsterDBL = list;
			createNewDataMonsters(list, list2);
			foreach (ZNetPeer peer2 in ZNet.instance.GetPeers())
			{
				if (peer2 == null)
				{
					break;
				}
				ZRoutedRpc.instance.InvokeRoutedRPC(peer2.m_uid, "EpicMMOSystem SetMonsterDB", new object[1] { MonsterDBL });
			}
		}

		public static void SetMonsterDB(long peer, List<string> json)
		{
			createNewDataMonsters(json);
		}
	}
	public static class MonsterDeath_Path
	{
		[HarmonyPatch(typeof(Game), "Start")]
		public static class RegisterRpc
		{
			public static void Postfix()
			{
				ZRoutedRpc.instance.Register<ZPackage>("EpicMMOSystem DeadMonsters", (Action<long, ZPackage>)RPC_DeadMonster);
				ZRoutedRpc.instance.Register<int, Vector3, int>("EpicMMOSystem AddGroupExp", (Action<long, int, Vector3, int>)RPC_AddGroupExp);
			}
		}

		[HarmonyPatch(typeof(Character), "Damage")]
		public static class ModifierDamage
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			public static void Prefix(Character __instance, HitData hit)
			{
				if (__instance.IsPlayer())
				{
					Character attacker = hit.GetAttacker();
					Player val = (Player)(object)((attacker is Player) ? attacker : null);
					if (val != null)
					{
						if ((Object)(object)val == (Object)null)
						{
							return;
						}
						Player val2 = (Player)(object)((__instance is Player) ? __instance : null);
						string playerName = val2.GetPlayerName();
						string playerName2 = val.GetPlayerName();
						int num = 0;
						int num2 = 0;
						foreach (Player allPlayer in Player.GetAllPlayers())
						{
							ZNetView nview = ((Character)allPlayer).m_nview;
							ZDO val3 = ((nview != null) ? nview.GetZDO() : null);
							if (val3 != null)
							{
								if (allPlayer.GetPlayerName() == playerName)
								{
									num = val3.GetInt("EpicMMOSystem_level", 1);
								}
								if (allPlayer.GetPlayerName() == playerName2)
								{
									num2 = val3.GetInt("EpicMMOSystem_level", 1);
								}
							}
						}
						if (num > 0 && num2 > 0)
						{
							int value = EpicMMOSystem.pvpPlayerRange.Value;
							if (Math.Abs(num2 - num) > value)
							{
								((Character)val2).Message((MessageType)1, $"PvP blocked: level difference too high (Range: {value})", 0, (Sprite)null);
								EpicMMOSystem.MLLogger.LogInfo((object)$"PvP blocked: level difference too high (Range: {value})");
								((Character)val).Message((MessageType)1, $"Your level difference with {playerName} is too high for PvP (Range: {value})", 0, (Sprite)null);
								hit.ApplyModifier(0f);
							}
						}
					}
				}
				if (!EpicMMOSystem.enabledLevelControl.Value)
				{
					return;
				}
				hit.m_toolTier = (short)LevelSystem.Instance.getLevel();
				if (EpicMMOSystem.lowDamageLevel.Value && !__instance.IsPlayer() && !__instance.IsTamed() && DataMonsters.contains(((Object)((Component)__instance).gameObject).name))
				{
					int level = LevelSystem.Instance.getLevel();
					int num3 = level + EpicMMOSystem.maxLevelExp.Value + EpicMMOSystem.lowDamageExtraConfig.Value;
					int num4 = DataMonsters.getLevel(((Object)((Component)__instance).gameObject).name);
					if (EpicMMOSystem.mobLvlPerStar.Value)
					{
						num4 = num4 + __instance.m_level - 1;
					}
					if (DataMonsters.getLevel(((Object)((Component)__instance).gameObject).name) != 0 && num4 > num3)
					{
						Mathf.Clamp(4, 1, 3);
						float num5 = Mathf.Clamp((float)((level + EpicMMOSystem.lowDamageExtraConfig.Value) / num4), 0.1f, 1f);
						hit.ApplyModifier(num5);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Character), "RPC_Damage")]
		[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
		private static class QuestEnemyKill
		{
			private static void Prefix(Character __instance, long sender, HitData hit)
			{
				//IL_000d: 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_0060: 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_007c: 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_00ed: Invalid comparison between Unknown and I4
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance == (Object)null || hit == null)
				{
					return;
				}
				_ = hit.m_damage;
				if (__instance.GetHealth() <= 0f)
				{
					return;
				}
				ZNetView nview = __instance.m_nview;
				ZDO val = (((Object)(object)nview != (Object)null && nview.IsValid()) ? nview.GetZDO() : null);
				if (__instance.m_seman == null || val == null)
				{
					DamageTypes damage = hit.m_damage;
					if (damage.m_frost > 0f)
					{
						damage.m_frost = 0f;
					}
					if (damage.m_spirit > 0f)
					{
						damage.m_spirit = 0f;
					}
					if (damage.m_fire > 0f)
					{
						damage.m_fire = 0f;
					}
					if (damage.m_poison > 0f)
					{
						damage.m_poison = 0f;
					}
					if (damage.m_lightning > 0f)
					{
						damage.m_lightning = 0f;
					}
				}
				bool flag = false;
				if ((int)__instance.GetFaction() == 8)
				{
					flag = true;
				}
				Character attacker = hit.GetAttacker();
				if (!Object.op_Implicit((Object)(object)attacker))
				{
					return;
				}
				lasthitplayer = attacker.IsPlayer();
				if (attacker.IsPlayer() || ((attacker.IsTamed() || ((Object)attacker).name == "staff_greenroots_tentaroot(Clone)" || ((Object)attacker).name == "Staff_root_TW(Clone)") && EpicMMOSystem.tamesGiveXP.Value))
				{
					CharacterLastDamageList[__instance] = sender;
					if (EpicMMOSystem.enabledLevelControl.Value && (EpicMMOSystem.removeBossDropMax.Value || EpicMMOSystem.removeBossDropMin.Value) && flag)
					{
						__instance.m_nview.GetZDO().Set("epic playerLevel", (int)hit.m_toolTier);
						return;
					}
					if (EpicMMOSystem.enabledLevelControl.Value && (EpicMMOSystem.removeDropMax.Value || EpicMMOSystem.removeDropMin.Value) && !flag)
					{
						__instance.m_nview.GetZDO().Set("epic playerLevel", -hit.m_toolTier);
						return;
					}
					if (EpicMMOSystem.enabledLevelControl.Value && EpicMMOSystem.removeAllDropsFromNonPlayerKills.Value && attacker.IsTamed())
					{
						__instance.m_nview.GetZDO().Set("epic playerLevel", -hit.m_toolTier);
						return;
					}
					if (EpicMMOSystem.extraDebug.Value)
					{
						EpicMMOSystem.MLLogger.LogInfo((object)"else ZDO epic playerLevel to 0");
					}
					if (__instance.m_nview.GetZDO().GetInt("epic playerLevel", 0) != 0)
					{
						__instance.m_nview.GetZDO().Set("epic playerLevel", 0);
						if (EpicMMOSystem.extraDebug.Value)
						{
							EpicMMOSystem.MLLogger.LogInfo((object)"Set ZDO epic playerLevel to 0");
						}
					}
				}
				else if (!attacker.IsTamed())
				{
					CharacterLastDamageList[__instance] = 100L;
					if (EpicMMOSystem.enabledLevelControl.Value && (EpicMMOSystem.removeBossDropMax.Value || EpicMMOSystem.removeBossDropMin.Value || EpicMMOSystem.removeDropMax.Value || EpicMMOSystem.removeDropMin.Value || EpicMMOSystem.removeAllDropsFromNonPlayerKills.Value))
					{
						__instance.m_nview.GetZDO().Set("epic playerLevel", 1000512);
					}
				}
			}

			private static void Postfix(Character __instance, long sender, HitData hit)
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Expected O, but got Unknown
				//IL_0140: Unknown result type (might be due to invalid IL or missing references)
				//IL_0146: Invalid comparison between Unknown and I4
				//IL_0154: Unknown result type (might be due to invalid IL or missing references)
				if (__instance.IsTamed() || !(__instance.GetHealth() <= 0f) || !CharacterLastDamageList.ContainsKey(__instance))
				{
					return;
				}
				ZPackage val = new ZPackage();
				val.Write(((Object)((Component)__instance).gameObject).name);
				long num = CharacterLastDamageList[__instance];
				if (((Object)((Component)__instance).gameObject).name == "Player(Clone)" && lasthitplayer)
				{
					if (!EpicMMOSystem.enablePVPXP.Value)
					{
						return;
					}
					Player val2 = (Player)(object)((__instance is Player) ? __instance : null);
					if (!((Object)(object)val2 != (Object)null))
					{
						EpicMMOSystem.MLLogger.LogWarning((object)"Didnt find player");
						return;
					}
					string playerName = val2.GetPlayerName();
					EpicMMOSystem.MLLogger.LogWarning((object)(playerName + " Player was killed pvp "));
					ZDO zDO = ((Character)val2).m_nview.GetZDO();
					int num2 = zDO.GetInt("EpicMMOSystem" + EpicMMOSystem.PlayerAliveString, -1);
					if (num2 == -1)
					{
						EpicMMOSystem.MLLogger.LogWarning((object)("Days alive not found" + num2));
						num2 = 0;
					}
					int num3 = zDO.GetInt("EpicMMOSystem_level", 1) * EpicMMOSystem.xpPerLevelPVP.Value + num2 * EpicMMOSystem.xpPerDayNotDead.Value;
					val.Write(num3);
				}
				else
				{
					val.Write(__instance.GetLevel());
				}
				val.Write((int)__instance.GetFaction() == 8);
				val.Write(((Component)__instance).transform.position);
				ZRoutedRpc.instance.InvokeRoutedRPC(num, "EpicMMOSystem DeadMonsters", new object[1] { val });
				CharacterLastDamageList.Remove(__instance);
			}
		}

		[HarmonyPatch(typeof(Character), "ApplyDamage")]
		public static class ApplyDamage
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			public static void Postfix(Character __instance, HitData hit)
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Expected O, but got Unknown
				//IL_0140: Unknown result type (might be due to invalid IL or missing references)
				//IL_0146: Invalid comparison between Unknown and I4
				//IL_0154: Unknown result type (might be due to invalid IL or missing references)
				if (__instance.IsTamed() || !(__instance.GetHealth() <= 0f) || !CharacterLastDamageList.ContainsKey(__instance))
				{
					return;
				}
				ZPackage val = new ZPackage();
				val.Write(((Object)((Component)__instance).gameObject).name);
				long num = CharacterLastDamageList[__instance];
				if (((Object)((Component)__instance).gameObject).name == "Player(Clone)" && lasthitplayer)
				{
					if (!EpicMMOSystem.enablePVPXP.Value)
					{
						return;
					}
					Player val2 = (Player)(object)((__instance is Player) ? __instance : null);
					if (!((Object)(object)val2 != (Object)null))
					{
						EpicMMOSystem.MLLogger.LogWarning((object)"Didnt find player");
						return;
					}
					string playerName = val2.GetPlayerName();
					EpicMMOSystem.MLLogger.LogWarning((object)(playerName + " Player was killed pvp "));
					ZDO zDO = ((Character)val2).m_nview.GetZDO();
					int num2 = zDO.GetInt("EpicMMOSystem" + EpicMMOSystem.PlayerAliveString, -1);
					if (num2 == -1)
					{
						EpicMMOSystem.MLLogger.LogWarning((object)("Days alive not found" + num2));
						num2 = 0;
					}
					int num3 = zDO.GetInt("EpicMMOSystem_level", 1) * EpicMMOSystem.xpPerLevelPVP.Value + num2 * EpicMMOSystem.xpPerDayNotDead.Value;
					val.Write(num3);
				}
				else
				{
					val.Write(__instance.GetLevel());
				}
				val.Write((int)__instance.GetFaction() == 8);
				val.Write(((Component)__instance).transform.position);
				ZRoutedRpc.instance.InvokeRoutedRPC(num, "EpicMMOSystem DeadMonsters", new object[1] { val });
				CharacterLastDamageList.Remove(__instance);
			}
		}

		[HarmonyPatch(typeof(Character), "OnDestroy")]
		private static class Character_OnDestroy_Patch
		{
			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			private static void Postfix(Character __instance)
			{
				if (CharacterLastDamageList.ContainsKey(__instance))
				{
					CharacterLastDamageList.Remove(__instance);
				}
			}
		}

		[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(1)]
		private static readonly Dictionary<Character, long> CharacterLastDamageList = new Dictionary<Character, long>();

		private static bool lasthitplayer = false;

		public static void RPC_AddGroupExp(long sender, int exp, Vector3 position, int monsterLevel)
		{
			//IL_001b: 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)
			try
			{
				if (EpicMMOSystem.extraDebug.Value)
				{
					EpicMMOSystem.MLLogger.LogInfo((object)"Player was in group so applying exp from group kill");
				}
				if ((double)Vector3.Distance(position, ((Component)Player.m_localPlayer).transform.position) >= (double)EpicMMOSystem.groupRange.Value)
				{
					return;
				}
				int num = exp;
				bool flag = false;
				if (monsterLevel < 0)
				{
					flag = true;
					monsterLevel = -1 * monsterLevel;
				}
				if (EpicMMOSystem.enabledLevelControl.Value && (EpicMMOSystem.curveExp.Value || (flag && EpicMMOSystem.curveBossExp.Value) || EpicMMOSystem.noExpPastLVL.Value) && monsterLevel != 0)
				{
					if (EpicMMOSystem.extraDebug.Value)
					{
						EpicMMOSystem.MLLogger.LogInfo((object)"Checking player lvl for group exp");
					}
					int num2 = LevelSystem.Instance.getLevel() + EpicMMOSystem.maxLevelExp.Value;
					if (monsterLevel > num2)
					{
						if (EpicMMOSystem.noExpPastLVL.Value)
						{
							num = 0;
						}
						else if (EpicMMOSystem.curveExp.Value)
						{
							num = Convert.ToInt32(exp / (monsterLevel - num2));
						}
						else if (flag && EpicMMOSystem.curveBossExp.Value)
						{
							num = Convert.ToInt32(exp / (monsterLevel - num2));
						}
					}
					int num3 = LevelSystem.Instance.getLevel() - EpicMMOSystem.minLevelExp.Value;
					if (monsterLevel < num3)
					{
						if (EpicMMOSystem.noExpPastLVL.Value)
						{
							num = 0;
						}
						else if (EpicMMOSystem.curveExp.Value)
						{
							num = Convert.ToInt32(exp / (num3 - monsterLevel));
						}
						else if (flag && EpicMMOSystem.curveBossExp.Value)
						{
							num = Convert.ToInt32(exp / (num3 - monsterLevel));
						}
					}
					if (monsterLevel > num2 && EpicMMOSystem.mentor.Value)
					{
						num = exp;
					}
				}
				if (num > 0)
				{
					LevelSystem.Instance.AddExp(num);
				}
			}
			catch
			{
				EpicMMOSystem.MLLogger.LogWarning((object)"Bug catch RPC_AddGroupExp");
			}
		}

		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
		public static void RPC_DeadMonster(long sender, ZPackage pkg)
		{
			//IL_002f: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)Player.m_localPlayer) || ((Character)Player.m_localPlayer).IsDead())
			{
				return;
			}
			string text = pkg.ReadString();
			int num = pkg.ReadInt();
			bool num2 = pkg.ReadBool();
			Vector3 val = pkg.ReadVector3();
			bool flag = num2;
			int num3 = 1;
			int num4 = 0;
			int num5 = 0;
			if (text == "Player(Clone)")
			{
				EpicMMOSystem.MLLogger.LogInfo((object)"You Killed Player - PVP");
				num4 = num;
				LevelSystem.Instance.AddExp(num4, noxpMulti: true);
			}
			else
			{
				if (!DataMonsters.contains(text))
				{
					MonoBehaviour.print((object)("EpicMMOSystem: Can't find monster " + text));
					return;
				}
				num3 = DataMonsters.getLevel(text);
				if (EpicMMOSystem.mobLvlPerStar.Value)
				{
					num3 = num3 + num - 1;
				}
				if (DataMonsters.getLevel(text) == 0)
				{
					num3 = 0;
				}
				if ((double)Vector3.Distance(val, ((Component)Player.m_localPlayer).transform.position) >= (double)EpicMMOSystem.playerRange.Value)
				{
					return;
				}
				int exp = DataMonsters.getExp(text);
				int maxExp = DataMonsters.getMaxExp(text);
				float value = EpicMMOSystem.expForLvlMonster.Value;
				num5 = Convert.ToInt32((float)exp + (float)maxExp * value * (float)(num - 1));
				num4 = num5;
				if (EpicMMOSystem.enabledLevelControl.Value && (EpicMMOSystem.curveExp.Value || (flag && EpicMMOSystem.curveBossExp.Value) || EpicMMOSystem.noExpPastLVL.Value) && num3 != 0)
				{
					if (EpicMMOSystem.extraDebug.Value)
					{
						EpicMMOSystem.MLLogger.LogInfo((object)"Checking player lvl");
					}
					int num6 = LevelSystem.Instance.getLevel() + EpicMMOSystem.maxLevelExp.Value;
					if (num3 > num6)
					{
						if (EpicMMOSystem.noExpPastLVL.Value)
						{
							num4 = -2;
						}
						else if (EpicMMOSystem.curveExp.Value)
						{
							num4 = Convert.ToInt32(num5 / (num3 - num6));
						}
						else if (flag && EpicMMOSystem.curveBossExp.Value)
						{
							num4 = Convert.ToInt32(num5 / (num3 - num6));
						}
					}
					int num7 = LevelSystem.Instance.getLevel() - EpicMMOSystem.minLevelExp.Value;
					if (num3 < num7)
					{
						if (EpicMMOSystem.noExpPastLVL.Value)
						{
							num4 = -2;
						}
						else if (EpicMMOSystem.curveExp.Value)
						{
							num4 = Convert.ToInt32(num5 / (num7 - num3));
						}
						else if (flag && EpicMMOSystem.curveBossExp.Value)
						{
							num4 = Convert.ToInt32(num5 / (num7 - num3));
						}
					}
				}
				LevelSystem.Instance.AddExp(num4);
			}
			if (!Groups.API.IsLoaded())
			{
				return;
			}
			if (EpicMMOSystem.extraDebug.Value)
			{
				EpicMMOSystem.MLLogger.LogInfo((object)"Player in Group");
			}
			if (flag && num3 != 0)
			{
				num3 = -1 * num3;
			}
			float value2 = EpicMMOSystem.groupExp.Value;
			foreach (PlayerReference item in Groups.API.GroupPlayers())
			{
				if (item.name != Player.m_localPlayer.GetPlayerName() && num5 > 0)
				{
					float num8 = (float)num5 * value2;
					ZRoutedRpc.instance.InvokeRoutedRPC(item.peerId, "EpicMMOSystem AddGroupExp", new object[3]
					{
						(int)num8,
						val,
						num3
					});
				}
			}
		}
	}
	public static class PlayerFVX
	{
		public static void levelUp()
		{
			//IL_005c: 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)
			Transform val = ((Component)Player.m_localPlayer).transform.Find("Visual/Armature/Hips/Spine/Spine1/Spine2");
			Transform val2 = null;
			val2 = (EpicMMOSystem.altLevelUpSound.Value ? Object.Instantiate<GameObject>(ZNetScene.instance.GetPrefab("LevelUpVFX2"), val).transform : Object.Instantiate<GameObject>(ZNetScene.instance.GetPrefab("LevelUpVFX"), val).transform);
			val2.localPosition = Vector3.zero;
			val2.localScale = new Vector3(0.01352632f, 0.01352632f, 0.01352632f);
		}
	}
	public class CritDmgVFX
	{
		public void CriticalVFX(Vector3 position, float damage)
		{
			//IL_003a: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			//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_0066: Expected O, but got Unknown
			//IL_0072: 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_00b7: 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_00c3: 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_00e6: Unknown result type (might be due to invalid IL or missing references)
			string text = "Crit " + Math.Round(damage);
			Random.Range(1.2f, 1.6f);
			Random.Range(1.2f, 1.6f);
			WorldTextInstance val = new WorldTextInstance
			{
				m_worldPos = position,
				m_gui = Object.Instantiate<GameObject>(DamageText.instance.m_worldTextBase, ((Component)DamageText.instance).transform)
			};
			RectTransform component = val.m_gui.GetComponent<RectTransform>();
			component.sizeDelta *= 2f;
			val.m_textField = val.m_gui.GetComponent<TMP_Text>();
			DamageText.instance.m_worldTexts.Add(val);
			val.m_textField.fontSize = 30f;
			Color cyan = Color.cyan;
			((Graphic)val.m_textField).color = cyan;
			val.m_textField.text = text;
			val.m_timer = -1f;
			Object.Destroy((Object)(object)Object.Instantiate<GameObject>(EpicMMOSystem.fx_seeker_crit, position, Quaternion.identity), 5f);
		}
	}
	[HarmonyPatch(typeof(Game), "SpawnPlayer")]
	public static class MainReloadStartSoLoad
	{
		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
		private static void Postfix(Game __instance)
		{
			EpicMMOSystem.MLLogger.LogInfo((object)"ReLoading exp chart");
			LevelSystem.Instance.FillLevelsExp();
		}
	}
	[HarmonyPatch(typeof(ZoneSystem), "Start")]
	public static class MainReloadStarEarly
	{
		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
		private static void Prefix(Game __instance)
		{
			EpicMMOSystem.runSSvalues();
		}
	}
	public enum Parameter
	{
		Strength,
		Agility,
		Intellect,
		Body,
		Vigour,
		Special
	}
	[HarmonyPatch(typeof(Game), "SpawnPlayer")]
	[HarmonyPriority(998)]
	public static class SetZDOLevel
	{
		public static void Postfix()
		{
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			int level = LevelSystem.Instance.getLevel();
			string value = level.ToString();
			if (!Player.m_localPlayer.m_customData.TryGetValue("epicmmolevel", out var _))
			{
				Player.m_localPlayer.m_customData.Add("epicmmolevel", value);
			}
			if (Player.m_localPlayer.m_customData.TryGetValue(EpicMMOSystem.PlayerAliveString, out var value3))
			{
				int.TryParse(value3, out var _);
			}
			else
			{
				Player.m_localPlayer.m_customData.Add(EpicMMOSystem.PlayerAliveString, "0");
			}
			ZDO zDO = ((Character)Player.m_localPlayer).m_nview.GetZDO();
			zDO.Set("EpicMMOSystem_level", level);
			zDO.Set("EpicMMOSystem" + EpicMMOSystem.PlayerAliveString, int.Parse(Player.m_localPlayer.m_customData[EpicMMOSystem.PlayerAliveString]));
			ZDOMan.instance.ForceSendZDO(zDO.m_uid);
		}
	}
	[HarmonyPatch(typeof(Player), "OnDeath")]
	public static class Death
	{
		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
		public static void Prefix(Player __instance)
		{
			if (((Character)__instance).m_nview.IsOwner())
			{
				Debug.Log((object)"OnDeath call but not the owner");
			}
			LevelSystem.Instance.DeathPlayer();
		}
	}
	[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
	[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
	public class Localizationold
	{
		private string defaultFileName = "eng_emmosLocalization.txt";

		private Dictionary<string, string> _dictionary = new Dictionary<string, string>();

		public string this[string key]
		{
			get
			{
				if (_dictionary.ContainsKey(key))
				{
					return _dictionary[key];
				}
				return "Missing language key";
			}
		}

		public Localizationold()
		{
			switch (Localization.instance.GetSelectedLanguage())
			{
			case "Russian":
				RusLocalization();
				return;
			case "English":
				EngLocalization();
				return;
			case "Spanish":
				SpanLocalization();
				return;
			case "German":
				GermanLocalization();
				return;
			case "Chinese":
				ChineseLocalization();
				return;
			case "Portuguese":
				PortugueseLocalization();
				return;
			case "Swedish":
				SwedishLocalization();
				return;
			case "French":
				FrenchLocalization();
				return;
			case "Korean":
				KoreanLocalization();
				return;
			case "Polish":
				PolishLocalization();
				return;
			case "Ukrainian":
				UkrLocalization();
				return;
			case "Turkish":
				TurkishLocalization();
				return;
			case "Portuguese_Brazilian":
				Portuguese_Brazilian();
				return;
			case "Hungarian":
				HungLocalization();
				return;
			case "Czech":
				CzechLocalization();
				return;
			}
			string path = "Custom_EpicMMOSystem_Localization.txt";
			string path2 = Path.Combine(Paths.PluginPath, "EpicMMOSystem", path);
			if (File.Exists(path2))
			{
				ReadLocalization(path2);
			}
			else
			{
				CreateLocalizationFile();
			}
		}

		private void ReadLocalization(string path)
		{
			string[] array = File.ReadAllLines(path);
			EngLocalization();
			bool flag = _dictionary.Count > array.Length;
			string[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				string[] array3 = array2[i].Split(new char[1] { '=' });
				string text = array3[1].Replace('*', '\n');
				_dictionary[array3[0].Trim()] = text.TrimStart(Array.Empty<char>());
			}
			if (!flag)
			{
				return;
			}
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, string> item in _dictionary)
			{
				list.Add(item.Key + " = " + item.Value);
			}
			File.WriteAllLines(path, list);
		}

		private void CreateLocalizationFile()
		{
			EngLocalization();
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, string> item in _dictionary)
			{
				list.Add(item.Key + " = " + item.Value);
			}
			string path = Path.Combine(Paths.ConfigPath, "EpicMMOSystem");
			if (!Directory.Exists(path))
			{
				Directory.CreateDirectory(path);
			}
			File.WriteAllLines(Path.Combine(Paths.ConfigPath, "EpicMMOSystem", defaultFileName), list);
		}

		private void EngLocalization()
		{
			_dictionary.Add("$attributes", "Attributes");
			_dictionary.Add("$parameter_strength", "Strength");
			_dictionary.Add("$parameter_intellect", "Intellect");
			_dictionary.Add("$free_points", "Available points");
			_dictionary.Add("$level", "Level");
			_dictionary.Add("$lvl", "Lvl.");
			_dictionary.Add("$exp", "Experience");
			_dictionary.Add("$cancel", "Cancel");
			_dictionary.Add("$apply", "Accept");
			_dictionary.Add("$reset_parameters", "Reset points");
			_dictionary.Add("$no", "No");
			_dictionary.Add("$yes", "Yes");
			_dictionary.Add("$get_exp", "Experience received");
			_dictionary.Add("$reset_point_text", "Do you really want to drop all the points for {0} {1}?");
			_dictionary.Add("$physic_damage", "Physical Damage");
			_dictionary.Add("$add_weight", "Carry weight");
			_dictionary.Add("$reduced_stamina", "Stamina consumption (running, jumping)");
			_dictionary.Add("$magic_damage", "Elemental damage");
			_dictionary.Add("$magic_armor", "Elemental reduced");
			_dictionary.Add("$add_hp", "Health increase");
			_dictionary.Add("$add_stamina", "Stamina increase");
			_dictionary.Add("$physic_armor", "Physical reduced");
			_dictionary.Add("$reduced_stamina_block", "Block stamina consumption");
			_dictionary.Add("$regen_hp", "Health regeneration");
			_dictionary.Add("$damage", "Damage");
			_dictionary.Add("$armor", "Armor");
			_dictionary.Add("$survival", "Survival");
			_dictionary.Add("$regen_eitr", "Eitr regeneration");
			_dictionary.Add("$stamina_reg", "Stamina regeneration");
			_dictionary.Add("$add_eitr", "Eitr Increase");
			_dictionary.Add("$parameter_agility", "Dexterity");
			_dictionary.Add("$parameter_body", "Endurance");
			_dictionary.Add("$parameter_vigour", "Vigour");
			_dictionary.Add("$parameter_special", "Specializing");
			_dictionary.Add("$specialother", "Special");
			_dictionary.Add("$attack_speed", "Attack speed");
			_dictionary.Add("$attack_stamina", "Attack stamina consumption");
			_dictionary.Add("$crtcDmgMulti", "Critical Damage Multiplier");
			_dictionary.Add("$mining_speed", "Mining Damage increase");
			_dictionary.Add("$piece_health", "Piece Health increase");
			_dictionary.Add("$tree_cutting", "Tree Damage increase");
			_dictionary.Add("$crit_chance", "Critical Chance increase");
			_dictionary.Add("$notify", "<color=#00E6FF>Alert</color>");
			_dictionary.Add("$friends_list", "Friends list");
			_dictionary.Add("$send", "Send");
			_dictionary.Add("$invited", "Invitations");
			_dictionary.Add("$friends", "Friends");
			_dictionary.Add("$online", "Online");
			_dictionary.Add("$offline", "Offline");
			_dictionary.Add("$not_found", "Player {0} is not found.");
			_dictionary.Add("$send_invite", "A friend request has been sent to player {0}.");
			_dictionary.Add("$get_invite", "Received a friend request from {0}.");
			_dictionary.Add("$accept_invite", "Player {0}, accepted the friend request.");
			_dictionary.Add("$cancel_invite", "Player {0}, canceled his friend request.");
			_dictionary.Add("$terminal_set_level", "You got {0} level");
			_dictionary.Add("$terminal_reset_points", "Your attributes points have been reset");
			_dictionary.Add("$strength_tooltip", "<size=20>Strength will enhance:</size> \n<color=yellow> Increase Physical Damage </color> \n<color=blue> Increase Carry Weight </color> \n<color=green> Decrease Block Stamina Consumption </color> \n<color=red> Increase Critical Damage when crit hits </color>");
			_dictionary.Add("$dexterity_tooltip", "<size=20>Dexterity will enhance:</size> \n<color=red> Increase Attack Speed (not bows)</color> \n<color=yellow> Decreased Attack Stamina Consumption </color> \n<color=green> Decreased Running/Jumping Stamina Consumption</color> ");
			_dictionary.Add("$intelect_tooltip", "<size=20>Intelligence will enhance:</size> \n<color=green> Increase all Elemental Damage </color>\n<color=red> Increase base Eitr amount (once you have eitr)</color> \n<color=red> Increase Eitr Regeneration</color> ");
			_dictionary.Add("$endurance_tooltip", "<size=20>Endurance will enhance:</size> \n<color=yellow> Increase Stamina amount</color>\n<color=yellow> Increase Stamina Regeneration </color> \n<color=green> Reduce Physical Damage Taken</color> ");
			_dictionary.Add("$vigour_tooltip", "<size=20>Vigour will enhance:</size> \n<color=red> Increase HP amount</color>\n<color=yellow> Health Regeneration </color> \n<color=green> Reduce Elemental Damage Taken</color> ");
			_dictionary.Add("$special_tooltip", "<size=20>Special will enhance:</size> \n<color=red> Increase Critical Attack Chance</color> \n<color=blue> Increase Mining Damage </color> \n<color=blue> Increase construction piece's health </color> \n<color=green> Increase Tree Cutting Damage</color>");
		}

		private void RusLocalization()
		{
			_dictionary.Add("$attributes", "Характеристики");
			_dictionary.Add("$parameter_strength", "Сила");
			_dictionary.Add("$parameter_intellect", "Интеллект");
			_dictionary.Add("$free_points", "Свободных очков");
			_dictionary.Add("$level", "Уровень");
			_dictionary.Add("$lvl", "Ур.");
			_dictionary.Add("$exp", "Опыт");
			_dictionary.Add("$cancel", "Отмена");
			_dictionary.Add("$apply", "Принять");
			_dictionary.Add("$reset_parameters", "Сбросить очки");
			_dictionary.Add("$no", "Нет");
			_dictionary.Add("$yes", "Да");
			_dictionary.Add("$get_exp", "Получено опыта");
			_dictionary.Add("$reset_point_text", "Вы действительно хотите сбросить все очки характеристик за {0} {1}?");
			_dictionary.Add("$physic_damage", "Физический урон");
			_dictionary.Add("$add_weight", "Переносимый вес");
			_dictionary.Add("$reduced_stamina", "Выносливость на бег и прыжки");
			_dictionary.Add("$magic_damage", "Магический урон");
			_dictionary.Add("$magic_armor", "Магическая защита");
			_dictionary.Add("$add_hp", "Здоровье");
			_dictionary.Add("$add_stamina", "Выносливость");
			_dictionary.Add("$physic_armor", "Физическая защита");
			_dictionary.Add("$reduced_stamina_block", "Выносливость на блок");
			_dictionary.Add("$regen_hp", "Восстановление здоровья");
			_dictionary.Add("$damage", "Урон");
			_dictionary.Add("$armor", "Защита");
			_dictionary.Add("$survival", "Выживаемость");
			_dictionary.Add("$regen_eitr", "Восстановление эйтра");
			_dictionary.Add("$stamina_reg", "Восстановление выносливости");
			_dictionary.Add("$add_eitr", "Эйтр");
			_dictionary.Add("$parameter_agility", "Ловкость");
			_dictionary.Add("$parameter_body", "Стойкость");
			_dictionary.Add("$parameter_vigour", "Телосложение");
			_dictionary.Add("$parameter_special", "Специализация");
			_dictionary.Add("$specialother", "Специализация");
			_dictionary.Add("$attack_speed", "Скорость атаки");
			_dictionary.Add("$attack_stamina", "Выносливость на атаку");
			_dictionary.Add("$crtcDmgMulti", "Крит. урон");
			_dictionary.Add("$mining_speed", "Урон по рудам");
			_dictionary.Add("$piece_health", "Прочность построек");
			_dictionary.Add("$tree_cutting", "Урон по деревьям");
			_dictionary.Add("$crit_chance", "Шанс крит. удара");
			_dictionary.Add("$notify", "<color=#00E6FF>Оповещение</color>");
			_dictionary.Add("$friends_list", "Список друзей");
			_dictionary.Add("$send", "Отправить");
			_dictionary.Add("$invited", "Приглашения");
			_dictionary.Add("$friends", "Друзья");
			_dictionary.Add("$online", "В игре");
			_dictionary.Add("$offline", "Не в игре");
			_dictionary.Add("$not_found", "Игрок {0} не найден.");
			_dictionary.Add("$send_invite", "Запрос в друзья отправлен игроку {0}.");
			_dictionary.Add("$get_invite", "Получен запрос в друзья от {0}.");
			_dictionary.Add("$accept_invite", "{0} принял ваш запрос в друзья.");
			_dictionary.Add("$cancel_invite", "{0} отклонил ваш запрос в друзья.");
			_dictionary.Add("$terminal_set_level", "Вы получили {0} уровень");
			_dictionary.Add("$terminal_reset_points", "Ваши очки характеристик были сброшены");
			_dictionary.Add("$strength_tooltip", "<size=20>Сила влияет на следующие показатели:</size> \n<color=yellow>Физический урон</color> \n<color=blue>Переносимый вес</color> \n<color=green>Расход выносливости на блок</color> \n<color=red>Множитель крит. урона</color>");
			_dictionary.Add("$dexterity_tooltip", "<size=20>Ловкость влияет на следующие показатели:</size> \n<color=red>Скорость атаки (кроме луков)</color> \n<color=yellow>Расход выносливости на атаку</color> \n<color=green>Расход выносливости на бег и прыжки</color> ");
			_dictionary.Add("$intelect_tooltip", "<size=20>Интеллект влияет на следующие показатели:</size> \n<color=green>Магический урон </color>\n<color=red>Запас эйтра (после его получения)</color> \n<color=red>Восстановление эйтра</color> ");
			_dictionary.Add("$endurance_tooltip", "<size=20>Стойкость влияет на следующие показатели:</size> \n<color=yellow>Запас выносливости</color>\n<color=yellow>Восстановление выносливости</color> \n<color=green>Получаемый физический урон</color> ");
			_dictionary.Add("$vigour_tooltip", "<size=20>Телосложение влияет на следующие показатели:</size> \n<color=red>Запас здоровья</color>\n<color=yellow>Восстановление здоровья</color> \n<color=green>Получаемый магический урон</color> ");
			_dictionary.Add("$special_tooltip", "<size=20>Специализация влияет на следующие показатели:</size> \n<color=red>Шанс крит. удара</color> \n<color=blue>Урон по рудам</color> \n<color=blue>Прочность построек</color> \n<color=green>Урон по деревьям</color>");
		}

		private void KoreanLocalization()
		{
			_dictionary.Add("$attributes", "속성");
			_dictionary.Add("$parameter_strength", "힘");
			_dictionary.Add("$parameter_intellect", "지능");
			_dictionary.Add("$free_points", "사용 가능한 포인트");
			_dictionary.Add("$level", "레벨");
			_dictionary.Add("$lvl", "레벨");
			_dictionary.Add("$exp", "경험치");
			_dictionary.Add("$cancel", "취소");
			_dictionary.Add("$apply", "적용");
			_dictionary.Add("$reset_parameters", "포인트 초기화");
			_dictionary.Add("$no", "아니요");
			_dictionary.Add("$yes", "예");
			_dictionary.Add("$get_exp", "받은 경험치");
			_dictionary.Add("$reset_point_text", "모든 포인트를 {0} {1}로 되돌리시겠습니까?");
			_dictionary.Add("$physic_damage", "물리 대미지");
			_dictionary.Add("$add_weight", "운반 무게");
			_dictionary.Add("$reduced_stamina", "스태미너 소모 (달리기, 점프)");
			_dictionary.Add("$magic_damage", "원소 대미지");
			_dictionary.Add("$magic_armor", "원소 저항");
			_dictionary.Add("$add_hp", "체력 증가");
			_dictionary.Add("$add_stamina", "스태미너 증가");
			_dictionary.Add("$physic_armor", "물리 저항");
			_dictionary.Add("$reduced_stamina_block", "방어 스태미너 소모 감소");
			_dictionary.Add("$regen_hp", "체력 재생");
			_dictionary.Add("$damage", "대미지");
			_dictionary.Add("$armor", "방어력");
			_dictionary.Add("$survival", "생존");
			_dictionary.Add("$regen_eitr", "아이트르 재생");
			_dictionary.Add("$stamina_reg", "스태미너 재생");
			_dictionary.Add("$add_eitr", "아이트르 증가");
			_dictionary.Add("$parameter_agility", "민첩성");
			_dictionary.Add("$parameter_body", "지구력");
			_dictionary.Add("$parameter_vigour", "활력");
			_dictionary.Add("$parameter_special", "특수화");
			_dictionary.Add("$specialother", "특수");
			_dictionary.Add("$attack_speed", "공격 속도");
			_dictionary.Add("$attack_stamina", "공격 스태미너 소모");
			_dictionary.Add("$crtcDmgMulti", "치명타 대미지 배율");
			_dictionary.Add("$mining_speed", "채광 대미지 증가");
			_dictionary.Add("$piece_health", "건물 체력 증가");
			_dictionary.Add("$tree_cutting", "나무 베기 대미지 증가");
			_dictionary.Add("$crit_chance", "치명타 확률 증가");
			_dictionary.Add("$notify", "<color=#00E6FF>알림</color>");
			_dictionary.Add("$friends_list", "친구 목록");
			_dictionary.Add("$send", "보내기");
			_dictionary.Add("$invited", "초대");
			_dictionary.Add("$friends", "친구");
			_dictionary.Add("$online", "온라인");
			_dictionary.Add("$offline", "오프라인");
			_dictionary.Add("$not_found", "'플레이어 {0}'을(를) 찾을 수 없습니다.");
			_dictionary.Add("$send_invite", "'플레이어 {0}'에게 친구 요청이 전송되었습니다.");
			_dictionary.Add("$get_invite", "'{0}'님으로부터 친구 요청을 받았습니다.");
			_dictionary.Add("$accept_invite", "'{0}'님이 친구 요청을 수락했습니다.");
			_dictionary.Add("$cancel_invite", "'{0}'님이 친구 요청을 취소했습니다.");
			_dictionary.Add("$terminal_set_level", "'{0}' 레벨을 획득했습니다.");
			_dictionary.Add("$terminal_reset_points", "속성 포인트가 초기화되었습니다.");
			_dictionary.Add("$strength_tooltip", "<size=20>힘은 다음을 향상시킵니다:</size> \n<color=yellow>물리 대미지 증가</color> \n<color=blue>운반 무게 증가</color> \n<color=green>방어 스태미너 소모 감소</color> \n<color=red>치명타 공격 시 치명타 대미지 증가</color>");
			_dictionary.Add("$dexterity_tooltip", "<size=20>민첩성은 다음을 향상시킵니다:</size> \n<color=red>공격 속도 증가 (활 제외)</color> \n<color=yellow>공격 스태미너 소모 감소</color> \n<color=green>달리기/점프 스태미너 소모 감소</color>");
			_dictionary.Add("$intelect_tooltip", "<size=20>지능은 다음을 향상시킵니다:</size> \n<color=green>모든 원소 대미지 증가</color>\n<color=red>기본 아이트르 양 증가 (아이트르 보유 시)</color> \n<color=red>아이트르 재생 증가</color> ");
			_dictionary.Add("$endurance_tooltip", "<size=20>지구력은 다음을 향상시킵니다:</size> \n<color=yellow>스태미너 양 증가</color>\n<color=yellow>스태미너 재생 증가</color> \n<color=green>받는 물리 대미지 감소</color>");
			_dictionary.Add("$vigour_tooltip", "<size=20>활력은 다음을 향상시킵니다:</size> \n<color=red>체력 양 증가</color>\n<color=yellow>체력 재생</color> \n<color=green>원소 대미지 감소</color>");
			_dictionary.Add("$special_tooltip", "<size=20>특수화는 다음을 향상시킵니다:</size> \n<color=red>치명타 공격 확률 증가</color>\n<color=blue>채광 대미지 증가</color> \n<color=blue>건물 체력 증가</color> \n<color=green>나무 베기 대미지 증가</color>");
		}

		private void FrenchLocalization()
		{
			_dictionary.Add("$attributes", "Attributs");
			_dictionary.Add("$parameter_strength", "Force");
			_dictionary.Add("$parameter_intellect", "Intellect");
			_dictionary.Add("$free_points", "Points disponibles");
			_dictionary.Add("$level", "Niveau");
			_dictionary.Add("$lvl", "Niv.");
			_dictionary.Add("$exp", "Expérience");
			_dictionary.Add("$cancel", "Annuler");
			_dictionary.Add("$apply", "Accepter");
			_dictionary.Add("$reset_parameters", "Réinitialiser les points");
			_dictionary.Add("$no", "Non");
			_dictionary.Add("$yes", "Oui");
			_dictionary.Add("$get_exp", "Expérience obtenue");
			_dictionary.Add("$reset_point_text", "Voulez-vous vraiment supprimer tous les points pour {0} {1} ?");
			_dictionary.Add("$physic_damage", "Dommages Physiques");
			_dictionary.Add("$add_weight", "Capacité de Port");
			_dictionary.Add("$reduced_stamina", "Consommation de Stamina (course, saut)");
			_dictionary.Add("$magic_damage", "Dommages Élémentaires");
			_dictionary.Add("$magic_armor", "Réduction des Dommages Élémentaires");
			_dictionary.Add("$add_hp", "Augmentation des Points de Vie");
			_dictionary.Add("$add_stamina", "Augmentation de la Stamina");
			_dictionary.Add("$physic_armor", "Réduction des Dommages Physiques");
			_dictionary.Add("$reduced_stamina_block", "Consommation de Stamina lors du Blocage");
			_dictionary.Add("$regen_hp", "Régénération des Points de Vie");
			_dictionary.Add("$damage", "Dommages");
			_dictionary.Add("$armor", "Armure");
			_dictionary.Add("$survival", "Survie");
			_dictionary.Add("$regen_eitr", "Régénération d'Eitr");
			_dictionary.Add("$stamina_reg", "Régénération de la Stamina");
			_dictionary.Add("$add_eitr", "Augmentation d'Eitr");
			_dictionary.Add("$parameter_agility", "Agilité");
			_dictionary.Add("$parameter_body", "Endurance");
			_dictionary.Add("$parameter_vigour", "Vigueur");
			_dictionary.Add("$parameter_special", "Spécialisation");
			_dictionary.Add("$specialother", "Spécialisation");
			_dictionary.Add("$attack_speed", "Vitesse d'Attaque");
			_dictionary.Add("$attack_stamina", "Consommation de Stamina lors de l'Attaque");
			_dictionary.Add("$crtcDmgMulti", "Multiplicateur de Dommages Critiques");
			_dictionary.Add("$mining_speed", "Augmentation des Dommages lors de l'Extraction");
			_dictionary.Add("$piece_health", "Augmentation des Points de Vie des Pièces");
			_dictionary.Add("$tree_cutting", "Augmentation des Dommages lors de la Coupe d'Arbres");
			_dictionary.Add("$crit_chance", "Augmentation des Chances de Critique");
			_dictionary.Add("$notify", "<color=#00E6FF>Alerte</color>");
			_dictionary.Add("$friends_list", "Liste d'Amis");
			_dictionary.Add("$send", "Envoyer");
			_dictionary.Add("$invited", "Invitations");
			_dictionary.Add("$friends", "Amis");
			_dictionary.Add("$online", "En Ligne");
			_dictionary.Add("$offline", "Hors Ligne");
			_dictionary.Add("$not_found", "Le joueur {0} n'est pas trouvé.");
			_dictionary.Add("$send_invite", "Une demande d'ami a été envoyée au joueur {0}.");
			_dictionary.Add("$get_invite", "Vous avez reçu une demande d'ami de {0}.");
			_dictionary.Add("$accept_invite", "Le joueur {0} a accepté la demande d'ami.");
			_dictionary.Add("$cancel_invite", "Le joueur {0} a annulé sa demande d'ami.");
			_dictionary.Add("$terminal_set_level", "Vous avez atteint le niveau {0}.");
			_dictionary.Add("$terminal_reset_points", "Vos points d'attributs ont été réinitialisés");
			_dictionary.Add("$strength_tooltip", "<size=20>La Force améliorera :</size> \n<color=yellow> Augmentation des Dommages Physiques </color> \n<color=blue> Augmentation de la Capacité de Port </color> \n<color=green> Réduction de la Consommation de Stamina lors du Blocage </color> \n<color=red> Augmentation des Dommages Critiques en cas de coups critiques </color>");
			_dictionary.Add("$dexterity_tooltip", "<size=20>L'Agilité améliorera :</size> \n<color=red> Augmentation de la Vitesse d'Attaque (hors arcs) </color> \n<color=yellow> Réduction de la Consommation de Stamina lors de l'Attaque </color> \n<color=green> Réduction de la Consommation de Stamina lors de la Course/Saut </color>");
			_dictionary.Add("$intelect_tooltip", "<size=20>L'Intellect améliorera :</size> \n<color=green> Augmentation de tous les Dommages Élémentaires </color> \n<color=red> Augmentation de la Quantité d'Eitr de base (une fois que vous avez de l'Eitr) </color> \n<color=red> Augmentation de la Régénération de l'Eitr </color>");
			_dictionary.Add("$endurance_tooltip", "<size=20>L'Endurance améliorera :</size> \n<color=yellow> Augmentation de la Quantité de Stamina </color> \n<color=yellow> Augmentation de la Régénération de Stamina </color> \n<color=green> Réduction des Dommages Physiques Subis </color>");
			_dictionary.Add("$vigour_tooltip", "<size=20>La Vigueur améliorera :</size> \n<color=red> Augmentation de la Quantité de Points de Vie </color> \n<color=yellow> Régénération des Points de Vie </color> \n<color=green> Réduction des Dommages Élémentaires Subis </color>");
			_dictionary.Add("$special_tooltip", "<size=20>La Spécialisation améliorera :</size> \n<color=red> Augmentation des Chances d'Attaque Critique </color> \n<color=blue> Augmentation des Dommages lors de l'Extraction </color> \n<color=blue> Augmentation de la Durabilité des Pièces de Construction </color> \n<color=green> Augmentation des Dommages lors de la Coupe d'Arbres </color>");
		}

		private void SwedishLocalization()
		{
			_dictionary.Add("$attributes", "Attribut");
			_dictionary.Add("$parameter_strength", "Styrka");
			_dictionary.Add("$parameter_intellect", "Intellekt");
			_dictionary.Add("$free_points", "Tillgängliga poäng");
			_dictionary.Add("$level", "Nivå");
			_dictionary.Add("$lvl", "Nivå.");
			_dictionary.Add("$exp", "Erfarenhet");
			_dictionary.Add("$cancel", "Avbryt");
			_dictionary.Add("$apply", "Godkänn");
			_dictionary.Add("$reset_parameters", "Återställ poäng");
			_dictionary.Add("$no", "Nej");
			_dictionary.Add("$yes", "Ja");
			_dictionary.Add("$get_exp", "Fått erfarenhet");
			_dictionary.Add("$reset_point_text", "Vill du verkligen ta bort alla poäng för {0} {1}?");
			_dictionary.Add("$physic_damage", "Fysiskt Skada");
			_dictionary.Add("$add_weight", "Bärkapacitet");
			_dictionary.Add("$reduced_stamina", "Stamina-förbrukning (springa, hoppa)");
			_dictionary.Add("$magic_damage", "Elemental skada");
			_dictionary.Add("$magic_armor", "Elemental reducerad");
			_dictionary.Add("$add_hp", "Hälsa ökar");
			_dictionary.Add("$add_stamina", "Stamina ökar");
			_dictionary.Add("$physic_armor", "Fysisk reducerad");
			_dictionary.Add("$reduced_stamina_block", "Blockera stamina-förbrukning");
			_dictionary.Add("$regen_hp", "Hälsoregeneration");
			_dictionary.Add("$damage", "Skada");
			_dictionary.Add("$armor", "Rustning");
			_dictionary.Add("$survival", "Överlevnad");
			_dictionary.Add("$regen_eitr", "Eitr-regeneration");
			_dictionary.Add("$stamina_reg", "Stamina-regeneration");
			_dictionary.Add("$add_eitr", "Eitr-ökning");
			_dictionary.Add("$parameter_agility", "Smidighet");
			_dictionary.Add("$parameter_body", "Uthållighet");
			_dictionary.Add("$parameter_vigour", "Kraft");
			_dictionary.Add("$parameter_special", "Specialisering");
			_dictionary.Add("$specialother", "Special");
			_dictionary.Add("$attack_speed", "Attackhastighet");
			_dictionary.Add("$attack_stamina", "Stamina-förbrukning vid attack");
			_dictionary.Add("$crtcDmgMulti", "Kritisk Skademultiplikator");
			_dictionary.Add("$mining_speed", "Ökad Skada vid Brytning");
			_dictionary.Add("$piece_health", "Ökad Hållbarhet för Delar");
			_dictionary.Add("$tree_cutting", "Ökad Skada vid Trädfällning");
			_dictionary.Add("$crit_chance", "Ökad Chans för Kritiska Träffar");
			_dictionary.Add("$notify", "<color=#00E6FF>Varning</color>");
			_dictionary.Add("$friends_list", "Vänlista");
			_dictionary.Add("$send", "Skicka");
			_dictionary.Add("$invited", "Inbjudningar");
			_dictionary.Add("$friends", "Vänner");
			_dictionary.Add("$online", "Online");
			_dictionary.Add("$offline", "Offline");
			_dictionary.Add("$not_found", "Spelare {0} hittades inte.");
			_dictionary.Add("$send_invite", "En vänförfrågan har skickats till spelare {0}.");
			_dictionary.Add("$get_invite", "Du har fått en vänförfrågan från {0}.");
			_dictionary.Add("$accept_invite", "Spelare {0} har accepterat vänförfrågan.");
			_dictionary.Add("$cancel_invite", "Spelare {0} har avbrutit sin vänförfrågan.");
			_dictionary.Add("$terminal_set_level", "Du har nått nivå {0}.");
			_dictionary.Add("$terminal_reset_points", "Dina attributpoäng har återställts");
			_dictionary.Add("$strength_tooltip", "<size=20>Styrka kommer att förbättra:</size> \n<color=yellow> Öka Fysisk Skada </color> \n<color=blue> Öka Bärkapacitet </color> \n<color=green> Minska Stamina-förbrukning vid blockering </color> \n<color=red> Öka Kritisk Skada vid kritiska träffar </color>");
			_dictionary.Add("$dexterity_tooltip", "<size=20>Smidighet kommer att förbättra:</size> \n<color=red> Öka Attackhastighet (ej bågar) </color> \n<color=yellow> Minska Stamina-förbrukning vid attack </color> \n<color=green> Minska Stamina-förbrukning vid löpning/hopp </color>");
			_dictionary.Add("$intelect_tooltip", "<size=20>Intellekt kommer att förbättra:</size> \n<color=green> Öka all Elementalskada </color> \n<color=red> Öka basmängden Eitr (när du har Eitr) </color> \n<color=red> Öka Eitr-regeneration </color>");
			_dictionary.Add("$endurance_tooltip", "<size=20>Uthållighet kommer att förbättra:</size> \n<color=yellow> Öka Stamina-mängden </color> \n<color=yellow> Öka Stamina-regeneration </color> \n<color=green> Minska Fysisk Skada som tas emot </color>");
			_dictionary.Add("$vigour_tooltip", "<size=20>Kraft kommer att förbättra:</size> \n<color=red> Öka HP-mängden </color> \n<color=yellow> Hälsoregeneration </color> \n<color=green> Minska Elemental Skada som tas emot </color>");
			_dictionary.Add("$special_tooltip", "<size=20>Specialisering kommer att förbättra:</size> \n<color=red> Öka Chansen för Kritiska Attacker </color> \n<color=blue> Öka Skadan vid Brytning </color> \n<color=blue> Öka Hållbarheten hos Byggnadsdelar </color> \n<color=green> Öka Skadan vid Trädfällning </color>");
		}

		private void SpanLocalization()
		{
			_dictionary.Add("$attributes", "Atributos");
			_dictionary.Add("$parameter_strength", "Fuerza");
			_dictionary.Add("$parameter_intellect", "Intelecto");
			_dictionary.Add("$free_points", "Puntos disponibles");
			_dictionary.Add("$level", "Nivel");
			_dictionary.Add("$lvl", "Nivel.");
			_dictionary.Add("$exp", "Experiencia");
			_dictionary.Add("$cancel", "Cancelar");
			_dictionary.Add("$apply", "Aceptar");
			_dictionary.Add("$reset_parameters", "Restablecer puntos");
			_dictionary.Add("$no", "No");
			_dictionary.Add("$yes", "Si");
			_dictionary.Add("$get_exp", "Experiencia recibida");
			_dictionary.Add("$reset_point_text", "¿De verdad quieres eliminar todos los puntos por {0} {1}?");
			_dictionary.Add("$physic_damage", "Daño Físico");
			_dictionary.Add("$add_weight", "Cargar Peso");
			_dictionary.Add("$speed_attack", "Consumo de resistencia de ataque");
			_dictionary.Add("$reduced_stamina", "Consumo de energía (correr, saltar)");
			_dictionary.Add("$magic_damage", "Daño mágico");
			_dictionary.Add("$magic_armor", "Armadura mágica");
			_dictionary.Add("$add_hp", "Aumento de la salud");
			_dictionary.Add("$add_stamina", "Aumento de resistencia");
			_dictionary.Add("$physic_armor", "Armadura física");
			_dictionary.Add("$reduced_stamina_block", "Consumo de energia de bloqueo");
			_dictionary.Add("$regen_hp", "Regeneración de salud");
			_dictionary.Add("$damage", "Daño");
			_dictionary.Add("$armor", "Armadura");
			_dictionary.Add("$survival", "Surpervivencia");
			_dictionary.Add("$parameter_agility", "Destreza");
			_dictionary.Add("$parameter_body", "Resistencia");
			_dictionary.Add("$parameter_vigour", "Vigor");
			_dictionary.Add("$parameter_special", "Especialización");
			_dictionary.Add("$specialother", "Especial");
			_dictionary.Add("$attack_speed", "Attack speed");
			_dictionary.Add("$attack_stamina", "Velocidad de ataque");
			_dictionary.Add("$crtcDmgMulti", "Multiplicador de Daño Crítico");
			_dictionary.Add("$mining_speed", "Aumento de daño minero");
			_dictionary.Add("$piece_health", "Aumento de la salud de la pieza");
			_dictionary.Add("$tree_cutting", "Aumento del daño del árbol\"");
			_dictionary.Add("$crit_chance", "Aumento de probabilidad crítica");
			_dictionary.Add("$regen_eitr", "regeneración de eitr");
			_dictionary.Add("$stamina_reg", "regeneración de resistencia");
			_dictionary.Add("$add_eitr", "Aumento de EIT");
			_dictionary.Add("$notify", "<color=#00E6FF>Alerta</color>");
			_dictionary.Add("$friends_list", "Lista de amigos");
			_dictionary.Add("$send", "Enviar");
			_dictionary.Add("$invited", "Invitaciones");
			_dictionary.Add("$friends", "Amigos");
			_dictionary.Add("$online", "Conectado");
			_dictionary.Add("$offline", "Desconectado");
			_dictionary.Add("$not_found", "Player {0} inexistente.");
			_dictionary.Add("$send_invite", "Se ha enviado una solicitud de amistad a {0}.");
			_dictionary.Add("$get_invite", "Has recivido una solicitud de amistad de {0}.");
			_dictionary.Add("$accept_invite", "{0} aceptó la solicitud de amistad.");
			_dictionary.Add("$cancel_invite", "{0} denegó la solicitud de amistad.");
			_dictionary.Add("$terminal_set_level", "Eres nivel {0}");
			_dictionary.Add("$terminal_reset_points", "Tus puntos de atributos han sido reiniciados");
			_dictionary.Add("$strength_tooltip", "<size=20>La fuerza mejorará:</size> \n<color=yellow> Aumento del daño físico </color> \n<color=blue> Aumento del peso que puedes llevar </color> \n<color=green> Reducción del consumo de resistencia al bloquear </color> \n<color=red> Aumento del daño crítico al realizar golpes críticos </color>");
			_dictionary.Add("$dexterity_tooltip", "<size=20>La destreza mejorará:</size> \n<color=red> Aumento de la velocidad de ataque (excepto con arcos)</color> \n<color=yellow> Reducción del consumo de resistencia al atacar </color> \n<color=green> Reducción del consumo de resistencia al correr/saltar </color>");
			_dictionary.Add("$intelect_tooltip", "<size=20>La inteligencia mejorará:</size> \n<color=green> Aumento del daño elemental </color>\n<color=red> Aumento de la cantidad de Eitr base (una vez que tengas Eitr)</color> \n<color=red> Aumento de la regeneración de Eitr</color>");
			_dictionary.Add("$endurance_tooltip", "<size=20>La resistencia mejorará:</size> \n<color=yellow> Aumento de la cantidad de resistencia </color>\n<color=yellow> Aumento de la regeneración de resistencia </color> \n<color=green> Reducción del daño físico recibido </color>");
			_dictionary.Add("$vigour_tooltip", "<size=20>El vigor mejorará:</size> \n<color=red> Aumento de la cantidad de puntos de vida </color>\n<color=yellow> Regeneración de salud </color> \n<color=green> Reducción del daño elemental recibido </color>");
			_dictionary.Add("$special_tooltip", "<size=20>Lo especial mejorará:</size> \n<color=red> Aumento de la probabilidad de ataque crítico </color> \n<color=blue> Aumento del daño de minería </color> \n<color=blue> Aumento de la resistencia de las piezas de construcción </color> \n<color=green> Aumento del daño al cortar árboles </color>");
		}

		private void GermanLocalization()
		{
			_dictionary.Add("$attributes", "Eigenschaften");
			_dictionary.Add("$parameter_strength", "Stärke");
			_dictionary.Add("$parameter_intellect", "Intelligenz");
			_dictionary.Add("$free_points", "Verfügbare Punkte");
			_dictionary.Add("$level", "Level");
			_dictionary.Add("$lvl", "Lvl.");
			_dictionary.Add("$exp", "Erfahrung");
			_dictionary.Add("$cancel", "Zurück");
			_dictionary.Add("$apply", "übernehmen");
			_dictionary.Add("$reset_parameters", "Punkte zurücksetzen");
			_dictionary.Add("$no", "Nein");
			_dictionary.Add("$yes", "Ja");
			_dictionary.Add("$get_exp", "Erfahrung erhalten");
			_dictionary.Add("$reset_point_text", "Möchtest du wirklich alle Punkte Löschen? {0} {1}?");
			_dictionary.Add("$physic_damage", "Körperlicher Schaden");
			_dictionary.Add("$add_weight", "Gewicht tragen");
			_dictionary.Add("$speed_attack", "Ausdauerverbrauch angreifen");
			_dictionary.Add("$reduced_stamina", "Ausdauerverbrauch (running, jumping)");
			_dictionary.Add("$magic_damage", "Elementarschaden");
			_dictionary.Add("$magic_armor", " Elementarschaden Rüstung");
			_dictionary.Add("$add_hp", "Gesundheitssteigerung");
			_dictionary.Add("$add_stamina", "Ausdauer erhöt um");
			_dictionary.Add("$physic_armor", "Physische Rüstung");
			_dictionary.Add("$reduced_stamina_block", "Ausdauerverbrauch blockieren");
			_dictionary.Add("$regen_hp", "Heilung");
			_dictionary.Add("$damage", "Schaden");
			_dictionary.Add("$armor", "Rüstung");
			_dictionary.Add("$survival", "überleben");
			_dictionary.Add("$parameter_agility", "Geschicklichkeit");
			_dictionary.Add("$parameter_body", "Ausdauer");
			_dictionary.Add("$parameter_vigour", "Kraft");
			_dictionary.Add("$parameter_special", "Spezialisierung");
			_dictionary.Add("$specialother", "Speziell");
			_dictionary.Add("$attack_speed", "Angriffsgeschwindigkeit");
			_dictionary.Add("$attack_stamina", "Verbrauch der Angriffsausdauer");
			_dictionary.Add("$crtcDmgMulti", "Multiplikator für kritischen Schaden");
			_dictionary.Add("$mining_speed", "Erhöhter Bergbauschaden");
			_dictionary.Add("$piece_health", "Stückgesundheitserhöhung");
			_dictionary.Add("$tree_cutting", "Baumschaden erhöht");
			_dictionary.Add("$crit_chance", "Erhöhung der kritischen Trefferchance");
			_dictionary.Add("$regen_eitr", "Eitr-Regeneration");
			_dictionary.Add("$stamina_reg", "Regeneration der Ausdauer");
			_dictionary.Add("$add_eitr", "Eitr erhöhen");
			_dictionary.Add("$notify", "<color=#00E6FF>Alarm");
			_dictionary.Add("$friends_list", "Freundesliste");
			_dictionary.Add("$send", "Senden");
			_dictionary.Add("$invited", "Einladungen");
			_dictionary.Add("$friends", "Freunde");
			_dictionary.Add("$online", "Online");
			_dictionary.Add("$offline", "Offline");
			_dictionary.Add("$not_found", "Spieler {0} nicht gefunden.");
			_dictionary.Add("$send_invite", "Eine Freundschaftsanfrage wurde an den Spieler gesendet {0}.");
			_dictionary.Add("$get_invite", "erhielt eine Freundschaftsanfrage von {0}.");
			_dictionary.Add("$accept_invite", "Spieler {0}, hat die Freundschaftsanfrage bestätigt.");
			_dictionary.Add("$cancel_invite", "Spieler {0}, hat die Freundschaftsanfrage abgelehnt.");
			_dictionary.Add("$terminal_set_level", "Du hast {0} level");
			_dictionary.Add("$terminal_reset_points", "Deine Attributspunkte wurden zurückgesetzt");
			_dictionary.Add("$strength_tooltip", "<size=20>Stärke wird verbessern:</size> \n<color=yellow> Erhöhten physischen Schaden </color> \n<color=blue> Erhöhte Tragfähigkeit </color> \n<color=green> Verringerten Block-Stamina-Verbrauch </color> \n<color=red> Erhöhten kritischen Schaden bei kritischen Treffern </color>");
			_dictionary.Add("$dexterity_tooltip", "<size=20>Geschicklichkeit wird verbessern:</size> \n<color=red> Erhöhte Angriffsgeschwindigkeit (außer Bögen)</color> \n<color=yellow> Verringerten Angriffs-Stamina-Verbrauch </color> \n<color=green> Verringerten Lauf-/Sprung-Stamina-Verbrauch </color>");
			_dictionary.Add("$intelect_tooltip", "<size=20>Intelligenz wird verbessern:</size> \n<color=green> Erhöhten Schaden aller Elemente </color>\n<color=red> Erhöhte Grundmenge an Eitr (sobald du Eitr hast)</color> \n<color=red> Erhöhte Eitr-Regeneration</color>");
			_dictionary.Add("$endurance_tooltip", "<size=20>Ausdauer wird verbessern:</size> \n<color=yellow> Erhöhte Ausdauer </color>\n<color=yellow> Erhöhte Ausdauer-Regeneration </color> \n<color=green> Verringerten erlittenen physischen Schaden </color>");
			_dictionary.Add("$vigour_tooltip", "<size=20>Vitalität wird verbessern:</size> \n<color=red> Erhöhte HP-Menge </color>\n<color=yellow> Gesundheitsregeneration </color> \n<color=green> Verringerten erlittenen elementaren Schaden </color>");
			_dictionary.Add("$special_tooltip", "<size=20>Besonderheit wird verbessern:</size> \n<color=red> Erhöhte Chance für kritische Angriffe </color> \n<color=blue> Erhöhten Bergbau-Schaden </color> \n<color=blue> Erhöhte Lebenspunkte von Konstruktionsstücken </color> \n<color=green> Erhöhten Schaden beim Baumfällen </color>");
		}

		private void ChineseLocalization()
		{
			_dictionary.Add("$attributes", "角色属性");
			_dictionary.Add("$parameter_strength", "力量");
			_dictionary.Add("$parameter_intellect", "智力");
			_dictionary.Add("$free_points", "可分配的属性");
			_dictionary.Add("$level", "等级");
			_dictionary.Add("$lvl", "等级：");
			_dictionary.Add("$exp", "经验");
			_dictionary.Add("$cancel", "取消");
			_dictionary.Add("$apply", "接受");
			_dictionary.Add("$reset_parameters", "重置属性");
			_dictionary.Add("$no", "否");
			_dictionary.Add("$yes", "是");
			_dictionary.Add("$get_exp", "获得经验");
			_dictionary.Add("$reset_point_text", "你是否要消耗 {0} {1} 重置你的所有属性吗? ");
			_dictionary.Add("$physic_damage", "物理伤害");
			_dictionary.Add("$add_weight", "负重");
			_dictionary.Add("$speed_attack", "攻击体力值消耗");
			_dictionary.Add("$reduced_stamina", "体力值消耗（奔跑/跳跃）");
			_dictionary.Add("$magic_damage", "元素伤害");
			_dictionary.Add("$magic_armor", "元素抗性");
			_dictionary.Add("$add_hp", "生命值");
			_dictionary.Add("$add_stamina", "体力值");
			_dictionary.Add("$physic_armor", "物理抗性");
			_dictionary.Add("$reduced_stamina_block", "格挡体力值消耗");
			_dictionary.Add("$regen_hp", "生命值恢复");
			_dictionary.Add("$damage", "攻击属性");
			_dictionary.Add("$armor", "防御属性");
			_dictionary.Add("$survival", "基础属性");
			_dictionary.Add("$regen_eitr", "魔力值恢复");
			_dictionary.Add("$stamina_reg", "体力值恢复");
			_dictionary.Add("$add_eitr", "魔力值");
			_dictionary.Add("$notify", "<color=#00E6FF>通知</color>");
			_dictionary.Add("$friends_list", "好友列表");
			_dictionary.Add("$send", "发送");
			_dictionary.Add("$invited", "邀请");
			_dictionary.Add("$friends", "好友");
			_dictionary.Add("$online", "在线");
			_dictionary.Add("$offline", "离线");
			_dictionary.Add("$not_found", "未找到 玩家 {0} ！");
			_dictionary.Add("$send_invite", "已向 玩家 {0} 发送好友请求。");
			_dictionary.Add("$get_invite", "收到来自 玩家 {0} 的好友请求。");
			_dictionary.Add("$accept_invite", "玩家 {0} , 已接受好友请求。");
			_dictionary.Add("$cancel_invite", "玩家 {0} , 拒绝了好友请求。");
			_dictionary.Add("$terminal_set_level", "您提升到了 {0} 级！");
			_dictionary.Add("$terminal_reset_points", "属性已重置！");
			_dictionary.Add("$parameter_agility", "敏捷");
			_dictionary.Add("$parameter_body", "体力");
			_dictionary.Add("$parameter_vigour", "精力");
			_dictionary.Add("$parameter_special", "特性");
			_dictionary.Add("$specialother", "特性属性");
			_dictionary.Add("$attack_speed", "攻击速度");
			_dictionary.Add("$attack_stamina", "攻击体力值消耗");
			_dictionary.Add("$crtcDmgMulti", "暴击伤害");
			_dictionary.Add("$mining_speed", "采矿伤害");
			_dictionary.Add("$piece_health", "建筑物耐久度");
			_dictionary.Add("$tree_cutting", "伐木伤害");
			_dictionary.Add("$crit_chance", "暴击率");
			_dictionary.Add("$strength_tooltip", "<size=20>力量将获得以下效果：</size> \n<color=yellow>增加：物理伤害</color> \n<color=blue>增加：负重上限</color> \n<color=green>减少：格挡体力值消耗</color> \n<color=red>增加：暴击伤害</color>");
			_dictionary.Add("$dexterity_tooltip", "<size=20>敏捷将获得以下效果：</size> \n<color=red>增加：攻击速度（仅限近战）</color> \n<color=yellow>减少：攻击体力值消耗</color> \n<color=green>减少：奔跑/跳跃 体力值消耗</color>");
			_dictionary.Add("$intelect_tooltip", "<size=20>智力将获得以下效果：</size> \n<color=green>增加：元素伤害</color> \n<color=red>增加：魔力值（激活魔力值后）</color> \n<color=red>增加：魔力值恢复速度</color>");
			_dictionary.Add("$endurance_tooltip", "<size=20>体力将获得以下效果：</size> \n<color=yellow>增加：体力值</color> \n<color=yellow>增加：体力值恢复速度</color> \n<color=green>增加：物理抗性</color>");
			_dictionary.Add("$vigour_tooltip", "<size=20>精力将获得以下效果：</size> \n<color=red>增加：生命值</color> \n<color=yellow>增加：生命值恢复速度</color> \n<color=green>增加：元素抗性</color>");
			_dictionary.Add("$special_tooltip", "<size=20>特性将获得以下效果：</size> \n<color=red>增加：暴击率</color> \n<color=blue>增加：采矿伤害</color> \n<color=blue>增加：建造物耐久度</color> \n<color=green>增加：伐木伤害</color>");
		}

		private void PortugueseLocalization()
		{
			_dictionary.Add("$attributes", "Atributos");
			_dictionary.Add("$parameter_strength", "Força");
			_dictionary.Add("$parameter_intellect", "Intelecto");
			_dictionary.Add("$free_points", "Pontos disponíveis");
			_dictionary.Add("$level", "Nível");
			_dictionary.Add("$lvl", "Nvl.");
			_dictionary.Add("$exp", "Experiência");
			_dictionary.Add("$cancel", "Cancelar");
			_dictionary.Add("$apply", "Aceitar");
			_dictionary.Add("$reset_parameters", "Redefinir pontos");
			_dictionary.Add("$no", "Não");
			_dictionary.Add("$yes", "Sim");
			_dictionary.Add("$get_exp", "Experiência recebida");
			_dictionary.Add("$reset_point_text", "Você realmente deseja remover todos os pontos para {0} {1}?");
			_dictionary.Add("$physic_damage", "Dano Físico");
			_dictionary.Add("$add_weight", "Peso que pode carregar");
			_dictionary.Add("$reduced_stamina", "Consumo de resistência (correr, pular)");
			_dictionary.Add("$magic_damage", "Dano Elemental");
			_dictionary.Add("$magic_armor", "Redução Elemental");
			_dictionary.Add("$add_hp", "Aumento de Vida");
			_dictionary.Add("$add_stamina", "Aumento de Resistência");
			_dictionary.Add("$physic_armor", "Redução Física");
			_dictionary.Add("$reduced_stamina_block", "Consumo de resistência ao bloquear");
			_dictionary.Add("$regen_hp", "Regeneração de Vida");
			_dictionary.Add("$damage", "Dano");
			_dictionary.Add("$armor", "Armadura");
			_dictionary.Add("$survival", "Sobrevivência");
			_dictionary.Add("$regen_eitr", "Regeneração de Eitr");
			_dictionary.Add("$stamina_reg", "Regeneração de Resistência");
			_dictionary.Add("$add_eitr", "Aumento de Eitr");
			_dictionary.Add("$parameter_agility", "Destreza");
			_dictionary.Add("$parameter_body", "Resistência");
			_dictionary.Add("$parameter_vigour", "Vigor");
			_dictionary.Add("$parameter_special", "Especialização");
			_dictionary.Add("$specialother", "Especial");
			_dictionary.Add("$attack_speed", "Velocidade de Ataque");
			_dictionary.Add("$attack_stamina", "Consumo de resistência ao atacar");
			_dictionary.Add("$crtcDmgMulti", "Multiplicador de Dano Crítico");
			_dictionary.Add("$mining_speed", "Aumento de Dano na Mineração");
			_dictionary.Add("$piece_health", "Aumento da Vida das Peças");
			_dictionary.Add("$tree_cutting", "Aumento do Dano ao Cortar Árvores");
			_dictionary.Add("$crit_chance", "Aumento da Chance de Ataque Crítico");
			_dictionary.Add("$notify", "<color=#00E6FF>Alerta</color>");
			_dictionary.Add("$friends_list", "Lista de Amigos");
			_dictionary.Add("$send", "Enviar");
			_dictionary.Add("$invited", "Convites");
			_dictionary.Add("$friends", "Amigos");
			_dictionary.Add("$online", "Online");
			_dictionary.Add("$offline", "Offline");
			_dictionary.Add("$not_found", "Jogador {0} não encontrado.");
			_dictionary.Add("$send_invite", "Um pedido de amizade foi enviado para o jogador {0}.");
			_dictionary.Add("$get_invite", "Recebeu um pedido de amizade de {0}.");
			_dictionary.Add("$accept_invite", "O jogador {0} aceitou o pedido de amizade.");
			_dictionary.Add("$cancel_invite", "O jogador {0} cancelou o pedido de amizade.");
			_dictionary.Add("$terminal_set_level", "Você alcançou o nível {0}.");
			_dictionary.Add("$terminal_reset_points", "Os pontos dos seus atributos foram redefinidos.");
			_dictionary.Add("$strength_tooltip", "<size=20>A força aumentará:</size> \n<color=yellow> Aumento do Dano Físico </color> \n<color=blue> Aumento do Peso que pode carregar </color> \n<color=green> Redução do Consumo de Resistência ao Bloquear </color> \n<color=red> Aumento do Dano Crítico quando acertar críticos </color>");
			_dictionary.Add("$dexterity_tooltip", "<size=20>A destreza aumentará:</size> \n<color=red> Aumento da Velocidade de Ataque (exceto arcos) </color> \n<color=yellow> Redução do Consumo de Resistência ao Atacar </color> \n<color=green> Redução do Consumo de Resistência ao Correr/Saltar </color>");
			_dictionary.Add("$intelect_tooltip", "<size=20>A inteligência aumentará:</size> \n<color=green> Aumento do Dano de Todos os Elementos </color> \n<color=red> Aumento da Quantidade de Eitr Base (quando tiver Eitr) </color> \n<color=red> Aumento da Regeneração de Eitr </color>");
			_dictionary.Add("$endurance_tooltip", "<size=20>A resistência aumentará:</size> \n<color=yellow> Aumento da Quantidade de Resistência </color> \n<color=yellow> Aumento da Regeneração de Resistência </color> \n<color=green> Redução do Dano Físico Recebido </color>");
			_dictionary.Add("$vigour_tooltip", "<size=20>O vigor aumentará:</size> \n<color=red> Aumento da Quantidade de Pontos de Vida </color> \n<color=yellow> Regeneração de Vida </color> \n<color=green> Redução do Dano Elemental Recebido </color>");
			_dictionary.Add("$special_tooltip", "<size=20>O especializar aumentará:</size> \n<color=red> Aumento da Chance de Ataque Crítico </color> \n<color=blue> Aumento do Dano de Mineração </color> \n<color=blue> Aumento da Vida das Peças de Construção </color> \n<color=green> Aumento do Dano ao Cortar Árvores </color>");
		}

		private void PolishLocalization()
		{
			_dictionary.Add("$attributes", "Cechy");
			_dictionary.Add("$parameter_strength", "Siła");
			_dictionary.Add("$parameter_intellect", "Inteligencja");
			_dictionary.Add("$free_points", "Dostępne punkty");
			_dictionary.Add("$level", "Poziom");
			_dictionary.Add("$lvl", "Lvl.");
			_dictionary.Add("$exp", "Doświadczenie");
			_dictionary.Add("$cancel", "Anuluj");
			_dictionary.Add("$apply", "Akceptuj");
			_dictionary.Add("$reset_parameters", "Resetuj Punkty");
			_dictionary.Add("$no", "Nie");
			_dictionary.Add("$yes", "Tak");
			_dictionary.Add("$get_exp", "Otrzymane Doświadczenie");
			_dictionary.Add("$reset_point_text", "Czy naprawdę chcesz zresetować wszystkie punkty za {0} {1}?");
			_dictionary.Add("$physic_damage", "Obrażenia Fizyczne");
			_dictionary.Add("$add_weight", "Udźwig");
			_dictionary.Add("$reduced_stamina", "Zużycie Wytrzymałości (Bieganie, Skakanie)");
			_dictionary.Add("$magic_damage", "Obrażenia Od Żywiołów");
			_dictionary.Add("$magic_armor", "Zmniejszone Obrażenia Od Żywiołów");
			_dictionary.Add("$add_hp", "Zwiększenie Zdrowia");
			_dictionary.Add("$add_stamina", "Zwiększenie Wytrzymałości");
			_dictionary.Add("$physic_armor", "Fizyczna Redukcja");
			_dictionary.Add("$reduced_stamina_block", "Zużycie Wytrzymałości podczas Blokowania");
			_dictionary.Add("$regen_hp", "Regeneracja Zdrowia");
			_dictionary.Add("$damage", "Obrażenia");
			_dictionary.Add("$armor", "Pancerz");
			_dictionary.Add("$survival", "Przetrwanie");
			_dictionary.Add("$regen_eitr", "Regeneracja Eitru");
			_dictionary.Add("$stamina_reg", "Regeneracja Wytrzymałości");
			_dictionary.Add("$add_eitr", "Zwiększenie Eitru");
			_dictionary.Add("$parameter_agility", "Zręczność");
			_dictionary.Add("$parameter_body", "Odporność");
			_dictionary.Add("$parameter_vigour", "Wigor");
			_dictionary.Add("$parameter_special", "Specjalizacja");
			_dictionary.Add("$specialother", "Specjalny");
			_dictionary.Add("$attack_speed", "Szybkość ataku");
			_dictionary.Add("$attack_stamina", "Zużycie Wytrzymałości Podczas Ataku");
			_dictionary.Add("$crtcDmgMulti", "Mnożnik Obrażeń Krytycznych");
			_dictionary.Add("$mining_speed", "Zwiększenie obrażeń Kilofa");
			_dictionary.Add("$piece_health", "Zwiększenie wytrzymałości Budowli");
			_dictionary.Add("$tree_cutting", "Zwiększenie obrażeń podczas ścinania drzew");
			_dictionary.Add("$crit_chance", "Zwiększenie Szansy na Obrażenia Krytyczne");
			_dictionary.Add("$notify", "<color=#00E6FF>Uwaga</color>");
			_dictionary.Add("$friends_list", "Lista Przyjaciół");
			_dictionary.Add("$send", "Wyślij");
			_dictionary.Add("$invited", "Zaproszenia");
			_dictionary.Add("$friends", "Przyjaciele");
			_dictionary.Add("$online", "Online");
			_dictionary.Add("$offline", "Offline");
			_dictionary.Add("$not_found", "Gracz {0} nie został/a odnaleziony/a.");
			_dictionary.Add("$send_invite", "Prośba o dodanie do znajomych została wysłana do gracza {0}.");
			_dictionary.Add("$get_invite", "Otrzymano zaproszenie do grona znajomych od {0}.");
			_dictionary.Add("$accept_invite", "Gracz {0}, zaakceptował/a zaproszenie do grona znajomych.");
			_dictionary.Add("$cancel_invite", "Gracz {0}, anulował/a zaproszenie do grona znajomych.");
			_dictionary.Add("$terminal_set_level", "Zdobyłeś/aś {0} poziom");
			_dictionary.Add("$terminal_reset_points", "Twoje punkty atrybutów zostały zresetowane");
			_dictionary.Add("$strength_tooltip", "<size=20>Siła wzmocni:</size> \n<color=yellow> Zwiększenie obrażeń fizycznych </color> \n<color=blue> Zwiększenie udźwigu </color> \n <color=green> Zmniejszenie zużycia wytrzymałości podczas blokowania </color> \n <color=red> Zwiększenie obrażeń krytycznych, gdy wejdzie cryt </color> ");
			_dictionary.Add("$dexterity_tooltip", "<size=20>Zwinność wzmocni:</size> \n<color=red> Zwiększenie prędkości ataku (not bows)</color> \n<color=yellow> Zmniejszenie zużycia wytrzymałości podczas ataku </color> \n<color=green> Zmniejszenie zużycia wytrzymałości Biegania/Skakania</color>");
			_dictionary.Add("$intelect_tooltip", "<size=20>Inteligencja wzmocni:</size> \n<color=green> Zwiększenie obrażeń od żywiołów </color> \n<color=red> Zwiększenie bazowej ilości Eitru (jak już będziesz miał/a Eitr)</color> \n<color=red> Zwiększenie regeneracji Eitru</color>");
			_dictionary.Add("$endurance_tooltip", "<size=20>Wytrwałość wzmocni:</size> \n<color=yellow> Zwiększenie ilości staminy</color> \n<color=yellow> Zwiększenie regeneracji staminy </color> \n<color=green> Zmniejszenie otrzymywanych obrażeń fizycznych</color>");
			_dictionary.Add("$vigour_tooltip", "<size=20>Wigor wzmocni:</size> \n<color=red> Zwiększenie Punktów Życia</color> \n<color=yellow> Regeneracja Zdrowia </color> \n<color=green> Zmniejszenie otrzymywanych obrażeń od żywiołów</color>");
			_dictionary.Add("$special_tooltip", "<size=20>Specjalizacja wzmocni:</size> \n<color=red> Zwiększenie szansy na zadanie obrażeń krytycznych </color> \n<color=blue> Zwiększenie obrażeń z kilofa </color> \n<color=blue> Zwiększenie wytrzymałości budowli </color> \n<color=green> Zwiększenie obrażeń podczas ścinania drzew</color>");
		}

		private void Portuguese_Brazilian()
		{
			_dictionary.Add("$attributes", "Atributos");
			_dictionary.Add("$parameter_strength", "Força");
			_dictionary.Add("$parameter_intellect", "Inteligência");
			_dictionary.Add("$free_points", "Pontos disponíveis");
			_dictionary.Add("$level", "Nível");
			_dictionary.Add("$lvl", "Lvl.");
			_dictionary.Add("$exp", "Experiência");
			_dictionary.Add("$cancel", "Cancelar");
			_dictionary.Add("$apply", "Aceitar");
			_dictionary.Add("$reset_parameters", "Redefinir pontos");
			_dictionary.Add("$no", "Não");
			_dictionary.Add("$yes", "Sim");
			_dictionary.Add("$get_exp", "Experiência recebida");
			_dictionary.Add("$reset_point_text", "Você realmente deseja perder todos os pontos por {0} {1}?");
			_dictionary.Add("$physic_damage", "Dano físico");
			_dictionary.Add("$add_weight", "Carregar peso");
			_dictionary.Add("$reduced_stamina", "Consumo de resistência (correr, pular)");
			_dictionary.Add("$magic_damage", "Dano elemental");
			_dictionary.Add("$magic_armor", "Redução de dano elemental");
			_dictionary.Add("$add_hp", "Aumento de vida");
			_dictionary.Add("$add_stamina", "Aumento de resistência");
			_dictionary.Add("$physic_armor", "Redução de dano físico");
			_dictionary.Add("$reduced_stamina_block", "Bloquear o consumo de resistência");
			_dictionary.Add("$regen_hp", "Regeneração de vida");
			_dictionary.Add("$damage", "Dano");
			_dictionary.Add("$armor", "Armadura");
			_dictionary.Add("$survival", "Sobrevivência");
			_dictionary.Add("$regen_eitr", "Regeneração de eitr");
			_dictionary.Add("$stamina_reg", "Regeneração de resistência");
			_dictionary.Add("$add_eitr", "Aumento de eitr");
			_dictionary.Add("$parameter_agility", "Destreza");
			_dictionary.Add("$parameter_body", "Resistência");
			_dictionary.Add("$parameter_vigour", "Vigor");
			_dictionary.Add("$parameter_special", "Especialização");
			_dictionary.Add("$specialother", "Especial");
			_dictionary.Add("$attack_speed", "Velocidade de ataque");
			_dictionary.Add("$attack_stamina", "Consumo de resistência em ataque");
			_dictionary.Add("$crtcDmgMulti", "Multiplicador de dano crítico");
			_dictionary.Add("$mining_speed", "Aumento de dano na mineração");
			_dictionary.Add("$piece_health", "Aumento da saúde das peças");
			_dictionary.Add("$tree_cutting", "Aumento de dano em árvores");
			_dictionary.Add("$crit_chance", "Aumento da chance de crítico");
			_dictionary.Add("$notify", "<color=#00E6FF>Alerta</color>");
			_dictionary.Add("$friends_list", "Lista de amigos");
			_dictionary.Add("$send", "Enviar");
			_dictionary.Add("$invited", "Convites");
			_dictionary.Add("$friends", "Amigos");
			_dictionary.Add("$online", "Online");
			_dictionary.Add("$offline", "Offline");
			_dictionary.Add("$not_found", "O jogador {0} não foi encontrado.");
			_dictionary.Add("$send_invite", "Uma solicitação de amizade foi enviada ao jogador {0}.");
			_dictionary.Add("$get_invite", "Uma solicitação de amizade foi recebida do jogador {0}");
			_dictionary.Add("$accept_invite", "Jogador {0} aceitou o pedido de amizade.");
			_dictionary.Add("$cancel_invite", "Jogador {0} cancelou seu pedido de amizade.");
			_dictionary.Add("$terminal_set_level", "Você atingiu {0} nível");
			_dictionary.Add("$terminal_reset_points", "Seus pontos de atributos foram redefinidos");
			_dictionary.Add("$strength_tooltip", "<size=20>Alterações de força:</size> \n<color=yellow> Aumento de dano físico </color> \n<color=blue> Aumento de capacidade de transporte </color> \n<color=green> Diminuição do consumo de resistência ao bloquear </color> \n<color=red> Aumento de dano crítico (em acertos críticos) </color>");
			_dictionary.Add("$dexterity_tooltip", "<size=20>Alterações de destreza:</size> \n<color=red> Aumento da velocidade de ataque (menos para arcos) </color> \n<color=yellow> Diminuição do consumo de resistência nos ataques </color> \n<color=green> Diminuição do consumo de resistência para correr e saltar </color> ");
			_dictionary.Add("$intelect_tooltip", "<size=20>Alterações de inteligência: </size> \n<color=green> Aumento de todo o dano elemental </color>\n<color=red> Aumento do valor base do Eitr (depois de ter o Eitr) </color> \n<color=red> Aumento de regeneração de Eitr </color> ");
			_dictionary.Add("$endurance_tooltip", "<size=20>Alterações de resistência:</size> \n<color=yellow> Aumento da quantidade de resistência </color>\n<color=yellow> Aumento da regeneração de resistência </color> \n<color=green> Redução do dano físico sofrido </color> ");
			_dictionary.Add("$vigour_tooltip", "<size=20>Alterações de vigor:</size> \n<color=red> Aumento na quantidade de HP </color>\n<color=yellow> Regeneração da vida </color> \n<color=green> Redução do dano elemental recebido </color> ");
			_dictionary.Add("$special_tooltip", "<size=20>Alterações especiais:</size> \n<color=red> Aumento da chance de ataque crítico </color> \n<color=blue> Aumento do dano na mineração </color> \n<color=blue> Aumento da saúde das peças de construção </color> \n<color=green> Aumento do dano causado \u200b\u200bao cortar árvores </color>");
		}

		private void UkrLocalization()
		{
			_dictionary.Add("$attributes", "Атрибути");
			_dictionary.Add("$parameter_strength", "Сила");
			_dictionary.Add("$parameter_intellect", "Інтелект");
			_dictionary.Add("$free_points", "Доступні очки");
			_dictionary.Add("$level", "Рівень");
			_dictionary.Add("$lvl", "Рів.");
			_dictionary.Add("$exp", "Досвід");
			_dictionary.Add("$cancel", "Скасувати");
			_dictionary.Add("$apply", "Прийняти");
			_dictionary.Add("$reset_parameters", "Скинути очки");
			_dictionary.Add("$no", "Ні");
			_dictionary.Add("$yes", "Так");
			_dictionary.Add("$get_exp", "Отримано досвіду");
			_dictionary.Add("$reset_point_text", "Ви дійсно хочете скинути всі очки для {0} {1}?");
			_dictionary.Add("$physic_damage", "Фізична шкода");
			_dictionary.Add("$add_weight", "Вага для переносу");
			_dictionary.Add("$reduced_stamina", "Витрати витривалості (біг, стрибки)");
			_dictionary.Add("$magic_damage", "Магічна шкода");
			_dictionary.Add("$magic_armor", "Зменшення магічної шкоди");
			_dictionary.Add("$add_hp", "Збільшення здоров'я");
			_dictionary.Add("$add_stamina", "Збільшення витривалості");
			_dictionary.Add("$physic_armor", "Зменшення фізичної шкоди");
			_dictionary.Add("$reduced_stamina_block", "Витрати витривалості на блокування");
			_dictionary.Add("$regen_hp", "Регенерація здоров'я");
			_dictionary.Add("$damage", "Шкода");
			_dictionary.Add("$armor", "Броня");
			_dictionary.Add("$survival", "Виживання");
			_dictionary.Add("$regen_eitr", "Регенерація Ейтра");
			_dictionary.Add("$stamina_reg", "Регенерація витривалості");
			_dictionary.Add("$add_eitr", "Збільшення Ейтра");
			_dictionary.Add("$parameter_agility", "Спритність");
			_dictionary.Add("$parameter_body", "Витривалість");
			_dictionary.Add("$parameter_vigour", "Життєва сила");
			_dictionary.Add("$parameter_special", "Спеціалізація");
			_dictionary.Add("$specialother", "Спеціальне");
			_dictionary.Add("$attack_speed", "Швидкість атаки");
			_dictionary.Add("$attack_stamina", "Витрати витривалості на атаку");
			_dictionary.Add("$crtcDmgMulti", "Множник критичної шкоди");
			_dictionary.Add("$mining_speed", "Збільшення шкоди при видобутку");
			_dictionary.Add("$piece_health", "Збільшення міцності будівель");
			_dictionary.Add("$tree_cutting", "Збільшення шкоди деревам");
			_dictionary.Add("$crit_chance", "Збільшення шансу критичної атаки");
			_dictionary.Add("$notify", "<color=#00E6FF>Сповіщення</color>");
			_dictionary.Add("$friends_list", "Список друзів");
			_dictionary.Add("$send", "Надіслати");
			_dictionary.Add("$invited", "Запрошення");
			_dictionary.Add("$friends", "Друзі");
			_dictionary.Add("$online", "Онлайн");
			_dictionary.Add("$offline", "Офлайн");
			_dictionary.Add("$not_found", "Гравця {0} не знайдено.");
			_dictionary.Add("$send_invite", "Запрошення в друзі надіслано гравцю {0}.");
			_dictionary.Add("$get_invite", "Отримано запит у друзі від {0}.");
			_dictionary.Add("$accept_invite", "Гравець {0} прийняв запит у друзі.");
			_dictionary.Add("$cancel_invite", "Гравець {0} скасував запит у друзі.");
			_dictionary.Add("$terminal_set_level", "Ви отримали {0} рівень");
			_dictionary.Add("$terminal_reset_points", "Ваші очки атрибутів були скинуті");
			_dictionary.Add("$strength_tooltip", "<size=20>Сила покращує:</size> \n<color=yellow> Збільшує фізичну шкоду </color> \n<color=blue> Збільшує вагу перенесення </color> \n<color=green> Зменшує витрати витривалості на блокування </color> \n<color=red> Збільшує критичну шкоду при критичних ударах </color>");
			_dictionary.Add("$dexterity_tooltip", "<size=20>Спритність покращує:</size> \n<color=red> Збільшує швидкість атаки (не для луків)</color> \n<color=yellow> Зменшує витрати витривалості на атаки </color> \n<color=green> Зменшує витрати витривалості на біг/стриби</color> ");
			_dictionary.Add("$intelect_tooltip", "<size=20>Інтелект покращує:</size> \n<color=green> Збільшує всю елементарну шкоду </color>\n<color=red> Збільшує базову кількість Еітру (коли він є)</color> \n<color=red> Збільшує регенерацію Еітру</color> ");
			_dictionary.Add("$endurance_tooltip", "<size=20>Витривалість покращує:</size> \n<color=yellow> Збільшує кількість витривалості</color>\n<color=yellow> Збільшує регенерацію витривалості </color> \n<color=green> Зменшує отриману фізичну шкоду</color> ");
			_dictionary.Add("$vigour_tooltip", "<size=20>Життєва сила покращує:</size> \n<color=red> Збільшує кількість HP</color>\n<color=yellow> Регенерацію здоров'я </color> \n<color=green> Зменшує отриману елементарну шкоду</color> ");
			_dictionary.Add("$special_tooltip", "<size=20>Особливість покращує:</size> \n<color=red> Збільшує шанс критичної атаки</color> \n<color=blue> Збільшує шкоду від видобутку </color> \n<color=blue> Збільшує здоров'я будівельних об'єктів </color> \n<color=green> Збільшує шкоду від рубання дерев</color>");
		}

		private void TurkishLocalization()
		{
			_dictionary.Add("$attributes", "Nitelikler");
			_dictionary.Add("$parameter_strength", "Güç");
			_dictionary.Add("$parameter_intellect", "Zeka");
			_dictionary.Add("$free_points", "Kullanılabilir Puanlar");
			_dictionary.Add("$level", "Seviye");
			_dictionary.Add("$lvl", "Sev.");
			_dictionary.Add("$exp", "Deneyim");
			_dictionary.Add("$cancel", "İptal");
			_dictionary.Add("$apply", "Onayla");
			_dictionary.Add("$reset_parameters", "Puanları Sıfırla");
			_dictionary.Add("$no", "Hayır");
			_dictionary.Add("$yes", "Evet");
			_dictionary.Add("$get_exp", "Kazanılan Deneyim");
			_dictionary.Add("$reset_point_text", "{0} {1} için tüm puanları gerçekten sıfırlamak istiyor musun?");
			_dictionary.Add("$physic_damage", "Fiziksel Hasar");
			_dictionary.Add("$add_weight", "Taşıma Kapasitesi");
			_dictionary.Add("$reduced_stamina", "Dayanıklılık Tüketimi (koşma, zıplama)");
			_dictionary.Add("$magic_damage", "Element Hasarı");
			_dictionary.Add("$magic_armor", "Element Direnci");
			_dictionary.Add("$add_hp", "Sağlık Artışı");
			_dictionary.Add("$add_stamina", "Dayanıklılık Artışı");
			_dictionary.Add("$physic_armor", "Fiziksel Direnç");
			_dictionary.Add("$reduced_stamina_block", "Blok Dayanıklılık Tüketimi");
			_dictionary.Add("$regen_hp", "Sağlık Yenilenmesi");
			_dictionary.Add("$damage", "Hasar");
			_dictionary.Add("$armor", "Zırh");
			_dictionary.Add("$survival", "Hayatta Kalma");
			_dictionary.Add("$regen_eitr", "Eitr Yenilenmesi");
			_dictionary.Add("$stamina_reg", "Dayanıklılık Yenilenmesi");
			_dictionary.Add("$add_eitr", "Eitr Artışı");
			_dictionary.Add("$parameter_agility", "Çeviklik");
			_dictionary.Add("$parameter_body", "Dayanıklılık");
			_dictionary.Add("$parameter_vigour", "Canlılık");
			_dictionary.Add("$parameter_special", "Uzmanlık");
			_dictionary.Add("$specialother", "Özel");
			_dictionary.Add("$attack_speed", "Saldırı Hızı");
			_dictionary.Add("$attack_stamina", "Saldırı Dayanıklılık Tüketimi");
			_dictionary.Add("$crtcDmgMulti", "Kritik Hasar Çarpanı");
			_dictionary.Add("$mining_speed", "Madencilik Hasar Artışı");
			_dictionary.Add("$piece_health", "Yapı Sağlığı Artışı");
			_dictionary.Add("$tree_cutting", "Ağaç Kesme Hasar Artışı");
			_dictionary.Add("$crit_chance", "Kritik Vuruş Şansı Artışı");
			_dictionary.Add("$notify", "<color=#00E6FF>Uyarı</color>");
			_dictionary.Add("$friends_list", "Arkadaş Listesi");
			_dictionary.Add("$send", "Gönder");
			_dictionary.Add("$invited", "Davetler");
			_dictionary.Add("$friends", "Arkadaşlar");
			_dictionary.Add("$online", "Çevrimiçi");
			_dictionary.Add("$offline", "Çevrimdışı");
			_dictionary.Add("$not_found", "{0} oyuncusu bulunamadı.");
			_dictionary.Add("$send_invite", "{0} oyuncusuna arkadaşlık isteği gönderildi.");
			_dictionary.Add("$get_invite", "{0} oyuncusundan arkadaşlık isteği alındı.");
			_dictionary.Add("$accept_invite", "{0} oyuncusu arkadaşlık isteğini kabul etti.");
			_dictionary.Add("$cancel_invite", "{0} oyuncusu arkadaşlık isteğini iptal etti.");
			_dictionary.Add("$terminal_set_level", "{0} seviye kazandın");
			_dictionary.Add("$terminal_reset_points", "Nitelik puanların sıfırlandı");
			_dictionary.Add("$strength_tooltip", "<size=20>Güç şu alanları geliştirir:</size> \n<color=yellow> Fiziksel Hasar Artışı </color> \n<color=blue> Taşıma Kapasitesi Artışı </color> \n<color=green> Blok Dayanıklılığı Tüketimini Azaltır </color> \n<color=red> Kritik Vuruşta Kritik Hasar Artışı </color>");
			_dictionary.Add("$dexterity_tooltip", "<size=20>Çeviklik şu alanları geliştirir:</size> \n<color=red> Saldırı Hızı Artışı (yaylar hariç)</color> \n<color=yellow> Saldırı Dayanıklılık Tüketimini Azaltır </color> \n<color=green> Koşma/Zıplama Dayanıklılık Tüketimini Azaltır</color> ");
			_dictionary.Add("$intelect_tooltip", "<size=20>Zeka şu alanları geliştirir:</size> \n<color=green> Tüm Element Hasarlarında Artış </color>\n<color=red> Temel Eitr Miktarı Artışı (eitr elde ettiğinde) </color> \n<color=red> Eitr Yenilenmesi Artışı</color> ");
			_dictionary.Add("$endurance_tooltip", "<size=20>Dayanıklılık şu alanları geliştirir:</size> \n<color=yellow> Dayanıklılık Miktarı Artışı</color>\n<color=yellow> Dayanıklılık Yenilenmesi Artışı </color> \n<color=green> Alınan Fiziksel Hasarı Azaltır</color> ");
			_dictionary.Add("$vigour_tooltip", "<size=20>Canlılık şu alanları geliştirir:</size> \n<color=red> HP Miktarı Artışı</color>\n<color=yellow> Sağlık Yenilenmesi </color> \n<color=green> Alınan Element Hasarını Azaltır</color> ");
			_dictionary.Add("$special_tooltip", "<size=20>Özel yetenekler şu alanları geliştirir:</size> \n<color=red> Kritik Saldırı Şansı Artışı</color> \n<color=blue> Madencilik Hasarı Artışı </color> \n<color=blue> Yapı Sağlığı Artışı </color> \n<color=green> Ağaç Kesme Hasarı Artışı</color>");
		}

		private void CzechLocalization()
		{
			_dictionary.Add("$attributes", "Atributy");
			_dictionary.Add("$parameter_strength", "Síla");
			_dictionary.Add("$parameter_intellect", "Inteligence");
			_dictionary.Add("$free_points", "Dostupné body");
			_dictionary.Add("$level", "Úroveň");
			_dictionary.Add("$lvl", "Úrov.");
			_dictionary.Add("$exp", "Zkušenosti");
			_dictionary.Add("$cancel", "Zrušit");
			_dictionary.Add("$apply", "Potvrdit");
			_dictionary.Add("$reset_parameters", "Resetovat body");
			_dictionary.Add("$no", "Ne");
			_dictionary.Add("$yes", "Ano");
			_dictionary.Add("$get_exp", "Získané zkušenosti");
			_dictionary.Add("$reset_point_text", "Opravdu chcete resetovat všechny body za {0} {1}?");
			_dictionary.Add("$physic_damage", "Fyzické poškození");
			_dictionary.Add("$add_weight", "Nosnost");
			_dictionary.Add("$reduced_stamina", "Spotřeba výdrže (běh, skákání)");
			_dictionary.Add("$magic_damage", "Elementární poškození");
			_dictionary.Add("$magic_armor", "Redukce elementárního poškození");
			_dictionary.Add("$add_hp", "Navýšení zdraví");
			_dictionary.Add("$add_stamina", "Navýšení výdrže");
			_dictionary.Add("$physic_armor", "Redukce fyzického poškození");
			_dictionary.Add("$reduced_stamina_block", "Spotřeba výdrže při blokování");
			_dictionary.Add("$regen_hp", "Regenerace zdraví");
			_dictionary.Add("$damage", "Poškození");
			_dictionary.Add("$armor", "Brnění");
			_dictionary.Add("$survival", "Přežití");
			_dictionary.Add("$regen_eitr", "Regenerace Eitru");
			_dictionary.Add("$stamina_reg", "Regenerace výdrže");
			_dictionary.Add("$add_eitr", "Navýšení Eitru");
			_dictionary.Add("$parameter_agility", "Obratnost");
			_dictionary.Add("$parameter_body", "Výdrž");
			_dictionary.Add("$parameter_vigour", "Vitalita");
			_dictionary.Add("$parameter_special", "Specializace");
			_dictionary.Add("$specialother", "Speciální");
			_dictionary.Add("$attack_speed", "Rychlost útoku");
			_dictionary.Add("$attack_stamina", "Spotřeba výdrže při útoku");
			_dictionary.Add("$crtcDmgMulti", "Násobič kritického poškození");
			_dictionary.Add("$mining_speed", "Zvýšení poškození těžby");
			_dictionary.Add("$piece_health", "Navýšení zdraví konstrukcí");
			_dictionary.Add("$tree_cutting", "Zvýšení poškození stromů");
			_dictionary.Add("$crit_chance", "Šance na kritický zásah");
			_dictionary.Add("$notify", "<color=#00E6FF>Upozornění</color>");
			_dictionary.Add("$friends_list", "Seznam přátel");
			_dictionary.Add("$send", "Odeslat");
			_dictionary.Add("$invited", "Pozvánky");
			_dictionary.Add("$friends", "Přátelé");
			_dictionary.Add("$online", "Online");
			_dictionary.Add("$offline", "Offline");
			_dictionary.Add("$not_found", "Hráč {0} nebyl nalezen.");
			_dictionary.Add("$send_invite", "Pozvánka byla odeslána hráči {0}.");
			_dictionary.Add("$get_invite", "Obdrželi jste žádost o přátelství od {0}.");
			_dictionary.Add("$accept_invite", "Hráč {0} přijal žádost o přátelství.");
			_dictionary.Add("$cancel_invite", "Hráč {0} zrušil svou žádost o přátelství.");
			_dictionary.Add("$terminal_set_level", "Získali jste úroveň {0}");
			_dictionary.Add("$terminal_reset_points", "Vaše atributové body byly resetovány");
			_dictionary.Add("$strength_tooltip", "<size=20>Silou získáte:</size> \n<color=yellow> Zvýšení fyzického poškození </color> \n<color=blue> Zvýšení nosnosti </color> \n<color=green> Snížení spotřeby výdrže při blokování </color> \n<color=red> Zvýšení kritického poškození při zásahu </color>");
			_dictionary.Add("$dexterity_tooltip", "<size=20>Obratností získáte:</size> \n<color=red> Zvýšení rychlosti útoku (ne luky)</color> \n<color=yellow> Snížená spotřeba výdrže při útoku </color> \n<color=green> Snížená spotřeba výdrže při běhu a skákání</color>");
			_dictionary.Add("$intelect_tooltip", "<size=20>Inteligencí získáte:</size> \n<color=green> Zvýšení elementárního poškození </color>\n<color=red> Zvýšení základního množství Eitru (jakmile jej máte)</color> \n<color=red> Zvýšení regenerace Eitru</color>");
			_dictionary.Add("$endurance_tooltip", "<size=20>Výdrží získáte:</size> \n<color=yellow> Zvýšení množství výdrže</color>\n<color=yellow> Zvýšení regenerace výdrže </color> \n<color=green> Snížení utrženého fyzického poškození</color>");
			_dictionary.Add("$vigour_tooltip", "<size=20>Vitalitou získáte:</size> \n<color=red> Zvýšení množství zdraví</color>\n<color=yellow> Regenerace zdraví </color> \n<color=green> Snížení utrženého elementárního poškození</color>");
			_dictionary.Add("$special_tooltip", "<size=20>Specializací získáte:</size> \n<color=red> Zvýšení šance na kritický útok</color> \n<color=blue> Zvýšení poškození při těžbě </color> \n<color=blue> Zvýšení zdraví stavebních prvků </color> \n<color=green> Zvýšení poškození při kácení stromů</color>");
		}

		private void HungLocalization()
		{
			_dictionary.Add("$attributes", "Tulajdonságok");
			_dictionary.Add("$parameter_strength", "Erő");
			_dictionary.Add("$parameter_intellect", "Intelligencia");
			_dictionary.Add("$free_points", "Elérhető pontok");
			_dictionary.Add("$level", "Szint");
			_dictionary.Add("$lvl", "Lvl.");
			_dictionary.Add("$exp", "Tapasztalat");
			_dictionary.Add("$cancel", "Mégse");
			_dictionary.Add("$apply", "Elfogad");
			_dictionary.Add("$reset_parameters", "Pontok visszaállítása");
			_dictionary.Add("$no", "Nem");
			_dictionary.Add("$yes", "Igen");
			_dictionary.Add("$get_exp", "Tapasztalat szerzve");
			_dictionary.Add("$reset_point_text", "Biztosan vissza akarod állítani az összes tulajdonságpontodat {0} {1} -ért?");
			_dictionary.Add("$physic_damage", "Fizikai sebzés");
			_dictionary.Add("$add_weight", "Teherbírás");
			_dictionary.Add("$reduced_stamina", "Állóképesség-fogyasztás (futás, ugrás)");
			_dictionary.Add("$magic_damage", "Elemi sebzés");
			_dictionary.Add("$magic_armor", "Elemi védelem");
			_dictionary.Add("$add_hp", "Életerő növelés");
			_dictionary.Add("$add_stamina", "Állóképesség növelés");
			_dictionary.Add("$physic_armor", "Fizikai védelem");
			_dictionary.Add("$reduced_stamina_block", "Blokkolás állóképesség-fogyasztása");
			_dictionary.Add("$regen_hp", "Életerő regeneráció");
			_dictionary.Add("$damage", "Sebzés");
			_dictionary.Add("$armor", "Páncél");
			_dictionary.Add("$survival", "Túlélés");
			_dictionary.Add("$regen_eitr", "Eitr regeneráció");
			_dictionary.Add("$stamina_reg", "Állóképesség regeneráció");
			_dictionary.Add("$add_eitr", "Eitr növelés");
			_dictionary.Add("$parameter_agility", "Ügyesség");
			_dictionary.Add("$parameter_body", "Kitartás");
			_dictionary.Add("$parameter_vigour", "Vitalitás");
			_dictionary.Add("$parameter_special", "Fókusz");
			_dictionary.Add("$specialother", "Speciális");
			_dictionary.Add("$attack_speed", "Támadási sebesség");
			_dictionary.Add("$attack_stamina", "Támadás állóképesség-fogyasztása");
			_dictionary.Add("$crtcDmgMulti", "Kritikus sebzés szorzó");
			_dictionary.Add("$mining_speed", "Bányászati sebzés növelés");
			_dictionary.Add("$piece_health", "Építmények életereje");
			_dictionary.Add("$tree_cutting", "Favágás sebzése");
			_dictionary.Add("$crit_chance", "Kritikus találat esélye");
			_dictionary.Add("$notify", "<color=#00E6FF>Értesítés</color>");
			_dictionary.Add("$friends_list", "Barátlista");
			_dictionary.Add("$send", "Küldés");
			_dictionary.Add("$invited", "Meghívások");
			_dictionary.Add("$friends", "Barátok");
			_dictionary.Add("$online", "Elérhető");
			_dictionary.Add("$offline", "Offline");
			_dictionary.Add("$not_found", "A(z) {0} nevű játékos nem található.");
			_dictionary.Add("$send_invite", "Barátkérelem elküldve neki: {0}");
			_dictionary.Add("$get_invite", "Barátkérelmet kaptál tőle: {0}");
			_dictionary.Add("$accept_invite", "{0} elfogadta a barátkérelmet.");
			_dictionary.Add("$cancel_invite", "{0} visszavonta a barátkérelmet.");
			_dictionary.Add("$terminal_set_level", "{0}. szintű lettél.");
			_dictionary.Add("$terminal_reset_points", "Tulajdonságpontok visszaállítva");
			_dictionary.Add("$strength_tooltip", "<size=20>Az Erő növeli:</size> \n<color=yellow> A fizikai sebzést </color> \n<color=blue> A teherbírást </color> \n<color=green> Csökkenti a blokkolás állóképesség-fogyasztását </color> \n<color=red> Növeli a kritikus találatok sebzését </color>");
			_dictionary.Add("$dexterity_tooltip", "<size=20>Az Ügyesség növeli:</size> \n<color=red> A támadások sebességét (íjak kivételével)</color> \n<color=yellow> Csökkenti a támadások állóképesség-fogyasztását </color> \n<color=green> Csökkenti a futás és ugrás állóképesség-fogyasztását</color> ");
			_dictionary.Add("$intelect_tooltip", "<size=20>Az Intelligencia növeli:</size> \n<color=green> Az összes elemi sebzést </color>\n<color=red> Az alap Eitr mennyiségét (ha rendelkezel vele)</color> \n<color=red> Az Eitr regenerációt</color> ");
			_dictionary.Add("$endurance_tooltip", "<size=20>A Kitartás növeli:</size> \n<color=yellow> Az állóképesség mennyiségét</color>\n<color=yellow> Az állóképesség regenerációt </color> \n<color=green> Csökkenti a kapott fizikai sebzést</color> ");
			_dictionary.Add("$vigour_tooltip", "<size=20>A Vitalitás növeli:</size> \n<color=red> A maximális életerőt (HP)</color>\n<color=yellow> Az életerő regenerációt </color> \n<color=green> Csökkenti a kapott elemi sebzést</color> ");
			_dictionary.Add("$special_tooltip", "<size=20>A Fókusz növeli:</size> \n<color=red> A kritikus találat esélyét</color> \n<color=blue> A bányászati sebzést </color> \n<color=blue> Az építmények életerejét </color> \n<color=green> A favágási sebzést</color>");
		}
	}
	[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
	[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
	public class ExpPanelRefs : MonoBehaviour
	{
		[SerializeField]
		public RectTransform ExpPanelRoot;

		[SerializeField]
		public RectTransform ExpPanelBkg;

		[SerializeField]
		public Image ExpPanelBarFil;

		[SerializeField]
		public Text ExpPanelLvlTxt;

		[SerializeField]
		public Text ExpPanelExpTxt;
	}
	[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
	[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
	public class EpicHudPanelRefs : MonoBehaviour
	{
		[SerializeField]
		public RectTransform ExpPanelRoot;

		[SerializeField]
		public RectTransform ExpPanelBkg;

		[SerializeField]
		public Image HealthBarFil;

		[SerializeField]
		public Image StaminaBarFil;

		[SerializeField]
		public Image EitrBarFil;

		[SerializeField]
		public Text EpicHudPanelLvlTxt;

		[SerializeField]
		public Text EpicHudPanelExpTxt;
	}
	[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
	[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
	public class FriendCellPanelRefs : MonoBehaviour
	{
		[SerializeField]
		public RectTransform PanelRoot;

		[SerializeField]
		public RectTransform PanelBkg;

		[SerializeField]
		public Image IconClass;

		[SerializeField]
		public Text PlayerName;

		[SerializeField]
		public Text Level;

		[SerializeField]
		public Text Status;

		[SerializeField]
		public RectTransform ButtonGroup;

		[SerializeField]
		public Button AddGroup;

		[SerializeField]
		public Button AcceptButton;

		[SerializeField]
		public Button DeclineButton;
	}
	[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
	[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
	public class LevelHudPanelRefs : MonoBehaviour
	{
		[SerializeField]
		[Header("MenuPanel")]
		public RectTransform CanvasRoot;

		[SerializeField]
		public RectTransform MenuPanelRoot;

		[SerializeField]
		public RectTransform MenuPanelBkg;

		[SerializeField]
		public RectTransform ButtonGroup;

		[SerializeField]
		public RectTransform ButtonLevelSystem;

		[SerializeField]
		public RectTransform ButtonFriends;

		[SerializeField]
		public RectTransform ButtonQuests;

		[SerializeField]
		public RectTransform ButtonProfessions;

		[SerializeField]
		public RectTransform ButtonShop;

		[Header("PointPanel")]
		[SerializeField]
		public RectTransform PointPanelRoot;

		[SerializeField]
		public RectTransform PointPanelBkg;

		[SerializeField]
		public Text HeaderText;

		[SerializeField]
		public RectTransform PointSectionRoot;

		[SerializeField]
		public RectTransform StrengthRoot;

		[SerializeField]
		public Text StrengthText;

		[SerializeField]
		public Button StrengthP1Button;

		[SerializeField]
		public Button StrengthP5Button;

		[SerializeField]
		public Text AgilityText;

		[SerializeField]
		public Button AgilityP1Button;

		[SerializeField]
		public Button AgilityP5Button;

		[SerializeField]
		public Text IntellectText;

		[SerializeField]
		public Button IntellectP1Button;

		[SerializeField]
		public Button IntellectP5Button;

		[SerializeField]
		public Text BodyText;

		[SerializeField]
		public Button BodyP1Button;

		[SerializeField]
		public Button BodyP5Button;

		[SerializeField]
		public GameObject DummyListStat;

		[SerializeField]
		public Text FreePointText;

		[SerializeField]
		public Button FreePointApply;

		[SerializeField]
		public Button FreePointCancel;

		[SerializeField]
		public Button PointResetButton;

		[SerializeField]
		public Text CurrentLvlText;

		[SerializeField]
		public Text CurrentExpText;

		[SerializeField]
		public RectTransform DescStatsContentParent;

		[SerializeField]
		public RectTransform DescStatsDummyHeader;

		[SerializeField]
		public Text DescStatsDummyText;

		[SerializeField]
		[Header("ApplyResetPanel")]
		public RectTransform ApplyResetPanelRoot;

		[SerializeField]
		public RectTransform ApplyResetPanelBkg;

		[SerializeField]
		public RectTransform ApplyResetButtonGroup;

		[SerializeField]
		public Button ButtonYes;

		[SerializeField]
		public Button ButtonNo;

		[SerializeField]
		public Text Text;

		[Header("FriendsListPanel")]
		[SerializeField]
		public RectTransform FriendsListPanelRoot;

		[SerializeField]
		public RectTransform FriendsListPanelBkg;

		[SerializeField]
		public RectTransform FriendsListPanelHeader;

		[SerializeField]
		public Image BorderImage;

		[SerializeField]
		public GameObject HeaderInvited;

		[SerializeField]
		public GameObject Invited;

		[SerializeField]
		public GameObject HeaderFriends;

		[SerializeField]
		public GameObject Friends;

		[SerializeField]
		public Text FriendsListPanelText;

		[SerializeField]
		public Button AddFriendButton;

		[Header("SendInvitePanel")]
		[SerializeField]
		public RectTransform SendInvitePanelRoot;

		[SerializeField]
		public RectTransform SendInvitePanelBkg;

		[SerializeField]
		public InputField SendInviteInputField;

		[SerializeField]
		public Button SendButton;

		[SerializeField]
		public Text SendText;

		[SerializeField]
		public Button CancelButton;

		[SerializeField]
		public Text CancelText;
	}
	[BepInPlugin("WackyMole.EpicMMOSystemUI", "EpicMMOSystemUI", "1.9.60")]
	[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
	[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
	public class EpicMMOSystemUI : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <Positionpanels>d__11 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
			private object <>2__current;

			[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
			public EpicMMOSystemUI <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				[return: <3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				[return: <3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
				get
				{
					return <>2__current;
				}
			}

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

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

			private bool MoveNext()
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Expected O, but got Unknown
				int num = <>1__state;
				EpicMMOSystemUI epicMMOSystemUI = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(1.5f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					EpicMMOSystem.MLLogger.LogInfo((object)"Restoring UI Positions ");
					Instance.ReadConfigValuesUI();
					((MonoBehaviour)epicMMOSystemUI).StopCoroutine(coroutine);
					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();
			}
		}

		internal const string ModName = "EpicMMOSystemUI";

		internal const string VERSION = "1.9.60";

		internal const string Author = "WackyMole";

		private const string ModGUID = "WackyMole.EpicMMOSystemUI";

		private static string ConfigFileName = "WackyMole.EpicMMOSystemUI.cfg";

		internal static EpicMMOSystemUI Instance;

		public static Coroutine coroutine = null;

		private ConfigEntry<T> config<[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(2)] T>(string group, string name, T value, ConfigDescription description, bool synchronizedSetting = false)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			ConfigDescription val = new ConfigDescription(description.Description + (synchronizedSetting ? " [Synced with Server]" : " [Not Synced with Server]"), description.AcceptableValues, description.Tags);
			return ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, val);
		}

		private ConfigEntry<T> config<[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(2)] T>(string group, string name, T value, string description, bool synchronizedSetting = false)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting);
		}

		private void Awake()
		{
			//IL_0065: 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_00ee: 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_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: 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_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			string group = "4.Hud--------------------";
			EpicMMOSystem.oldExpBar = config(group, "OldXPBar", value: false, "Use the old eXP Bar only (need restart, not server sync) Does not move or scale");
			EpicMMOSystem.showMaxHp = config(group, "ShowMaxHp", value: true, "Show max hp (100 / 100)");
			EpicMMOSystem.forceMagicBar = config(group, "Force EitrBar", value: false, "Force the Eitr bar to always show up even when empty");
			EpicMMOSystem.HudPanelPosition = config<Vector2>(group, "1.0HudGrouplPosition", new Vector2(0f, 0f), "Position of the Main EpicHudBarBackground in (x,y) - You can drag individual components below");
			EpicMMOSystem.HudExpBackgroundCol = config(group, "1.1BackgroundCol", "#2F1600", "Background color in Hex, set to 'none' to make transparent");
			EpicMMOSystem.HudExpBackgroundScale = config<Vector3>(group, "1.1BackgroundScale", new Vector3(1f, 1f, 1f), "Background Bar Scale");
			EpicMMOSystem.HudBarScale = config(group, "1.2HudGroupScale", 0.9f, "Scale for HudGroup - exp, background, hp, stamina, eitr - You can do individual below");
			EpicMMOSystem.ExpPanelPosition = config<Vector2>(group, "2.0ExpPanelPosition", new Vector2(0f, 0f), "Position of the Exp panel (x,y)");
			EpicMMOSystem.ExpColor = config(group, "2.1ExpColor", "#1E0620", "Exp fill color in Hex or a named color -  Set to 'none' to have no xp bar");
			EpicMMOSystem.ExpScale = config<Vector3>(group, "2.2ExpScale", new Vector3(1f, 1f, 1f), "Exp Bar Scale factor");
			EpicMMOSystem.StaminaPanelPosition = config<Vector2>(group, "3.0StaminaPanelPosition", new Vector2(0f, 0f), "Position of the Stamina panel (x,y)");
			EpicMMOSystem.StaminaColor = config(group, "3.1StaminaColor", "#986100", "Stamina color in Hex, set to 'none' to make vanilla");
			EpicMMOSystem.StaminaScale = config<Vector3>(group, "3.2StaminaScale", new Vector3(1f, 1f, 1f), "Stamina Bar Scale factor");
			EpicMMOSystem.HpPanelPosition = config<Vector2>(group, "4.0HpPanelPosition", new Vector2(0f, 0f), "Position of the Hp panel (x,y)");
			EpicMMOSystem.HpColor = config(group, "4.1HPColor", "#870000", "HP color in Hex, set to 'none' to make vanilla");
			EpicMMOSystem.HPScale = config<Vector3>(group, "4.2HPScale", new Vector3(1f, 1f, 1f), "HP Bar Scale factor");
			EpicMMOSystem.EitrPanelPosition = config<Vector2>(group, "5.0EitrPanelPosition", new Vector2(0f, 0f), "Position of the Eitr panel (x,y)");
			EpicMMOSystem.EitrColor = config(group, "5.1EitrColor", "#84257C", "Eitr color in Hex, set to 'none' to make vanilla");
			EpicMMOSystem.EitrScale = config<Vector3>(group, "5.2EitrScale", new Vector3(1f, 1f, 1f), "Eitr Bar Scale factor");
			EpicMMOSystem.LevelHudGroupScale = config(group, "6.2LevelHudGroupScale", 1f, "LevelHud Group of Objects Scale factor (Nav Bar, Point Hub)");
			EpicMMOSystem.LevelPointPosition = config<Vector2>(group, "7.0PointHudPosition", new Vector2(0f, 0f), "Position of the Point panel (x,y)");
			EpicMMOSystem.LevelNavPosition = config<Vector2>(group, "8.0NavBarPosition", new Vector2(0f, 100f), "Position of the NavBar (x,y)");
			SetupWatcher();
		}

		private void SetupWatcher()
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Paths.ConfigPath, ConfigFileName);
			fileSystemWatcher.Changed += ReadConfigValuesUI;
			fileSystemWatcher.IncludeSubdirectories = false;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		[IteratorStateMachine(typeof(<Positionpanels>d__11))]
		private IEnumerator Positionpanels()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Positionpanels>d__11(0)
			{
				<>4__this = this
			};
		}

		public static void UIReload()
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: 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_021f: 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)
			((Component)MyUI.expPanelRoot).GetComponent<CanvasScaler>().scaleFactor = EpicMMOSystem.HudBarScale.Value;
			MyUI.levelSystemPanelRoot.GetComponent<CanvasScaler>().scaleFactor = EpicMMOSystem.LevelHudGroupScale.Value;
			Color val = default(Color);
			if (EpicMMOSystem.HudExpBackgroundCol.Value == "none")
			{
				MyUI.expPanelBackground.SetActive(false);
			}
			else
			{
				MyUI.expPanelBackground.SetActive(true);
				if (ColorUtility.TryParseHtmlString(EpicMMOSystem.HudExpBackgroundCol.Value, ref val))
				{
					((Graphic)MyUI.expPanelBackground.GetComponent<Image>()).color = val;
				}
			}
			MyUI.DisableHPBar = EpicMMOSystem.HpColor.Value == "none";
			MyUI.DisableStaminaBar = EpicMMOSystem.StaminaColor.Value == "none";
			MyUI.DisableEitrBar = EpicMMOSystem.EitrColor.Value == "none";
			MyUI.DisableExpBar = EpicMMOSystem.ExpColor.Value == "none";
			((Component)MyUI.hp).gameObject.SetActive(!MyUI.DisableHPBar);
			MyUI.DHpBar.SetActive(MyUI.DisableHPBar);
			MyUI.IconHpBar.SetActive(MyUI.DisableHPBar);
			((Component)MyUI.Exp).gameObject.SetActive(!MyUI.DisableExpBar);
			((Component)MyUI.stamina).gameObject.SetActive(!MyUI.DisableStaminaBar);
			if (ColorUtility.TryParseHtmlString(EpicMMOSystem.HpColor.Value, ref val))
			{
				((Graphic)MyUI.hpImage).color = val;
			}
			if (ColorUtility.TryParseHtmlString(EpicMMOSystem.StaminaColor.Value, ref val))
			{
				((Graphic)MyUI.staminaImage).color = val;
			}
			if (ColorUtility.TryParseHtmlString(EpicMMOSystem.EitrColor.Value, ref val))
			{
				((Graphic)MyUI.EitrImage).color = val;
			}
			if (ColorUtility.TryParseHtmlString(EpicMMOSystem.ExpColor.Value, ref val))
			{
				if (EpicMMOSystem.ExpColor.Value == "#FFFFFF")
				{
					((Graphic)MyUI.eBarImage).color = val;
					if ((Object)(object)MyUI.eOldBarImage != (Object)null)
					{
						((Graphic)MyUI.eOldBarImage).color = val;
					}
				}
				else
				{
					((Graphic)MyUI.eBarImage).color = val * 2f;
					if ((Object)(object)MyUI.eOldBarImage != (Object)null)
					{
						((Graphic)MyUI.eOldBarImage).color = val * 2f;
					}
				}
			}
			((Transform)((Component)MyUI.Exp).GetComponent<RectTransform>()).localScale = EpicMMOSystem.ExpScale.Value;
			((Transform)((Component)MyUI.hp).GetComponent<RectTransform>()).localScale = EpicMMOSystem.HPScale.Value;
			((Transform)((Component)MyUI.stamina).GetComponent<RectTransform>()).localScale = EpicMMOSystem.StaminaScale.Value;
			((Transform)((Component)MyUI.EitrTran).GetComponent<RectTransform>()).localScale = EpicMMOSystem.EitrScale.Value;
			((Transform)MyUI.expPanelBackground.GetComponent<RectTransform>()).localScale = EpicMMOSystem.HudExpBackgroundScale.Value;
			try
			{
				if (EpicMMOSystem.extraDebug.Value)
				{
					EpicMMOSystem.MLLogger.LogInfo((object)"MMO Manual ReadConfigValues called");
				}
				DragControl.RestoreWindow(((Component)MyUI.expPanel).gameObject);
				DragControl.RestoreWindow(((Component)MyUI.hp).gameObject);
				DragControl.RestoreWindow(((Component)MyUI.Exp).gameObject);
				DragControl.RestoreWindow(((Component)MyUI.stamina).gameObject);
				DragControl.RestoreWindow(MyUI.EitrGameObj);
				DragWindowCntrl.RestoreWindow(MyUI.navigationPanel, checkfor0: false);
				DragWindowCntrl.RestoreWindow(MyUI.levelSystemPanel, checkfor0: false);
			}
			catch
			{
				EpicMMOSystem.MLLogger.LogError((object)("There was an issue loading your " + ConfigFileName));
				EpicMMOSystem.MLLogger.LogError((object)"Please check your config entries for spelling and format!");
			}
		}

		internal void ReadConfigValuesUI(object sender = null, FileSystemEventArgs e = null)
		{
			((BaseUnityPlugin)this).Config.Reload();
			UIReload();
		}
	}
	[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
	[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
	public class DragControl : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <Positionpanels>d__5 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
			private object <>2__current;

			[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
			public DragControl <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				[return: <3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				[return: <3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
				get
				{
					return <>2__current;
				}
			}

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

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

			private bool MoveNext()
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Expected O, but got Unknown
				int num = <>1__state;
				DragControl dragControl = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.001f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					SaveWindowPositions(((Component)dragControl).gameObject, initialLoad: true);
					((MonoBehaviour)dragControl).StopCoroutine(coroutine);
					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 RectTransform window;

		private Vector2 delta;

		public static Coroutine coroutine;

		public void Awake()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			RectTransform val = (RectTransform)((Component)this).transform;
			window = val;
			coroutine = ((MonoBehaviour)this).StartCoroutine("Positionpanels");
		}

		public void StartDelayPosition()
		{
			coroutine = ((MonoBehaviour)this).StartCoroutine("Positionpanels");
		}

		[IteratorStateMachine(typeof(<Positionpanels>d__5))]
		private IEnumerator Positionpanels()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Positionpanels>d__5(0)
			{
				<>4__this = this
			};
		}

		public static void ApplyDragWindowCntrl(GameObject go)
		{
			go.AddComponent<DragControl>();
		}

		internal static void RestoreWindow(GameObject go, bool checkfor0 = true)
		{
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: 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_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: 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_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: 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_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: 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_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: 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)
			RectTransform component = go.GetComponent<RectTransform>();
			if (checkfor0)
			{
				switch (((Object)go).name)
				{
				case "EpicHudPanel":
					component.anchoredPosition = EpicMMOSystem.HudPanelPosition.Value;
					break;
				case "Exp":
					if (EpicMMOSystem.ExpPanelPosition.Value != new Vector2(0f, 0f))
					{
						component.anchoredPosition = EpicMMOSystem.ExpPanelPosition.Value;
					}
					break;
				case "Hp":
					if (EpicMMOSystem.HpPanelPosition.Value != new Vector2(0f, 0f))
					{
						component.anchoredPosition = EpicMMOSystem.HpPanelPosition.Value;
					}
					break;
				case "Stamina":
					if (EpicMMOSystem.StaminaPanelPosition.Value != new Vector2(0f, 0f))
					{
						component.anchoredPosition = EpicMMOSystem.StaminaPanelPosition.Value;
					}
					break;
				case "Eitr":
					if (EpicMMOSystem.EitrPanelPosition.Value != new Vector2(0f, 0f))
					{
						component.anchoredPosition = EpicMMOSystem.EitrPanelPosition.Value;
					}
					break;
				}
			}
			else
			{
				RectTransform val = component;
				val.anchoredPosition = (Vector2)(((Object)go).name switch
				{
					"EpicHudPanel" => EpicMMOSystem.HudPanelPosition.Value, 
					"Exp" => EpicMMOSystem.ExpPanelPosition.Value, 
					"Hp" => EpicMMOSystem.HpPanelPosition.Value, 
					"Stamina" => EpicMMOSystem.StaminaPanelPosition.Value, 
					"Eitr" => EpicMMOSystem.EitrPanelPosition.Value, 
					_ => component.anchoredPosition, 
				});
			}
		}

		internal static void MoveEitr(GameObject go, int Extra)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			go.GetComponent<RectTransform>().anchoredPosition = new Vector2((float)Extra, (float)Extra);
		}

		internal static void RestoreEitr(GameObject go)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			go.GetComponent<RectTransform>().anchoredPosition = EpicMMOSystem.EitrPanelPosition.Value;
		}

		internal static void SaveWindowPositions(GameObject go, bool initialLoad)
		{
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: 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_00b2: 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_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: 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_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: 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_0122: 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_0146: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = go.GetComponent<RectTransform>();
			if (initialLoad)
			{
				switch (((Object)go).name)
				{
				case "EpicHudPanel":
					component.anchoredPosition = EpicMMOSystem.HudPanelPosition.Value;
					break;
				case "Exp":
					if (EpicMMOSystem.ExpPanelPosition.Value != new Vector2(0f, 0f))
					{
						component.anchoredPosition = EpicMMOSystem.ExpPanelPosition.Value;
					}
					break;
				case "Hp":
					if (EpicMMOSystem.HpPanelPosition.Value != new Vector2(0f, 0f))
					{
						component.anchoredPosition = EpicMMOSystem.HpPanelPosition.Value;
					}
					break;
				case "Stamina":
					if (EpicMMOSystem.StaminaPanelPosition.Value != new Vector2(0f, 0f))
					{
						component.anchoredPosition = EpicMMOSystem.StaminaPanelPosition.Value;
					}
					break;
				case "Eitr":
					if (EpicMMOSystem.EitrPanelPosition.Value != new Vector2(0f, 0f))
					{
						component.anchoredPosition = EpicMMOSystem.EitrPanelPosition.Value;
					}
					break;
				}
			}
			else
			{
				switch (((Object)go).name)
				{
				case "EpicHudPanel":
					EpicMMOSystem.HudPanelPosition.Value = component.anchoredPosition;
					break;
				case "Exp":
					EpicMMOSystem.ExpPanelPosition.Value = component.anchoredPosition;
					break;
				case "Hp":
					EpicMMOSystem.HpPanelPosition.Value = component.anchoredPosition;
					break;
				case "Stamina":
					EpicMMOSystem.StaminaPanelPosition.Value = component.anchoredPosition;
					break;
				case "Eitr":
					EpicMMOSystem.EitrPanelPosition.Value = component.anchoredPosition;
					break;
				}
			}
			((BaseUnityPlugin)EpicMMOSystem.Instance).Config.Save();
		}

		public void BeginDrag()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: 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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			delta = Vector2.op_Implicit(Input.mousePosition - ((Transform)window).position);
		}

		public void Drag()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//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_0015: 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_0037: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: 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_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: 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_0104: 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)
			//IL_013e: 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_0130: 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_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = Vector2.op_Implicit(Input.mousePosition) - delta;
			Rect rect = window.rect;
			float num = ((Rect)(ref rect)).width * ((Component)this).transform.root.lossyScale.x;
			rect = window.rect;
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(num, ((Rect)(ref rect)).height * ((Component)this).transform.root.lossyScale.y);
			Vector2 val3 = default(Vector2);
			val3.x = val.x - window.pivot.x * val2.x;
			val3.y = val.y - window.pivot.y * val2.y;
			Vector2 val4 = default(Vector2);
			val4.x = val.x + (1f - window.pivot.x) * val2.x;
			val4.y = val.y + (1f - window.pivot.y) * val2.y;
			if (val3.x < 0f)
			{
				val.x = window.pivot.x * val2.x;
			}
			else if (val4.x > (float)Screen.width)
			{
				val.x = (float)Screen.width - (1f - window.pivot.x) * val2.x;
			}
			if (val3.y < 0f)
			{
				val.y = window.pivot.y * val2.y;
			}
			else if (val4.y > (float)Screen.height)
			{
				val.y = (float)Screen.height - (1f - window.pivot.y) * val2.y;
			}
			((Transform)window).position = Vector2.op_Implicit(val);
		}

		public void OnEndDrag()
		{
			SaveWindowPositions(((Component)window).gameObject, initialLoad: false);
		}

		public void OnBeginDrag(PointerEventData eventData)
		{
		}
	}
	[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
	[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
	public static class TerminalCommands
	{
		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		private static class ZrouteMethodsServerFeedback
		{
			private static void Postfix()
			{
				if (!isServer)
				{
					ZRoutedRpc.instance.Register<int>(modName + " terminal_SetLevel", (Action<long, int>)RPC_SetLevel);
					ZRoutedRpc.instance.Register(modName + " terminal_ResetPoints", (Action<long>)RPC_ResetPoints);
					ZRoutedRpc.instance.Register(modName + " terminal_ResetTotalPoints", (Action<long>)RPC_ResetTotalPoints);
					ZRoutedRpc.instance.Register(modName + " terminal_Recalc", (Action<long>)RPC_Recalc);
				}
			}
		}

		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		[HarmonyPatch(typeof(Terminal), "InitTerminal")]
		public class AddChatCommands
		{
			[Serializable]
			[CompilerGenerated]
			private sealed class <>c
			{
				public static readonly <>c <>9 = new <>c();

				public static ConsoleEvent <>9__0_1;

				public static ConsoleOptionsFetcher <>9__0_2;

				internal void <Postfix>b__0_1(ConsoleEventArgs args)
				{
					if (!EpicMMOSystem.ConfigSync.IsAdmin && !ZNet.instance.IsServer())
					{
						args.Context.AddString("You are not an admin on this server.");
						return;
					}
					if (args[1] == "level")
					{
						int num = int.Parse(args[2]);
						string text = args[3];
						if (args.Length > 4)
						{
							for (int i = 4; i < args.Length; i++)
							{
								text = text + " " + args[i];
							}
						}
						long? num2 = <Postfix>g__getPlayerId|0_0(text);
						if (!num2.HasValue)
						{
							MonoBehaviour.print((object)"Player is not found");
						}
						ZRoutedRpc.instance.InvokeRoutedRPC(num2.GetValueOrDefault(200L), modName + " terminal_SetLevel", new object[1] { num });
					}
					else if (args[1] == "reset_points")
					{
						string text2 = args[2];
						if (args.Length > 3)
						{
							for (int j = 3; j < args.Length; j++)
							{
								text2 = text2 + " " + args[j];
							}
						}
						long? num3 = <Postfix>g__getPlayerId|0_0(text2);
						if (!num3.HasValue)
						{
							MonoBehaviour.print((object)"Player is not found");
						}
						ZRoutedRpc.instance.InvokeRoutedRPC(num3.GetValueOrDefault(200L), modName + " terminal_ResetPoints", Array.Empty<object>());
					}
					else if (args[1] == "reset_totalpoints")
					{
						string text3 = args[2];
						if (args.Length > 3)
						{
							for (int k = 3; k < args.Length; k++)
							{
								text3 = text3 + " " + args[k];
							}
						}
						long? num4 = <Postfix>g__getPlayerId|0_0(text3);
						if (!num4.HasValue)
						{
							MonoBehaviour.print((object)"Player is not found");
						}
						ZRoutedRpc.instance.InvokeRoutedRPC(num4.GetValueOrDefault(200L), modName + " terminal_ResetTotalPoints", Array.Empty<object>());
					}
					else if (args[1] == "recalc")
					{
						string text4 = args[2];
						if (args.Length > 3)
						{
							for (int l = 3; l < args.Length; l++)
							{
								text4 = text4 + " " + args[l];
							}
						}
						long? num5 = <Postfix>g__getPlayerId|0_0(text4);
						if (!num5.HasValue)
						{
							MonoBehaviour.print((object)"Player is not found");
						}
						ZRoutedRpc.instance.InvokeRoutedRPC(num5.GetValueOrDefault(200L), modName + " terminal_Recalc", Array.Empty<object>());
					}
					else if (args[1] == "update")
					{
						ZNetPeer serverPeer = ZNet.instance.GetServerPeer();
						if (serverPeer == null)
						{
							return;
						}
						ZRoutedRpc.instance.InvokeRoutedRPC(serverPeer.m_uid, "EpicMMOSystem ReloadJsons", new object[1] { true });
					}
					args.Context.AddString("level [value] [name] - set level for player name");
					args.Context.AddString("reset_points [name] - reset all attributes points for player");
					args.Context.AddString("reset_totalpoints [name] - reset total/current/level for player ");
					args.Context.AddString("recalc [name] - recalc level for player name based on total gained XP");
					args.Context.AddString("update - Updates the Json and pushes to all clients");
				}

				internal List<string> <Postfix>b__0_2()
				{
					return new List<string> { "level", "reset_points", "reset_totalpoints", "recalc", "update" };
				}
			}

			private static void Postfix()
			{
				//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_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: 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_004d: Expected O, but got Unknown
				object obj = <>c.<>9__0_1;
				if (obj == null)
				{
					ConsoleEvent val = delegate(ConsoleEventArgs args)
					{
						if (!EpicMMOSystem.ConfigSync.IsAdmin && !ZNet.instance.IsServer())
						{
							args.Context.AddString("You are not an admin on this server.");
						}
						else
						{
							if (args[1] == "level")
							{
								int num = int.Parse(args[2]);
								string text2 = args[3];
								if (args.Length > 4)
								{
									for (int i = 4; i < args.Length; i++)
									{
										text2 = text2 + " " + args[i];
									}
								}
								long? playerId = getPlayerId(text2);
								if (!playerId.HasValue)
								{
									MonoBehaviour.print((object)"Player is not found");
								}
								ZRoutedRpc.instance.InvokeRoutedRPC(playerId.GetValueOrDefault(200L), modName + " terminal_SetLevel", new object[1] { num });
							}
							else if (args[1] == "reset_points")
							{
								string text3 = args[2];
								if (args.Length > 3)
								{
									for (int j = 3; j < args.Length; j++)
									{
										text3 = text3 + " " + args[j];
									}
								}
								long? playerId2 = getPlayerId(text3);
								if (!playerId2.HasValue)
								{
									MonoBehaviour.print((object)"Player is not found");
								}
								ZRoutedRpc.instance.InvokeRoutedRPC(playerId2.GetValueOrDefault(200L), modName + " terminal_ResetPoints", Array.Empty<object>());
							}
							else if (args[1] == "reset_totalpoints")
							{
								string text4 = args[2];
								if (args.Length > 3)
								{
									for (int k = 3; k < args.Length; k++)
									{
										text4 = text4 + " " + args[k];
									}
								}
								long? playerId3 = getPlayerId(text4);
								if (!playerId3.HasValue)
								{
									MonoBehaviour.print((object)"Player is not found");
								}
								ZRoutedRpc.instance.InvokeRoutedRPC(playerId3.GetValueOrDefault(200L), modName + " terminal_ResetTotalPoints", Array.Empty<object>());
							}
							else if (args[1] == "recalc")
							{
								string text5 = args[2];
								if (args.Length > 3)
								{
									for (int l = 3; l < args.Length; l++)
									{
										text5 = text5 + " " + args[l];
									}
								}
								long? playerId4 = getPlayerId(text5);
								if (!playerId4.HasValue)
								{
									MonoBehaviour.print((object)"Player is not found");
								}
								ZRoutedRpc.instance.InvokeRoutedRPC(playerId4.GetValueOrDefault(200L), modName + " terminal_Recalc", Array.Empty<object>());
							}
							else if (args[1] == "update")
							{
								ZNetPeer serverPeer = ZNet.instance.GetServerPeer();
								if (serverPeer == null)
								{
									return;
								}
								ZRoutedRpc.instance.InvokeRoutedRPC(serverPeer.m_uid, "EpicMMOSystem ReloadJsons", new object[1] { true });
							}
							args.Context.AddString("level [value] [name] - set level for player name");
							args.Context.AddString("reset_points [name] - reset all attributes points for player");
							args.Context.AddString("reset_totalpoints [name] - reset total/current/level for player ");
							args.Context.AddString("recalc [name] - recalc level for player name based on total gained XP");
							args.Context.AddString("update - Updates the Json and pushes to all clients");
						}
					};
					<>c.<>9__0_1 = val;
					obj = (object)val;
				}
				object obj2 = <>c.<>9__0_2;
				if (obj2 == null)
				{
					ConsoleOptionsFetcher val2 = () => new List<string> { "level", "reset_points", "reset_totalpoints", "recalc", "update" };
					<>c.<>9__0_2 = val2;
					obj2 = (object)val2;
				}
				new ConsoleCommand("EpicMMOSystem", "Manages the EpicMMOSystem commands.", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)obj2, false, false, false);
				[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
				static long? getPlayerId(string name)
				{
					//IL_001f: 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_0025: 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_0039: Unknown result type (might be due to invalid IL or missing references)
					string text = name.Replace('&', ' ');
					foreach (PlayerInfo player in ZNet.instance.GetPlayerList())
					{
						if (player.m_name == text)
						{
							ZDOID characterID = player.m_characterID;
							return ((ZDOID)(ref characterID)).UserID;
						}
					}
					return null;
				}
			}

			[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
			[CompilerGenerated]
			internal static long? <Postfix>g__getPlayerId|0_0(string name)
			{
				//IL_001f: 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_0025: 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_0039: Unknown result type (might be due to invalid IL or missing references)
				string text = name.Replace('&', ' ');
				foreach (PlayerInfo player in ZNet.instance.GetPlayerList())
				{
					if (player.m_name == text)
					{
						ZDOID characterID = player.m_characterID;
						return ((ZDOID)(ref characterID)).UserID;
					}
				}
				return null;
			}
		}

		private static bool isServer => (int)SystemInfo.graphicsDeviceType == 4;

		private static string modName => "EpicMMOSystem";

		private static Localizationold local => EpicMMOSystem.localizationold;

		private static void RPC_SetLevel(long sender, int level)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			LevelSystem.Instance.terminalSetLevel(level);
			Chat.instance.RPC_ChatMessage(200L, Vector3.zero, 0, UserInfo.GetLocalUser(), string.Format(local["$terminal_set_level"], level));
		}

		private static void RPC_Recalc(long sender)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			LevelSystem.Instance.recalcLevel();
			Chat.instance.RPC_ChatMessage(200L, Vector3.zero, 0, UserInfo.GetLocalUser(), "Recalc your Level");
		}

		private static void RPC_ResetPoints(long sender)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			LevelSystem.Instance.ResetAllParameter();
			Chat.instance.RPC_ChatMessage(200L, Vector3.zero, 0, UserInfo.GetLocalUser(), local["$terminal_reset_points"]);
		}

		private static void RPC_ResetTotalPoints(long sender)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			LevelSystem.Instance.ResetTotalPoints();
			Chat.instance.RPC_ChatMessage(200L, Vector3.zero, 0, UserInfo.GetLocalUser(), "Reset Everything -  Level/Points/Total of Player");
		}
	}
}
namespace EpicMMOSystem.StatusEffects
{
	public static class EffectPatches
	{
		[HarmonyPatch(typeof(Player), "ConsumeItem")]
		[HarmonyPriority(200)]
		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
		[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
		public static class ConsumeMMOXP
		{
			private static ItemData tempItem;

			public static void Prefix(Inventory inventory, ItemData item, bool checkWorldLevel = false)
			{
				if (!((Character)Player.m_localPlayer).m_seman.HaveStatusEffect(StringExtensionMethods.GetStableHashCode("MMO_XP")))
				{
					tempItem = item;
				}
			}

			public static void Postfix(ref bool __result)
			{
				if (!__result || tempItem == null)
				{
					return;
				}
				GameObject val = null;
				foreach (GameObject item in ObjectDB.instance.m_items)
				{
					if (item.GetComponent<ItemDrop>()?.m_itemData.m_shared.m_name == tempItem.m_shared.m_name)
					{
						val = item;
						break;
					}
				}
				switch ((val != null) ? ((Object)val).name : null)
				{
				case "mmo_orb1":
					LevelSystem.Instance.AddExp(EpicMMOSystem.XPforOrb1.Value, noxpMulti: true);
					break;
				case "mmo_orb2":
					LevelSystem.Instance.AddExp(EpicMMOSystem.XPforOrb2.Value, noxpMulti: true);
					break;
				case "mmo_orb3":
					LevelSystem.Instance.AddExp(EpicMMOSystem.XPforOrb3.Value, noxpMulti: true);
					break;
				case "mmo_orb4":
					LevelSystem.Instance.AddExp(EpicMMOSystem.XPforOrb4.Value, noxpMulti: true);
					break;
				case "mmo_orb5":
					LevelSystem.Instance.AddExp(EpicMMOSystem.XPforOrb5.Value, noxpMulti: true);
					break;
				case "mmo_orb6":
					LevelSystem.Instance.AddExp(EpicMMOSystem.XPforOrb6.Value, noxpMulti: true);
					break;
				case "mmo_orb7":
					LevelSystem.Instance.AddExp(EpicMMOSystem.XPforOrb7.Value, noxpMulti: true);
					break;
				case "mmo_orb8":
					LevelSystem.Instance.AddExp(EpicMMOSystem.XPforOrb8.Value, noxpMulti: true);
					break;
				}
				tempItem = null;
			}
		}
	}
}
namespace EpicMMOSystem.MonoScripts
{
	[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
	[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
	public class DragWindowCntrl : MonoBehaviour, IBeginDragHandler, IEventSystemHandler, IDragHandler, IEndDragHandler
	{
		private float size;

		private float _scale = 1f;

		[SerializeField]
		private float minimumScale = 0.5f;

		[SerializeField]
		private float maximumScale = 3f;

		[SerializeField]
		private float scaleStep = 0.1f;

		private RectTransform _window;

		private Vector2 _delta;

		public static void ApplyDragWindowCntrl(GameObject go)
		{
			go.AddComponent<DragWindowCntrl>();
		}

		private void Awake()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			_window = (RectTransform)((Component)this).transform;
		}

		private void Start()
		{
			//IL_0007: 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)
			size = _window.sizeDelta.x;
			_scale = ((Transform)_window).localScale.x;
			RestoreWindow(((Component)_window).gameObject);
		}

		internal static void RestoreWindow(GameObject go, bool checkfor0 = true)
		{
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: 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_0068: 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_00d4: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = go.GetComponent<RectTransform>();
			if (checkfor0)
			{
				string name = ((Object)go).name;
				if (!(name == "NavigatePanel"))
				{
					if (name == "PointPanel" && EpicMMOSystem.LevelPointPosition.Value != new Vector2(0f, 0f))
					{
						component.anchoredPosition = EpicMMOSystem.LevelPointPosition.Value;
					}
				}
				else if (EpicMMOSystem.LevelNavPosition.Value != new Vector2(0f, 0f))
				{
					component.anchoredPosition = EpicMMOSystem.LevelNavPosition.Value;
				}
			}
			else
			{
				RectTransform val = component;
				string name = ((Object)go).name;
				Vector2 anchoredPosition = ((name == "NavigatePanel") ? EpicMMOSystem.LevelNavPosition.Value : ((!(name == "PointPanel")) ? component.anchoredPosition : EpicMMOSystem.LevelPointPosition.Value));
				val.anchoredPosition = anchoredPosition;
			}
		}

		public void OnBeginDrag(PointerEventData eventData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: 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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			_delta = Vector2.op_Implicit(Input.mousePosition - ((Transform)_window).position);
		}

		public void OnDrag(PointerEventData eventData)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//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_0015: 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_002d: 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_003c: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: 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_006b: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: 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_009d: 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)
			//IL_00b0: 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)
			//IL_00d2: 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_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: 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)
			//IL_0175: 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_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: 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_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = Vector2.op_Implicit(Input.mousePosition) - _delta;
			Vector3 lossyScale = ((Component)this).transform.root.lossyScale;
			Rect rect = _window.rect;
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(((Rect)(ref rect)).width * lossyScale.x, ((Rect)(ref rect)).height * lossyScale.y);
			Vector2 pivot = _window.pivot;
			Vector2 val3 = default(Vector2);
			val3.x = val.x - pivot.x * val2.x;
			val3.y = val.y - pivot.y * val2.y;
			Vector2 val4 = default(Vector2);
			val4.x = val.x + (1f - pivot.x) * val2.x;
			val4.y = val.y + (1f - pivot.y) * val2.y;
			if (val3.x < 0f)
			{
				val.x = _window.pivot.x * val2.x;
			}
			else if (val4.x > (float)Screen.width)
			{
				val.x = (float)Screen.width - (1f - _window.pivot.x) * val2.x;
			}
			if (val3.y < 0f)
			{
				val.y = _window.pivot.y * val2.y;
			}
			else if (val4.y > (float)Screen.height)
			{
				val.y = (float)Screen.height - (1f - _window.pivot.y) * val2.y;
			}
			((Transform)_window).position = Vector2.op_Implicit(val);
		}

		public void OnEndDrag(PointerEventData eventData)
		{
			//IL_0039: 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)
			GameObject gameObject = ((Component)_window).gameObject;
			RectTransform component = gameObject.GetComponent<RectTransform>();
			string name = ((Object)gameObject).name;
			if (!(name == "NavigatePanel"))
			{
				if (name == "PointPanel")
				{
					EpicMMOSystem.LevelPointPosition.Value = component.anchoredPosition;
				}
			}
			else
			{
				EpicMMOSystem.LevelNavPosition.Value = component.anchoredPosition;
			}
		}
	}
}
namespace EpicMMOSystem.OtherApi
{
	public static class Guilds_API
	{
		private enum API_State
		{
			NotReady,
			NotInstalled,
			Ready
		}

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

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.25f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					TryOpenGuilds();
					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 API_State state;

		private const int MaxTries = 4;

		private static int _tries;

		public static bool IsInstalled()
		{
			Init();
			return state == API_State.Ready;
		}

		public static void ShowGuilds()
		{
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				_tries = 0;
				TryOpenGuilds();
			}
		}

		private static void TryOpenGuilds()
		{
			try
			{
				Type type = Type.GetType("Guilds.Interface, Guilds");
				if (type == null)
				{
					Debug.LogWarning((object)"[EpicMMO] Guilds UI: Interface type not found.");
					return;
				}
				FieldInfo field = type.GetField("NoGuildUI", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				FieldInfo? field2 = type.GetField("GuildManagementUI", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				object? obj = field?.GetValue(null);
				GameObject val = (GameObject)((obj is GameObject) ? obj : null);
				object? obj2 = field2?.GetValue(null);
				GameObject val2 = (GameObject)((obj2 is GameObject) ? obj2 : null);
				if (!Object.op_Implicit((Object)(object)val) && !Object.op_Implicit((Object)(object)val2))
				{
					RetryLater("[EpicMMO] Guilds UI: objects not ready yet.");
					return;
				}
				Type type2 = Type.GetType("Guilds.API, Guilds");
				bool flag = false;
				if (type2 != null)
				{
					MethodInfo method = type2.GetMethod("GetOwnGuild", BindingFlags.Static | BindingFlags.Public);
					if (method != null)
					{
						object obj3 = method.Invoke(null, null);
						if (obj3 != null)
						{
							Type type3 = obj3.GetType();
							object obj4 = type3.GetField("General", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(obj3);
							if (obj4 == null)
							{
								obj4 = type3.GetProperty("General", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(obj3, null);
							}
							flag = obj4 != null;
						}
					}
				}
				if (Object.op_Implicit((Object)(object)val) && val.activeSelf)
				{
					val.SetActive(false);
				}
				if (Object.op_Implicit((Object)(object)val2) && val2.activeSelf)
				{
					val2.SetActive(false);
				}
				if (flag)
				{
					if (!Object.op_Implicit((Object)(object)val2))
					{
						RetryLater("[EpicMMO] Guilds UI: mgmt panel not ready yet.");
						return;
					}
					val2.SetActive(true);
				}
				else
				{
					if (!Object.op_Implicit((Object)(object)val))
					{
						RetryLater("[EpicMMO] Guilds UI: no-guild panel not ready yet.");
						return;
					}
					val.SetActive(true);
				}
				Debug.Log((object)"[EpicMMO] Guilds UI opened safely.");
				_tries = 0;
			}
			catch (NullReferenceException)
			{
				RetryLater("[EpicMMO] Guilds UI: NRE during open (Guilds not fully initialized).");
			}
			catch (Exception ex2)
			{
				Debug.LogWarning((object)$"[EpicMMO] Guilds UI: failed to open ({ex2.GetType().Name}): {ex2}");
			}
		}

		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
		private static void RetryLater(string reason)
		{
			if (_tries++ >= 4)
			{
				Debug.LogWarning((object)$"{reason} Gave up after {_tries} tries.");
			}
			else if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				((MonoBehaviour)Player.m_localPlayer).StartCoroutine(DelayedRetry());
			}
		}

		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
		[IteratorStateMachine(typeof(<DelayedRetry>d__8))]
		private static IEnumerator DelayedRetry()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedRetry>d__8(0);
		}

		private static void Init()
		{
			API_State aPI_State = state;
			if ((uint)(aPI_State - 1) > 1u)
			{
				if (Type.GetType("Guilds.Guilds, Guilds") == null && Type.GetType("Guilds.Interface, Guilds") == null && Type.GetType("Guilds.API, Guilds") == null)
				{
					state = API_State.NotInstalled;
				}
				else
				{
					state = API_State.Ready;
				}
			}
		}

		private static void ForceInit()
		{
			state = API_State.NotReady;
			Init();
		}
	}
	[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
	[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
	public class WackyDatabase_API
	{
		private static readonly bool _IsInstalled;

		private static MethodInfo eAddBlacklistClone;

		public static bool IsInstalled()
		{
			return _IsInstalled;
		}

		public static void AddBlacklistClone(string value)
		{
			eAddBlacklistClone?.Invoke(null, new object[1] { value });
		}

		static WackyDatabase_API()
		{
			if (Type.GetType("API.WackyAPI, WackysDatabase") == null)
			{
				_IsInstalled = false;
				return;
			}
			Type? type = Type.GetType("API.WackyAPI, WackysDatabase");
			_IsInstalled = true;
			eAddBlacklistClone = type.GetMethod("AddBlacklistClone", BindingFlags.Static | BindingFlags.Public);
		}
	}
	[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
	[<3b2bd33d-f87e-4f02-816f-4bef815516a7>Nullable(0)]
	public static class Professions_API
	{
		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(0)]
		private enum API_State
		{
			NotReady,
			NotInstalled,
			Ready
		}

		private static API_State state = API_State.NotReady;

		private static GameObject mShowProfessions;

		private static MethodInfo mUpdateSelected;

		private static MethodInfo mRequestServerTime;

		private static bool firstOpen = true;

		public static bool IsInstalled()
		{
			Init();
			return state == API_State.Ready;
		}

		public static void showProfessions()
		{
			Init();
			if (state == API_State.Ready)
			{
				if (!Object.op_Implicit((Object)(object)mShowProfessions))
				{
					forceInit();
				}
				mShowProfessions.SetActive(!mShowProfessions.activeSelf);
				if (mShowProfessions.activeSelf)
				{
					mUpdateSelected.Invoke(null, null);
					mRequestServerTime.Invoke(null, null);
					firstOpen = false;
				}
			}
		}

		private static void Init()
		{
			if (!firstOpen)
			{
				API_State aPI_State = state;
				if ((uint)(aPI_State - 1) <= 1u)
				{
					return;
				}
			}
			if (Type.GetType("Professions.Professions, Professions") == null)
			{
				state = API_State.NotInstalled;
				return;
			}
			state = API_State.Ready;
			Type? type = Type.GetType("Professions.Professions, Professions");
			object? value = AccessTools.Field(type, "professionPanelInstance").GetValue(null);
			mShowProfessions = (GameObject)((value is GameObject) ? value : null);
			mUpdateSelected = type.GetMethod("UpdateSelectPanelSelections", BindingFlags.Static | BindingFlags.NonPublic);
			mRequestServerTime = type.GetMethod("requestServerTime", BindingFlags.Static | BindingFlags.NonPublic);
		}

		private static void forceInit()
		{
			if (Type.GetType("Professions.Professions, Professions") == null)
			{
				state = API_State.NotInstalled;
				return;
			}
			state = API_State.Ready;
			Type? type = Type.GetType("Professions.Professions, Professions");
			object? value = AccessTools.Field(type, "professionPanelInstance").GetValue(null);
			mShowProfessions = (GameObject)((value is GameObject) ? value : null);
			mUpdateSelected = type.GetMethod("UpdateSelectPanelSelections", BindingFlags.Static | BindingFlags.NonPublic);
			mRequestServerTime = type.GetMethod("requestServerTime", BindingFlags.Static | BindingFlags.NonPublic);
		}
	}
}
namespace EpicMMOSystem.Gui
{
	public class Util
	{
		[<2507ed2f-d1a8-45b5-b44c-6d44143fc8d0>NullableContext(1)]
		public static void FloatingText(string text, string text2 = null)
		{
			//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_0030: 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_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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: 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_0084: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: 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_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: 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_00e8: Expected O, but got Unknown
			//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_0139: 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_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			float num = Random.Range(1.2f, 1.6f);
			float num2 = Random.Range(1.2f, 1.6f);
			WorldTextInstance val = new WorldTextInstance
			{
				m_worldPos = ((Component)Player.m_localPlayer).transform.position + ((Component)Player.m_localPlayer).transform.right * num + Vector3.up * num2,
				m_gui = Object.Instantiate<GameObject>(DamageText.instance.m_worldTextBase, ((Component)DamageText.instance).transform)
			};
			WorldTextInstance val2 = new WorldTextInstance
			{
				m_worldPos = ((Component)Player.m_localPlayer).transform.position + ((Component)Player.m_localPlayer).transform.right * num + Vector3.up * num2,
				m_gui = Object.Instantiate<GameObject>(DamageText.instance.m_worldTextBase, ((Component)DamageText.instance).transform)
			};
			RectTransform component = val.m_gui.GetComponent<RectTransform>();
			component.sizeDelta *= 2f;
			val.m_textField = val.m_gui.GetComponent<TMP_Text>();
			DamageText.instance.m_worldTexts.Add(val);
			val.m_textField.fontSize = 30f;
			Color yellow = Color.yellow;
			if (ColorUtility.TryParseHtmlString(EpicMMOSystem.XPColor.Value, ref yellow))
			{
				((Graphic)val.m_textField).color = yellow;
			}
			val.m_textField.text = text;
			val.m_timer = -1f;
			if (text2 != null)
			{
				RectTransform component2 = val2.m_gui.GetComponent<RectTransform>();
				component2.sizeDelta *= 2f;
				val2.m_textField = val2.m_gui.GetComponent<TMP_Text>();
				val2.m_worldPos += new Vector3(0f, 5f, 0f);
				DamageText.instance.m_worldTexts.Add(val2);
				val2.m_textField.fontSize = 20f;
				((Graphic)val.m_textField).color = Color.blue;
				val2.m_textField.text = text2;
				val2.m_timer = -1f;
			}
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[<50be0538-6066-4213-922c-d3ae6b70d94a>Embedded]
	[CompilerGenerated]
	internal sealed class <50be0538-6066-4213-922c-d3ae6b70d94a>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[<50be0538-6066-4213-922c-d3ae6b70d94a>Embedded]
	[CompilerGenerated]
	internal sealed class <818acac2-0580-4a59-90c1-7d988c23d156>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <818acac2-0580-4a59-90c1-7d988c23d156>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <818acac2-0580-4a59-90c1-7d988c23d156>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[<50be0538-6066-4213-922c-d3ae6b70d94a>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class <d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[<50be0538-6066-4213-922c-d3ae6b70d94a>Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	internal sealed class <b4405fc7-f135-4c7a-bb54-b4d9cba53533>RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public <b4405fc7-f135-4c7a-bb54-b4d9cba53533>RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ServerSync
{
	[PublicAPI]
	[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(0)]
	[<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(1)]
	internal abstract class OwnConfigEntryBase
	{
		[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)]
		public object LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(1)]
	[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(0)]
	[PublicAPI]
	internal class SyncedConfigEntry<[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)] 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;
			}
		}
	}
	[<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(2)]
	[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(0)]
	internal abstract class CustomSyncedValueBase
	{
		public object LocalBaseValue;

		[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(1)]
		public readonly string Identifier;

		[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(1)]
		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;

		[<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(1)]
		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;
			};
		}
	}
	[<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(1)]
	[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(0)]
	[PublicAPI]
	internal sealed class CustomSyncedValue<[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)] 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;
	}
	[<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(1)]
	[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(0)]
	[PublicAPI]
	internal class ConfigSync
	{
		[<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)]
		[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
		private static class SnatchCurrentlyHandlingRPC
		{
			[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)]
			public static ZRpc currentRpc;

			[HarmonyPrefix]
			[<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(1)]
			private static void Prefix(ZRpc __instance)
			{
				currentRpc = __instance;
			}
		}

		[HarmonyPatch(typeof(ZNet), "Awake")]
		[<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)]
		internal static class RegisterRPCPatch
		{
			[HarmonyPostfix]
			[<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(1)]
			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());
				}
				[<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(1)]
				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));
					}
				}
				[<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(1)]
				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")]
		[<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)]
		private static class RegisterClientRPCPatch
		{
			[HarmonyPostfix]
			[<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(1)]
			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);
				}
			}
		}

		[<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)]
		private class ParsedConfigs
		{
			[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(new byte[] { 1, 1, 2 })]
			public readonly Dictionary<OwnConfigEntryBase, object> configValues = new Dictionary<OwnConfigEntryBase, object>();

			[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(new byte[] { 1, 1, 2 })]
			public readonly Dictionary<CustomSyncedValueBase, object> customValues = new Dictionary<CustomSyncedValueBase, object>();
		}

		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		[<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)]
		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")]
		[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(0)]
		private class SendConfigsAfterLogin
		{
			[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(0)]
			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([<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(new byte[] { 2, 1, 1 })] 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)
			{
				ZNetPeer peer;
				if (__instance.IsServer())
				{
					object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
					peer = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
					if (peer == null)
					{
						SendBufferedData();
					}
					else
					{
						((MonoBehaviour)__instance).StartCoroutine(sendAsync());
					}
				}
				void SendBufferedData()
				{
					if (rpc.GetSocket() is BufferingSocket bufferingSocket)
					{
						AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket.Original);
						object? obj2 = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
						ZNetPeer val = (ZNetPeer)((obj2 is ZNetPeer) ? obj2 : null);
						if (val != null)
						{
							AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, bufferingSocket.Original);
						}
					}
					BufferingSocket bufferingSocket2 = __state[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(rpc.GetSocket().GetHostName())) : listContainsId.Invoke(ZNet.instance, new object[2]
							{
								adminList,
								rpc.GetSocket().GetHostName()
							}))
						});
						ZPackage package = ConfigsToPackage(configSync.allConfigs.Select([<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)] (OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, entries, partial: false);
						yield return ((MonoBehaviour)__instance).StartCoroutine(configSync.sendZPackage(new List<ZNetPeer> { peer }, package));
					}
					SendBufferedData();
				}
			}
		}

		[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(0)]
		private class PackageEntry
		{
			public string section = null;

			public string key = null;

			public Type type = null;

			[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)]
			public object value;
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
		[<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)]
		private static class PreventSavingServerInfo
		{
			[<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(1)]
			[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")]
		[<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)]
		private static class PreventConfigRereadChangingValues
		{
			[<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(1)]
			[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;
			}
		}

		[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(0)]
		private class InvalidDeserializationTypeException : Exception
		{
			public string expected = null;

			public string received = null;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)]
		public string DisplayName;

		[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)]
		public string CurrentVersion;

		[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)]
		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;

		[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)]
		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[]>>();

		[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(new byte[] { 1, 0, 1 })]
		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;


		[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)]
		[method: <d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(2)]
		[field: <818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)]
		public event Action<bool> SourceOfTruthChanged;

		[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)]
		[method: <d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(2)]
		[field: <818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)]
		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<[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)] T>(ConfigEntry<T> configEntry)
		{
			OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)(object)configEntry);
			SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
			if (syncedEntry == null)
			{
				syncedEntry = new SyncedConfigEntry<T>(configEntry);
				AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(((ConfigEntryBase)configEntry).Description, new object[1]
				{
					new ConfigurationManagerAttributes()
				}.Concat(((ConfigEntryBase)configEntry).Description.Tags ?? Array.Empty<object>()).Concat(new SyncedConfigEntry<T>[1] { syncedEntry }).ToArray());
				configEntry.SettingChanged += [<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)] (object _, EventArgs _) =>
				{
					if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
					{
						Broadcast(ZRoutedRpc.Everybody, (ConfigEntryBase)configEntry);
					}
				};
				allConfigs.Add(syncedEntry);
			}
			return syncedEntry;
		}

		public SyncedConfigEntry<T> AddLockingConfigEntry<[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(0)] T>(ConfigEntry<T> lockingConfig) where T : IConvertible
		{
			if (lockedConfig != null)
			{
				throw new Exception("Cannot initialize locking ConfigEntry twice");
			}
			lockedConfig = AddConfigEntry<T>(lockingConfig);
			lockingConfig.SettingChanged += [<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)] (object _, EventArgs _) =>
			{
				this.lockedConfigChanged?.Invoke();
			};
			return (SyncedConfigEntry<T>)lockedConfig;
		}

		internal void AddCustomValue(CustomSyncedValueBase customValue)
		{
			if (allCustomValues.Select([<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)] (CustomSyncedValueBase v) => v.Identifier).Concat(new string[1] { "serverversion" }).Contains(customValue.Identifier))
			{
				throw new Exception("Cannot have multiple settings with the same name or with a reserved name (serverversion)");
			}
			allCustomValues.Add(customValue);
			allCustomValues = new HashSet<CustomSyncedValueBase>(allCustomValues.OrderByDescending([<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)] (CustomSyncedValueBase v) => v.Priority));
			customValue.ValueChanged += delegate
			{
				if (!ProcessingServerUpdate)
				{
					Broadcast(ZRoutedRpc.Everybody, customValue);
				}
			};
		}

		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(([<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(new byte[] { 0, 1 })] 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 var 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([<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)] (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([<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)] (OwnConfigEntryBase c) => c.SynchronizedConfig).ToDictionary([<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)] (OwnConfigEntryBase c) => c.BaseConfig.Definition.Section + "_" + c.BaseConfig.Definition.Key, [<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)] (OwnConfigEntryBase c) => c);
			Dictionary<string, CustomSyncedValueBase> dictionary2 = allCustomValues.ToDictionary([<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)] (CustomSyncedValueBase c) => c.Identifier, [<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)] (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)
		{
			ConfigSync configSync = configSyncs.FirstOrDefault([<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)] (ConfigSync cs) => cs.allConfigs.Contains(config));
			if (configSync == null)
			{
				return true;
			}
			return configSync.IsSourceOfTruth || !config.SynchronizedConfig || config.LocalBaseValue == null || (!configSync.IsLocked && (config != 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([<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)] (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([<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)] (CustomSyncedValueBase config) => config.LocalBaseValue != null))
			{
				item2.BoxedValue = item2.LocalBaseValue;
				item2.LocalBaseValue = null;
			}
			lockedConfigChanged -= serverLockedSettingChanged;
			serverLockedSettingChanged();
		}

		private IEnumerator<bool> distributeConfigToPeers(ZNetPeer peer, ZPackage package)
		{
			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 (peer.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)
				{
					peer.m_rpc.Invoke(text, new object[1] { pkg });
				}
				else
				{
					rpc.InvokeRoutedRPC(peer.m_server ? 0 : peer.m_uid, text, new object[1] { pkg });
				}
			}
			IEnumerable<bool> waitForQueue()
			{
				float timeout = Time.time + 30f;
				while (peer.m_socket.GetSendQueueSize() > 20000)
				{
					if (Time.time > timeout)
					{
						Debug.Log((object)$"Disconnecting {peer.m_uid} after 30 seconds config sending timeout");
						peer.m_rpc.Invoke("Error", new object[1] { (object)(ConnectionStatus)5 });
						ZNet.instance.Disconnect(peer);
						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([<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)] (ZNetPeer p) => p.m_uid == target).ToList();
			}
			return sendZPackage(list, package);
		}

		private IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				yield break;
			}
			byte[] rawData = package.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());
				package = compressedPackage;
			}
			List<IEnumerator<bool>> writers = (from peer in peers
				where peer.IsReady()
				select peer into p
				select distributeConfigToPeers(p, package)).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));
				}
			}
		}

		[return: <818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)]
		private static OwnConfigEntryBase configData(ConfigEntryBase config)
		{
			return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
		}

		[return: <818acac2-0580-4a59-90c1-7d988c23d156>Nullable(new byte[] { 2, 1 })]
		public static SyncedConfigEntry<T> ConfigData<[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)] T>(ConfigEntry<T> config)
		{
			return ((ConfigEntryBase)config).Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
		}

		private static T configAttribute<[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)] 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([<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(new byte[] { 2, 1 })] IEnumerable<ConfigEntryBase> configs = null, [<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(new byte[] { 2, 1 })] IEnumerable<CustomSyncedValueBase> customValues = null, [<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(new byte[] { 2, 1 })] 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([<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)] (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, [<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)] 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();
		}
	}
	[<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(1)]
	[PublicAPI]
	[HarmonyPatch]
	[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(0)]
	internal class VersionCheck
	{
		private static readonly HashSet<VersionCheck> versionChecks;

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)]
		private string displayName;

		[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)]
		private string currentVersion;

		[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)]
		private string minimumRequiredVersion;

		public bool ModRequired = true;

		[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)]
		private string ReceivedCurrentVersion;

		[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)]
		private string ReceivedMinimumRequiredVersion;

		private readonly List<ZRpc> ValidatedClients = new List<ZRpc>();

		[<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)]
		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([<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)] (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([<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(2)] ZRpc rpc = null)
		{
			return (rpc == null) ? ErrorClient() : ErrorServer(rpc);
		}

		private static VersionCheck[] GetFailedClient()
		{
			return versionChecks.Where([<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)] (VersionCheck check) => !check.IsVersionOk()).ToArray();
		}

		private static VersionCheck[] GetFailedServer(ZRpc rpc)
		{
			return versionChecks.Where([<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)] (VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc)).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, [<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(new byte[] { 2, 1, 1 })] 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);
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		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;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		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>)([<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)] (ZRpc rpc, [<818acac2-0580-4a59-90c1-7d988c23d156>Nullable(1)] 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);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
		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([<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)] (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([<d4712d07-adb0-41d4-9b5a-a2a786742025>NullableContext(0)] (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>);
			}
		}
	}
	internal sealed class DatasetSchema
	{
		public List<string> Info;

		public string Name;
	}
	internal 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();
		}
	}
	internal 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('"');
		}
	}
	internal 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
			};
		}
	}
	internal 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);
		}
	}
	internal struct Getters
	{
		public string Name;

		public string lcName;

		public string memberName;

		public Reflection.GenericGetter Getter;

		public bool ReadOnly;
	}
	internal enum myPropInfoType
	{
		Int,
		Long,
		String,
		Bool,
		DateTime,
		Enum,
		Guid,
		Array,
		ByteArray,
		Dictionary,
		StringKeyDictionary,
		NameValue,
		StringDictionary,
		Hashtable,
		DataSet,
		DataTable,
		Custom,
		Unknown
	}
	internal 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;
	}
	internal 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);
		}
	}
	internal 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);
		}
	}
	internal 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 Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<63084356-04d4-424a-9762-d61f9c79fbbe>Embedded]
	internal sealed class <63084356-04d4-424a-9762-d61f9c79fbbe>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[<63084356-04d4-424a-9762-d61f9c79fbbe>Embedded]
	[CompilerGenerated]
	internal sealed class <19f229ea-700e-4241-b7dc-3f435183fe31>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <19f229ea-700e-4241-b7dc-3f435183fe31>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <19f229ea-700e-4241-b7dc-3f435183fe31>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[<63084356-04d4-424a-9762-d61f9c79fbbe>Embedded]
	[CompilerGenerated]
	internal sealed class <fe71c8ff-2e6c-4da0-9f05-e8794a5cfea4>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <fe71c8ff-2e6c-4da0-9f05-e8794a5cfea4>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace Groups
{
	[PublicAPI]
	[<19f229ea-700e-4241-b7dc-3f435183fe31>Nullable(0)]
	[<fe71c8ff-2e6c-4da0-9f05-e8794a5cfea4>NullableContext(2)]
	internal class API
	{
		public static event Action joinedGroup;

		public static event Action leftGroup;

		public static event Action<PlayerReference> memberJoined;

		public static event Action<PlayerReference> memberLeft;

		public static event Action<PlayerReference> leaderChanged;

		[<19f229ea-700e-4241-b7dc-3f435183fe31>Nullable(new byte[] { 2, 1 })]
		[method: <19f229ea-700e-4241-b7dc-3f435183fe31>Nullable(new byte[] { 2, 1 })]
		[field: <19f229ea-700e-4241-b7dc-3f435183fe31>Nullable(new byte[] { 2, 1 })]
		public static event Action<PlayerReference, GameObject> invitationReceived;

		[<19f229ea-700e-4241-b7dc-3f435183fe31>Nullable(new byte[] { 2, 1 })]
		[method: <19f229ea-700e-4241-b7dc-3f435183fe31>Nullable(new byte[] { 2, 1 })]
		[field: <19f229ea-700e-4241-b7dc-3f435183fe31>Nullable(new byte[] { 2, 1 })]
		public static event Action<PlayerReference, GameObject> uiUpdate;

		internal static void InvokeGroupJoined()
		{
			API.joinedGroup?.Invoke();
		}

		internal static void InvokeGroupLeft()
		{
			API.leftGroup?.Invoke();
		}

		internal static void InvokeMemberJoined(PlayerReference player)
		{
			API.memberJoined?.Invoke(player);
		}

		internal static void InvokeMemberLeft(PlayerReference player)
		{
			API.memberLeft?.Invoke(player);
		}

		internal static void InvokeLeaderChanged(PlayerReference player)
		{
			API.leaderChanged?.Invoke(player);
		}

		[<fe71c8ff-2e6c-4da0-9f05-e8794a5cfea4>NullableContext(1)]
		internal static void InvokeInvitationReceived(PlayerReference player, GameObject invitationDialog)
		{
			API.invitationReceived?.Invoke(player, invitationDialog);
		}

		[<fe71c8ff-2e6c-4da0-9f05-e8794a5cfea4>NullableContext(1)]
		internal static void InvokeUIUpdate(PlayerReference player, GameObject playerRoot)
		{
			API.uiUpdate?.Invoke(player, playerRoot);
		}

		public static bool IsLoaded()
		{
			return false;
		}

		public static int GetMaxGroupSize()
		{
			return 0;
		}

		[<fe71c8ff-2e6c-4da0-9f05-e8794a5cfea4>NullableContext(1)]
		public static List<PlayerReference> GroupPlayers()
		{
			return new List<PlayerReference>();
		}

		public static PlayerReference? GetLeader()
		{
			return null;
		}

		public static bool CreateNewGroup()
		{
			return false;
		}

		[<fe71c8ff-2e6c-4da0-9f05-e8794a5cfea4>NullableContext(1)]
		public static bool WriteToGroup(string message)
		{
			return false;
		}

		public static bool LeaveGroup()
		{
			return false;
		}

		public static bool JoinGroup(PlayerReference targetPlayer)
		{
			return false;
		}

		public static bool PromoteToLeader(PlayerReference groupMember)
		{
			return false;
		}

		public static bool ForcePlayerIntoOwnGroup(PlayerReference targetPlayer)
		{
			return false;
		}

		public static PlayerReference? FindGroupMemberByPlayerId(long playerId)
		{
			if (playerId == Game.instance.m_playerProfile.GetPlayerID())
			{
				return PlayerReference.fromPlayerId(ZDOMan.GetSessionID());
			}
			return null;
		}
	}
	[<19f229ea-700e-4241-b7dc-3f435183fe31>Nullable(0)]
	[PublicAPI]
	[<fe71c8ff-2e6c-4da0-9f05-e8794a5cfea4>NullableContext(1)]
	internal struct PlayerReference
	{
		public long peerId;

		public string name;

		public static PlayerReference fromPlayerId(long id)
		{
			return ZNet.instance.m_players.Where((PlayerInfo p) => ((ZDOID)(ref p.m_characterID)).UserID == id).Select(fromPlayerInfo).FirstOrDefault();
		}

		public static PlayerReference fromPlayerInfo(PlayerInfo playerInfo)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			PlayerReference result = default(PlayerReference);
			result.peerId = ((ZDOID)(ref playerInfo.m_characterID)).UserID;
			result.name = playerInfo.m_name ?? "";
			return result;
		}

		public static PlayerReference fromPlayer(Player player)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)player == (Object)(object)Player.m_localPlayer))
			{
				return fromPlayerInfo(((IEnumerable<PlayerInfo>)ZNet.instance.m_players).FirstOrDefault((Func<PlayerInfo, bool>)((PlayerInfo info) => info.m_characterID == ((Character)player).GetZDOID())));
			}
			PlayerReference result = default(PlayerReference);
			result.peerId = ZDOMan.GetSessionID();
			result.name = Game.instance.GetPlayerProfile().GetName();
			return result;
		}

		public static bool operator !=(PlayerReference a, PlayerReference b)
		{
			return !(a == b);
		}

		public static bool operator ==(PlayerReference a, PlayerReference b)
		{
			if (a.peerId == b.peerId)
			{
				return a.name == b.name;
			}
			return false;
		}

		public bool Equals(PlayerReference other)
		{
			return this == other;
		}

		[<fe71c8ff-2e6c-4da0-9f05-e8794a5cfea4>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (obj is PlayerReference other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return (peerId.GetHashCode() * 397) ^ (name?.GetHashCode() ?? 0);
		}

		public override string ToString()
		{
			return $"{peerId}:{name}";
		}

		public static PlayerReference fromString(string str)
		{
			string[] array = str.Split(new char[1] { ':' });
			PlayerReference result = default(PlayerReference);
			result.peerId = long.Parse(array[0]);
			result.name = array[1];
			return result;
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[<112b52fc-385e-4422-8766-76e3d2c67965>Embedded]
	[CompilerGenerated]
	internal sealed class <112b52fc-385e-4422-8766-76e3d2c67965>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[<112b52fc-385e-4422-8766-76e3d2c67965>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class <1bfc4759-c5a6-4eb1-bee9-a1d0c5c59449>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <1bfc4759-c5a6-4eb1-bee9-a1d0c5c59449>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <1bfc4759-c5a6-4eb1-bee9-a1d0c5c59449>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[<112b52fc-385e-4422-8766-76e3d2c67965>Embedded]
	[CompilerGenerated]
	internal sealed class <79594173-e941-4ad9-973e-713c0d41eb0b>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <79594173-e941-4ad9-973e-713c0d41eb0b>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	[<112b52fc-385e-4422-8766-76e3d2c67965>Embedded]
	[CompilerGenerated]
	internal sealed class <581ace1b-ccf7-47af-9e92-0db546ef9c78>RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public <581ace1b-ccf7-47af-9e92-0db546ef9c78>RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace LocalizationManager
{
	[PublicAPI]
	[<79594173-e941-4ad9-973e-713c0d41eb0b>NullableContext(1)]
	[<1bfc4759-c5a6-4eb1-bee9-a1d0c5c59449>Nullable(0)]
	internal class Localizer
	{
		private static readonly Dictionary<string, Dictionary<string, Func<string>>> PlaceholderProcessors;

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

		private static readonly ConditionalWeakTable<Localization, string> localizationLanguage;

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

		[<1bfc4759-c5a6-4eb1-bee9-a1d0c5c59449>Nullable(2)]
		private static BaseUnityPlugin _plugin;

		private static readonly List<string> fileExtensions;

		private static BaseUnityPlugin plugin
		{
			get
			{
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: 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([<79594173-e941-4ad9-973e-713c0d41eb0b>NullableContext(0)] (TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
				}
				return _plugin;
			}
		}

		[<1bfc4759-c5a6-4eb1-bee9-a1d0c5c59449>Nullable(2)]
		[method: <79594173-e941-4ad9-973e-713c0d41eb0b>NullableContext(2)]
		[field: <1bfc4759-c5a6-4eb1-bee9-a1d0c5c59449>Nullable(2)]
		public static event Action OnLocalizationComplete;

		private static void UpdatePlaceholderText(Localization localization, string key)
		{
			localizationLanguage.TryGetValue(localization, out var value);
			string text = loadedTexts[value][key];
			if (PlaceholderProcessors.TryGetValue(key, out var value2))
			{
				text = value2.Aggregate(text, [<79594173-e941-4ad9-973e-713c0d41eb0b>NullableContext(0)] (string current, KeyValuePair<string, Func<string>> kv) => current.Replace("{" + kv.Key + "}", kv.Value()));
			}
			localization.AddWord(key, text);
		}

		public static void AddPlaceholder<T>(string key, string placeholder, ConfigEntry<T> config, [<1bfc4759-c5a6-4eb1-bee9-a1d0c5c59449>Nullable(new byte[] { 2, 1, 1 })] Func<T, string> convertConfigValue = null)
		{
			if (convertConfigValue == null)
			{
				convertConfigValue = (T val) => val.ToString();
			}
			if (!PlaceholderProcessors.ContainsKey(key))
			{
				PlaceholderProcessors[key] = new Dictionary<string, Func<string>>();
			}
			config.SettingChanged += [<79594173-e941-4ad9-973e-713c0d41eb0b>NullableContext(0)] (object _, EventArgs _) =>
			{
				UpdatePlaceholder();
			};
			if (loadedTexts.ContainsKey(Localization.instance.GetSelectedLanguage()))
			{
				UpdatePlaceholder();
			}
			void UpdatePlaceholder()
			{
				PlaceholderProcessors[key][placeholder] = () => convertConfigValue(config.Value);
				UpdatePlaceholderText(Localization.instance, key);
			}
		}

		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))
				{
					Dictionary<string, string> dictionary = loadedTexts[localizationLanguage.GetOrCreateValue(target)];
					if (!target.m_translations.ContainsKey(key))
					{
						dictionary[key] = text;
						target.AddWord(key, text);
					}
				}
				else
				{
					list.Add(localizationObject);
				}
			}
			foreach (WeakReference<Localization> item in list)
			{
				localizationObjects.Remove(item);
			}
		}

		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);
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			foreach (string item in from f in Directory.GetFiles(Path.GetDirectoryName(Paths.PluginPath), plugin.Info.Metadata.Name + ".*", SearchOption.AllDirectories)
				where fileExtensions.IndexOf(Path.GetExtension(f)) >= 0
				select f)
			{
				string text = Path.GetFileNameWithoutExtension(item).Split(new char[1] { '.' })[1];
				if (dictionary.ContainsKey(text))
				{
					Debug.LogWarning((object)("Duplicate key " + text + " found for " + plugin.Info.Metadata.Name + ". The duplicate file found at " + item + " will be skipped."));
				}
				else
				{
					dictionary[text] = item;
				}
			}
			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> dictionary2 = new <09e33b7f-b9e8-4527-b231-a587d3f3164d>DeserializerBuilder().IgnoreFields().Build().Deserialize<Dictionary<string, string>>(Encoding.UTF8.GetString(array));
			if (dictionary2 == null)
			{
				throw new Exception("Localization for mod " + plugin.Info.Metadata.Name + " failed: Localization file was empty.");
			}
			string text2 = null;
			if (language != "English")
			{
				if (dictionary.TryGetValue(language, out var value))
				{
					text2 = File.ReadAllText(value);
				}
				else
				{
					byte[] array2 = LoadTranslationFromAssembly(language);
					if (array2 != null)
					{
						text2 = Encoding.UTF8.GetString(array2);
					}
				}
			}
			if (text2 == null && dictionary.TryGetValue("English", out var value2))
			{
				text2 = File.ReadAllText(value2);
			}
			if (text2 != null)
			{
				foreach (KeyValuePair<string, string> item2 in new <09e33b7f-b9e8-4527-b231-a587d3f3164d>DeserializerBuilder().IgnoreFields().Build().Deserialize<Dictionary<string, string>>(text2) ?? new Dictionary<string, string>())
				{
					dictionary2[item2.Key] = item2.Value;
				}
			}
			loadedTexts[language] = dictionary2;
			foreach (KeyValuePair<string, string> item3 in dictionary2)
			{
				UpdatePlaceholderText(__instance, item3.Key);
			}
		}

		static Localizer()
		{
			//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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected O, but got Unknown
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Expected O, but got Unknown
			PlaceholderProcessors = new Dictionary<string, Dictionary<string, Func<string>>>();
			loadedTexts = new Dictionary<string, Dictionary<string, string>>();
			localizationLanguage = new ConditionalWeakTable<Localization, string>();
			localizationObjects = new List<WeakReference<Localization>>();
			fileExtensions = new List<string>(2) { ".json", ".yml" };
			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);
		}

		[return: <1bfc4759-c5a6-4eb1-bee9-a1d0c5c59449>Nullable(2)]
		private static byte[] LoadTranslationFromAssembly(string language)
		{
			foreach (string fileExtension in fileExtensions)
			{
				byte[] array = ReadEmbeddedFileBytes("translations." + language + fileExtension);
				if (array != null)
				{
					return array;
				}
			}
			return null;
		}

		[<79594173-e941-4ad9-973e-713c0d41eb0b>NullableContext(2)]
		public static byte[] ReadEmbeddedFileBytes([<1bfc4759-c5a6-4eb1-bee9-a1d0c5c59449>Nullable(1)] string resourceFileName, Assembly containingAssembly = null)
		{
			using MemoryStream memoryStream = new MemoryStream();
			if ((object)containingAssembly == null)
			{
				containingAssembly = Assembly.GetCallingAssembly();
			}
			string text = containingAssembly.GetManifestResourceNames().FirstOrDefault([<79594173-e941-4ad9-973e-713c0d41eb0b>NullableContext(0)] (string str) => str.EndsWith(resourceFileName, StringComparison.Ordinal));
			if (text != null)
			{
				containingAssembly.GetManifestResourceStream(text)?.CopyTo(memoryStream);
			}
			return (memoryStream.Length == 0L) ? null : memoryStream.ToArray();
		}
	}
	internal static class LocalizationManagerVersion
	{
		[<1bfc4759-c5a6-4eb1-bee9-a1d0c5c59449>Nullable(1)]
		public const string Version = "1.4.0";
	}
}
namespace Microsoft.CodeAnalysis
{
	[<baca5936-4706-46d4-a379-b51972831ac6>Embedded]
	[CompilerGenerated]
	internal sealed class <baca5936-4706-46d4-a379-b51972831ac6>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	[<baca5936-4706-46d4-a379-b51972831ac6>Embedded]
	internal sealed class <928a8975-a5bb-4379-8af9-f23309a66ace>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <928a8975-a5bb-4379-8af9-f23309a66ace>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <928a8975-a5bb-4379-8af9-f23309a66ace>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[<baca5936-4706-46d4-a379-b51972831ac6>Embedded]
	internal sealed class <0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	internal sealed class <0ef66e9f-f8f2-4d34-9dcc-35996d168209>AllowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	internal sealed class <79d4181f-eb6c-42df-a707-5613c0fad41c>DisallowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	internal sealed class <90aade56-45d7-4d87-9404-08f5e964175b>DoesNotReturnAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class <de6ce45e-d980-4223-a2f5-c6c48e07e2ab>DoesNotReturnIfAttribute : Attribute
	{
		public bool ParameterValue { get; }

		public <de6ce45e-d980-4223-a2f5-c6c48e07e2ab>DoesNotReturnIfAttribute(bool parameterValue)
		{
			ParameterValue = parameterValue;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	internal sealed class <b74b0580-53ad-40e3-9124-0c9200762bdf>MaybeNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class <b3ae408d-452a-47a4-a4cd-28743506c159>MaybeNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public <b3ae408d-452a-47a4-a4cd-28743506c159>MaybeNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	internal sealed class <b7b22442-9c94-4ab5-88ea-6611fcb5ad91>NotNullAttribute : Attribute
	{
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <2c695bc9-954c-4557-9eb2-68662412c4cc>NotNullIfNotNullAttribute : Attribute
	{
		public string ParameterName { get; }

		public <2c695bc9-954c-4557-9eb2-68662412c4cc>NotNullIfNotNullAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class <3ce10464-8c9e-4f9f-b9c2-e0d3e385de9a>NotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public <3ce10464-8c9e-4f9f-b9c2-e0d3e385de9a>NotNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
}
namespace System.Collections.Generic
{
	internal static class <a2cb941c-8ec0-4cb2-89e0-8323aa72a1d3>DeconstructionExtensions
	{
		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public static void Deconstruct<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TKey, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TValue>([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 0, 1, 1 })] this KeyValuePair<TKey, TValue> pair, out TKey key, out TValue value)
		{
			key = pair.Key;
			value = pair.Value;
		}
	}
}
namespace YamlDotNet
{
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <8d67ac96-8305-4788-9f4a-0e3d502e85e6>CultureInfoAdapter : CultureInfo
	{
		private readonly IFormatProvider provider;

		public <8d67ac96-8305-4788-9f4a-0e3d502e85e6>CultureInfoAdapter(CultureInfo baseCulture, IFormatProvider provider)
			: base(baseCulture.LCID)
		{
			this.provider = provider;
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
		public override object GetFormat(Type formatType)
		{
			return provider.GetFormat(formatType);
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal static class <acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		private static readonly FieldInfo RemoteStackTraceField = typeof(Exception).GetField("_remoteStackTraceString", BindingFlags.Instance | BindingFlags.NonPublic);

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public static Type BaseType(this Type type)
		{
			return type.BaseType;
		}

		public static bool IsValueType(this Type type)
		{
			return type.IsValueType;
		}

		public static bool IsGenericType(this Type type)
		{
			return type.IsGenericType;
		}

		public static bool IsGenericTypeDefinition(this Type type)
		{
			return type.IsGenericTypeDefinition;
		}

		public static bool IsInterface(this Type type)
		{
			return type.IsInterface;
		}

		public static bool IsEnum(this Type type)
		{
			return type.IsEnum;
		}

		public static bool IsDbNull(this object value)
		{
			return value is DBNull;
		}

		public static bool HasDefaultConstructor(this Type type)
		{
			if (!type.IsValueType)
			{
				return type.GetConstructor(BindingFlags.Instance | BindingFlags.Public, null, Type.EmptyTypes, null) != null;
			}
			return true;
		}

		public static TypeCode GetTypeCode(this Type type)
		{
			return Type.GetTypeCode(type);
		}

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public static PropertyInfo GetPublicProperty(this Type type, string name)
		{
			return type.GetProperty(name);
		}

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public static FieldInfo GetPublicStaticField(this Type type, string name)
		{
			return type.GetField(name, BindingFlags.Static | BindingFlags.Public);
		}

		public static IEnumerable<PropertyInfo> GetProperties(this Type type, bool includeNonPublic)
		{
			BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public;
			if (includeNonPublic)
			{
				bindingFlags |= BindingFlags.NonPublic;
			}
			if (!type.IsInterface)
			{
				return type.GetProperties(bindingFlags);
			}
			return new Type[1] { type }.Concat(type.GetInterfaces()).SelectMany([<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] (Type i) => i.GetProperties(bindingFlags));
		}

		public static IEnumerable<PropertyInfo> GetPublicProperties(this Type type)
		{
			return GetProperties(type, includeNonPublic: false);
		}

		public static IEnumerable<FieldInfo> GetPublicFields(this Type type)
		{
			return type.GetFields(BindingFlags.Instance | BindingFlags.Public);
		}

		public static IEnumerable<MethodInfo> GetPublicStaticMethods(this Type type)
		{
			return type.GetMethods(BindingFlags.Static | BindingFlags.Public);
		}

		public static MethodInfo GetPrivateStaticMethod(this Type type, string name)
		{
			return type.GetMethod(name, BindingFlags.Static | BindingFlags.NonPublic) ?? throw new MissingMethodException("Expected to find a method named '" + name + "' in '" + type.FullName + "'.");
		}

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public static MethodInfo GetPublicStaticMethod(this Type type, string name, params Type[] parameterTypes)
		{
			return type.GetMethod(name, BindingFlags.Static | BindingFlags.Public, null, parameterTypes, null);
		}

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public static MethodInfo GetPublicInstanceMethod(this Type type, string name)
		{
			return type.GetMethod(name, BindingFlags.Instance | BindingFlags.Public);
		}

		public static Exception Unwrap(this TargetInvocationException ex)
		{
			Exception innerException = ex.InnerException;
			if (innerException == null)
			{
				return ex;
			}
			if (RemoteStackTraceField != null)
			{
				RemoteStackTraceField.SetValue(innerException, innerException.StackTrace + "\r\n");
			}
			return innerException;
		}

		public static bool IsInstanceOf(this Type type, object o)
		{
			return type.IsInstanceOfType(o);
		}

		public static Attribute[] GetAllCustomAttributes<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TAttribute>(this PropertyInfo property)
		{
			return Attribute.GetCustomAttributes(property, typeof(TAttribute));
		}
	}
	internal static class <c9696b4d-ea07-415b-aef8-257468acf22c>PropertyInfoExtensions
	{
		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public static object ReadValue(this PropertyInfo property, object target)
		{
			return property.GetValue(target, null);
		}
	}
	internal static class <f84b0dc1-29fc-4418-9205-163f41df52ea>StandardRegexOptions
	{
		public const RegexOptions Compiled = RegexOptions.Compiled;
	}
}
namespace YamlDotNet.Serialization
{
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal abstract class <fb6a88d4-c53e-4466-8d30-1fe3973b5ec5>BuilderSkeleton<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] TBuilder> where TBuilder : <fb6a88d4-c53e-4466-8d30-1fe3973b5ec5>BuilderSkeleton<TBuilder>
	{
		internal <2282eb5c-6849-4bd4-9f7d-f9cba43dc317>INamingConvention namingConvention = <b7f3b459-c7ee-4e45-a5a4-df1e39b37601>NullNamingConvention.Instance;

		internal <a0cad0d5-d219-4360-a990-d287fb745b59>ITypeResolver typeResolver;

		internal readonly <698cfdd6-bb84-41bf-9c32-581dc9d8f35c>YamlAttributeOverrides overrides;

		internal readonly <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing, <d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> typeConverterFactories;

		internal readonly <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector, <c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector> typeInspectorFactories;

		private bool ignoreFields;

		private bool includeNonPublicProperties;

		protected abstract TBuilder Self { get; }

		internal <fb6a88d4-c53e-4466-8d30-1fe3973b5ec5>BuilderSkeleton(<a0cad0d5-d219-4360-a990-d287fb745b59>ITypeResolver typeResolver)
		{
			overrides = new <698cfdd6-bb84-41bf-9c32-581dc9d8f35c>YamlAttributeOverrides();
			typeConverterFactories = new <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing, <d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter>
			{
				{
					typeof(<089ccd08-703f-46c5-9096-8e9c6c6e1322>GuidConverter),
					(<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing _) => new <089ccd08-703f-46c5-9096-8e9c6c6e1322>GuidConverter(jsonCompatible: false)
				},
				{
					typeof(<7eb23e15-084f-40a9-b160-434a3dabedce>SystemTypeConverter),
					(<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing _) => new <7eb23e15-084f-40a9-b160-434a3dabedce>SystemTypeConverter()
				}
			};
			typeInspectorFactories = new <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector, <c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector>();
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
		}

		internal <c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector BuildTypeInspector()
		{
			<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector <c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector2 = new <159aff9c-3798-434e-b82c-443115fbaf81>ReadablePropertiesTypeInspector(typeResolver, includeNonPublicProperties);
			if (!ignoreFields)
			{
				<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector2 = new <f92d4208-2e7f-44b9-8f84-90e8f1cd872e>CompositeTypeInspector(new <1bccea63-99dc-4dae-8fa1-69fd1b6eb7d6>ReadableFieldsTypeInspector(typeResolver), <c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector2);
			}
			return typeInspectorFactories.BuildComponentChain(<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector2);
		}

		public TBuilder IgnoreFields()
		{
			ignoreFields = true;
			return Self;
		}

		public TBuilder IncludeNonPublicProperties()
		{
			includeNonPublicProperties = true;
			return Self;
		}

		public TBuilder WithNamingConvention(<2282eb5c-6849-4bd4-9f7d-f9cba43dc317>INamingConvention namingConvention)
		{
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
			return Self;
		}

		public TBuilder WithTypeResolver(<a0cad0d5-d219-4360-a990-d287fb745b59>ITypeResolver typeResolver)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			return Self;
		}

		public abstract TBuilder WithTagMapping(<9b965c76-e42b-4be8-b468-b7eefab6d624>TagName tag, Type type);

		public TBuilder WithAttributeOverride<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] 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(<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter typeConverter)
		{
			return WithTypeConverter(typeConverter, delegate(<da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeConverter(<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter typeConverter, Action<<da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter>> where)
		{
			if (typeConverter == null)
			{
				throw new ArgumentNullException("typeConverter");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter.GetType(), (<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing _) => typeConverter));
			return Self;
		}

		public TBuilder WithTypeConverter<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] TYamlTypeConverter>(<abcc739a-3cd5-4a0d-8a88-9cfef1aa4e82>WrapperFactory<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter, <d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> typeConverterFactory, Action<<076c1b1b-cf5e-43de-aa04-fbe8d6feb0e4>ITrackingRegistrationLocationSelectionSyntax<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter>> where) where TYamlTypeConverter : <d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter
		{
			if (typeConverterFactory == null)
			{
				throw new ArgumentNullException("typeConverterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter wrapped, <56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing _) => typeConverterFactory(wrapped)));
			return Self;
		}

		public TBuilder WithoutTypeConverter<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] TYamlTypeConverter>() where TYamlTypeConverter : <d0dabece-5cfd-403b-809a-d405b26a97c8>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<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] TTypeInspector>(Func<<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : <c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector
		{
			return WithTypeInspector(typeInspectorFactory, delegate(<da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeInspector<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] TTypeInspector>(Func<<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector, TTypeInspector> typeInspectorFactory, Action<<da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector>> where) where TTypeInspector : <c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector
		{
			if (typeInspectorFactory == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector inner) => typeInspectorFactory(inner)));
			return Self;
		}

		public TBuilder WithTypeInspector<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] TTypeInspector>(<05ec3915-2ffa-4099-8b31-c436678cbfa1>WrapperFactory<<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector, <c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector, TTypeInspector> typeInspectorFactory, Action<<076c1b1b-cf5e-43de-aa04-fbe8d6feb0e4>ITrackingRegistrationLocationSelectionSyntax<<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector>> where) where TTypeInspector : <c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector
		{
			if (typeInspectorFactory == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector wrapped, <c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector inner) => typeInspectorFactory(wrapped, inner)));
			return Self;
		}

		public TBuilder WithoutTypeInspector<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] TTypeInspector>() where TTypeInspector : <c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector
		{
			return WithoutTypeInspector(typeof(TTypeInspector));
		}

		public TBuilder WithoutTypeInspector(Type inspectorType)
		{
			if (inspectorType == null)
			{
				throw new ArgumentNullException("inspectorType");
			}
			typeInspectorFactories.Remove(inspectorType);
			return Self;
		}

		protected IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> BuildTypeConverters()
		{
			return typeConverterFactories.BuildComponentList();
		}
	}
	internal delegate TComponent <abcc739a-3cd5-4a0d-8a88-9cfef1aa4e82>WrapperFactory<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TComponentBase, TComponent>(TComponentBase wrapped) where TComponent : TComponentBase;
	internal delegate TComponent <05ec3915-2ffa-4099-8b31-c436678cbfa1>WrapperFactory<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TArgument, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TComponentBase, TComponent>(TComponentBase wrapped, TArgument argument) where TComponent : TComponentBase;
	[Flags]
	internal enum <82c71c17-8813-4fa6-8ba4-ee0247932a58>DefaultValuesHandling
	{
		Preserve = 0,
		OmitNull = 1,
		OmitDefaults = 2,
		OmitEmptyCollections = 4
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <09056b75-4fe4-40d0-99cf-d2b2ebb1010c>Deserializer : <2f525b19-b34f-467d-9bed-f3f6cc4ee768>IDeserializer
	{
		private readonly <59bc90d3-d6d7-4700-894d-caa6cefe9734>IValueDeserializer valueDeserializer;

		public <09056b75-4fe4-40d0-99cf-d2b2ebb1010c>Deserializer()
			: this(new <09e33b7f-b9e8-4527-b231-a587d3f3164d>DeserializerBuilder().BuildValueDeserializer())
		{
		}

		private <09056b75-4fe4-40d0-99cf-d2b2ebb1010c>Deserializer(<59bc90d3-d6d7-4700-894d-caa6cefe9734>IValueDeserializer valueDeserializer)
		{
			this.valueDeserializer = valueDeserializer ?? throw new ArgumentNullException("valueDeserializer");
		}

		public static <09056b75-4fe4-40d0-99cf-d2b2ebb1010c>Deserializer FromValueDeserializer(<59bc90d3-d6d7-4700-894d-caa6cefe9734>IValueDeserializer valueDeserializer)
		{
			return new <09056b75-4fe4-40d0-99cf-d2b2ebb1010c>Deserializer(valueDeserializer);
		}

		public T Deserialize<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] T>(string input)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize<T>(input2);
		}

		public T Deserialize<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] T>(TextReader input)
		{
			return Deserialize<T>(new <7af46315-d2cb-4c12-a8f4-c7dfa3fb4b89>Parser(input));
		}

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public object Deserialize(TextReader input)
		{
			return Deserialize(input, typeof(object));
		}

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public object Deserialize(string input, Type type)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize(input2, type);
		}

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public object Deserialize(TextReader input, Type type)
		{
			return Deserialize(new <7af46315-d2cb-4c12-a8f4-c7dfa3fb4b89>Parser(input), type);
		}

		public T Deserialize<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] T>(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser)
		{
			return (T)Deserialize(parser, typeof(T));
		}

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public object Deserialize(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser)
		{
			return Deserialize(parser, typeof(object));
		}

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public object Deserialize(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, Type type)
		{
			if (parser == null)
			{
				throw new ArgumentNullException("parser");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			<c6735cbe-6b41-41ed-9735-1c5651a9fd34>StreamStart @event;
			bool flag = parser.TryConsume<<c6735cbe-6b41-41ed-9735-1c5651a9fd34>StreamStart>(out @event);
			<20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart event2;
			bool flag2 = parser.TryConsume<<20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart>(out event2);
			object result = null;
			if (!parser.Accept<<ce28eaa8-1705-4d9d-86ca-3aaeb4704887>DocumentEnd>(out var _) && !parser.Accept<<22699db6-dc9d-47cf-852e-e20a3076c7be>StreamEnd>(out var _))
			{
				using <e8b5a30e-e5b1-4404-8295-1146ea66a434>SerializerState <e8b5a30e-e5b1-4404-8295-1146ea66a434>SerializerState = new <e8b5a30e-e5b1-4404-8295-1146ea66a434>SerializerState();
				result = valueDeserializer.DeserializeValue(parser, type, <e8b5a30e-e5b1-4404-8295-1146ea66a434>SerializerState, valueDeserializer);
				<e8b5a30e-e5b1-4404-8295-1146ea66a434>SerializerState.OnDeserialization();
			}
			if (flag2)
			{
				parser.Consume<<ce28eaa8-1705-4d9d-86ca-3aaeb4704887>DocumentEnd>();
			}
			if (flag)
			{
				parser.Consume<<22699db6-dc9d-47cf-852e-e20a3076c7be>StreamEnd>();
			}
			return result;
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 0, 1 })]
	internal sealed class <09e33b7f-b9e8-4527-b231-a587d3f3164d>DeserializerBuilder : <fb6a88d4-c53e-4466-8d30-1fe3973b5ec5>BuilderSkeleton<<09e33b7f-b9e8-4527-b231-a587d3f3164d>DeserializerBuilder>
	{
		private Lazy<<25b8d310-26e9-45f0-963c-cac44ad61cd4>IObjectFactory> objectFactory;

		private readonly <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing, <5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer> nodeDeserializerFactories;

		private readonly <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing, <d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver> nodeTypeResolverFactories;

		private readonly Dictionary<<9b965c76-e42b-4be8-b468-b7eefab6d624>TagName, Type> tagMappings;

		private readonly Dictionary<Type, Type> typeMappings;

		private bool ignoreUnmatched;

		protected override <09e33b7f-b9e8-4527-b231-a587d3f3164d>DeserializerBuilder Self => this;

		public <09e33b7f-b9e8-4527-b231-a587d3f3164d>DeserializerBuilder()
			: base((<a0cad0d5-d219-4360-a990-d287fb745b59>ITypeResolver)new <7b16730a-6bcc-451e-9956-ab5db3e49063>StaticTypeResolver())
		{
			typeMappings = new Dictionary<Type, Type>();
			objectFactory = new Lazy<<25b8d310-26e9-45f0-963c-cac44ad61cd4>IObjectFactory>(() => new <65e87768-98ae-49df-9570-67b9ec9243d5>DefaultObjectFactory(typeMappings), isThreadSafe: true);
			tagMappings = new Dictionary<<9b965c76-e42b-4be8-b468-b7eefab6d624>TagName, Type>
			{
				{
					<f9890ec4-e989-4845-94cf-bbacb908cd8f>FailsafeSchema.Tags.Map,
					typeof(Dictionary<object, object>)
				},
				{
					<f9890ec4-e989-4845-94cf-bbacb908cd8f>FailsafeSchema.Tags.Str,
					typeof(string)
				},
				{
					<54c3bbba-5048-4fe1-bca0-881daf687cad>JsonSchema.Tags.Bool,
					typeof(bool)
				},
				{
					<54c3bbba-5048-4fe1-bca0-881daf687cad>JsonSchema.Tags.Float,
					typeof(double)
				},
				{
					<54c3bbba-5048-4fe1-bca0-881daf687cad>JsonSchema.Tags.Int,
					typeof(int)
				},
				{
					<798dfe55-7b25-4a02-b11d-118d7dc1906f>DefaultSchema.Tags.Timestamp,
					typeof(DateTime)
				}
			};
			typeInspectorFactories.Add(typeof(<dace3dd6-0f6a-40a0-950a-bb1fef69a1a7>CachedTypeInspector), (<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector inner) => new <dace3dd6-0f6a-40a0-950a-bb1fef69a1a7>CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(<384827fc-2549-46e1-838b-08144eee85ef>NamingConventionTypeInspector), (<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector inner) => (!(namingConvention is <b7f3b459-c7ee-4e45-a5a4-df1e39b37601>NullNamingConvention)) ? new <384827fc-2549-46e1-838b-08144eee85ef>NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(<cbdec7df-23b2-476b-8366-97511b82a1d2>YamlAttributesTypeInspector), (<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector inner) => new <cbdec7df-23b2-476b-8366-97511b82a1d2>YamlAttributesTypeInspector(inner));
			typeInspectorFactories.Add(typeof(<954f5de4-5a92-46ec-a889-762e47478d5e>YamlAttributeOverridesInspector), (<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector inner) => (overrides == null) ? inner : new <954f5de4-5a92-46ec-a889-762e47478d5e>YamlAttributeOverridesInspector(inner, overrides.Clone()));
			typeInspectorFactories.Add(typeof(<f81f28d6-2802-4980-b60b-a409dcfe10eb>ReadableAndWritablePropertiesTypeInspector), (<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector inner) => new <f81f28d6-2802-4980-b60b-a409dcfe10eb>ReadableAndWritablePropertiesTypeInspector(inner));
			nodeDeserializerFactories = new <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing, <5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer>
			{
				{
					typeof(<d7d1bce2-2b37-47a9-8099-4b785a1b8422>YamlConvertibleNodeDeserializer),
					(<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing _) => new <d7d1bce2-2b37-47a9-8099-4b785a1b8422>YamlConvertibleNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(<f52d6fae-a397-4ed0-b79e-9ec7c62bc294>YamlSerializableNodeDeserializer),
					(<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing _) => new <f52d6fae-a397-4ed0-b79e-9ec7c62bc294>YamlSerializableNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(<45e790a0-85e1-40aa-886b-c1753f6dc8f8>TypeConverterNodeDeserializer),
					(<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing _) => new <45e790a0-85e1-40aa-886b-c1753f6dc8f8>TypeConverterNodeDeserializer(BuildTypeConverters())
				},
				{
					typeof(<b1d95a82-44aa-4464-86f2-6869ef62deec>NullNodeDeserializer),
					(<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing _) => new <b1d95a82-44aa-4464-86f2-6869ef62deec>NullNodeDeserializer()
				},
				{
					typeof(<652d8919-fb7e-4461-8ae8-bb475ac7818f>ScalarNodeDeserializer),
					(<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing _) => new <652d8919-fb7e-4461-8ae8-bb475ac7818f>ScalarNodeDeserializer()
				},
				{
					typeof(<94159d23-739a-4f4e-a08e-efc516e2a0c1>ArrayNodeDeserializer),
					(<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing _) => new <94159d23-739a-4f4e-a08e-efc516e2a0c1>ArrayNodeDeserializer()
				},
				{
					typeof(<c59313c3-f7ec-4263-b815-ebccf2a80fce>DictionaryNodeDeserializer),
					(<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing _) => new <c59313c3-f7ec-4263-b815-ebccf2a80fce>DictionaryNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(<9657c1c0-3df4-4cf9-b3b7-5964148cd7ff>CollectionNodeDeserializer),
					(<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing _) => new <9657c1c0-3df4-4cf9-b3b7-5964148cd7ff>CollectionNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(<09339fe4-0506-4b49-a7bf-c0cdfeaa93f8>EnumerableNodeDeserializer),
					(<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing _) => new <09339fe4-0506-4b49-a7bf-c0cdfeaa93f8>EnumerableNodeDeserializer()
				},
				{
					typeof(<26220309-8886-44df-bcd2-53084bccad89>ObjectNodeDeserializer),
					(<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing _) => new <26220309-8886-44df-bcd2-53084bccad89>ObjectNodeDeserializer(objectFactory.Value, BuildTypeInspector(), ignoreUnmatched)
				}
			};
			nodeTypeResolverFactories = new <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing, <d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver>
			{
				{
					typeof(<a36aae16-0204-474b-86c1-4b2c15b6aa74>MappingNodeTypeResolver),
					(<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing _) => new <a36aae16-0204-474b-86c1-4b2c15b6aa74>MappingNodeTypeResolver(typeMappings)
				},
				{
					typeof(<44b0424c-2cc0-4b42-b7c1-5546be912965>YamlConvertibleTypeResolver),
					(<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing _) => new <44b0424c-2cc0-4b42-b7c1-5546be912965>YamlConvertibleTypeResolver()
				},
				{
					typeof(<1974a413-9317-4103-8d3b-65efe5d91105>YamlSerializableTypeResolver),
					(<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing _) => new <1974a413-9317-4103-8d3b-65efe5d91105>YamlSerializableTypeResolver()
				},
				{
					typeof(<aa598de4-1ba1-4dab-b351-fefa11c38945>TagNodeTypeResolver),
					(<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing _) => new <aa598de4-1ba1-4dab-b351-fefa11c38945>TagNodeTypeResolver(tagMappings)
				},
				{
					typeof(<37d43683-7c0c-4e1e-aac5-64c3fd657ad1>PreventUnknownTagsNodeTypeResolver),
					(<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing _) => new <37d43683-7c0c-4e1e-aac5-64c3fd657ad1>PreventUnknownTagsNodeTypeResolver()
				},
				{
					typeof(<1a765f1c-028e-4c6a-9d6a-850d7b81b253>DefaultContainersNodeTypeResolver),
					(<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing _) => new <1a765f1c-028e-4c6a-9d6a-850d7b81b253>DefaultContainersNodeTypeResolver()
				}
			};
		}

		public <09e33b7f-b9e8-4527-b231-a587d3f3164d>DeserializerBuilder WithObjectFactory(<25b8d310-26e9-45f0-963c-cac44ad61cd4>IObjectFactory objectFactory)
		{
			if (objectFactory == null)
			{
				throw new ArgumentNullException("objectFactory");
			}
			this.objectFactory = new Lazy<<25b8d310-26e9-45f0-963c-cac44ad61cd4>IObjectFactory>(() => objectFactory, isThreadSafe: true);
			return this;
		}

		public <09e33b7f-b9e8-4527-b231-a587d3f3164d>DeserializerBuilder WithObjectFactory(Func<Type, object> objectFactory)
		{
			if (objectFactory == null)
			{
				throw new ArgumentNullException("objectFactory");
			}
			return WithObjectFactory(new <087c1052-b2d8-4a5c-96a6-2a1eea9a9e45>LambdaObjectFactory(objectFactory));
		}

		public <09e33b7f-b9e8-4527-b231-a587d3f3164d>DeserializerBuilder WithNodeDeserializer(<5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer nodeDeserializer)
		{
			return WithNodeDeserializer(nodeDeserializer, delegate(<da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<<5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer> w)
			{
				w.OnTop();
			});
		}

		public <09e33b7f-b9e8-4527-b231-a587d3f3164d>DeserializerBuilder WithNodeDeserializer(<5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer nodeDeserializer, Action<<da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<<5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer>> where)
		{
			if (nodeDeserializer == null)
			{
				throw new ArgumentNullException("nodeDeserializer");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer.GetType(), (<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing _) => nodeDeserializer));
			return this;
		}

		public <09e33b7f-b9e8-4527-b231-a587d3f3164d>DeserializerBuilder WithNodeDeserializer<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] TNodeDeserializer>(<abcc739a-3cd5-4a0d-8a88-9cfef1aa4e82>WrapperFactory<<5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<<076c1b1b-cf5e-43de-aa04-fbe8d6feb0e4>ITrackingRegistrationLocationSelectionSyntax<<5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer>> where) where TNodeDeserializer : <5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer
		{
			if (nodeDeserializerFactory == null)
			{
				throw new ArgumentNullException("nodeDeserializerFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (<5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer wrapped, <56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing _) => nodeDeserializerFactory(wrapped)));
			return this;
		}

		public <09e33b7f-b9e8-4527-b231-a587d3f3164d>DeserializerBuilder WithoutNodeDeserializer<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] TNodeDeserializer>() where TNodeDeserializer : <5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer
		{
			return WithoutNodeDeserializer(typeof(TNodeDeserializer));
		}

		public <09e33b7f-b9e8-4527-b231-a587d3f3164d>DeserializerBuilder WithoutNodeDeserializer(Type nodeDeserializerType)
		{
			if (nodeDeserializerType == null)
			{
				throw new ArgumentNullException("nodeDeserializerType");
			}
			nodeDeserializerFactories.Remove(nodeDeserializerType);
			return this;
		}

		public <09e33b7f-b9e8-4527-b231-a587d3f3164d>DeserializerBuilder WithNodeTypeResolver(<d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver nodeTypeResolver)
		{
			return WithNodeTypeResolver(nodeTypeResolver, delegate(<da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<<d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver> w)
			{
				w.OnTop();
			});
		}

		public <09e33b7f-b9e8-4527-b231-a587d3f3164d>DeserializerBuilder WithNodeTypeResolver(<d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver nodeTypeResolver, Action<<da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<<d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver>> where)
		{
			if (nodeTypeResolver == null)
			{
				throw new ArgumentNullException("nodeTypeResolver");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver.GetType(), (<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing _) => nodeTypeResolver));
			return this;
		}

		public <09e33b7f-b9e8-4527-b231-a587d3f3164d>DeserializerBuilder WithNodeTypeResolver<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] TNodeTypeResolver>(<abcc739a-3cd5-4a0d-8a88-9cfef1aa4e82>WrapperFactory<<d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<<076c1b1b-cf5e-43de-aa04-fbe8d6feb0e4>ITrackingRegistrationLocationSelectionSyntax<<d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver>> where) where TNodeTypeResolver : <d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver
		{
			if (nodeTypeResolverFactory == null)
			{
				throw new ArgumentNullException("nodeTypeResolverFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (<d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver wrapped, <56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing _) => nodeTypeResolverFactory(wrapped)));
			return this;
		}

		public <09e33b7f-b9e8-4527-b231-a587d3f3164d>DeserializerBuilder WithoutNodeTypeResolver<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] TNodeTypeResolver>() where TNodeTypeResolver : <d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver
		{
			return WithoutNodeTypeResolver(typeof(TNodeTypeResolver));
		}

		public <09e33b7f-b9e8-4527-b231-a587d3f3164d>DeserializerBuilder WithoutNodeTypeResolver(Type nodeTypeResolverType)
		{
			if (nodeTypeResolverType == null)
			{
				throw new ArgumentNullException("nodeTypeResolverType");
			}
			nodeTypeResolverFactories.Remove(nodeTypeResolverType);
			return this;
		}

		public override <09e33b7f-b9e8-4527-b231-a587d3f3164d>DeserializerBuilder WithTagMapping(<9b965c76-e42b-4be8-b468-b7eefab6d624>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 var value))
			{
				throw new ArgumentException($"Type already has a registered type '{value.FullName}' for tag '{tag}'", "tag");
			}
			tagMappings.Add(tag, type);
			return this;
		}

		public <09e33b7f-b9e8-4527-b231-a587d3f3164d>DeserializerBuilder WithTypeMapping<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TInterface, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] 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 (typeMappings.ContainsKey(typeFromHandle))
			{
				typeMappings[typeFromHandle] = typeFromHandle2;
			}
			else
			{
				typeMappings.Add(typeFromHandle, typeFromHandle2);
			}
			return this;
		}

		public <09e33b7f-b9e8-4527-b231-a587d3f3164d>DeserializerBuilder WithoutTagMapping(<9b965c76-e42b-4be8-b468-b7eefab6d624>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 <09e33b7f-b9e8-4527-b231-a587d3f3164d>DeserializerBuilder IgnoreUnmatchedProperties()
		{
			ignoreUnmatched = true;
			return this;
		}

		public <2f525b19-b34f-467d-9bed-f3f6cc4ee768>IDeserializer Build()
		{
			return <09056b75-4fe4-40d0-99cf-d2b2ebb1010c>Deserializer.FromValueDeserializer(BuildValueDeserializer());
		}

		public <59bc90d3-d6d7-4700-894d-caa6cefe9734>IValueDeserializer BuildValueDeserializer()
		{
			return new <45ddfc0a-42f9-45b6-a52f-1b19cfba73e2>AliasValueDeserializer(new <84d08373-c369-4018-ab8f-7b61622623d7>NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList()));
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <01b55b5f-2386-4395-a010-eda1ba2fa7b1>EmissionPhaseObjectGraphVisitorArgs
	{
		private readonly IEnumerable<<ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>> preProcessingPhaseVisitors;

		public <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter> InnerVisitor { get; private set; }

		public <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter EventEmitter { get; private set; }

		public <dd379040-fcd6-4c71-bd11-b3912495c170>ObjectSerializer NestedObjectSerializer { get; private set; }

		public IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> TypeConverters { get; private set; }

		public <01b55b5f-2386-4395-a010-eda1ba2fa7b1>EmissionPhaseObjectGraphVisitorArgs(<ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter> innerVisitor, <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter eventEmitter, IEnumerable<<ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>> preProcessingPhaseVisitors, IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> typeConverters, <dd379040-fcd6-4c71-bd11-b3912495c170>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<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] T>() where T : <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>
		{
			return preProcessingPhaseVisitors.OfType<T>().Single();
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal abstract class <4394590b-7b10-4e6a-8f74-df84ae6d338b>EventInfo
	{
		public <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor Source { get; }

		protected <4394590b-7b10-4e6a-8f74-df84ae6d338b>EventInfo(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor source)
		{
			Source = source ?? throw new ArgumentNullException("source");
		}
	}
	internal class <e70d24c7-2fc4-4deb-935f-2f167bd4ad87>AliasEventInfo : <4394590b-7b10-4e6a-8f74-df84ae6d338b>EventInfo
	{
		public <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName Alias { get; }

		public bool NeedsExpansion { get; set; }

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <e70d24c7-2fc4-4deb-935f-2f167bd4ad87>AliasEventInfo(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor source, <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName alias)
			: base(source)
		{
			if (alias.IsEmpty)
			{
				throw new ArgumentNullException("alias");
			}
			Alias = alias;
		}
	}
	internal class <c26fc2b8-434a-4e27-9cf1-fe8e1206dd94>ObjectEventInfo : <4394590b-7b10-4e6a-8f74-df84ae6d338b>EventInfo
	{
		public <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName Anchor { get; set; }

		public <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName Tag { get; set; }

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		protected <c26fc2b8-434a-4e27-9cf1-fe8e1206dd94>ObjectEventInfo(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <3a8120f0-1e22-4688-9f35-7f39f0ca5705>ScalarEventInfo : <c26fc2b8-434a-4e27-9cf1-fe8e1206dd94>ObjectEventInfo
	{
		public string RenderedValue { get; set; }

		public <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle Style { get; set; }

		public bool IsPlainImplicit { get; set; }

		public bool IsQuotedImplicit { get; set; }

		public <3a8120f0-1e22-4688-9f35-7f39f0ca5705>ScalarEventInfo(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor source)
			: base(source)
		{
			Style = source.ScalarStyle;
			RenderedValue = string.Empty;
		}
	}
	internal sealed class <b5820e3d-2ea9-478e-aa86-8bf43ebfe369>MappingStartEventInfo : <c26fc2b8-434a-4e27-9cf1-fe8e1206dd94>ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public <bc2eacde-da96-4de8-a058-605c487b5916>MappingStyle Style { get; set; }

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <b5820e3d-2ea9-478e-aa86-8bf43ebfe369>MappingStartEventInfo(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class <0b621565-c1a3-4977-9130-2cc1e01ee81f>MappingEndEventInfo : <4394590b-7b10-4e6a-8f74-df84ae6d338b>EventInfo
	{
		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <0b621565-c1a3-4977-9130-2cc1e01ee81f>MappingEndEventInfo(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class <bd85e032-3c9d-4aa1-92f8-9a11ece4a496>SequenceStartEventInfo : <c26fc2b8-434a-4e27-9cf1-fe8e1206dd94>ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public <71ce5569-3f87-4b73-9e15-59e4c0c26f9f>SequenceStyle Style { get; set; }

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <bd85e032-3c9d-4aa1-92f8-9a11ece4a496>SequenceStartEventInfo(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class <8e533513-9138-4fd4-8a1f-35a40ae25316>SequenceEndEventInfo : <4394590b-7b10-4e6a-8f74-df84ae6d338b>EventInfo
	{
		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <8e533513-9138-4fd4-8a1f-35a40ae25316>SequenceEndEventInfo(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal interface <91d2ca13-c2ab-4684-92c9-140b8c0f4d02>IAliasProvider
	{
		<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName GetAlias(object target);
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal interface <2f525b19-b34f-467d-9bed-f3f6cc4ee768>IDeserializer
	{
		T Deserialize<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] T>(string input);

		T Deserialize<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] T>(TextReader input);

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		object Deserialize(TextReader input);

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		object Deserialize(string input, Type type);

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		object Deserialize(TextReader input, Type type);

		T Deserialize<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] T>(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser);

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		object Deserialize(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser);

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		object Deserialize(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, Type type);
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal interface <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter
	{
		void Emit(<e70d24c7-2fc4-4deb-935f-2f167bd4ad87>AliasEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter);

		void Emit(<3a8120f0-1e22-4688-9f35-7f39f0ca5705>ScalarEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter);

		void Emit(<b5820e3d-2ea9-478e-aa86-8bf43ebfe369>MappingStartEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter);

		void Emit(<0b621565-c1a3-4977-9130-2cc1e01ee81f>MappingEndEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter);

		void Emit(<bd85e032-3c9d-4aa1-92f8-9a11ece4a496>SequenceStartEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter);

		void Emit(<8e533513-9138-4fd4-8a1f-35a40ae25316>SequenceEndEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter);
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal interface <2282eb5c-6849-4bd4-9f7d-f9cba43dc317>INamingConvention
	{
		string Apply(string value);
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal interface <5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer
	{
		bool Deserialize(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser reader, Type expectedType, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser, Type, object> nestedObjectDeserializer, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] out object value);
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal interface <d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver
	{
		bool Resolve([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] <1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent nodeEvent, ref Type currentType);
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal interface <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		object Value
		{
			[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
			get;
		}

		Type Type { get; }

		Type StaticType { get; }

		<4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle ScalarStyle { get; }
	}
	internal static class <add189f3-12f5-494b-947c-ca0a3465e0e9>ObjectDescriptorExtensions
	{
		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public static object NonNullValue(this <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>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.");
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal interface <25b8d310-26e9-45f0-963c-cac44ad61cd4>IObjectFactory
	{
		object Create(Type type);
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal interface <8fec2f07-147a-4858-aec8-d12a2f118a9c>IObjectGraphTraversalStrategy
	{
		void Traverse<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TContext>(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor graph, <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<TContext> visitor, TContext context);
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal interface <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TContext>
	{
		bool Enter(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value, TContext context);

		bool EnterMapping(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor key, <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value, TContext context);

		bool EnterMapping(<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor key, <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value, TContext context);

		void VisitScalar(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor scalar, TContext context);

		void VisitMappingStart(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor mapping, Type keyType, Type valueType, TContext context);

		void VisitMappingEnd(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor mapping, TContext context);

		void VisitSequenceStart(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor sequence, Type elementType, TContext context);

		void VisitSequenceEnd(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor sequence, TContext context);
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal interface <b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor
	{
		string Name { get; }

		bool CanWrite { get; }

		Type Type { get; }

		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		Type TypeOverride
		{
			[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
			get;
			[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
			set;
		}

		int Order { get; set; }

		<4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle ScalarStyle { get; set; }

		T GetCustomAttribute<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] T>() where T : Attribute;

		<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor Read(object target);

		void Write(object target, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object value);
	}
	internal interface <da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;

		void Before<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;

		void After<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;

		void OnTop();

		void OnBottom();
	}
	internal interface <076c1b1b-cf5e-43de-aa04-fbe8d6feb0e4>ITrackingRegistrationLocationSelectionSyntax<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal interface <02be5cab-5e04-47ac-b2cb-9e40af11d936>ISerializer
	{
		void Serialize(TextWriter writer, object graph);

		string Serialize(object graph);

		void Serialize(TextWriter writer, object graph, Type type);

		void Serialize(<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter, object graph);

		void Serialize(<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter, object graph, Type type);
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal interface <c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector
	{
		IEnumerable<<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor> GetProperties(Type type, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object container);

		<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor GetProperty(Type type, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object container, string name, [<b3ae408d-452a-47a4-a4cd-28743506c159>MaybeNullWhen(true)] bool ignoreUnmatched);
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal interface <a0cad0d5-d219-4360-a990-d287fb745b59>ITypeResolver
	{
		Type Resolve(Type staticType, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object actualValue);
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal interface <59bc90d3-d6d7-4700-894d-caa6cefe9734>IValueDeserializer
	{
		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		object DeserializeValue(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, Type expectedType, <e8b5a30e-e5b1-4404-8295-1146ea66a434>SerializerState state, <59bc90d3-d6d7-4700-894d-caa6cefe9734>IValueDeserializer nestedObjectDeserializer);
	}
	internal interface <cf2045f1-17de-4280-8f65-79ee218e11fd>IValuePromise
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 2 })]
		event Action<object> ValueAvailable;
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
	internal interface <b36ce955-3411-45a4-97de-85b2696966cb>IValueSerializer
	{
		void SerializeValue([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)] <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter, object value, Type type);
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal interface <3e02419b-73d0-43d6-8614-b0bb250feb69>IYamlConvertible
	{
		void Read(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, Type expectedType, <e75d04a3-617f-4e9f-93b7-e90dcd228b4c>ObjectDeserializer nestedObjectDeserializer);

		void Write(<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter, <dd379040-fcd6-4c71-bd11-b3912495c170>ObjectSerializer nestedObjectSerializer);
	}
	[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
	internal delegate object <e75d04a3-617f-4e9f-93b7-e90dcd228b4c>ObjectDeserializer(Type type);
	internal delegate void <dd379040-fcd6-4c71-bd11-b3912495c170>ObjectSerializer(object value, Type type = null);
	[Obsolete("Please use IYamlConvertible instead")]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal interface <1d8915a2-3217-4c29-b984-c926423b449f>IYamlSerializable
	{
		void ReadYaml(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser);

		void WriteYaml(<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter);
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal interface <d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter
	{
		bool Accepts(Type type);

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		object ReadYaml(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, Type type);

		void WriteYaml(<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object value, Type type);
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TArgument, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TComponent> : IEnumerable<Func<TArgument, TComponent>>, IEnumerable
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
		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;
			}
		}

		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
		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;
			}
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)]
		private class RegistrationLocationSelector : <da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<TComponent>
		{
			[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)]
			private readonly <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<TArgument, TComponent> registrations;

			[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 0, 0 })]
			private readonly LazyComponentRegistration newRegistration;

			[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
			public RegistrationLocationSelector(<57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<TArgument, TComponent> registrations, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 0, 0 })] LazyComponentRegistration newRegistration)
			{
				this.registrations = registrations;
				this.newRegistration = newRegistration;
			}

			void <da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<TComponent>.InsteadOf<TRegistrationType>()
			{
				if (newRegistration.ComponentType != typeof(TRegistrationType))
				{
					registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				}
				int index = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries[index] = newRegistration;
			}

			void <da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<TComponent>.After<TRegistrationType>()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				int num = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries.Insert(num + 1, newRegistration);
			}

			void <da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<TComponent>.Before<TRegistrationType>()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				int index = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries.Insert(index, newRegistration);
			}

			void <da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<TComponent>.OnBottom()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				registrations.entries.Add(newRegistration);
			}

			void <da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<TComponent>.OnTop()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				registrations.entries.Insert(0, newRegistration);
			}
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)]
		private class TrackingRegistrationLocationSelector : <076c1b1b-cf5e-43de-aa04-fbe8d6feb0e4>ITrackingRegistrationLocationSelectionSyntax<TComponent>
		{
			[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)]
			private readonly <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<TArgument, TComponent> registrations;

			[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 0, 0 })]
			private readonly TrackingLazyComponentRegistration newRegistration;

			[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
			public TrackingRegistrationLocationSelector(<57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<TArgument, TComponent> registrations, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 0, 0 })] TrackingLazyComponentRegistration newRegistration)
			{
				this.registrations = registrations;
				this.newRegistration = newRegistration;
			}

			void <076c1b1b-cf5e-43de-aa04-fbe8d6feb0e4>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, [<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)] (TArgument arg) => newRegistration.Factory(innerComponentFactory(arg), arg));
			}
		}

		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 1, 0, 0 })]
		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 <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<TArgument, TComponent> Clone()
		{
			<57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<TArgument, TComponent> <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList2 = new <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<TArgument, TComponent>();
			foreach (LazyComponentRegistration entry in entries)
			{
				<57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList2.entries.Add(entry);
			}
			return <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList2;
		}

		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 <da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<TComponent> CreateRegistrationLocationSelector(Type componentType, Func<TArgument, TComponent> factory)
		{
			return new RegistrationLocationSelector(this, new LazyComponentRegistration(componentType, factory));
		}

		public <076c1b1b-cf5e-43de-aa04-fbe8d6feb0e4>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([<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] (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.");
			}
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
		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;
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal static class <72bd269b-0c3b-4cfb-9395-46a3e6bb0e05>LazyComponentRegistrationListExtensions
	{
		public static TComponent BuildComponentChain<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TComponent>(this <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<TComponent, TComponent> registrations, TComponent innerComponent)
		{
			return registrations.InReverseOrder.Aggregate(innerComponent, [<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] (TComponent inner, Func<TComponent, TComponent> factory) => factory(inner));
		}

		public static TComponent BuildComponentChain<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TArgument, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TComponent>(this <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<TArgument, TComponent> registrations, TComponent innerComponent, Func<TComponent, TArgument> argumentBuilder)
		{
			return registrations.InReverseOrder.Aggregate(innerComponent, [<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] (TComponent inner, Func<TArgument, TComponent> factory) => factory(argumentBuilder(inner)));
		}

		public static List<TComponent> BuildComponentList<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TComponent>(this <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing, TComponent> registrations)
		{
			return registrations.Select([<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] (Func<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing, TComponent> factory) => factory(default(<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing))).ToList();
		}

		public static List<TComponent> BuildComponentList<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TArgument, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TComponent>(this <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<TArgument, TComponent> registrations, TArgument argument)
		{
			return registrations.Select([<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] (Func<TArgument, TComponent> factory) => factory(argument)).ToList();
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	internal struct <56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing
	{
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <060951e9-e294-406d-a792-8a5d53b008e3>ObjectDescriptor : <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		[field: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public object Value
		{
			[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
			get;
			[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
			private set;
		}

		public Type Type { get; private set; }

		public Type StaticType { get; private set; }

		public <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle ScalarStyle { get; private set; }

		public <060951e9-e294-406d-a792-8a5d53b008e3>ObjectDescriptor([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object value, Type type, Type staticType)
			: this(value, type, staticType, <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Any)
		{
		}

		public <060951e9-e294-406d-a792-8a5d53b008e3>ObjectDescriptor([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object value, Type type, Type staticType, <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle scalarStyle)
		{
			Value = value;
			Type = type ?? throw new ArgumentNullException("type");
			StaticType = staticType ?? throw new ArgumentNullException("staticType");
			ScalarStyle = scalarStyle;
		}
	}
	internal delegate <8fec2f07-147a-4858-aec8-d12a2f118a9c>IObjectGraphTraversalStrategy <06749d51-9f42-4380-a85b-968f20b18529>ObjectGraphTraversalStrategyFactory(<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector typeInspector, <a0cad0d5-d219-4360-a990-d287fb745b59>ITypeResolver typeResolver, IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> typeConverters, int maximumRecursion);
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <ea25870f-853c-44d7-91ee-50f7d3c45c0e>PropertyDescriptor : <b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor
	{
		private readonly <b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor baseDescriptor;

		public string Name { get; set; }

		public Type Type => baseDescriptor.Type;

		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public Type TypeOverride
		{
			[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
			get
			{
				return baseDescriptor.TypeOverride;
			}
			[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
			set
			{
				baseDescriptor.TypeOverride = value;
			}
		}

		public int Order { get; set; }

		public <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle ScalarStyle
		{
			get
			{
				return baseDescriptor.ScalarStyle;
			}
			set
			{
				baseDescriptor.ScalarStyle = value;
			}
		}

		public bool CanWrite => baseDescriptor.CanWrite;

		public <ea25870f-853c-44d7-91ee-50f7d3c45c0e>PropertyDescriptor(<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor baseDescriptor)
		{
			this.baseDescriptor = baseDescriptor;
			Name = baseDescriptor.Name;
		}

		public void Write(object target, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object value)
		{
			baseDescriptor.Write(target, value);
		}

		public T GetCustomAttribute<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] T>() where T : Attribute
		{
			return baseDescriptor.GetCustomAttribute<T>();
		}

		public <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor Read(object target)
		{
			return baseDescriptor.Read(target);
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <221732a8-002b-4e4c-9d34-106d4d0d232c>Serializer : <02be5cab-5e04-47ac-b2cb-9e40af11d936>ISerializer
	{
		private readonly <b36ce955-3411-45a4-97de-85b2696966cb>IValueSerializer valueSerializer;

		private readonly <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings emitterSettings;

		public <221732a8-002b-4e4c-9d34-106d4d0d232c>Serializer()
			: this(new <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder().BuildValueSerializer(), <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings.Default)
		{
		}

		private <221732a8-002b-4e4c-9d34-106d4d0d232c>Serializer(<b36ce955-3411-45a4-97de-85b2696966cb>IValueSerializer valueSerializer, <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings emitterSettings)
		{
			this.valueSerializer = valueSerializer ?? throw new ArgumentNullException("valueSerializer");
			this.emitterSettings = emitterSettings ?? throw new ArgumentNullException("emitterSettings");
		}

		public static <221732a8-002b-4e4c-9d34-106d4d0d232c>Serializer FromValueSerializer(<b36ce955-3411-45a4-97de-85b2696966cb>IValueSerializer valueSerializer, <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings emitterSettings)
		{
			return new <221732a8-002b-4e4c-9d34-106d4d0d232c>Serializer(valueSerializer, emitterSettings);
		}

		public void Serialize(TextWriter writer, object graph)
		{
			Serialize(new <b397acda-0b92-4004-a792-33a13435c7d5>Emitter(writer, emitterSettings), graph);
		}

		public string Serialize(object graph)
		{
			using StringWriter stringWriter = new StringWriter();
			Serialize(stringWriter, graph);
			return stringWriter.ToString();
		}

		public void Serialize(TextWriter writer, object graph, Type type)
		{
			Serialize(new <b397acda-0b92-4004-a792-33a13435c7d5>Emitter(writer, emitterSettings), graph, type);
		}

		public void Serialize(<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter, object graph)
		{
			if (emitter == null)
			{
				throw new ArgumentNullException("emitter");
			}
			EmitDocument(emitter, graph, null);
		}

		public void Serialize(<e1dd7872-6261-45fd-8d2f-add601861c41>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(<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter, object graph, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] Type type)
		{
			emitter.Emit(new <c6735cbe-6b41-41ed-9735-1c5651a9fd34>StreamStart());
			emitter.Emit(new <20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart());
			valueSerializer.SerializeValue(emitter, graph, type);
			emitter.Emit(new <ce28eaa8-1705-4d9d-86ca-3aaeb4704887>DocumentEnd(isImplicit: true));
			emitter.Emit(new <22699db6-dc9d-47cf-852e-e20a3076c7be>StreamEnd());
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 0, 1 })]
	internal sealed class <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder : <fb6a88d4-c53e-4466-8d30-1fe3973b5ec5>BuilderSkeleton<<538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder>
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
		private class ValueSerializer : <b36ce955-3411-45a4-97de-85b2696966cb>IValueSerializer
		{
			private readonly <8fec2f07-147a-4858-aec8-d12a2f118a9c>IObjectGraphTraversalStrategy traversalStrategy;

			private readonly <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter eventEmitter;

			private readonly IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> typeConverters;

			private readonly <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter>, <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

			private readonly <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<<01b55b5f-2386-4395-a010-eda1ba2fa7b1>EmissionPhaseObjectGraphVisitorArgs, <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter>> emissionPhaseObjectGraphVisitorFactories;

			public ValueSerializer(<8fec2f07-147a-4858-aec8-d12a2f118a9c>IObjectGraphTraversalStrategy traversalStrategy, <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter eventEmitter, IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> typeConverters, <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter>, <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>> preProcessingPhaseObjectGraphVisitorFactories, <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<<01b55b5f-2386-4395-a010-eda1ba2fa7b1>EmissionPhaseObjectGraphVisitorArgs, <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter>> emissionPhaseObjectGraphVisitorFactories)
			{
				this.traversalStrategy = traversalStrategy;
				this.eventEmitter = eventEmitter;
				this.typeConverters = typeConverters;
				this.preProcessingPhaseObjectGraphVisitorFactories = preProcessingPhaseObjectGraphVisitorFactories;
				this.emissionPhaseObjectGraphVisitorFactories = emissionPhaseObjectGraphVisitorFactories;
			}

			[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
			public void SerializeValue([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)] <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter, object value, Type type)
			{
				Type type2 = type ?? ((value != null) ? value.GetType() : typeof(object));
				Type staticType = type ?? typeof(object);
				<060951e9-e294-406d-a792-8a5d53b008e3>ObjectDescriptor graph = new <060951e9-e294-406d-a792-8a5d53b008e3>ObjectDescriptor(value, type2, staticType);
				List<<ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>> preProcessingPhaseObjectGraphVisitors = preProcessingPhaseObjectGraphVisitorFactories.BuildComponentList(typeConverters);
				foreach (<ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing> item in preProcessingPhaseObjectGraphVisitors)
				{
					traversalStrategy.Traverse(graph, item, default(<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing));
				}
				<ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter> visitor = emissionPhaseObjectGraphVisitorFactories.BuildComponentChain(new <677ee053-2e07-4ae4-84b2-fc20f131f86e>EmittingObjectGraphVisitor(eventEmitter), [<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] (<ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter> inner) => new <01b55b5f-2386-4395-a010-eda1ba2fa7b1>EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
				traversalStrategy.Traverse(graph, visitor, emitter);
				[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
				void NestedObjectSerializer(object v, Type t)
				{
					SerializeValue(emitter, v, t);
				}
			}
		}

		private <06749d51-9f42-4380-a85b-968f20b18529>ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory;

		private readonly <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter>, <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

		private readonly <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<<01b55b5f-2386-4395-a010-eda1ba2fa7b1>EmissionPhaseObjectGraphVisitorArgs, <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter>> emissionPhaseObjectGraphVisitorFactories;

		private readonly <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<<88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter, <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter> eventEmitterFactories;

		private readonly IDictionary<Type, <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName> tagMappings = new Dictionary<Type, <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName>();

		private int maximumRecursion = 50;

		private <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings emitterSettings = <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings.Default;

		private <82c71c17-8813-4fa6-8ba4-ee0247932a58>DefaultValuesHandling defaultValuesHandlingConfiguration;

		protected override <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder Self => this;

		public <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder()
			: base((<a0cad0d5-d219-4360-a990-d287fb745b59>ITypeResolver)new <b5752c80-5c0a-4e9d-b404-4b65a5526ba2>DynamicTypeResolver())
		{
			typeInspectorFactories.Add(typeof(<dace3dd6-0f6a-40a0-950a-bb1fef69a1a7>CachedTypeInspector), (<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector inner) => new <dace3dd6-0f6a-40a0-950a-bb1fef69a1a7>CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(<384827fc-2549-46e1-838b-08144eee85ef>NamingConventionTypeInspector), (<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector inner) => (!(namingConvention is <b7f3b459-c7ee-4e45-a5a4-df1e39b37601>NullNamingConvention)) ? new <384827fc-2549-46e1-838b-08144eee85ef>NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(<cbdec7df-23b2-476b-8366-97511b82a1d2>YamlAttributesTypeInspector), (<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector inner) => new <cbdec7df-23b2-476b-8366-97511b82a1d2>YamlAttributesTypeInspector(inner));
			typeInspectorFactories.Add(typeof(<954f5de4-5a92-46ec-a889-762e47478d5e>YamlAttributeOverridesInspector), (<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector inner) => (overrides == null) ? inner : new <954f5de4-5a92-46ec-a889-762e47478d5e>YamlAttributeOverridesInspector(inner, overrides.Clone()));
			preProcessingPhaseObjectGraphVisitorFactories = new <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter>, <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>> { 
			{
				typeof(<22caa531-c414-407a-87ad-b6b899c3101a>AnchorAssigner),
				(IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> typeConverters) => new <22caa531-c414-407a-87ad-b6b899c3101a>AnchorAssigner(typeConverters)
			} };
			emissionPhaseObjectGraphVisitorFactories = new <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<<01b55b5f-2386-4395-a010-eda1ba2fa7b1>EmissionPhaseObjectGraphVisitorArgs, <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter>>
			{
				{
					typeof(<4cdbc022-7886-4e8e-a801-eacfb1c5ad04>CustomSerializationObjectGraphVisitor),
					(<01b55b5f-2386-4395-a010-eda1ba2fa7b1>EmissionPhaseObjectGraphVisitorArgs args) => new <4cdbc022-7886-4e8e-a801-eacfb1c5ad04>CustomSerializationObjectGraphVisitor(args.InnerVisitor, args.TypeConverters, args.NestedObjectSerializer)
				},
				{
					typeof(<61c08950-c763-485f-b012-f8feedbe96f9>AnchorAssigningObjectGraphVisitor),
					(<01b55b5f-2386-4395-a010-eda1ba2fa7b1>EmissionPhaseObjectGraphVisitorArgs args) => new <61c08950-c763-485f-b012-f8feedbe96f9>AnchorAssigningObjectGraphVisitor(args.InnerVisitor, args.EventEmitter, args.GetPreProcessingPhaseObjectGraphVisitor<<22caa531-c414-407a-87ad-b6b899c3101a>AnchorAssigner>())
				},
				{
					typeof(<8f79150d-630f-49f4-b68d-c49c69c727d7>DefaultValuesObjectGraphVisitor),
					(<01b55b5f-2386-4395-a010-eda1ba2fa7b1>EmissionPhaseObjectGraphVisitorArgs args) => new <8f79150d-630f-49f4-b68d-c49c69c727d7>DefaultValuesObjectGraphVisitor(defaultValuesHandlingConfiguration, args.InnerVisitor)
				},
				{
					typeof(<c73ea7a5-082f-42d3-9a73-2b91de13ca80>CommentsObjectGraphVisitor),
					(<01b55b5f-2386-4395-a010-eda1ba2fa7b1>EmissionPhaseObjectGraphVisitorArgs args) => new <c73ea7a5-082f-42d3-9a73-2b91de13ca80>CommentsObjectGraphVisitor(args.InnerVisitor)
				}
			};
			eventEmitterFactories = new <57166afb-82b8-40ac-a0f7-5760cd2b3027>LazyComponentRegistrationList<<88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter, <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter> { 
			{
				typeof(<525b36b9-3eba-481e-b0e0-b4af5934ae49>TypeAssigningEventEmitter),
				(<88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter inner) => new <525b36b9-3eba-481e-b0e0-b4af5934ae49>TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: false, tagMappings)
			} };
			objectGraphTraversalStrategyFactory = (<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector typeInspector, <a0cad0d5-d219-4360-a990-d287fb745b59>ITypeResolver typeResolver, IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> typeConverters, int maximumRecursion) => new <ff2c6430-7179-4dfe-8c29-acf94684d0d2>FullObjectGraphTraversalStrategy(typeInspector, typeResolver, maximumRecursion, namingConvention);
		}

		public <538a020d-f1b6-477a-854a-3265c85f81d9>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 <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder WithEventEmitter<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] TEventEmitter>(Func<<88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(<da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<<88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder WithEventEmitter<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] TEventEmitter>(Func<<88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter, TEventEmitter> eventEmitterFactory, Action<<da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<<88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter>> where) where TEventEmitter : <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter
		{
			if (eventEmitterFactory == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateRegistrationLocationSelector(typeof(TEventEmitter), (<88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter inner) => eventEmitterFactory(inner)));
			return Self;
		}

		public <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder WithEventEmitter<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] TEventEmitter>(<05ec3915-2ffa-4099-8b31-c436678cbfa1>WrapperFactory<<88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter, <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter, TEventEmitter> eventEmitterFactory, Action<<076c1b1b-cf5e-43de-aa04-fbe8d6feb0e4>ITrackingRegistrationLocationSelectionSyntax<<88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter>> where) where TEventEmitter : <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter
		{
			if (eventEmitterFactory == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateTrackingRegistrationLocationSelector(typeof(TEventEmitter), (<88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter wrapped, <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter inner) => eventEmitterFactory(wrapped, inner)));
			return Self;
		}

		public <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder WithoutEventEmitter<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] TEventEmitter>() where TEventEmitter : <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter
		{
			return WithoutEventEmitter(typeof(TEventEmitter));
		}

		public <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder WithoutEventEmitter(Type eventEmitterType)
		{
			if (eventEmitterType == null)
			{
				throw new ArgumentNullException("eventEmitterType");
			}
			eventEmitterFactories.Remove(eventEmitterType);
			return this;
		}

		public override <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder WithTagMapping(<9b965c76-e42b-4be8-b468-b7eefab6d624>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 <538a020d-f1b6-477a-854a-3265c85f81d9>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 <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder EnsureRoundtrip()
		{
			objectGraphTraversalStrategyFactory = (<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector typeInspector, <a0cad0d5-d219-4360-a990-d287fb745b59>ITypeResolver typeResolver, IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> typeConverters, int maximumRecursion) => new <aa7ff869-915e-4370-b5a1-804acd474ce7>RoundtripObjectGraphTraversalStrategy(typeConverters, typeInspector, typeResolver, maximumRecursion, namingConvention);
			WithEventEmitter([<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] ([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)] <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter inner) => new <525b36b9-3eba-481e-b0e0-b4af5934ae49>TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: true, tagMappings), delegate(<da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<<88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter> loc)
			{
				loc.InsteadOf<<525b36b9-3eba-481e-b0e0-b4af5934ae49>TypeAssigningEventEmitter>();
			});
			return WithTypeInspector([<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] ([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)] <c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector inner) => new <f81f28d6-2802-4980-b60b-a409dcfe10eb>ReadableAndWritablePropertiesTypeInspector(inner), delegate(<da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector> loc)
			{
				loc.OnBottom();
			});
		}

		public <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder DisableAliases()
		{
			preProcessingPhaseObjectGraphVisitorFactories.Remove(typeof(<22caa531-c414-407a-87ad-b6b899c3101a>AnchorAssigner));
			emissionPhaseObjectGraphVisitorFactories.Remove(typeof(<61c08950-c763-485f-b012-f8feedbe96f9>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 <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder EmitDefaults()
		{
			return ConfigureDefaultValuesHandling(<82c71c17-8813-4fa6-8ba4-ee0247932a58>DefaultValuesHandling.Preserve);
		}

		public <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder ConfigureDefaultValuesHandling(<82c71c17-8813-4fa6-8ba4-ee0247932a58>DefaultValuesHandling configuration)
		{
			defaultValuesHandlingConfiguration = configuration;
			return this;
		}

		public <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder JsonCompatible()
		{
			emitterSettings = emitterSettings.WithMaxSimpleKeyLength(int.MaxValue).WithoutAnchorName();
			return WithTypeConverter(new <089ccd08-703f-46c5-9096-8e9c6c6e1322>GuidConverter(jsonCompatible: true), delegate(<da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> w)
			{
				w.InsteadOf<<089ccd08-703f-46c5-9096-8e9c6c6e1322>GuidConverter>();
			}).WithEventEmitter([<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] ([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)] <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter inner) => new <860f24a1-4f5b-4985-983d-4649cfab681d>JsonEventEmitter(inner), delegate(<da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<<88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter> loc)
			{
				loc.InsteadOf<<525b36b9-3eba-481e-b0e0-b4af5934ae49>TypeAssigningEventEmitter>();
			});
		}

		public <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(<da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<<ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>> w)
			{
				w.OnTop();
			});
		}

		public <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor, Action<<da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<<ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>>> where) where TObjectGraphVisitor : <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>
		{
			if (objectGraphVisitor == null)
			{
				throw new ArgumentNullException("objectGraphVisitor");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> _) => objectGraphVisitor));
			return this;
		}

		public <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] TObjectGraphVisitor>(<abcc739a-3cd5-4a0d-8a88-9cfef1aa4e82>WrapperFactory<<ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<<076c1b1b-cf5e-43de-aa04-fbe8d6feb0e4>ITrackingRegistrationLocationSelectionSyntax<<ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>>> where) where TObjectGraphVisitor : <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (<ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing> wrapped, IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> _) => objectGraphVisitorFactory(wrapped)));
			return this;
		}

		public <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] TObjectGraphVisitor>() where TObjectGraphVisitor : <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>
		{
			return WithoutPreProcessingPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

		public <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor(Type objectGraphVisitorType)
		{
			if (objectGraphVisitorType == null)
			{
				throw new ArgumentNullException("objectGraphVisitorType");
			}
			preProcessingPhaseObjectGraphVisitorFactories.Remove(objectGraphVisitorType);
			return this;
		}

		public <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder WithObjectGraphTraversalStrategyFactory(<06749d51-9f42-4380-a85b-968f20b18529>ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory)
		{
			this.objectGraphTraversalStrategyFactory = objectGraphTraversalStrategyFactory;
			return this;
		}

		public <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder WithEmissionPhaseObjectGraphVisitor<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] TObjectGraphVisitor>(Func<<01b55b5f-2386-4395-a010-eda1ba2fa7b1>EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter>
		{
			return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(<da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<<ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter>> w)
			{
				w.OnTop();
			});
		}

		public <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder WithEmissionPhaseObjectGraphVisitor<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] TObjectGraphVisitor>(Func<<01b55b5f-2386-4395-a010-eda1ba2fa7b1>EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory, Action<<da7d5765-149e-49a3-961a-f8462404360c>IRegistrationLocationSelectionSyntax<<ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter>>> where) where TObjectGraphVisitor : <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (<01b55b5f-2386-4395-a010-eda1ba2fa7b1>EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(args)));
			return this;
		}

		public <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder WithEmissionPhaseObjectGraphVisitor<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] TObjectGraphVisitor>(<05ec3915-2ffa-4099-8b31-c436678cbfa1>WrapperFactory<<01b55b5f-2386-4395-a010-eda1ba2fa7b1>EmissionPhaseObjectGraphVisitorArgs, <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<<076c1b1b-cf5e-43de-aa04-fbe8d6feb0e4>ITrackingRegistrationLocationSelectionSyntax<<ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter>>> where) where TObjectGraphVisitor : <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (<ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter> wrapped, <01b55b5f-2386-4395-a010-eda1ba2fa7b1>EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(wrapped, args)));
			return this;
		}

		public <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder WithoutEmissionPhaseObjectGraphVisitor<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] TObjectGraphVisitor>() where TObjectGraphVisitor : <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter>
		{
			return WithoutEmissionPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

		public <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder WithoutEmissionPhaseObjectGraphVisitor(Type objectGraphVisitorType)
		{
			if (objectGraphVisitorType == null)
			{
				throw new ArgumentNullException("objectGraphVisitorType");
			}
			emissionPhaseObjectGraphVisitorFactories.Remove(objectGraphVisitorType);
			return this;
		}

		public <538a020d-f1b6-477a-854a-3265c85f81d9>SerializerBuilder WithIndentedSequences()
		{
			emitterSettings = emitterSettings.WithIndentedSequences();
			return this;
		}

		public <02be5cab-5e04-47ac-b2cb-9e40af11d936>ISerializer Build()
		{
			return <221732a8-002b-4e4c-9d34-106d4d0d232c>Serializer.FromValueSerializer(BuildValueSerializer(), emitterSettings);
		}

		public <b36ce955-3411-45a4-97de-85b2696966cb>IValueSerializer BuildValueSerializer()
		{
			IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> typeConverters = BuildTypeConverters();
			<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector typeInspector = BuildTypeInspector();
			<8fec2f07-147a-4858-aec8-d12a2f118a9c>IObjectGraphTraversalStrategy traversalStrategy = objectGraphTraversalStrategyFactory(typeInspector, typeResolver, typeConverters, maximumRecursion);
			<88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter eventEmitter = eventEmitterFactories.BuildComponentChain(new <c35a9c34-ba2f-44f4-a294-0908aae5017f>WriterEventEmitter());
			return new ValueSerializer(traversalStrategy, eventEmitter, typeConverters, preProcessingPhaseObjectGraphVisitorFactories.Clone(), emissionPhaseObjectGraphVisitorFactories.Clone());
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <57a1a983-9c63-48ff-9fd4-85083d62d2fc>StreamFragment : <3e02419b-73d0-43d6-8614-b0bb250feb69>IYamlConvertible
	{
		private readonly List<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> events = new List<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent>();

		public IList<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> Events => events;

		void <3e02419b-73d0-43d6-8614-b0bb250feb69>IYamlConvertible.Read(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, Type expectedType, <e75d04a3-617f-4e9f-93b7-e90dcd228b4c>ObjectDeserializer nestedObjectDeserializer)
		{
			events.Clear();
			int num = 0;
			do
			{
				if (!parser.MoveNext())
				{
					throw new InvalidOperationException("The parser has reached the end before deserialization completed.");
				}
				<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent current = parser.Current;
				events.Add(current);
				num += current.NestingIncrease;
			}
			while (num > 0);
		}

		void <3e02419b-73d0-43d6-8614-b0bb250feb69>IYamlConvertible.Write(<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter, <dd379040-fcd6-4c71-bd11-b3912495c170>ObjectSerializer nestedObjectSerializer)
		{
			foreach (<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent @event in events)
			{
				emitter.Emit(@event);
			}
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <aee1c6e0-d71c-466f-b8cd-b78527ef3c39>TagMappings
	{
		private readonly IDictionary<string, Type> mappings;

		public <aee1c6e0-d71c-466f-b8cd-b78527ef3c39>TagMappings()
		{
			mappings = new Dictionary<string, Type>();
		}

		public <aee1c6e0-d71c-466f-b8cd-b78527ef3c39>TagMappings(IDictionary<string, Type> mappings)
		{
			this.mappings = new Dictionary<string, Type>(mappings);
		}

		public void Add(string tag, Type mapping)
		{
			mappings.Add(tag, mapping);
		}

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		internal Type GetMapping(string tag)
		{
			if (!mappings.TryGetValue(tag, out var value))
			{
				return null;
			}
			return value;
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <698cfdd6-bb84-41bf-9c32-581dc9d8f35c>YamlAttributeOverrides
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
		private struct AttributeKey
		{
			public readonly Type AttributeType;

			public readonly string PropertyName;

			public AttributeKey(Type attributeType, string propertyName)
			{
				AttributeType = attributeType;
				PropertyName = propertyName;
			}

			[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
			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 <ca709e83-a9df-4fcf-9dd7-e6aed3e61227>HashCode.CombineHashCodes(AttributeType.GetHashCode(), PropertyName.GetHashCode());
			}
		}

		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
		private sealed class AttributeMapping
		{
			public readonly Type RegisteredType;

			public readonly Attribute Attribute;

			public AttributeMapping(Type registeredType, Attribute attribute)
			{
				RegisteredType = registeredType;
				Attribute = attribute;
			}

			[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
			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 <ca709e83-a9df-4fcf-9dd7-e6aed3e61227>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 = <acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.BaseType(type);
				}
				if (matchType.GetInterfaces().Contains(RegisteredType))
				{
					return num;
				}
				return 0;
			}
		}

		private readonly Dictionary<AttributeKey, List<AttributeMapping>> overrides = new Dictionary<AttributeKey, List<AttributeMapping>>();

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public T GetAttribute<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] T>(Type type, string member) where T : Attribute
		{
			if (overrides.TryGetValue(new AttributeKey(typeof(T), member), out var 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 var 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 <698cfdd6-bb84-41bf-9c32-581dc9d8f35c>YamlAttributeOverrides Clone()
		{
			<698cfdd6-bb84-41bf-9c32-581dc9d8f35c>YamlAttributeOverrides <698cfdd6-bb84-41bf-9c32-581dc9d8f35c>YamlAttributeOverrides2 = new <698cfdd6-bb84-41bf-9c32-581dc9d8f35c>YamlAttributeOverrides();
			foreach (KeyValuePair<AttributeKey, List<AttributeMapping>> @override in overrides)
			{
				foreach (AttributeMapping item in @override.Value)
				{
					<698cfdd6-bb84-41bf-9c32-581dc9d8f35c>YamlAttributeOverrides2.Add(item.RegisteredType, @override.Key.PropertyName, item.Attribute);
				}
			}
			return <698cfdd6-bb84-41bf-9c32-581dc9d8f35c>YamlAttributeOverrides2;
		}

		public void Add<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
		{
			PropertyInfo propertyInfo = <b78fbfa8-7538-4073-8c88-70abe52dcb8d>ExpressionExtensions.AsProperty(propertyAccessor);
			Add(typeof(TClass), propertyInfo.Name, attribute);
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <954f5de4-5a92-46ec-a889-762e47478d5e>YamlAttributeOverridesInspector : <86e43c96-a221-419e-9bd7-b0faa290d0f0>TypeInspectorSkeleton
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
		public sealed class OverridePropertyDescriptor : <b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor
		{
			private readonly <b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor baseDescriptor;

			private readonly <698cfdd6-bb84-41bf-9c32-581dc9d8f35c>YamlAttributeOverrides overrides;

			private readonly Type classType;

			public string Name => baseDescriptor.Name;

			public bool CanWrite => baseDescriptor.CanWrite;

			public Type Type => baseDescriptor.Type;

			[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
			public Type TypeOverride
			{
				[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
				get
				{
					return baseDescriptor.TypeOverride;
				}
				[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
				set
				{
					baseDescriptor.TypeOverride = value;
				}
			}

			public int Order
			{
				get
				{
					return baseDescriptor.Order;
				}
				set
				{
					baseDescriptor.Order = value;
				}
			}

			public <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle ScalarStyle
			{
				get
				{
					return baseDescriptor.ScalarStyle;
				}
				set
				{
					baseDescriptor.ScalarStyle = value;
				}
			}

			public OverridePropertyDescriptor(<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor baseDescriptor, <698cfdd6-bb84-41bf-9c32-581dc9d8f35c>YamlAttributeOverrides overrides, Type classType)
			{
				this.baseDescriptor = baseDescriptor;
				this.overrides = overrides;
				this.classType = classType;
			}

			public void Write(object target, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object value)
			{
				baseDescriptor.Write(target, value);
			}

			public T GetCustomAttribute<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] T>() where T : Attribute
			{
				return overrides.GetAttribute<T>(classType, Name) ?? baseDescriptor.GetCustomAttribute<T>();
			}

			public <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor Read(object target)
			{
				return baseDescriptor.Read(target);
			}
		}

		private readonly <c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector innerTypeDescriptor;

		private readonly <698cfdd6-bb84-41bf-9c32-581dc9d8f35c>YamlAttributeOverrides overrides;

		public <954f5de4-5a92-46ec-a889-762e47478d5e>YamlAttributeOverridesInspector(<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector innerTypeDescriptor, <698cfdd6-bb84-41bf-9c32-581dc9d8f35c>YamlAttributeOverrides overrides)
		{
			this.innerTypeDescriptor = innerTypeDescriptor;
			this.overrides = overrides;
		}

		public override IEnumerable<<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor> GetProperties(Type type, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object container)
		{
			IEnumerable<<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor> enumerable = innerTypeDescriptor.GetProperties(type, container);
			if (overrides != null)
			{
				enumerable = enumerable.Select((Func<<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor, <b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor>)([<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] (<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor p) => new OverridePropertyDescriptor(p, overrides, type)));
			}
			return enumerable;
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <cbdec7df-23b2-476b-8366-97511b82a1d2>YamlAttributesTypeInspector : <86e43c96-a221-419e-9bd7-b0faa290d0f0>TypeInspectorSkeleton
	{
		private readonly <c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector innerTypeDescriptor;

		public <cbdec7df-23b2-476b-8366-97511b82a1d2>YamlAttributesTypeInspector(<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor;
		}

		public override IEnumerable<<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor> GetProperties(Type type, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object container)
		{
			return from p in (from p in innerTypeDescriptor.GetProperties(type, container)
					where p.GetCustomAttribute<<6c17837b-b745-4559-bc99-954588eee29b>YamlIgnoreAttribute>() == null
					select p).Select((Func<<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor, <b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor>)([<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] (<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor p) =>
				{
					<ea25870f-853c-44d7-91ee-50f7d3c45c0e>PropertyDescriptor <ea25870f-853c-44d7-91ee-50f7d3c45c0e>PropertyDescriptor2 = new <ea25870f-853c-44d7-91ee-50f7d3c45c0e>PropertyDescriptor(p);
					<ea041798-c1a6-4d46-aca6-4bf883e221c4>YamlMemberAttribute customAttribute = p.GetCustomAttribute<<ea041798-c1a6-4d46-aca6-4bf883e221c4>YamlMemberAttribute>();
					if (customAttribute != null)
					{
						if (customAttribute.SerializeAs != null)
						{
							<ea25870f-853c-44d7-91ee-50f7d3c45c0e>PropertyDescriptor2.TypeOverride = customAttribute.SerializeAs;
						}
						<ea25870f-853c-44d7-91ee-50f7d3c45c0e>PropertyDescriptor2.Order = customAttribute.Order;
						<ea25870f-853c-44d7-91ee-50f7d3c45c0e>PropertyDescriptor2.ScalarStyle = customAttribute.ScalarStyle;
						if (customAttribute.Alias != null)
						{
							<ea25870f-853c-44d7-91ee-50f7d3c45c0e>PropertyDescriptor2.Name = customAttribute.Alias;
						}
					}
					return <ea25870f-853c-44d7-91ee-50f7d3c45c0e>PropertyDescriptor2;
				}))
				orderby p.Order
				select p;
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal static class <46127bb1-62af-4f27-b7c6-e869bac36295>YamlFormatter
	{
		public static readonly NumberFormatInfo NumberFormat = 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 static string FormatNumber(object number)
		{
			return Convert.ToString(number, NumberFormat);
		}

		public static string FormatNumber(double number)
		{
			return number.ToString("G17", NumberFormat);
		}

		public static string FormatNumber(float number)
		{
			return number.ToString("G17", NumberFormat);
		}

		public static string FormatBoolean(object boolean)
		{
			if (!boolean.Equals(true))
			{
				return "false";
			}
			return "true";
		}

		public static string FormatDateTime(object dateTime)
		{
			return ((DateTime)dateTime).ToString("o", CultureInfo.InvariantCulture);
		}

		public static string FormatTimeSpan(object timeSpan)
		{
			return ((TimeSpan)timeSpan).ToString();
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	internal sealed class <6c17837b-b745-4559-bc99-954588eee29b>YamlIgnoreAttribute : Attribute
	{
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	internal sealed class <ea041798-c1a6-4d46-aca6-4bf883e221c4>YamlMemberAttribute : Attribute
	{
		private <82c71c17-8813-4fa6-8ba4-ee0247932a58>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 <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle ScalarStyle { get; set; }

		public <82c71c17-8813-4fa6-8ba4-ee0247932a58>DefaultValuesHandling DefaultValuesHandling
		{
			get
			{
				return defaultValuesHandling.GetValueOrDefault();
			}
			set
			{
				defaultValuesHandling = value;
			}
		}

		public bool IsDefaultValuesHandlingSpecified => defaultValuesHandling.HasValue;

		public <ea041798-c1a6-4d46-aca6-4bf883e221c4>YamlMemberAttribute()
		{
			ScalarStyle = <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Any;
			ApplyNamingConventions = true;
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <ea041798-c1a6-4d46-aca6-4bf883e221c4>YamlMemberAttribute(Type serializeAs)
			: this()
		{
			SerializeAs = serializeAs ?? throw new ArgumentNullException("serializeAs");
		}
	}
}
namespace YamlDotNet.Serialization.ValueDeserializers
{
	internal sealed class <45ddfc0a-42f9-45b6-a52f-1b19cfba73e2>AliasValueDeserializer : <59bc90d3-d6d7-4700-894d-caa6cefe9734>IValueDeserializer
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 0, 1 })]
		private sealed class AliasState : Dictionary<<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName, ValuePromise>, <9838f301-20fb-43ff-912f-ce4fa4f0a035>IPostDeserializationCallback
		{
			public void OnDeserialization()
			{
				foreach (ValuePromise value in base.Values)
				{
					if (!value.HasValue)
					{
						<5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias alias = value.Alias;
						throw new <6f9a9fe8-ee96-4d89-94b1-d3035acc9d78>AnchorNotFoundException(alias.Start, alias.End, $"Anchor '{alias.Value}' not found");
					}
				}
			}
		}

		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
		private sealed class ValuePromise : <cf2045f1-17de-4280-8f65-79ee218e11fd>IValuePromise
		{
			private object value;

			public readonly <5c69e3ec-21af-445a-ac93-12786d7b3fe6>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;

			[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
			public ValuePromise(<5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias alias)
			{
				Alias = alias;
			}

			public ValuePromise(object value)
			{
				HasValue = true;
				this.value = value;
			}
		}

		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)]
		private readonly <59bc90d3-d6d7-4700-894d-caa6cefe9734>IValueDeserializer innerDeserializer;

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <45ddfc0a-42f9-45b6-a52f-1b19cfba73e2>AliasValueDeserializer(<59bc90d3-d6d7-4700-894d-caa6cefe9734>IValueDeserializer innerDeserializer)
		{
			this.innerDeserializer = innerDeserializer ?? throw new ArgumentNullException("innerDeserializer");
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public object DeserializeValue(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, Type expectedType, <e8b5a30e-e5b1-4404-8295-1146ea66a434>SerializerState state, <59bc90d3-d6d7-4700-894d-caa6cefe9734>IValueDeserializer nestedObjectDeserializer)
		{
			if (parser.TryConsume<<5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias>(out var @event))
			{
				if (!state.Get<AliasState>().TryGetValue(@event.Value, out var value))
				{
					throw new <6f9a9fe8-ee96-4d89-94b1-d3035acc9d78>AnchorNotFoundException(@event.Start, @event.End, $"Alias ${@event.Value} cannot precede anchor declaration");
				}
				if (!value.HasValue)
				{
					return value;
				}
				return value.Value;
			}
			<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName = <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName.Empty;
			if (parser.Accept<<1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent>(out var event2) && !event2.Anchor.IsEmpty)
			{
				<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName = event2.Anchor;
				AliasState aliasState = state.Get<AliasState>();
				if (!aliasState.ContainsKey(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName))
				{
					aliasState[<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName] = new ValuePromise(new <5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName));
				}
			}
			object obj = innerDeserializer.DeserializeValue(parser, expectedType, state, nestedObjectDeserializer);
			if (!<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName.IsEmpty)
			{
				AliasState aliasState2 = state.Get<AliasState>();
				if (!aliasState2.TryGetValue(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName, out var value2))
				{
					aliasState2.Add(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName, new ValuePromise(obj));
				}
				else if (!value2.HasValue)
				{
					value2.Value = obj;
				}
				else
				{
					aliasState2[<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName] = new ValuePromise(obj);
				}
			}
			return obj;
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <84d08373-c369-4018-ab8f-7b61622623d7>NodeValueDeserializer : <59bc90d3-d6d7-4700-894d-caa6cefe9734>IValueDeserializer
	{
		private readonly IList<<5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer> deserializers;

		private readonly IList<<d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver> typeResolvers;

		public <84d08373-c369-4018-ab8f-7b61622623d7>NodeValueDeserializer(IList<<5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer> deserializers, IList<<d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver> typeResolvers)
		{
			this.deserializers = deserializers ?? throw new ArgumentNullException("deserializers");
			this.typeResolvers = typeResolvers ?? throw new ArgumentNullException("typeResolvers");
		}

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public object DeserializeValue(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, Type expectedType, <e8b5a30e-e5b1-4404-8295-1146ea66a434>SerializerState state, <59bc90d3-d6d7-4700-894d-caa6cefe9734>IValueDeserializer nestedObjectDeserializer)
		{
			parser.Accept<<1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent>(out var @event);
			Type typeFromEvent = GetTypeFromEvent(@event, expectedType);
			try
			{
				foreach (<5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer deserializer in deserializers)
				{
					if (deserializer.Deserialize(parser, typeFromEvent, [return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] (<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser r, Type t) => nestedObjectDeserializer.DeserializeValue(r, t, state, nestedObjectDeserializer), out var value))
					{
						return <57e98fe4-e44d-4ae6-be9d-c111589c4e53>TypeConverter.ChangeType(value, expectedType);
					}
				}
			}
			catch (<c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException)
			{
				throw;
			}
			catch (Exception innerException)
			{
				throw new <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException(@event?.Start ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, @event?.End ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, "Exception during deserialization", innerException);
			}
			throw new <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException(@event?.Start ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, @event?.End ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, "No node deserializer was able to deserialize the node into type " + expectedType.AssemblyQualifiedName);
		}

		private Type GetTypeFromEvent([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] <1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent nodeEvent, Type currentType)
		{
			using (IEnumerator<<d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver> enumerator = typeResolvers.GetEnumerator())
			{
				while (enumerator.MoveNext() && !enumerator.Current.Resolve(nodeEvent, ref currentType))
				{
				}
			}
			return currentType;
		}
	}
}
namespace YamlDotNet.Serialization.Utilities
{
	internal interface <9838f301-20fb-43ff-912f-ce4fa4f0a035>IPostDeserializationCallback
	{
		void OnDeserialization();
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <33b0eac6-1925-4083-af6b-721927908545>ObjectAnchorCollection
	{
		private readonly IDictionary<string, object> objectsByAnchor = new Dictionary<string, object>();

		private readonly IDictionary<object, string> anchorsByObject = new Dictionary<object, string>();

		public object this[string anchor]
		{
			get
			{
				if (objectsByAnchor.TryGetValue(anchor, out var value))
				{
					return value;
				}
				throw new <6f9a9fe8-ee96-4d89-94b1-d3035acc9d78>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, [<b3ae408d-452a-47a4-a4cd-28743506c159>MaybeNullWhen(false)][<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] out string anchor)
		{
			return anchorsByObject.TryGetValue(@object, out anchor);
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal static class <2ea259c5-a144-4d42-b39c-a8adef3fb3cb>ReflectionUtility
	{
		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public static Type GetImplementedGenericInterface(Type type, Type genericInterfaceType)
		{
			foreach (Type implementedInterface in GetImplementedInterfaces(type))
			{
				if (<acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.IsGenericType(implementedInterface) && implementedInterface.GetGenericTypeDefinition() == genericInterfaceType)
				{
					return implementedInterface;
				}
			}
			return null;
		}

		public static IEnumerable<Type> GetImplementedInterfaces(Type type)
		{
			if (<acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.IsInterface(type))
			{
				yield return type;
			}
			Type[] interfaces = type.GetInterfaces();
			for (int i = 0; i < interfaces.Length; i++)
			{
				yield return interfaces[i];
			}
		}
	}
	internal sealed class <e8b5a30e-e5b1-4404-8295-1146ea66a434>SerializerState : IDisposable
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)]
		private readonly IDictionary<Type, object> items = new Dictionary<Type, object>();

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public T Get<T>() where T : class, new()
		{
			if (!items.TryGetValue(typeof(T), out var value))
			{
				value = new T();
				items.Add(typeof(T), value);
			}
			return (T)value;
		}

		public void OnDeserialization()
		{
			foreach (<9838f301-20fb-43ff-912f-ce4fa4f0a035>IPostDeserializationCallback item in items.Values.OfType<<9838f301-20fb-43ff-912f-ce4fa4f0a035>IPostDeserializationCallback>())
			{
				item.OnDeserialization();
			}
		}

		public void Dispose()
		{
			foreach (IDisposable item in items.Values.OfType<IDisposable>())
			{
				item.Dispose();
			}
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal static class <ac867188-473d-4882-aa28-c6c465c24f34>StringExtensions
	{
		private static string ToCamelOrPascalCase(string str, Func<char, char> firstLetterTransform)
		{
			string text = Regex.Replace(str, "([_\\-])(?<char>[a-z])", [<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] (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)
		{
			str = char.ToLower(str[0]) + str.Substring(1);
			str = Regex.Replace(ToCamelCase(str), "(?<char>[A-Z])", [<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] (Match match) => separator + match.Groups["char"].Value.ToLowerInvariant());
			return str;
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal static class <57e98fe4-e44d-4ae6-be9d-c111589c4e53>TypeConverter
	{
		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)]
		public static T ChangeType<T>(object value)
		{
			return (T)ChangeType(value, typeof(T));
		}

		public static T ChangeType<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] T>([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object value, IFormatProvider provider)
		{
			return (T)ChangeType(value, typeof(T), provider);
		}

		public static T ChangeType<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] T>([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object value, CultureInfo culture)
		{
			return (T)ChangeType(value, typeof(T), culture);
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
		public static object ChangeType(object value, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)] Type destinationType)
		{
			return ChangeType(value, destinationType, CultureInfo.InvariantCulture);
		}

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public static object ChangeType([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object value, Type destinationType, IFormatProvider provider)
		{
			return ChangeType(value, destinationType, new <8d67ac96-8305-4788-9f4a-0e3d502e85e6>CultureInfoAdapter(CultureInfo.CurrentCulture, provider));
		}

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public static object ChangeType([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object value, Type destinationType, CultureInfo culture)
		{
			if (value == null || <acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.IsDbNull(value))
			{
				if (!<acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.IsValueType(destinationType))
				{
					return null;
				}
				return Activator.CreateInstance(destinationType);
			}
			Type type = value.GetType();
			if (destinationType == type || destinationType.IsAssignableFrom(type))
			{
				return value;
			}
			if (<acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.IsGenericType(destinationType) && destinationType.GetGenericTypeDefinition() == typeof(Nullable<>))
			{
				Type destinationType2 = destinationType.GetGenericArguments()[0];
				object obj = ChangeType(value, destinationType2, culture);
				return Activator.CreateInstance(destinationType, obj);
			}
			if (<acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.IsEnum(destinationType))
			{
				if (!(value is string value2))
				{
					return value;
				}
				return Enum.Parse(destinationType, value2, ignoreCase: true);
			}
			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 };
			for (int i = 0; i < array.Length; i++)
			{
				foreach (MethodInfo publicStaticMethod2 in <acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.GetPublicStaticMethods(array[i]))
				{
					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 <acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.Unwrap(ex);
						}
					}
				}
			}
			if (type == typeof(string))
			{
				try
				{
					MethodInfo publicStaticMethod = <acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.GetPublicStaticMethod(destinationType, "Parse", typeof(string), typeof(IFormatProvider));
					if (publicStaticMethod != null)
					{
						return publicStaticMethod.Invoke(null, new object[2] { value, culture });
					}
					publicStaticMethod = <acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.GetPublicStaticMethod(destinationType, "Parse", typeof(string));
					if (publicStaticMethod != null)
					{
						return publicStaticMethod.Invoke(null, new object[1] { value });
					}
				}
				catch (TargetInvocationException ex2)
				{
					throw <acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.Unwrap(ex2);
				}
			}
			if (destinationType == typeof(TimeSpan))
			{
				return TimeSpan.Parse((string)ChangeType(value, typeof(string), CultureInfo.InvariantCulture));
			}
			return Convert.ChangeType(value, destinationType, CultureInfo.InvariantCulture);
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)]
		[PermissionSet(SecurityAction.LinkDemand, Name = "FullTrust")]
		public static void RegisterTypeConverter<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TConvertible, TConverter>() where TConverter : System.ComponentModel.TypeConverter
		{
			if (!TypeDescriptor.GetAttributes(typeof(TConvertible)).OfType<TypeConverterAttribute>().Any([<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] (TypeConverterAttribute a) => a.ConverterTypeName == typeof(TConverter).AssemblyQualifiedName))
			{
				TypeDescriptor.AddAttributes(typeof(TConvertible), new TypeConverterAttribute(typeof(TConverter)));
			}
		}
	}
}
namespace YamlDotNet.Serialization.TypeResolvers
{
	internal sealed class <b5752c80-5c0a-4e9d-b404-4b65a5526ba2>DynamicTypeResolver : <a0cad0d5-d219-4360-a990-d287fb745b59>ITypeResolver
	{
		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public Type Resolve(Type staticType, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object actualValue)
		{
			if (actualValue == null)
			{
				return staticType;
			}
			return actualValue.GetType();
		}
	}
	internal sealed class <7b16730a-6bcc-451e-9956-ab5db3e49063>StaticTypeResolver : <a0cad0d5-d219-4360-a990-d287fb745b59>ITypeResolver
	{
		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public Type Resolve(Type staticType, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object actualValue)
		{
			return staticType;
		}
	}
}
namespace YamlDotNet.Serialization.TypeInspectors
{
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <dace3dd6-0f6a-40a0-950a-bb1fef69a1a7>CachedTypeInspector : <86e43c96-a221-419e-9bd7-b0faa290d0f0>TypeInspectorSkeleton
	{
		private readonly <c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector innerTypeDescriptor;

		private readonly ConcurrentDictionary<Type, List<<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor>> cache = new ConcurrentDictionary<Type, List<<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor>>();

		public <dace3dd6-0f6a-40a0-950a-bb1fef69a1a7>CachedTypeInspector(<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
		}

		public override IEnumerable<<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor> GetProperties(Type type, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object container)
		{
			return cache.GetOrAdd(type, (Type t) => innerTypeDescriptor.GetProperties(t, container).ToList());
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <f92d4208-2e7f-44b9-8f84-90e8f1cd872e>CompositeTypeInspector : <86e43c96-a221-419e-9bd7-b0faa290d0f0>TypeInspectorSkeleton
	{
		private readonly IEnumerable<<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector> typeInspectors;

		public <f92d4208-2e7f-44b9-8f84-90e8f1cd872e>CompositeTypeInspector(params <c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector[] typeInspectors)
			: this((IEnumerable<<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector>)typeInspectors)
		{
		}

		public <f92d4208-2e7f-44b9-8f84-90e8f1cd872e>CompositeTypeInspector(IEnumerable<<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector> typeInspectors)
		{
			this.typeInspectors = typeInspectors?.ToList() ?? throw new ArgumentNullException("typeInspectors");
		}

		public override IEnumerable<<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor> GetProperties(Type type, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object container)
		{
			return typeInspectors.SelectMany([<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] (<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector i) => i.GetProperties(type, container));
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <384827fc-2549-46e1-838b-08144eee85ef>NamingConventionTypeInspector : <86e43c96-a221-419e-9bd7-b0faa290d0f0>TypeInspectorSkeleton
	{
		private readonly <c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector innerTypeDescriptor;

		private readonly <2282eb5c-6849-4bd4-9f7d-f9cba43dc317>INamingConvention namingConvention;

		public <384827fc-2549-46e1-838b-08144eee85ef>NamingConventionTypeInspector(<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector innerTypeDescriptor, <2282eb5c-6849-4bd4-9f7d-f9cba43dc317>INamingConvention namingConvention)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
		}

		public override IEnumerable<<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor> GetProperties(Type type, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object container)
		{
			return innerTypeDescriptor.GetProperties(type, container).Select([<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] (<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor p) =>
			{
				<ea041798-c1a6-4d46-aca6-4bf883e221c4>YamlMemberAttribute customAttribute = p.GetCustomAttribute<<ea041798-c1a6-4d46-aca6-4bf883e221c4>YamlMemberAttribute>();
				return (customAttribute != null && !customAttribute.ApplyNamingConventions) ? p : new <ea25870f-853c-44d7-91ee-50f7d3c45c0e>PropertyDescriptor(p)
				{
					Name = namingConvention.Apply(p.Name)
				};
			});
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <f81f28d6-2802-4980-b60b-a409dcfe10eb>ReadableAndWritablePropertiesTypeInspector : <86e43c96-a221-419e-9bd7-b0faa290d0f0>TypeInspectorSkeleton
	{
		private readonly <c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector innerTypeDescriptor;

		public <f81f28d6-2802-4980-b60b-a409dcfe10eb>ReadableAndWritablePropertiesTypeInspector(<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
		}

		public override IEnumerable<<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor> GetProperties(Type type, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object container)
		{
			return from p in innerTypeDescriptor.GetProperties(type, container)
				where p.CanWrite
				select p;
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <1bccea63-99dc-4dae-8fa1-69fd1b6eb7d6>ReadableFieldsTypeInspector : <86e43c96-a221-419e-9bd7-b0faa290d0f0>TypeInspectorSkeleton
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
		private sealed class ReflectionFieldDescriptor : <b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor
		{
			private readonly FieldInfo fieldInfo;

			private readonly <a0cad0d5-d219-4360-a990-d287fb745b59>ITypeResolver typeResolver;

			public string Name => fieldInfo.Name;

			public Type Type => fieldInfo.FieldType;

			[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
			[field: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
			public Type TypeOverride
			{
				[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
				get;
				[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
				set;
			}

			public int Order { get; set; }

			public bool CanWrite => !fieldInfo.IsInitOnly;

			public <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle ScalarStyle { get; set; }

			public ReflectionFieldDescriptor(FieldInfo fieldInfo, <a0cad0d5-d219-4360-a990-d287fb745b59>ITypeResolver typeResolver)
			{
				this.fieldInfo = fieldInfo;
				this.typeResolver = typeResolver;
				ScalarStyle = <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Any;
			}

			public void Write(object target, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object value)
			{
				fieldInfo.SetValue(target, value);
			}

			public T GetCustomAttribute<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] T>() where T : Attribute
			{
				return (T)fieldInfo.GetCustomAttributes(typeof(T), inherit: true).FirstOrDefault();
			}

			public <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor Read(object target)
			{
				object value = fieldInfo.GetValue(target);
				Type type = TypeOverride ?? typeResolver.Resolve(Type, value);
				return new <060951e9-e294-406d-a792-8a5d53b008e3>ObjectDescriptor(value, type, Type, ScalarStyle);
			}
		}

		private readonly <a0cad0d5-d219-4360-a990-d287fb745b59>ITypeResolver typeResolver;

		public <1bccea63-99dc-4dae-8fa1-69fd1b6eb7d6>ReadableFieldsTypeInspector(<a0cad0d5-d219-4360-a990-d287fb745b59>ITypeResolver typeResolver)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
		}

		public override IEnumerable<<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor> GetProperties(Type type, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object container)
		{
			return <acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.GetPublicFields(type).Select((Func<FieldInfo, <b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor>)([<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] (FieldInfo p) => new ReflectionFieldDescriptor(p, typeResolver)));
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <159aff9c-3798-434e-b82c-443115fbaf81>ReadablePropertiesTypeInspector : <86e43c96-a221-419e-9bd7-b0faa290d0f0>TypeInspectorSkeleton
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
		private sealed class ReflectionPropertyDescriptor : <b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor
		{
			private readonly PropertyInfo propertyInfo;

			private readonly <a0cad0d5-d219-4360-a990-d287fb745b59>ITypeResolver typeResolver;

			public string Name => propertyInfo.Name;

			public Type Type => propertyInfo.PropertyType;

			[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
			[field: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
			public Type TypeOverride
			{
				[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
				get;
				[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
				set;
			}

			public int Order { get; set; }

			public bool CanWrite => propertyInfo.CanWrite;

			public <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle ScalarStyle { get; set; }

			public ReflectionPropertyDescriptor(PropertyInfo propertyInfo, <a0cad0d5-d219-4360-a990-d287fb745b59>ITypeResolver typeResolver)
			{
				this.propertyInfo = propertyInfo ?? throw new ArgumentNullException("propertyInfo");
				this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
				ScalarStyle = <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Any;
			}

			public void Write(object target, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object value)
			{
				propertyInfo.SetValue(target, value, null);
			}

			public T GetCustomAttribute<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] T>() where T : Attribute
			{
				return (T)<acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.GetAllCustomAttributes<T>(propertyInfo).FirstOrDefault();
			}

			public <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor Read(object target)
			{
				object obj = <c9696b4d-ea07-415b-aef8-257468acf22c>PropertyInfoExtensions.ReadValue(propertyInfo, target);
				Type type = TypeOverride ?? typeResolver.Resolve(Type, obj);
				return new <060951e9-e294-406d-a792-8a5d53b008e3>ObjectDescriptor(obj, type, Type, ScalarStyle);
			}
		}

		private readonly <a0cad0d5-d219-4360-a990-d287fb745b59>ITypeResolver typeResolver;

		private readonly bool includeNonPublicProperties;

		public <159aff9c-3798-434e-b82c-443115fbaf81>ReadablePropertiesTypeInspector(<a0cad0d5-d219-4360-a990-d287fb745b59>ITypeResolver typeResolver)
			: this(typeResolver, includeNonPublicProperties: false)
		{
		}

		public <159aff9c-3798-434e-b82c-443115fbaf81>ReadablePropertiesTypeInspector(<a0cad0d5-d219-4360-a990-d287fb745b59>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<<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor> GetProperties(Type type, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object container)
		{
			return <acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.GetProperties(type, includeNonPublicProperties).Where(IsValidProperty).Select((Func<PropertyInfo, <b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor>)([<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] (PropertyInfo p) => new ReflectionPropertyDescriptor(p, typeResolver)));
		}
	}
	internal abstract class <86e43c96-a221-419e-9bd7-b0faa290d0f0>TypeInspectorSkeleton : <c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector
	{
		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public abstract IEnumerable<<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor> GetProperties(Type type, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object container);

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor GetProperty(Type type, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object container, string name, [<b3ae408d-452a-47a4-a4cd-28743506c159>MaybeNullWhen(true)] bool ignoreUnmatched)
		{
			IEnumerable<<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor> enumerable = from p in GetProperties(type, container)
				where p.Name == name
				select p;
			using IEnumerator<<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor> enumerator = enumerable.GetEnumerator();
			if (!enumerator.MoveNext())
			{
				if (ignoreUnmatched)
				{
					return null;
				}
				throw new SerializationException("Property '" + name + "' not found on type '" + type.FullName + "'.");
			}
			<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor current = enumerator.Current;
			if (enumerator.MoveNext())
			{
				throw new SerializationException("Multiple properties with the name/alias '" + name + "' 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((<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor p) => p.Name).ToArray()));
			}
			return current;
		}
	}
}
namespace YamlDotNet.Serialization.Schemas
{
	internal sealed class <f9890ec4-e989-4845-94cf-bbacb908cd8f>FailsafeSchema
	{
		public static class Tags
		{
			public static readonly <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName Map = new <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName("tag:yaml.org,2002:map");

			public static readonly <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName Seq = new <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName("tag:yaml.org,2002:seq");

			public static readonly <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName Str = new <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName("tag:yaml.org,2002:str");
		}
	}
	internal sealed class <54c3bbba-5048-4fe1-bca0-881daf687cad>JsonSchema
	{
		public static class Tags
		{
			public static readonly <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName Null = new <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName("tag:yaml.org,2002:null");

			public static readonly <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName Bool = new <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName("tag:yaml.org,2002:bool");

			public static readonly <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName Int = new <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName("tag:yaml.org,2002:int");

			public static readonly <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName Float = new <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName("tag:yaml.org,2002:float");
		}
	}
	internal sealed class <4d6718e5-6ebd-4ce3-838d-1dcce3d44414>CoreSchema
	{
		public static class Tags
		{
		}
	}
	internal sealed class <798dfe55-7b25-4a02-b11d-118d7dc1906f>DefaultSchema
	{
		public static class Tags
		{
			public static readonly <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName Timestamp = new <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName("tag:yaml.org,2002:timestamp");
		}
	}
}
namespace YamlDotNet.Serialization.ObjectGraphVisitors
{
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <22caa531-c414-407a-87ad-b6b899c3101a>AnchorAssigner : <4b60b00b-738e-48ce-86a5-34b76bb69cbe>PreProcessingPhaseObjectGraphVisitorSkeleton, <91d2ca13-c2ab-4684-92c9-140b8c0f4d02>IAliasProvider
	{
		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)]
		private class AnchorAssignment
		{
			public <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName Anchor;
		}

		private readonly IDictionary<object, AnchorAssignment> assignments = new Dictionary<object, AnchorAssignment>();

		private uint nextId;

		public <22caa531-c414-407a-87ad-b6b899c3101a>AnchorAssigner(IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> typeConverters)
			: base(typeConverters)
		{
		}

		protected override bool Enter(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value)
		{
			if (value.Value != null && assignments.TryGetValue(value.Value, out var value2))
			{
				if (value2.Anchor.IsEmpty)
				{
					value2.Anchor = new <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName("o" + nextId.ToString(CultureInfo.InvariantCulture));
					nextId++;
				}
				return false;
			}
			return true;
		}

		protected override bool EnterMapping(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor key, <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value)
		{
			return true;
		}

		protected override bool EnterMapping(<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor key, <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value)
		{
			return true;
		}

		protected override void VisitScalar(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor scalar)
		{
		}

		protected override void VisitMappingStart(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor mapping, Type keyType, Type valueType)
		{
			VisitObject(mapping);
		}

		protected override void VisitMappingEnd(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor mapping)
		{
		}

		protected override void VisitSequenceStart(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor sequence, Type elementType)
		{
			VisitObject(sequence);
		}

		protected override void VisitSequenceEnd(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor sequence)
		{
		}

		private void VisitObject(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value)
		{
			if (value.Value != null)
			{
				assignments.Add(value.Value, new AnchorAssignment());
			}
		}

		<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName <91d2ca13-c2ab-4684-92c9-140b8c0f4d02>IAliasProvider.GetAlias(object target)
		{
			if (target != null && assignments.TryGetValue(target, out var value))
			{
				return value.Anchor;
			}
			return <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName.Empty;
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <61c08950-c763-485f-b012-f8feedbe96f9>AnchorAssigningObjectGraphVisitor : <2b8f0cc0-e6c9-48a7-8c26-6d77cb113cca>ChainedObjectGraphVisitor
	{
		private readonly <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter eventEmitter;

		private readonly <91d2ca13-c2ab-4684-92c9-140b8c0f4d02>IAliasProvider aliasProvider;

		private readonly HashSet<<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName> emittedAliases = new HashSet<<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName>();

		public <61c08950-c763-485f-b012-f8feedbe96f9>AnchorAssigningObjectGraphVisitor(<ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter> nextVisitor, <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter eventEmitter, <91d2ca13-c2ab-4684-92c9-140b8c0f4d02>IAliasProvider aliasProvider)
			: base(nextVisitor)
		{
			this.eventEmitter = eventEmitter;
			this.aliasProvider = aliasProvider;
		}

		public override bool Enter(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			if (value.Value != null)
			{
				<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName alias = aliasProvider.GetAlias(value.Value);
				if (!alias.IsEmpty && !emittedAliases.Add(alias))
				{
					<e70d24c7-2fc4-4deb-935f-2f167bd4ad87>AliasEventInfo <e70d24c7-2fc4-4deb-935f-2f167bd4ad87>AliasEventInfo = new <e70d24c7-2fc4-4deb-935f-2f167bd4ad87>AliasEventInfo(value, alias);
					eventEmitter.Emit(<e70d24c7-2fc4-4deb-935f-2f167bd4ad87>AliasEventInfo, context);
					return <e70d24c7-2fc4-4deb-935f-2f167bd4ad87>AliasEventInfo.NeedsExpansion;
				}
			}
			return base.Enter(value, context);
		}

		public override void VisitMappingStart(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor mapping, Type keyType, Type valueType, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName alias = aliasProvider.GetAlias(mapping.NonNullValue());
			eventEmitter.Emit(new <b5820e3d-2ea9-478e-aa86-8bf43ebfe369>MappingStartEventInfo(mapping)
			{
				Anchor = alias
			}, context);
		}

		public override void VisitSequenceStart(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor sequence, Type elementType, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName alias = aliasProvider.GetAlias(sequence.NonNullValue());
			eventEmitter.Emit(new <bd85e032-3c9d-4aa1-92f8-9a11ece4a496>SequenceStartEventInfo(sequence)
			{
				Anchor = alias
			}, context);
		}

		public override void VisitScalar(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor scalar, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			<3a8120f0-1e22-4688-9f35-7f39f0ca5705>ScalarEventInfo <3a8120f0-1e22-4688-9f35-7f39f0ca5705>ScalarEventInfo = new <3a8120f0-1e22-4688-9f35-7f39f0ca5705>ScalarEventInfo(scalar);
			if (scalar.Value != null)
			{
				<3a8120f0-1e22-4688-9f35-7f39f0ca5705>ScalarEventInfo.Anchor = aliasProvider.GetAlias(scalar.Value);
			}
			eventEmitter.Emit(<3a8120f0-1e22-4688-9f35-7f39f0ca5705>ScalarEventInfo, context);
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal abstract class <2b8f0cc0-e6c9-48a7-8c26-6d77cb113cca>ChainedObjectGraphVisitor : <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter>
	{
		private readonly <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter> nextVisitor;

		protected <2b8f0cc0-e6c9-48a7-8c26-6d77cb113cca>ChainedObjectGraphVisitor(<ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter> nextVisitor)
		{
			this.nextVisitor = nextVisitor;
		}

		public virtual bool Enter(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			return nextVisitor.Enter(value, context);
		}

		public virtual bool EnterMapping(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor key, <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			return nextVisitor.EnterMapping(key, value, context);
		}

		public virtual bool EnterMapping(<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor key, <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			return nextVisitor.EnterMapping(key, value, context);
		}

		public virtual void VisitScalar(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor scalar, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			nextVisitor.VisitScalar(scalar, context);
		}

		public virtual void VisitMappingStart(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor mapping, Type keyType, Type valueType, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			nextVisitor.VisitMappingStart(mapping, keyType, valueType, context);
		}

		public virtual void VisitMappingEnd(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor mapping, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			nextVisitor.VisitMappingEnd(mapping, context);
		}

		public virtual void VisitSequenceStart(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor sequence, Type elementType, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			nextVisitor.VisitSequenceStart(sequence, elementType, context);
		}

		public virtual void VisitSequenceEnd(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor sequence, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			nextVisitor.VisitSequenceEnd(sequence, context);
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <c73ea7a5-082f-42d3-9a73-2b91de13ca80>CommentsObjectGraphVisitor : <2b8f0cc0-e6c9-48a7-8c26-6d77cb113cca>ChainedObjectGraphVisitor
	{
		public <c73ea7a5-082f-42d3-9a73-2b91de13ca80>CommentsObjectGraphVisitor(<ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		public override bool EnterMapping(<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor key, <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			<ea041798-c1a6-4d46-aca6-4bf883e221c4>YamlMemberAttribute customAttribute = key.GetCustomAttribute<<ea041798-c1a6-4d46-aca6-4bf883e221c4>YamlMemberAttribute>();
			if (customAttribute != null && customAttribute.Description != null)
			{
				context.Emit(new <7d01ae39-3c87-4fa0-8b6c-f9a55cfe3ac0>Comment(customAttribute.Description, isInline: false));
			}
			return base.EnterMapping(key, value, context);
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <4cdbc022-7886-4e8e-a801-eacfb1c5ad04>CustomSerializationObjectGraphVisitor : <2b8f0cc0-e6c9-48a7-8c26-6d77cb113cca>ChainedObjectGraphVisitor
	{
		private readonly IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> typeConverters;

		private readonly <dd379040-fcd6-4c71-bd11-b3912495c170>ObjectSerializer nestedObjectSerializer;

		public <4cdbc022-7886-4e8e-a801-eacfb1c5ad04>CustomSerializationObjectGraphVisitor(<ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter> nextVisitor, IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> typeConverters, <dd379040-fcd6-4c71-bd11-b3912495c170>ObjectSerializer nestedObjectSerializer)
			: base(nextVisitor)
		{
			IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> enumerable;
			if (typeConverters == null)
			{
				enumerable = Enumerable.Empty<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter>();
			}
			else
			{
				IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> enumerable2 = typeConverters.ToList();
				enumerable = enumerable2;
			}
			this.typeConverters = enumerable;
			this.nestedObjectSerializer = nestedObjectSerializer;
		}

		public override bool Enter(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter <d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter = typeConverters.FirstOrDefault([<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] (<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter t) => t.Accepts(value.Type));
			if (<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter != null)
			{
				<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter.WriteYaml(context, value.Value, value.Type);
				return false;
			}
			if (value.Value is <3e02419b-73d0-43d6-8614-b0bb250feb69>IYamlConvertible <3e02419b-73d0-43d6-8614-b0bb250feb69>IYamlConvertible)
			{
				<3e02419b-73d0-43d6-8614-b0bb250feb69>IYamlConvertible.Write(context, nestedObjectSerializer);
				return false;
			}
			if (value.Value is <1d8915a2-3217-4c29-b984-c926423b449f>IYamlSerializable <1d8915a2-3217-4c29-b984-c926423b449f>IYamlSerializable)
			{
				<1d8915a2-3217-4c29-b984-c926423b449f>IYamlSerializable.WriteYaml(context);
				return false;
			}
			return base.Enter(value, context);
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <f20cbed7-4caf-4402-82fb-b4d539478403>DefaultExclusiveObjectGraphVisitor : <2b8f0cc0-e6c9-48a7-8c26-6d77cb113cca>ChainedObjectGraphVisitor
	{
		public <f20cbed7-4caf-4402-82fb-b4d539478403>DefaultExclusiveObjectGraphVisitor(<ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		private static object GetDefault(Type type)
		{
			if (!<acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.IsValueType(type))
			{
				return null;
			}
			return Activator.CreateInstance(type);
		}

		public override bool EnterMapping(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor key, <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			if (!object.Equals(value.Value, GetDefault(value.Type)))
			{
				return base.EnterMapping(key, value, context);
			}
			return false;
		}

		public override bool EnterMapping(<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor key, <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			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);
			}
			return false;
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <8f79150d-630f-49f4-b68d-c49c69c727d7>DefaultValuesObjectGraphVisitor : <2b8f0cc0-e6c9-48a7-8c26-6d77cb113cca>ChainedObjectGraphVisitor
	{
		private readonly <82c71c17-8813-4fa6-8ba4-ee0247932a58>DefaultValuesHandling handling;

		public <8f79150d-630f-49f4-b68d-c49c69c727d7>DefaultValuesObjectGraphVisitor(<82c71c17-8813-4fa6-8ba4-ee0247932a58>DefaultValuesHandling handling, <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter> nextVisitor)
			: base(nextVisitor)
		{
			this.handling = handling;
		}

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		private static object GetDefault(Type type)
		{
			if (!<acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.IsValueType(type))
			{
				return null;
			}
			return Activator.CreateInstance(type);
		}

		public override bool EnterMapping(<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor key, <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			<82c71c17-8813-4fa6-8ba4-ee0247932a58>DefaultValuesHandling defaultValuesHandling = handling;
			<ea041798-c1a6-4d46-aca6-4bf883e221c4>YamlMemberAttribute customAttribute = key.GetCustomAttribute<<ea041798-c1a6-4d46-aca6-4bf883e221c4>YamlMemberAttribute>();
			if (customAttribute != null && customAttribute.IsDefaultValuesHandlingSpecified)
			{
				defaultValuesHandling = customAttribute.DefaultValuesHandling;
			}
			if ((defaultValuesHandling & <82c71c17-8813-4fa6-8ba4-ee0247932a58>DefaultValuesHandling.OmitNull) != 0 && value.Value == null)
			{
				return false;
			}
			if ((defaultValuesHandling & <82c71c17-8813-4fa6-8ba4-ee0247932a58>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 & <82c71c17-8813-4fa6-8ba4-ee0247932a58>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);
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <677ee053-2e07-4ae4-84b2-fc20f131f86e>EmittingObjectGraphVisitor : <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter>
	{
		private readonly <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter eventEmitter;

		public <677ee053-2e07-4ae4-84b2-fc20f131f86e>EmittingObjectGraphVisitor(<88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter eventEmitter)
		{
			this.eventEmitter = eventEmitter;
		}

		bool <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter>.Enter(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			return true;
		}

		bool <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter>.EnterMapping(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor key, <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			return true;
		}

		bool <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter>.EnterMapping(<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor key, <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			return true;
		}

		void <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter>.VisitScalar(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor scalar, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			eventEmitter.Emit(new <3a8120f0-1e22-4688-9f35-7f39f0ca5705>ScalarEventInfo(scalar), context);
		}

		void <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter>.VisitMappingStart(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor mapping, Type keyType, Type valueType, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			eventEmitter.Emit(new <b5820e3d-2ea9-478e-aa86-8bf43ebfe369>MappingStartEventInfo(mapping), context);
		}

		void <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter>.VisitMappingEnd(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor mapping, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			eventEmitter.Emit(new <0b621565-c1a3-4977-9130-2cc1e01ee81f>MappingEndEventInfo(mapping), context);
		}

		void <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter>.VisitSequenceStart(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor sequence, Type elementType, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			eventEmitter.Emit(new <bd85e032-3c9d-4aa1-92f8-9a11ece4a496>SequenceStartEventInfo(sequence), context);
		}

		void <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter>.VisitSequenceEnd(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor sequence, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter context)
		{
			eventEmitter.Emit(new <8e533513-9138-4fd4-8a1f-35a40ae25316>SequenceEndEventInfo(sequence), context);
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal abstract class <4b60b00b-738e-48ce-86a5-34b76bb69cbe>PreProcessingPhaseObjectGraphVisitorSkeleton : <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>
	{
		protected readonly IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> typeConverters;

		public <4b60b00b-738e-48ce-86a5-34b76bb69cbe>PreProcessingPhaseObjectGraphVisitorSkeleton(IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> typeConverters)
		{
			IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> enumerable;
			if (typeConverters == null)
			{
				enumerable = Enumerable.Empty<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter>();
			}
			else
			{
				IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> enumerable2 = typeConverters.ToList();
				enumerable = enumerable2;
			}
			this.typeConverters = enumerable;
		}

		bool <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>.Enter(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value, <56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing context)
		{
			if (typeConverters.FirstOrDefault([<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] (<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter t) => t.Accepts(value.Type)) != null)
			{
				return false;
			}
			if (value.Value is <3e02419b-73d0-43d6-8614-b0bb250feb69>IYamlConvertible)
			{
				return false;
			}
			if (value.Value is <1d8915a2-3217-4c29-b984-c926423b449f>IYamlSerializable)
			{
				return false;
			}
			return Enter(value);
		}

		bool <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>.EnterMapping(<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor key, <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value, <56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing context)
		{
			return EnterMapping(key, value);
		}

		bool <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>.EnterMapping(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor key, <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value, <56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing context)
		{
			return EnterMapping(key, value);
		}

		void <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>.VisitMappingEnd(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor mapping, <56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing context)
		{
			VisitMappingEnd(mapping);
		}

		void <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>.VisitMappingStart(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor mapping, Type keyType, Type valueType, <56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing context)
		{
			VisitMappingStart(mapping, keyType, valueType);
		}

		void <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>.VisitScalar(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor scalar, <56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing context)
		{
			VisitScalar(scalar);
		}

		void <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>.VisitSequenceEnd(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor sequence, <56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing context)
		{
			VisitSequenceEnd(sequence);
		}

		void <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<<56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing>.VisitSequenceStart(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor sequence, Type elementType, <56a3c231-7d1c-456a-818a-89e7f2df3256>Nothing context)
		{
			VisitSequenceStart(sequence, elementType);
		}

		protected abstract bool Enter(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value);

		protected abstract bool EnterMapping(<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor key, <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value);

		protected abstract bool EnterMapping(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor key, <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value);

		protected abstract void VisitMappingEnd(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor mapping);

		protected abstract void VisitMappingStart(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor mapping, Type keyType, Type valueType);

		protected abstract void VisitScalar(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor scalar);

		protected abstract void VisitSequenceEnd(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor sequence);

		protected abstract void VisitSequenceStart(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor sequence, Type elementType);
	}
}
namespace YamlDotNet.Serialization.ObjectGraphTraversalStrategies
{
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal class <ff2c6430-7179-4dfe-8c29-acf94684d0d2>FullObjectGraphTraversalStrategy : <8fec2f07-147a-4858-aec8-d12a2f118a9c>IObjectGraphTraversalStrategy
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
		protected struct ObjectPathSegment
		{
			public readonly object Name;

			public readonly <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor Value;

			public ObjectPathSegment(object name, <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value)
			{
				Name = name;
				Value = value;
			}
		}

		private readonly int maxRecursion;

		private readonly <c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector typeDescriptor;

		private readonly <a0cad0d5-d219-4360-a990-d287fb745b59>ITypeResolver typeResolver;

		private readonly <2282eb5c-6849-4bd4-9f7d-f9cba43dc317>INamingConvention namingConvention;

		public <ff2c6430-7179-4dfe-8c29-acf94684d0d2>FullObjectGraphTraversalStrategy(<c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector typeDescriptor, <a0cad0d5-d219-4360-a990-d287fb745b59>ITypeResolver typeResolver, int maxRecursion, <2282eb5c-6849-4bd4-9f7d-f9cba43dc317>INamingConvention namingConvention)
		{
			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");
		}

		void <8fec2f07-147a-4858-aec8-d12a2f118a9c>IObjectGraphTraversalStrategy.Traverse<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TContext>(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor graph, <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<TContext> visitor, TContext context)
		{
			Traverse("<root>", graph, visitor, context, new Stack<ObjectPathSegment>(maxRecursion));
		}

		protected virtual void Traverse<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TContext>(object name, <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value, <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
		{
			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 = <57e98fe4-e44d-4ae6-be9d-c111589c4e53>TypeConverter.ChangeType<string>(item.Name);
					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 <84c979da-2a78-4796-94af-e7533b7b0006>MaximumRecursionLevelReachedException(stringBuilder.ToString());
			}
			if (!visitor.Enter(value, context))
			{
				return;
			}
			path.Push(new ObjectPathSegment(name, value));
			try
			{
				TypeCode typeCode = <acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.GetTypeCode(value.Type);
				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);
					return;
				case TypeCode.Empty:
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
				if (<acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.IsDbNull(value))
				{
					visitor.VisitScalar(new <060951e9-e294-406d-a792-8a5d53b008e3>ObjectDescriptor(null, typeof(object), typeof(object)), context);
				}
				if (value.Value == null || value.Type == typeof(TimeSpan))
				{
					visitor.VisitScalar(value, context);
					return;
				}
				Type underlyingType = Nullable.GetUnderlyingType(value.Type);
				if (underlyingType != null)
				{
					Traverse("Value", new <060951e9-e294-406d-a792-8a5d53b008e3>ObjectDescriptor(value.Value, underlyingType, value.Type, value.ScalarStyle), visitor, context, path);
				}
				else
				{
					TraverseObject(value, visitor, context, path);
				}
			}
			finally
			{
				path.Pop();
			}
		}

		protected virtual void TraverseObject<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TContext>(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value, <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
		{
			if (typeof(IDictionary).IsAssignableFrom(value.Type))
			{
				TraverseDictionary(value, visitor, typeof(object), typeof(object), context, path);
				return;
			}
			Type implementedGenericInterface = <2ea259c5-a144-4d42-b39c-a8adef3fb3cb>ReflectionUtility.GetImplementedGenericInterface(value.Type, typeof(IDictionary<, >));
			if (implementedGenericInterface != null)
			{
				Type[] genericArguments = implementedGenericInterface.GetGenericArguments();
				object value2 = Activator.CreateInstance(typeof(<2debfdfd-6eb0-4011-bf16-b461e83dd771>GenericDictionaryToNonGenericAdapter<, >).MakeGenericType(genericArguments), value.Value);
				TraverseDictionary(new <060951e9-e294-406d-a792-8a5d53b008e3>ObjectDescriptor(value2, value.Type, value.StaticType, value.ScalarStyle), visitor, genericArguments[0], genericArguments[1], context, path);
			}
			else if (typeof(IEnumerable).IsAssignableFrom(value.Type))
			{
				TraverseList(value, visitor, context, path);
			}
			else
			{
				TraverseProperties(value, visitor, context, path);
			}
		}

		protected virtual void TraverseDictionary<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TContext>(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor dictionary, <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<TContext> visitor, Type keyType, Type valueType, TContext context, Stack<ObjectPathSegment> path)
		{
			visitor.VisitMappingStart(dictionary, keyType, valueType, context);
			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);
				<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor objectDescriptor = GetObjectDescriptor(obj, keyType);
				<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor objectDescriptor2 = GetObjectDescriptor(value.Value, valueType);
				if (visitor.EnterMapping(objectDescriptor, objectDescriptor2, context))
				{
					Traverse(obj, objectDescriptor, visitor, context, path);
					Traverse(obj, objectDescriptor2, visitor, context, path);
				}
			}
			visitor.VisitMappingEnd(dictionary, context);
		}

		private void TraverseList<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TContext>(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value, <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
		{
			Type implementedGenericInterface = <2ea259c5-a144-4d42-b39c-a8adef3fb3cb>ReflectionUtility.GetImplementedGenericInterface(value.Type, typeof(IEnumerable<>));
			Type type = ((implementedGenericInterface != null) ? implementedGenericInterface.GetGenericArguments()[0] : typeof(object));
			visitor.VisitSequenceStart(value, type, context);
			int num = 0;
			foreach (object item in (IEnumerable)value.NonNullValue())
			{
				Traverse(num, GetObjectDescriptor(item, type), visitor, context, path);
				num++;
			}
			visitor.VisitSequenceEnd(value, context);
		}

		protected virtual void TraverseProperties<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TContext>(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value, <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
		{
			visitor.VisitMappingStart(value, typeof(string), typeof(object), context);
			object obj = value.NonNullValue();
			foreach (<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor property in typeDescriptor.GetProperties(value.Type, obj))
			{
				<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value2 = property.Read(obj);
				if (visitor.EnterMapping(property, value2, context))
				{
					Traverse(property.Name, new <060951e9-e294-406d-a792-8a5d53b008e3>ObjectDescriptor(property.Name, typeof(string), typeof(string)), visitor, context, path);
					Traverse(property.Name, value2, visitor, context, path);
				}
			}
			visitor.VisitMappingEnd(value, context);
		}

		private <e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor GetObjectDescriptor([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object value, Type staticType)
		{
			return new <060951e9-e294-406d-a792-8a5d53b008e3>ObjectDescriptor(value, typeResolver.Resolve(staticType, value), staticType);
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal class <aa7ff869-915e-4370-b5a1-804acd474ce7>RoundtripObjectGraphTraversalStrategy : <ff2c6430-7179-4dfe-8c29-acf94684d0d2>FullObjectGraphTraversalStrategy
	{
		private readonly IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> converters;

		public <aa7ff869-915e-4370-b5a1-804acd474ce7>RoundtripObjectGraphTraversalStrategy(IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> converters, <c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector typeDescriptor, <a0cad0d5-d219-4360-a990-d287fb745b59>ITypeResolver typeResolver, int maxRecursion, <2282eb5c-6849-4bd4-9f7d-f9cba43dc317>INamingConvention namingConvention)
			: base(typeDescriptor, typeResolver, maxRecursion, namingConvention)
		{
			this.converters = converters;
		}

		protected override void TraverseProperties<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TContext>(<e1f60ee2-4f43-4f7b-9c40-e273eae7a57f>IObjectDescriptor value, <ab2b345b-040d-4348-b8f4-9a251253b5fa>IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
		{
			if (!<acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.HasDefaultConstructor(value.Type) && !converters.Any([<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] (<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter c) => c.Accepts(value.Type)))
			{
				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);
		}
	}
}
namespace YamlDotNet.Serialization.ObjectFactories
{
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <65e87768-98ae-49df-9570-67b9ec9243d5>DefaultObjectFactory : <25b8d310-26e9-45f0-963c-cac44ad61cd4>IObjectFactory
	{
		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>)
			}
		};

		public <65e87768-98ae-49df-9570-67b9ec9243d5>DefaultObjectFactory()
		{
		}

		public <65e87768-98ae-49df-9570-67b9ec9243d5>DefaultObjectFactory(IDictionary<Type, Type> 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}'.");
				}
				DefaultNonGenericInterfaceImplementations.Add(mapping.Key, mapping.Value);
			}
		}

		public object Create(Type type)
		{
			if (<acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.IsInterface(type))
			{
				Type value2;
				if (<acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.IsGenericType(type))
				{
					if (DefaultGenericInterfaceImplementations.TryGetValue(type.GetGenericTypeDefinition(), out var value))
					{
						type = value.MakeGenericType(type.GetGenericArguments());
					}
				}
				else if (DefaultNonGenericInterfaceImplementations.TryGetValue(type, out value2))
				{
					type = value2;
				}
			}
			try
			{
				return Activator.CreateInstance(type);
			}
			catch (Exception innerException)
			{
				throw new InvalidOperationException("Failed to create an instance of type '" + type.FullName + "'.", innerException);
			}
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <087c1052-b2d8-4a5c-96a6-2a1eea9a9e45>LambdaObjectFactory : <25b8d310-26e9-45f0-963c-cac44ad61cd4>IObjectFactory
	{
		private readonly Func<Type, object> factory;

		public <087c1052-b2d8-4a5c-96a6-2a1eea9a9e45>LambdaObjectFactory(Func<Type, object> factory)
		{
			this.factory = factory ?? throw new ArgumentNullException("factory");
		}

		public object Create(Type type)
		{
			return factory(type);
		}
	}
}
namespace YamlDotNet.Serialization.NodeTypeResolvers
{
	internal sealed class <1a765f1c-028e-4c6a-9d6a-850d7b81b253>DefaultContainersNodeTypeResolver : <d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver
	{
		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		bool <d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver.Resolve([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] <1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent nodeEvent, ref Type currentType)
		{
			if (currentType == typeof(object))
			{
				if (nodeEvent is <d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart)
				{
					currentType = typeof(List<object>);
					return true;
				}
				if (nodeEvent is <3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart)
				{
					currentType = typeof(Dictionary<object, object>);
					return true;
				}
			}
			return false;
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal class <a36aae16-0204-474b-86c1-4b2c15b6aa74>MappingNodeTypeResolver : <d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver
	{
		private readonly IDictionary<Type, Type> _mappings;

		public <a36aae16-0204-474b-86c1-4b2c15b6aa74>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}'.");
				}
			}
			_mappings = mappings;
		}

		public bool Resolve([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] <1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent nodeEvent, ref Type currentType)
		{
			if (_mappings.TryGetValue(currentType, out var value))
			{
				currentType = value;
				return true;
			}
			return false;
		}
	}
	internal class <37d43683-7c0c-4e1e-aac5-64c3fd657ad1>PreventUnknownTagsNodeTypeResolver : <d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver
	{
		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		bool <d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver.Resolve([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] <1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty)
			{
				throw new <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException(nodeEvent.Start, nodeEvent.End, $"Encountered an unresolved tag '{nodeEvent.Tag}'");
			}
			return false;
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <aa598de4-1ba1-4dab-b351-fefa11c38945>TagNodeTypeResolver : <d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver
	{
		private readonly IDictionary<<9b965c76-e42b-4be8-b468-b7eefab6d624>TagName, Type> tagMappings;

		public <aa598de4-1ba1-4dab-b351-fefa11c38945>TagNodeTypeResolver(IDictionary<<9b965c76-e42b-4be8-b468-b7eefab6d624>TagName, Type> tagMappings)
		{
			this.tagMappings = tagMappings ?? throw new ArgumentNullException("tagMappings");
		}

		bool <d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver.Resolve([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] <1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty && tagMappings.TryGetValue(nodeEvent.Tag, out var 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.")]
	internal sealed class <ba6580ac-4030-4582-877c-7213ed3885d5>TypeNameInTagNodeTypeResolver : <d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver
	{
		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		bool <d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver.Resolve([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] <1532194c-e40d-420a-9a09-3cfeb36413b0>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;
		}
	}
	internal sealed class <44b0424c-2cc0-4b42-b7c1-5546be912965>YamlConvertibleTypeResolver : <d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver
	{
		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public bool Resolve([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] <1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent nodeEvent, ref Type currentType)
		{
			return typeof(<3e02419b-73d0-43d6-8614-b0bb250feb69>IYamlConvertible).IsAssignableFrom(currentType);
		}
	}
	internal sealed class <1974a413-9317-4103-8d3b-65efe5d91105>YamlSerializableTypeResolver : <d6dc49bf-de96-4b1a-8b94-b107bd47f689>INodeTypeResolver
	{
		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public bool Resolve([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] <1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent nodeEvent, ref Type currentType)
		{
			return typeof(<1d8915a2-3217-4c29-b984-c926423b449f>IYamlSerializable).IsAssignableFrom(currentType);
		}
	}
}
namespace YamlDotNet.Serialization.NodeDeserializers
{
	internal sealed class <94159d23-739a-4f4e-a08e-efc516e2a0c1>ArrayNodeDeserializer : <5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer
	{
		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
		private sealed class ArrayList : IList, ICollection, IEnumerable
		{
			[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 2 })]
			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;

			[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)]
			public object SyncRoot
			{
				[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
				get
				{
					return 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();
			}

			[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
			public void CopyTo(Array array, int index)
			{
				Array.Copy(data, 0, array, index, Count);
			}

			[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
			public IEnumerator GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return data[i];
					int num = i + 1;
					i = num;
				}
			}
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		bool <5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer.Deserialize(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, Type expectedType, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser, Type, object> nestedObjectDeserializer, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] out object value)
		{
			if (!expectedType.IsArray)
			{
				value = false;
				return false;
			}
			Type? elementType = expectedType.GetElementType();
			ArrayList arrayList = new ArrayList();
			<9657c1c0-3df4-4cf9-b3b7-5964148cd7ff>CollectionNodeDeserializer.DeserializeHelper(elementType, parser, nestedObjectDeserializer, arrayList, canUpdate: true);
			Array array = Array.CreateInstance(elementType, arrayList.Count);
			arrayList.CopyTo(array, 0);
			value = array;
			return true;
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <9657c1c0-3df4-4cf9-b3b7-5964148cd7ff>CollectionNodeDeserializer : <5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer
	{
		private readonly <25b8d310-26e9-45f0-963c-cac44ad61cd4>IObjectFactory objectFactory;

		public <9657c1c0-3df4-4cf9-b3b7-5964148cd7ff>CollectionNodeDeserializer(<25b8d310-26e9-45f0-963c-cac44ad61cd4>IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		bool <5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer.Deserialize(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, Type expectedType, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser, Type, object> nestedObjectDeserializer, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] out object value)
		{
			bool canUpdate = true;
			Type implementedGenericInterface = <2ea259c5-a144-4d42-b39c-a8adef3fb3cb>ReflectionUtility.GetImplementedGenericInterface(expectedType, typeof(ICollection<>));
			Type type;
			IList list;
			if (implementedGenericInterface != null)
			{
				type = implementedGenericInterface.GetGenericArguments()[0];
				value = objectFactory.Create(expectedType);
				list = value as IList;
				if (list == null)
				{
					canUpdate = <2ea259c5-a144-4d42-b39c-a8adef3fb3cb>ReflectionUtility.GetImplementedGenericInterface(expectedType, typeof(IList<>)) != null;
					list = (IList)Activator.CreateInstance(typeof(<27544c65-9d5a-4beb-8b79-2465eef129b2>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);
			return true;
		}

		internal static void DeserializeHelper(Type tItem, <2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser, Type, object> nestedObjectDeserializer, IList result, bool canUpdate)
		{
			parser.Consume<<d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart>();
			<1851bced-7720-45bc-a55f-1347cc414c40>SequenceEnd @event;
			while (!parser.TryConsume<<1851bced-7720-45bc-a55f-1347cc414c40>SequenceEnd>(out @event))
			{
				<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem);
				if (obj is <cf2045f1-17de-4280-8f65-79ee218e11fd>IValuePromise <cf2045f1-17de-4280-8f65-79ee218e11fd>IValuePromise)
				{
					if (!canUpdate)
					{
						throw new <8d566825-d19e-4f4e-bba8-65bf424c80ea>ForwardAnchorNotSupportedException(current?.Start ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, current?.End ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, "Forward alias references are not allowed because this type does not implement IList<>");
					}
					int index = result.Add(<acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.IsValueType(tItem) ? Activator.CreateInstance(tItem) : null);
					<cf2045f1-17de-4280-8f65-79ee218e11fd>IValuePromise.ValueAvailable += [<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)] (object v) =>
					{
						result[index] = <57e98fe4-e44d-4ae6-be9d-c111589c4e53>TypeConverter.ChangeType(v, tItem);
					};
				}
				else
				{
					result.Add(<57e98fe4-e44d-4ae6-be9d-c111589c4e53>TypeConverter.ChangeType(obj, tItem));
				}
			}
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <c59313c3-f7ec-4263-b815-ebccf2a80fce>DictionaryNodeDeserializer : <5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer
	{
		private readonly <25b8d310-26e9-45f0-963c-cac44ad61cd4>IObjectFactory objectFactory;

		public <c59313c3-f7ec-4263-b815-ebccf2a80fce>DictionaryNodeDeserializer(<25b8d310-26e9-45f0-963c-cac44ad61cd4>IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		bool <5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer.Deserialize(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, Type expectedType, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser, Type, object> nestedObjectDeserializer, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] out object value)
		{
			Type implementedGenericInterface = <2ea259c5-a144-4d42-b39c-a8adef3fb3cb>ReflectionUtility.GetImplementedGenericInterface(expectedType, typeof(IDictionary<, >));
			Type type;
			Type type2;
			IDictionary dictionary;
			if (implementedGenericInterface != null)
			{
				Type[] genericArguments = implementedGenericInterface.GetGenericArguments();
				type = genericArguments[0];
				type2 = genericArguments[1];
				value = objectFactory.Create(expectedType);
				dictionary = value as IDictionary;
				if (dictionary == null)
				{
					dictionary = (IDictionary)Activator.CreateInstance(typeof(<2debfdfd-6eb0-4011-bf16-b461e83dd771>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;
			}
			DeserializeHelper(type, type2, parser, nestedObjectDeserializer, dictionary);
			return true;
		}

		private static void DeserializeHelper(Type tKey, Type tValue, <2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser, Type, object> nestedObjectDeserializer, IDictionary result)
		{
			parser.Consume<<3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart>();
			<05f36264-c97d-43b8-9e56-0f8741a6ea35>MappingEnd @event;
			while (!parser.TryConsume<<05f36264-c97d-43b8-9e56-0f8741a6ea35>MappingEnd>(out @event))
			{
				object key = nestedObjectDeserializer(parser, tKey);
				object value = nestedObjectDeserializer(parser, tValue);
				<cf2045f1-17de-4280-8f65-79ee218e11fd>IValuePromise <cf2045f1-17de-4280-8f65-79ee218e11fd>IValuePromise = value as <cf2045f1-17de-4280-8f65-79ee218e11fd>IValuePromise;
				if (key is <cf2045f1-17de-4280-8f65-79ee218e11fd>IValuePromise <cf2045f1-17de-4280-8f65-79ee218e11fd>IValuePromise2)
				{
					if (<cf2045f1-17de-4280-8f65-79ee218e11fd>IValuePromise == null)
					{
						<cf2045f1-17de-4280-8f65-79ee218e11fd>IValuePromise2.ValueAvailable += [<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)] (object v) =>
						{
							result[v] = value;
						};
						continue;
					}
					bool hasFirstPart = false;
					<cf2045f1-17de-4280-8f65-79ee218e11fd>IValuePromise2.ValueAvailable += [<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)] (object v) =>
					{
						if (hasFirstPart)
						{
							result[v] = value;
						}
						else
						{
							key = v;
							hasFirstPart = true;
						}
					};
					<cf2045f1-17de-4280-8f65-79ee218e11fd>IValuePromise.ValueAvailable += [<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)] (object v) =>
					{
						if (hasFirstPart)
						{
							result[key] = v;
						}
						else
						{
							value = v;
							hasFirstPart = true;
						}
					};
				}
				else if (<cf2045f1-17de-4280-8f65-79ee218e11fd>IValuePromise == null)
				{
					result[key] = value;
				}
				else
				{
					<cf2045f1-17de-4280-8f65-79ee218e11fd>IValuePromise.ValueAvailable += [<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)] (object v) =>
					{
						result[key] = v;
					};
				}
			}
		}
	}
	internal sealed class <09339fe4-0506-4b49-a7bf-c0cdfeaa93f8>EnumerableNodeDeserializer : <5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer
	{
		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		bool <5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer.Deserialize(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, Type expectedType, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser, Type, object> nestedObjectDeserializer, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] out object value)
		{
			Type type;
			if (expectedType == typeof(IEnumerable))
			{
				type = typeof(object);
			}
			else
			{
				Type implementedGenericInterface = <2ea259c5-a144-4d42-b39c-a8adef3fb3cb>ReflectionUtility.GetImplementedGenericInterface(expectedType, typeof(IEnumerable<>));
				if (implementedGenericInterface != expectedType)
				{
					value = null;
					return false;
				}
				type = implementedGenericInterface.GetGenericArguments()[0];
			}
			Type arg = typeof(List<>).MakeGenericType(type);
			value = nestedObjectDeserializer(parser, arg);
			return true;
		}
	}
	internal sealed class <b1d95a82-44aa-4464-86f2-6869ef62deec>NullNodeDeserializer : <5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer
	{
		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		bool <5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer.Deserialize(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, Type expectedType, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser, Type, object> nestedObjectDeserializer, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] out object value)
		{
			value = null;
			if (parser.Accept<<1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent>(out var @event) && NodeIsNull(@event))
			{
				parser.SkipThisAndNestedEvents();
				return true;
			}
			return false;
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		private bool NodeIsNull(<1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent nodeEvent)
		{
			if (nodeEvent.Tag == "tag:yaml.org,2002:null")
			{
				return true;
			}
			if (nodeEvent is <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar && <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar.Style == <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Plain)
			{
				string value = <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar.Value;
				switch (value)
				{
				default:
					return value == "NULL";
				case "":
				case "~":
				case "null":
				case "Null":
					return true;
				}
			}
			return false;
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <26220309-8886-44df-bcd2-53084bccad89>ObjectNodeDeserializer : <5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer
	{
		private readonly <25b8d310-26e9-45f0-963c-cac44ad61cd4>IObjectFactory objectFactory;

		private readonly <c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector typeDescriptor;

		private readonly bool ignoreUnmatched;

		public <26220309-8886-44df-bcd2-53084bccad89>ObjectNodeDeserializer(<25b8d310-26e9-45f0-963c-cac44ad61cd4>IObjectFactory objectFactory, <c78dca86-41c3-4405-8ecd-e259ad0c23f9>ITypeInspector typeDescriptor, bool ignoreUnmatched)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
			this.typeDescriptor = typeDescriptor ?? throw new ArgumentNullException("typeDescriptor");
			this.ignoreUnmatched = ignoreUnmatched;
		}

		bool <5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer.Deserialize(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, Type expectedType, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser, Type, object> nestedObjectDeserializer, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] out object value)
		{
			if (!parser.TryConsume<<3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart>(out var _))
			{
				value = null;
				return false;
			}
			Type type = Nullable.GetUnderlyingType(expectedType) ?? expectedType;
			value = objectFactory.Create(type);
			<05f36264-c97d-43b8-9e56-0f8741a6ea35>MappingEnd event2;
			while (!parser.TryConsume<<05f36264-c97d-43b8-9e56-0f8741a6ea35>MappingEnd>(out event2))
			{
				<1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar = parser.Consume<<1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar>();
				<b5b3350a-8000-4a74-91d3-373050a185b1>IPropertyDescriptor property = typeDescriptor.GetProperty(type, null, <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar.Value, ignoreUnmatched);
				if (property == null)
				{
					parser.SkipThisAndNestedEvents();
					continue;
				}
				object obj = nestedObjectDeserializer(parser, property.Type);
				if (obj is <cf2045f1-17de-4280-8f65-79ee218e11fd>IValuePromise <cf2045f1-17de-4280-8f65-79ee218e11fd>IValuePromise)
				{
					object valueRef = value;
					<cf2045f1-17de-4280-8f65-79ee218e11fd>IValuePromise.ValueAvailable += [<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)] (object v) =>
					{
						object value3 = <57e98fe4-e44d-4ae6-be9d-c111589c4e53>TypeConverter.ChangeType(v, property.Type);
						property.Write(valueRef, value3);
					};
				}
				else
				{
					object value2 = <57e98fe4-e44d-4ae6-be9d-c111589c4e53>TypeConverter.ChangeType(obj, property.Type);
					property.Write(value, value2);
				}
			}
			return true;
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <652d8919-fb7e-4461-8ae8-bb475ac7818f>ScalarNodeDeserializer : <5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer
	{
		private const string BooleanTruePattern = "^(true|y|yes|on)$";

		private const string BooleanFalsePattern = "^(false|n|no|off)$";

		bool <5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer.Deserialize(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, Type expectedType, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser, Type, object> nestedObjectDeserializer, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] out object value)
		{
			if (!parser.TryConsume<<1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar>(out var @event))
			{
				value = null;
				return false;
			}
			Type type = Nullable.GetUnderlyingType(expectedType) ?? expectedType;
			if (<acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.IsEnum(type))
			{
				value = Enum.Parse(type, @event.Value, ignoreCase: true);
				return true;
			}
			TypeCode typeCode = <acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.GetTypeCode(type);
			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, <46127bb1-62af-4f27-b7c6-e869bac36295>YamlFormatter.NumberFormat);
				break;
			case TypeCode.Double:
				value = double.Parse(@event.Value, <46127bb1-62af-4f27-b7c6-e869bac36295>YamlFormatter.NumberFormat);
				break;
			case TypeCode.Decimal:
				value = decimal.Parse(@event.Value, <46127bb1-62af-4f27-b7c6-e869bac36295>YamlFormatter.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))
				{
					value = @event.Value;
				}
				else
				{
					value = <57e98fe4-e44d-4ae6-be9d-c111589c4e53>TypeConverter.ChangeType(@event.Value, expectedType);
				}
				break;
			}
			return true;
		}

		private object DeserializeBooleanHelper(string value)
		{
			bool flag;
			if (Regex.IsMatch(value, "^(true|y|yes|on)$", RegexOptions.IgnoreCase))
			{
				flag = true;
			}
			else
			{
				if (!Regex.IsMatch(value, "^(false|n|no|off)$", RegexOptions.IgnoreCase))
				{
					throw new FormatException("The value \"" + value + "\" is not a valid YAML Boolean");
				}
				flag = false;
			}
			return flag;
		}

		private object DeserializeIntegerHelper(TypeCode typeCode, string value)
		{
			StringBuilder stringBuilder = new StringBuilder();
			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] != '_')
					{
						stringBuilder.Append(value[i]);
					}
				}
				switch (num2)
				{
				case 2:
				case 8:
					num = Convert.ToUInt64(stringBuilder.ToString(), num2);
					break;
				case 16:
					num = ulong.Parse(stringBuilder.ToString(), NumberStyles.HexNumber, <46127bb1-62af-4f27-b7c6-e869bac36295>YamlFormatter.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("_", ""));
				}
			}
			if (flag)
			{
				return CastInteger(checked(-(long)num), typeCode);
			}
			return CastInteger(num, typeCode);
		}

		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, 
			});
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <45e790a0-85e1-40aa-886b-c1753f6dc8f8>TypeConverterNodeDeserializer : <5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer
	{
		private readonly IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> converters;

		public <45e790a0-85e1-40aa-886b-c1753f6dc8f8>TypeConverterNodeDeserializer(IEnumerable<<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter> converters)
		{
			this.converters = converters ?? throw new ArgumentNullException("converters");
		}

		bool <5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer.Deserialize(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, Type expectedType, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser, Type, object> nestedObjectDeserializer, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] out object value)
		{
			<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter <d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter = converters.FirstOrDefault([<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] (<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter c) => c.Accepts(expectedType));
			if (<d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter == null)
			{
				value = null;
				return false;
			}
			value = <d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter.ReadYaml(parser, expectedType);
			return true;
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <d7d1bce2-2b37-47a9-8099-4b785a1b8422>YamlConvertibleNodeDeserializer : <5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer
	{
		private readonly <25b8d310-26e9-45f0-963c-cac44ad61cd4>IObjectFactory objectFactory;

		public <d7d1bce2-2b37-47a9-8099-4b785a1b8422>YamlConvertibleNodeDeserializer(<25b8d310-26e9-45f0-963c-cac44ad61cd4>IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, Type expectedType, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser, Type, object> nestedObjectDeserializer, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] out object value)
		{
			if (typeof(<3e02419b-73d0-43d6-8614-b0bb250feb69>IYamlConvertible).IsAssignableFrom(expectedType))
			{
				<3e02419b-73d0-43d6-8614-b0bb250feb69>IYamlConvertible <3e02419b-73d0-43d6-8614-b0bb250feb69>IYamlConvertible = (<3e02419b-73d0-43d6-8614-b0bb250feb69>IYamlConvertible)objectFactory.Create(expectedType);
				<3e02419b-73d0-43d6-8614-b0bb250feb69>IYamlConvertible.Read(parser, expectedType, [return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] (Type type) => nestedObjectDeserializer(parser, type));
				value = <3e02419b-73d0-43d6-8614-b0bb250feb69>IYamlConvertible;
				return true;
			}
			value = null;
			return false;
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <f52d6fae-a397-4ed0-b79e-9ec7c62bc294>YamlSerializableNodeDeserializer : <5fb20b87-d400-4f06-9600-ff4a2de9f7a6>INodeDeserializer
	{
		private readonly <25b8d310-26e9-45f0-963c-cac44ad61cd4>IObjectFactory objectFactory;

		public <f52d6fae-a397-4ed0-b79e-9ec7c62bc294>YamlSerializableNodeDeserializer(<25b8d310-26e9-45f0-963c-cac44ad61cd4>IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, Type expectedType, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser, Type, object> nestedObjectDeserializer, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] out object value)
		{
			if (typeof(<1d8915a2-3217-4c29-b984-c926423b449f>IYamlSerializable).IsAssignableFrom(expectedType))
			{
				<1d8915a2-3217-4c29-b984-c926423b449f>IYamlSerializable <1d8915a2-3217-4c29-b984-c926423b449f>IYamlSerializable = (<1d8915a2-3217-4c29-b984-c926423b449f>IYamlSerializable)objectFactory.Create(expectedType);
				<1d8915a2-3217-4c29-b984-c926423b449f>IYamlSerializable.ReadYaml(parser);
				value = <1d8915a2-3217-4c29-b984-c926423b449f>IYamlSerializable;
				return true;
			}
			value = null;
			return false;
		}
	}
}
namespace YamlDotNet.Serialization.NamingConventions
{
	internal sealed class <3664ec21-621b-4605-b7cc-49abe4eeb6b9>CamelCaseNamingConvention : <2282eb5c-6849-4bd4-9f7d-f9cba43dc317>INamingConvention
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)]
		public static readonly <2282eb5c-6849-4bd4-9f7d-f9cba43dc317>INamingConvention Instance = new <3664ec21-621b-4605-b7cc-49abe4eeb6b9>CamelCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public <3664ec21-621b-4605-b7cc-49abe4eeb6b9>CamelCaseNamingConvention()
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public string Apply(string value)
		{
			return <ac867188-473d-4882-aa28-c6c465c24f34>StringExtensions.ToCamelCase(value);
		}
	}
	internal sealed class <5b70aad1-e425-4525-b9af-aec50a865732>HyphenatedNamingConvention : <2282eb5c-6849-4bd4-9f7d-f9cba43dc317>INamingConvention
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)]
		public static readonly <2282eb5c-6849-4bd4-9f7d-f9cba43dc317>INamingConvention Instance = new <5b70aad1-e425-4525-b9af-aec50a865732>HyphenatedNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public <5b70aad1-e425-4525-b9af-aec50a865732>HyphenatedNamingConvention()
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public string Apply(string value)
		{
			return <ac867188-473d-4882-aa28-c6c465c24f34>StringExtensions.FromCamelCase(value, "-");
		}
	}
	internal sealed class <325db9a0-bfbf-4230-8401-8fb8d8ad3842>LowerCaseNamingConvention : <2282eb5c-6849-4bd4-9f7d-f9cba43dc317>INamingConvention
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)]
		public static readonly <2282eb5c-6849-4bd4-9f7d-f9cba43dc317>INamingConvention Instance = new <325db9a0-bfbf-4230-8401-8fb8d8ad3842>LowerCaseNamingConvention();

		private <325db9a0-bfbf-4230-8401-8fb8d8ad3842>LowerCaseNamingConvention()
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public string Apply(string value)
		{
			return <ac867188-473d-4882-aa28-c6c465c24f34>StringExtensions.ToCamelCase(value).ToLower();
		}
	}
	internal sealed class <b7f3b459-c7ee-4e45-a5a4-df1e39b37601>NullNamingConvention : <2282eb5c-6849-4bd4-9f7d-f9cba43dc317>INamingConvention
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)]
		public static readonly <2282eb5c-6849-4bd4-9f7d-f9cba43dc317>INamingConvention Instance = new <b7f3b459-c7ee-4e45-a5a4-df1e39b37601>NullNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public <b7f3b459-c7ee-4e45-a5a4-df1e39b37601>NullNamingConvention()
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public string Apply(string value)
		{
			return value;
		}
	}
	internal sealed class <529c9867-b3a5-4281-a985-b3cbbdb8a673>PascalCaseNamingConvention : <2282eb5c-6849-4bd4-9f7d-f9cba43dc317>INamingConvention
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)]
		public static readonly <2282eb5c-6849-4bd4-9f7d-f9cba43dc317>INamingConvention Instance = new <529c9867-b3a5-4281-a985-b3cbbdb8a673>PascalCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public <529c9867-b3a5-4281-a985-b3cbbdb8a673>PascalCaseNamingConvention()
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public string Apply(string value)
		{
			return <ac867188-473d-4882-aa28-c6c465c24f34>StringExtensions.ToPascalCase(value);
		}
	}
	internal sealed class <f30c8a3d-e71e-4e02-b5b8-c76b87e7b93f>UnderscoredNamingConvention : <2282eb5c-6849-4bd4-9f7d-f9cba43dc317>INamingConvention
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)]
		public static readonly <2282eb5c-6849-4bd4-9f7d-f9cba43dc317>INamingConvention Instance = new <f30c8a3d-e71e-4e02-b5b8-c76b87e7b93f>UnderscoredNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public <f30c8a3d-e71e-4e02-b5b8-c76b87e7b93f>UnderscoredNamingConvention()
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public string Apply(string value)
		{
			return <ac867188-473d-4882-aa28-c6c465c24f34>StringExtensions.FromCamelCase(value, "_");
		}
	}
}
namespace YamlDotNet.Serialization.EventEmitters
{
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal abstract class <23a71e3a-cd5c-4a04-9181-7080f9ba3b80>ChainedEventEmitter : <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter
	{
		protected readonly <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter nextEmitter;

		protected <23a71e3a-cd5c-4a04-9181-7080f9ba3b80>ChainedEventEmitter(<88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter nextEmitter)
		{
			this.nextEmitter = nextEmitter ?? throw new ArgumentNullException("nextEmitter");
		}

		public virtual void Emit(<e70d24c7-2fc4-4deb-935f-2f167bd4ad87>AliasEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(<3a8120f0-1e22-4688-9f35-7f39f0ca5705>ScalarEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(<b5820e3d-2ea9-478e-aa86-8bf43ebfe369>MappingStartEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(<0b621565-c1a3-4977-9130-2cc1e01ee81f>MappingEndEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(<bd85e032-3c9d-4aa1-92f8-9a11ece4a496>SequenceStartEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(<8e533513-9138-4fd4-8a1f-35a40ae25316>SequenceEndEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <860f24a1-4f5b-4985-983d-4649cfab681d>JsonEventEmitter : <23a71e3a-cd5c-4a04-9181-7080f9ba3b80>ChainedEventEmitter
	{
		public <860f24a1-4f5b-4985-983d-4649cfab681d>JsonEventEmitter(<88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter nextEmitter)
			: base(nextEmitter)
		{
		}

		public override void Emit(<e70d24c7-2fc4-4deb-935f-2f167bd4ad87>AliasEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter)
		{
			eventInfo.NeedsExpansion = true;
		}

		public override void Emit(<3a8120f0-1e22-4688-9f35-7f39f0ca5705>ScalarEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter)
		{
			eventInfo.IsPlainImplicit = true;
			eventInfo.Style = <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Plain;
			object value = eventInfo.Source.Value;
			if (value == null)
			{
				eventInfo.RenderedValue = "null";
			}
			else
			{
				TypeCode typeCode = <acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.GetTypeCode(eventInfo.Source.Type);
				switch (typeCode)
				{
				case TypeCode.Boolean:
					eventInfo.RenderedValue = <46127bb1-62af-4f27-b7c6-e869bac36295>YamlFormatter.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 (<acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.IsEnum(eventInfo.Source.Type))
					{
						eventInfo.RenderedValue = value.ToString();
						eventInfo.Style = <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.DoubleQuoted;
					}
					else
					{
						eventInfo.RenderedValue = <46127bb1-62af-4f27-b7c6-e869bac36295>YamlFormatter.FormatNumber(value);
					}
					break;
				case TypeCode.Single:
				case TypeCode.Double:
				case TypeCode.Decimal:
					eventInfo.RenderedValue = <46127bb1-62af-4f27-b7c6-e869bac36295>YamlFormatter.FormatNumber(value);
					break;
				case TypeCode.Char:
				case TypeCode.String:
					eventInfo.RenderedValue = value.ToString();
					eventInfo.Style = <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.DoubleQuoted;
					break;
				case TypeCode.DateTime:
					eventInfo.RenderedValue = <46127bb1-62af-4f27-b7c6-e869bac36295>YamlFormatter.FormatDateTime(value);
					break;
				case TypeCode.Empty:
					eventInfo.RenderedValue = "null";
					break;
				default:
					if (eventInfo.Source.Type == typeof(TimeSpan))
					{
						eventInfo.RenderedValue = <46127bb1-62af-4f27-b7c6-e869bac36295>YamlFormatter.FormatTimeSpan(value);
						break;
					}
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
			}
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(<b5820e3d-2ea9-478e-aa86-8bf43ebfe369>MappingStartEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter)
		{
			eventInfo.Style = <bc2eacde-da96-4de8-a058-605c487b5916>MappingStyle.Flow;
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(<bd85e032-3c9d-4aa1-92f8-9a11ece4a496>SequenceStartEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter)
		{
			eventInfo.Style = <71ce5569-3f87-4b73-9e15-59e4c0c26f9f>SequenceStyle.Flow;
			base.Emit(eventInfo, emitter);
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <525b36b9-3eba-481e-b0e0-b4af5934ae49>TypeAssigningEventEmitter : <23a71e3a-cd5c-4a04-9181-7080f9ba3b80>ChainedEventEmitter
	{
		private readonly bool requireTagWhenStaticAndActualTypesAreDifferent;

		private readonly IDictionary<Type, <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName> tagMappings;

		public <525b36b9-3eba-481e-b0e0-b4af5934ae49>TypeAssigningEventEmitter(<88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter nextEmitter, bool requireTagWhenStaticAndActualTypesAreDifferent, IDictionary<Type, <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName> tagMappings)
			: base(nextEmitter)
		{
			this.requireTagWhenStaticAndActualTypesAreDifferent = requireTagWhenStaticAndActualTypesAreDifferent;
			this.tagMappings = tagMappings ?? throw new ArgumentNullException("tagMappings");
		}

		public override void Emit(<3a8120f0-1e22-4688-9f35-7f39f0ca5705>ScalarEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter)
		{
			<4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle style = <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Plain;
			object value = eventInfo.Source.Value;
			if (value == null)
			{
				eventInfo.Tag = <54c3bbba-5048-4fe1-bca0-881daf687cad>JsonSchema.Tags.Null;
				eventInfo.RenderedValue = "";
			}
			else
			{
				TypeCode typeCode = <acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.GetTypeCode(eventInfo.Source.Type);
				switch (typeCode)
				{
				case TypeCode.Boolean:
					eventInfo.Tag = <54c3bbba-5048-4fe1-bca0-881daf687cad>JsonSchema.Tags.Bool;
					eventInfo.RenderedValue = <46127bb1-62af-4f27-b7c6-e869bac36295>YamlFormatter.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:
					eventInfo.Tag = <54c3bbba-5048-4fe1-bca0-881daf687cad>JsonSchema.Tags.Int;
					eventInfo.RenderedValue = <46127bb1-62af-4f27-b7c6-e869bac36295>YamlFormatter.FormatNumber(value);
					break;
				case TypeCode.Single:
					eventInfo.Tag = <54c3bbba-5048-4fe1-bca0-881daf687cad>JsonSchema.Tags.Float;
					eventInfo.RenderedValue = <46127bb1-62af-4f27-b7c6-e869bac36295>YamlFormatter.FormatNumber((float)value);
					break;
				case TypeCode.Double:
					eventInfo.Tag = <54c3bbba-5048-4fe1-bca0-881daf687cad>JsonSchema.Tags.Float;
					eventInfo.RenderedValue = <46127bb1-62af-4f27-b7c6-e869bac36295>YamlFormatter.FormatNumber((double)value);
					break;
				case TypeCode.Decimal:
					eventInfo.Tag = <54c3bbba-5048-4fe1-bca0-881daf687cad>JsonSchema.Tags.Float;
					eventInfo.RenderedValue = <46127bb1-62af-4f27-b7c6-e869bac36295>YamlFormatter.FormatNumber(value);
					break;
				case TypeCode.Char:
				case TypeCode.String:
					eventInfo.Tag = <f9890ec4-e989-4845-94cf-bbacb908cd8f>FailsafeSchema.Tags.Str;
					eventInfo.RenderedValue = value.ToString();
					style = <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Any;
					break;
				case TypeCode.DateTime:
					eventInfo.Tag = <798dfe55-7b25-4a02-b11d-118d7dc1906f>DefaultSchema.Tags.Timestamp;
					eventInfo.RenderedValue = <46127bb1-62af-4f27-b7c6-e869bac36295>YamlFormatter.FormatDateTime(value);
					break;
				case TypeCode.Empty:
					eventInfo.Tag = <54c3bbba-5048-4fe1-bca0-881daf687cad>JsonSchema.Tags.Null;
					eventInfo.RenderedValue = "";
					break;
				default:
					if (eventInfo.Source.Type == typeof(TimeSpan))
					{
						eventInfo.RenderedValue = <46127bb1-62af-4f27-b7c6-e869bac36295>YamlFormatter.FormatTimeSpan(value);
						break;
					}
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
			}
			eventInfo.IsPlainImplicit = true;
			if (eventInfo.Style == <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Any)
			{
				eventInfo.Style = style;
			}
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(<b5820e3d-2ea9-478e-aa86-8bf43ebfe369>MappingStartEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter)
		{
			AssignTypeIfNeeded(eventInfo);
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(<bd85e032-3c9d-4aa1-92f8-9a11ece4a496>SequenceStartEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter)
		{
			AssignTypeIfNeeded(eventInfo);
			base.Emit(eventInfo, emitter);
		}

		private void AssignTypeIfNeeded(<c26fc2b8-434a-4e27-9cf1-fe8e1206dd94>ObjectEventInfo eventInfo)
		{
			if (tagMappings.TryGetValue(eventInfo.Source.Type, out var value))
			{
				eventInfo.Tag = value;
			}
			else if (requireTagWhenStaticAndActualTypesAreDifferent && eventInfo.Source.Value != null && eventInfo.Source.Type != eventInfo.Source.StaticType)
			{
				throw new <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException("Cannot serialize type '" + eventInfo.Source.Type.FullName + "' where a '" + eventInfo.Source.StaticType.FullName + "' was expected because no tag mapping has been registered for '" + eventInfo.Source.Type.FullName + "', which means that it won't be possible to deserialize the document.\nRegister a tag mapping using the SerializerBuilder.WithTagMapping method.\n\nE.g: builder.WithTagMapping(\"!" + eventInfo.Source.Type.Name + "\", typeof(" + eventInfo.Source.Type.FullName + "));");
			}
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <c35a9c34-ba2f-44f4-a294-0908aae5017f>WriterEventEmitter : <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter
	{
		void <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter.Emit(<e70d24c7-2fc4-4deb-935f-2f167bd4ad87>AliasEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter)
		{
			emitter.Emit(new <5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias(eventInfo.Alias));
		}

		void <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter.Emit(<3a8120f0-1e22-4688-9f35-7f39f0ca5705>ScalarEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter)
		{
			emitter.Emit(new <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar(eventInfo.Anchor, eventInfo.Tag, eventInfo.RenderedValue, eventInfo.Style, eventInfo.IsPlainImplicit, eventInfo.IsQuotedImplicit));
		}

		void <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter.Emit(<b5820e3d-2ea9-478e-aa86-8bf43ebfe369>MappingStartEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter)
		{
			emitter.Emit(new <3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart(eventInfo.Anchor, eventInfo.Tag, eventInfo.IsImplicit, eventInfo.Style));
		}

		void <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter.Emit(<0b621565-c1a3-4977-9130-2cc1e01ee81f>MappingEndEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter)
		{
			emitter.Emit(new <05f36264-c97d-43b8-9e56-0f8741a6ea35>MappingEnd());
		}

		void <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter.Emit(<bd85e032-3c9d-4aa1-92f8-9a11ece4a496>SequenceStartEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter)
		{
			emitter.Emit(new <d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart(eventInfo.Anchor, eventInfo.Tag, eventInfo.IsImplicit, eventInfo.Style));
		}

		void <88c07efb-5003-4e39-b80c-db91d583aaa8>IEventEmitter.Emit(<8e533513-9138-4fd4-8a1f-35a40ae25316>SequenceEndEventInfo eventInfo, <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter)
		{
			emitter.Emit(new <1851bced-7720-45bc-a55f-1347cc414c40>SequenceEnd());
		}
	}
}
namespace YamlDotNet.Serialization.Converters
{
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal class <78d83bca-e407-4ae7-bc09-94edb313afc6>DateTimeConverter : <d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter
	{
		private readonly DateTimeKind kind;

		private readonly IFormatProvider provider;

		private readonly string[] formats;

		public <78d83bca-e407-4ae7-bc09-94edb313afc6>DateTimeConverter(DateTimeKind kind = DateTimeKind.Utc, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] IFormatProvider provider = null, params string[] formats)
		{
			this.kind = ((kind == DateTimeKind.Unspecified) ? DateTimeKind.Utc : kind);
			this.provider = provider ?? CultureInfo.InvariantCulture;
			this.formats = formats.DefaultIfEmpty("G").ToArray();
		}

		public bool Accepts(Type type)
		{
			return type == typeof(DateTime);
		}

		public object ReadYaml(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, Type type)
		{
			return EnsureDateTimeKind(DateTime.ParseExact(parser.Consume<<1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar>().Value, style: (kind == DateTimeKind.Local) ? DateTimeStyles.AssumeLocal : DateTimeStyles.AssumeUniversal, formats: formats, provider: provider), kind);
		}

		public void WriteYaml(<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object value, Type type)
		{
			DateTime dateTime = (DateTime)value;
			string value2 = ((kind == DateTimeKind.Local) ? dateTime.ToLocalTime() : dateTime.ToUniversalTime()).ToString(formats.First(), provider);
			emitter.Emit(new <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName.Empty, <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName.Empty, value2, <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>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;
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal class <089ccd08-703f-46c5-9096-8e9c6c6e1322>GuidConverter : <d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter
	{
		private readonly bool jsonCompatible;

		public <089ccd08-703f-46c5-9096-8e9c6c6e1322>GuidConverter(bool jsonCompatible)
		{
			this.jsonCompatible = jsonCompatible;
		}

		public bool Accepts(Type type)
		{
			return type == typeof(Guid);
		}

		public object ReadYaml(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, Type type)
		{
			return new Guid(parser.Consume<<1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar>().Value);
		}

		public void WriteYaml(<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object value, Type type)
		{
			Guid guid = (Guid)value;
			emitter.Emit(new <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName.Empty, <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName.Empty, guid.ToString("D"), jsonCompatible ? <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.DoubleQuoted : <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal class <7eb23e15-084f-40a9-b160-434a3dabedce>SystemTypeConverter : <d0dabece-5cfd-403b-809a-d405b26a97c8>IYamlTypeConverter
	{
		public bool Accepts(Type type)
		{
			return typeof(Type).IsAssignableFrom(type);
		}

		public object ReadYaml(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, Type type)
		{
			return Type.GetType(parser.Consume<<1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar>().Value, throwOnError: true);
		}

		public void WriteYaml(<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] object value, Type type)
		{
			Type type2 = (Type)value;
			emitter.Emit(new <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName.Empty, <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName.Empty, type2.AssemblyQualifiedName, <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
}
namespace YamlDotNet.RepresentationModel
{
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal class <e74f579e-b8eb-4e33-8a88-8ed16f961c36>DocumentLoadingState
	{
		private readonly IDictionary<<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> anchors = new Dictionary<<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode>();

		private readonly IList<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> nodesWithUnresolvedAliases = new List<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode>();

		public void AddAnchor(<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode node)
		{
			if (node.Anchor.IsEmpty)
			{
				throw new ArgumentException("The specified node does not have an anchor");
			}
			if (anchors.ContainsKey(node.Anchor))
			{
				anchors[node.Anchor] = node;
			}
			else
			{
				anchors.Add(node.Anchor, node);
			}
		}

		public <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode GetNode(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName anchor, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
		{
			if (anchors.TryGetValue(anchor, out var value))
			{
				return value;
			}
			throw new <6f9a9fe8-ee96-4d89-94b1-d3035acc9d78>AnchorNotFoundException(start, end, $"The anchor '{anchor}' does not exists");
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
		public bool TryGetNode(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName anchor, [<3ce10464-8c9e-4f9f-b9c2-e0d3e385de9a>NotNullWhen(true)] out <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode node)
		{
			return anchors.TryGetValue(anchor, out node);
		}

		public void AddNodeWithUnresolvedAliases(<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode node)
		{
			nodesWithUnresolvedAliases.Add(node);
		}

		public void ResolveAliases()
		{
			foreach (<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode nodesWithUnresolvedAlias in nodesWithUnresolvedAliases)
			{
				nodesWithUnresolvedAlias.ResolveAliases(this);
			}
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal class <6ec76337-5db6-41b6-8976-cfb304c509c8>EmitterState
	{
		public HashSet<<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName> EmittedAnchors { get; } = new HashSet<<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName>();

	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal interface <3f7d80b5-6201-4392-b1f2-0cbe5595782e>IYamlVisitor
	{
		void Visit(<c60f0e0b-3cab-4320-87a1-98918c9dac4d>YamlStream stream);

		void Visit(<b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument document);

		void Visit(<b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode scalar);

		void Visit(<fb7a5b62-7881-4a01-9e2d-8c75c2e3d466>YamlSequenceNode sequence);

		void Visit(<570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode mapping);
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal class <d1e8c435-a254-47bb-af41-8adfc7912fda>LibYamlEventStream
	{
		private readonly <2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser;

		public <d1e8c435-a254-47bb-af41-8adfc7912fda>LibYamlEventStream(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser iParser)
		{
			parser = iParser ?? throw new ArgumentNullException("iParser");
		}

		public void WriteTo(TextWriter textWriter)
		{
			while (parser.MoveNext())
			{
				<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent current = parser.Current;
				if (!(current is <5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias <5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias))
				{
					if (!(current is <ce28eaa8-1705-4d9d-86ca-3aaeb4704887>DocumentEnd <ce28eaa8-1705-4d9d-86ca-3aaeb4704887>DocumentEnd))
					{
						if (!(current is <20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart <20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart))
						{
							if (!(current is <05f36264-c97d-43b8-9e56-0f8741a6ea35>MappingEnd))
							{
								if (!(current is <3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart nodeEvent))
								{
									if (!(current is <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar))
									{
										if (!(current is <1851bced-7720-45bc-a55f-1347cc414c40>SequenceEnd))
										{
											if (!(current is <d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart nodeEvent2))
											{
												if (!(current is <22699db6-dc9d-47cf-852e-e20a3076c7be>StreamEnd))
												{
													if (current is <c6735cbe-6b41-41ed-9735-1c5651a9fd34>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, <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar);
										switch (<1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar.Style)
										{
										case <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.DoubleQuoted:
											textWriter.Write(" \"");
											break;
										case <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.SingleQuoted:
											textWriter.Write(" '");
											break;
										case <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Folded:
											textWriter.Write(" >");
											break;
										case <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Literal:
											textWriter.Write(" |");
											break;
										default:
											textWriter.Write(" :");
											break;
										}
										string value = <1281ad32-4e8c-4505-9607-ea15acf4a70d>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 (!<20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart.IsImplicit)
							{
								textWriter.Write(" ---");
							}
						}
					}
					else
					{
						textWriter.Write("-DOC");
						if (!<ce28eaa8-1705-4d9d-86ca-3aaeb4704887>DocumentEnd.IsImplicit)
						{
							textWriter.Write(" ...");
						}
					}
				}
				else
				{
					textWriter.Write("=ALI *");
					textWriter.Write(<5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias.Value);
				}
				textWriter.WriteLine();
			}
		}

		private void WriteAnchorAndTag(TextWriter textWriter, <1532194c-e40d-420a-9a09-3cfeb36413b0>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(">");
			}
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal class <cc5aeb82-e76f-4f7f-af52-9c339aed4cdf>YamlAliasNode : <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode
	{
		public override <186506e0-ff6d-4804-be67-c038ed9f82d7>YamlNodeType NodeType => <186506e0-ff6d-4804-be67-c038ed9f82d7>YamlNodeType.Alias;

		internal <cc5aeb82-e76f-4f7f-af52-9c339aed4cdf>YamlAliasNode(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName anchor)
		{
			base.Anchor = anchor;
		}

		internal override void ResolveAliases(<e74f579e-b8eb-4e33-8a88-8ed16f961c36>DocumentLoadingState state)
		{
			throw new NotSupportedException("Resolving an alias on an alias node does not make sense");
		}

		internal override void Emit(<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter, <6ec76337-5db6-41b6-8976-cfb304c509c8>EmitterState state)
		{
			throw new NotSupportedException("A YamlAliasNode is an implementation detail and should never be saved.");
		}

		public override void Accept(<3f7d80b5-6201-4392-b1f2-0cbe5595782e>IYamlVisitor visitor)
		{
			throw new NotSupportedException("A YamlAliasNode is an implementation detail and should never be visited.");
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (obj is <cc5aeb82-e76f-4f7f-af52-9c339aed4cdf>YamlAliasNode <cc5aeb82-e76f-4f7f-af52-9c339aed4cdf>YamlAliasNode2 && Equals(<cc5aeb82-e76f-4f7f-af52-9c339aed4cdf>YamlAliasNode2))
			{
				return object.Equals(base.Anchor, <cc5aeb82-e76f-4f7f-af52-9c339aed4cdf>YamlAliasNode2.Anchor);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		internal override string ToString(<c7b9cad7-9392-4689-a5f6-745ade406936>RecursionLevel level)
		{
			return "*" + base.Anchor.ToString();
		}

		internal override IEnumerable<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> SafeAllNodes(<c7b9cad7-9392-4689-a5f6-745ade406936>RecursionLevel level)
		{
			yield return this;
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal class <b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
		private class AnchorAssigningVisitor : <66ac3a8e-5974-4236-9c7f-0ed2c9734182>YamlVisitorBase
		{
			private readonly HashSet<<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName> existingAnchors = new HashSet<<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName>();

			private readonly Dictionary<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, bool> visitedNodes = new Dictionary<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, bool>();

			public void AssignAnchors(<b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument document)
			{
				existingAnchors.Clear();
				visitedNodes.Clear();
				document.Accept(this);
				Random random = new Random();
				foreach (KeyValuePair<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, bool> visitedNode in visitedNodes)
				{
					if (!visitedNode.Value)
					{
						continue;
					}
					<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName;
					if (!visitedNode.Key.Anchor.IsEmpty && !existingAnchors.Contains(visitedNode.Key.Anchor))
					{
						<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName = visitedNode.Key.Anchor;
					}
					else
					{
						do
						{
							<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName = new <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName(random.Next().ToString(CultureInfo.InvariantCulture));
						}
						while (existingAnchors.Contains(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName));
					}
					existingAnchors.Add(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName);
					visitedNode.Key.Anchor = <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName;
				}
			}

			private bool VisitNodeAndFindDuplicates(<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>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(<b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode scalar)
			{
				VisitNodeAndFindDuplicates(scalar);
			}

			public override void Visit(<570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode mapping)
			{
				if (!VisitNodeAndFindDuplicates(mapping))
				{
					base.Visit(mapping);
				}
			}

			public override void Visit(<fb7a5b62-7881-4a01-9e2d-8c75c2e3d466>YamlSequenceNode sequence)
			{
				if (!VisitNodeAndFindDuplicates(sequence))
				{
					base.Visit(sequence);
				}
			}
		}

		public <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode RootNode { get; private set; }

		public IEnumerable<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> AllNodes => RootNode.AllNodes;

		public <b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument(<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode rootNode)
		{
			RootNode = rootNode;
		}

		public <b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument(string rootNode)
		{
			RootNode = new <b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode(rootNode);
		}

		internal <b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser)
		{
			<e74f579e-b8eb-4e33-8a88-8ed16f961c36>DocumentLoadingState <e74f579e-b8eb-4e33-8a88-8ed16f961c36>DocumentLoadingState2 = new <e74f579e-b8eb-4e33-8a88-8ed16f961c36>DocumentLoadingState();
			parser.Consume<<20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart>();
			<ce28eaa8-1705-4d9d-86ca-3aaeb4704887>DocumentEnd @event;
			while (!parser.TryConsume<<ce28eaa8-1705-4d9d-86ca-3aaeb4704887>DocumentEnd>(out @event))
			{
				RootNode = <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode.ParseNode(parser, <e74f579e-b8eb-4e33-8a88-8ed16f961c36>DocumentLoadingState2);
				if (RootNode is <cc5aeb82-e76f-4f7f-af52-9c339aed4cdf>YamlAliasNode)
				{
					throw new <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException("A document cannot contain only an alias");
				}
			}
			<e74f579e-b8eb-4e33-8a88-8ed16f961c36>DocumentLoadingState2.ResolveAliases();
			if (RootNode == null)
			{
				throw new ArgumentException("Atempted to parse an empty document");
			}
		}

		private void AssignAnchors()
		{
			new AnchorAssigningVisitor().AssignAnchors(this);
		}

		internal void Save(<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter, bool assignAnchors = true)
		{
			if (assignAnchors)
			{
				AssignAnchors();
			}
			emitter.Emit(new <20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart());
			RootNode.Save(emitter, new <6ec76337-5db6-41b6-8976-cfb304c509c8>EmitterState());
			emitter.Emit(new <ce28eaa8-1705-4d9d-86ca-3aaeb4704887>DocumentEnd(isImplicit: false));
		}

		public void Accept(<3f7d80b5-6201-4392-b1f2-0cbe5595782e>IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode : <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, IEnumerable<KeyValuePair<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode>>, IEnumerable, <3e02419b-73d0-43d6-8614-b0bb250feb69>IYamlConvertible
	{
		private readonly <66431b35-1bd5-4b79-9b70-e045c0d8726e>IOrderedDictionary<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> children = new <9f3077b2-e211-4110-83ff-f05e67185325>OrderedDictionary<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode>();

		public <66431b35-1bd5-4b79-9b70-e045c0d8726e>IOrderedDictionary<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> Children => children;

		public <bc2eacde-da96-4de8-a058-605c487b5916>MappingStyle Style { get; set; }

		public override <186506e0-ff6d-4804-be67-c038ed9f82d7>YamlNodeType NodeType => <186506e0-ff6d-4804-be67-c038ed9f82d7>YamlNodeType.Mapping;

		internal <570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, <e74f579e-b8eb-4e33-8a88-8ed16f961c36>DocumentLoadingState state)
		{
			Load(parser, state);
		}

		private void Load(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, <e74f579e-b8eb-4e33-8a88-8ed16f961c36>DocumentLoadingState state)
		{
			<3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart <3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart = parser.Consume<<3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart>();
			Load(<3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart, state);
			Style = <3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart.Style;
			bool flag = false;
			<05f36264-c97d-43b8-9e56-0f8741a6ea35>MappingEnd @event;
			while (!parser.TryConsume<<05f36264-c97d-43b8-9e56-0f8741a6ea35>MappingEnd>(out @event))
			{
				<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode2 = <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode.ParseNode(parser, state);
				<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode3 = <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode.ParseNode(parser, state);
				try
				{
					children.Add(<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode2, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode3);
				}
				catch (ArgumentException innerException)
				{
					throw new <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException(<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode2.Start, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode2.End, "Duplicate key", innerException);
				}
				flag = flag || <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode2 is <cc5aeb82-e76f-4f7f-af52-9c339aed4cdf>YamlAliasNode || <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode3 is <cc5aeb82-e76f-4f7f-af52-9c339aed4cdf>YamlAliasNode;
			}
			if (flag)
			{
				state.AddNodeWithUnresolvedAliases(this);
			}
		}

		public <570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode()
		{
		}

		public <570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 0, 1, 1 })] params KeyValuePair<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode>[] children)
			: this((IEnumerable<KeyValuePair<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode>>)children)
		{
		}

		public <570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 0, 1, 1 })] IEnumerable<KeyValuePair<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode>> children)
		{
			foreach (KeyValuePair<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> child in children)
			{
				this.children.Add(child);
			}
		}

		public <570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode(params <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode[] children)
			: this((IEnumerable<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode>)children)
		{
		}

		public <570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode(IEnumerable<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> children)
		{
			using IEnumerator<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> enumerator = children.GetEnumerator();
			while (enumerator.MoveNext())
			{
				<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>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(<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode key, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode value)
		{
			children.Add(key, value);
		}

		public void Add(string key, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode value)
		{
			children.Add(new <b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode(key), value);
		}

		public void Add(<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode key, string value)
		{
			children.Add(key, new <b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode(value));
		}

		public void Add(string key, string value)
		{
			children.Add(new <b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode(key), new <b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode(value));
		}

		internal override void ResolveAliases(<e74f579e-b8eb-4e33-8a88-8ed16f961c36>DocumentLoadingState state)
		{
			Dictionary<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> dictionary = null;
			Dictionary<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> dictionary2 = null;
			foreach (KeyValuePair<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> child in children)
			{
				if (child.Key is <cc5aeb82-e76f-4f7f-af52-9c339aed4cdf>YamlAliasNode)
				{
					if (dictionary == null)
					{
						dictionary = new Dictionary<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode>();
					}
					dictionary.Add(child.Key, state.GetNode(child.Key.Anchor, child.Key.Start, child.Key.End));
				}
				if (child.Value is <cc5aeb82-e76f-4f7f-af52-9c339aed4cdf>YamlAliasNode)
				{
					if (dictionary2 == null)
					{
						dictionary2 = new Dictionary<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode>();
					}
					dictionary2.Add(child.Key, state.GetNode(child.Value.Anchor, child.Value.Start, child.Value.End));
				}
			}
			if (dictionary2 != null)
			{
				foreach (KeyValuePair<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> item in dictionary2)
				{
					children[item.Key] = item.Value;
				}
			}
			if (dictionary == null)
			{
				return;
			}
			foreach (KeyValuePair<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> item2 in dictionary)
			{
				<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode value = children[item2.Key];
				children.Remove(item2.Key);
				children.Add(item2.Value, value);
			}
		}

		internal override void Emit(<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter, <6ec76337-5db6-41b6-8976-cfb304c509c8>EmitterState state)
		{
			emitter.Emit(new <3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart(base.Anchor, base.Tag, isImplicit: true, Style));
			foreach (KeyValuePair<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> child in children)
			{
				child.Key.Save(emitter, state);
				child.Value.Save(emitter, state);
			}
			emitter.Emit(new <05f36264-c97d-43b8-9e56-0f8741a6ea35>MappingEnd());
		}

		public override void Accept(<3f7d80b5-6201-4392-b1f2-0cbe5595782e>IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (!(obj is <570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode <570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode2) || !object.Equals(base.Tag, <570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode2.Tag) || children.Count != <570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode2.children.Count)
			{
				return false;
			}
			foreach (KeyValuePair<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> child in children)
			{
				if (!<570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode2.children.TryGetValue(child.Key, out var value) || !object.Equals(child.Value, value))
				{
					return false;
				}
			}
			return true;
		}

		public override int GetHashCode()
		{
			int num = base.GetHashCode();
			foreach (KeyValuePair<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> child in children)
			{
				num = <ca709e83-a9df-4fcf-9dd7-e6aed3e61227>HashCode.CombineHashCodes(num, child.Key);
				num = <ca709e83-a9df-4fcf-9dd7-e6aed3e61227>HashCode.CombineHashCodes(num, child.Value);
			}
			return num;
		}

		internal override IEnumerable<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> SafeAllNodes(<c7b9cad7-9392-4689-a5f6-745ade406936>RecursionLevel level)
		{
			level.Increment();
			yield return this;
			foreach (KeyValuePair<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> child in children)
			{
				foreach (<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode item in child.Key.SafeAllNodes(level))
				{
					yield return item;
				}
				foreach (<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode item2 in child.Value.SafeAllNodes(level))
				{
					yield return item2;
				}
			}
			level.Decrement();
		}

		internal override string ToString(<c7b9cad7-9392-4689-a5f6-745ade406936>RecursionLevel level)
		{
			if (!level.TryIncrement())
			{
				return "WARNING! INFINITE RECURSION!";
			}
			StringBuilder stringBuilder = new StringBuilder("{ ");
			foreach (KeyValuePair<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> child in children)
			{
				if (stringBuilder.Length > 2)
				{
					stringBuilder.Append(", ");
				}
				stringBuilder.Append("{ ").Append(child.Key.ToString(level)).Append(", ")
					.Append(child.Value.ToString(level))
					.Append(" }");
			}
			stringBuilder.Append(" }");
			level.Decrement();
			return stringBuilder.ToString();
		}

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 0, 1, 1 })]
		public IEnumerator<KeyValuePair<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode>> GetEnumerator()
		{
			return children.GetEnumerator();
		}

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

		void <3e02419b-73d0-43d6-8614-b0bb250feb69>IYamlConvertible.Read(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, Type expectedType, <e75d04a3-617f-4e9f-93b7-e90dcd228b4c>ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new <e74f579e-b8eb-4e33-8a88-8ed16f961c36>DocumentLoadingState());
		}

		void <3e02419b-73d0-43d6-8614-b0bb250feb69>IYamlConvertible.Write(<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter, <dd379040-fcd6-4c71-bd11-b3912495c170>ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new <6ec76337-5db6-41b6-8976-cfb304c509c8>EmitterState());
		}

		public static <570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode FromObject(object mapping)
		{
			if (mapping == null)
			{
				throw new ArgumentNullException("mapping");
			}
			<570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode <570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode2 = new <570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode();
			foreach (PropertyInfo publicProperty in <acf80c83-396a-4485-927f-7e45930171a8>ReflectionExtensions.GetPublicProperties(mapping.GetType()))
			{
				if (publicProperty.CanRead && publicProperty.GetGetMethod(nonPublic: false).GetParameters().Length == 0)
				{
					object value = publicProperty.GetValue(mapping, null);
					<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode2 = value as <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode;
					if (<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode2 == null)
					{
						<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode2 = Convert.ToString(value) ?? string.Empty;
					}
					<570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode2.Add(publicProperty.Name, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode2);
				}
			}
			return <570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode2;
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal abstract class <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode
	{
		private const int MaximumRecursionLevel = 1000;

		internal const string MaximumRecursionLevelReachedToStringValue = "WARNING! INFINITE RECURSION!";

		public <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName Anchor { get; set; }

		public <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName Tag { get; set; }

		public <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark Start { get; private set; } = <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty;


		public <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark End { get; private set; } = <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty;


		public IEnumerable<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> AllNodes
		{
			get
			{
				<c7b9cad7-9392-4689-a5f6-745ade406936>RecursionLevel level = new <c7b9cad7-9392-4689-a5f6-745ade406936>RecursionLevel(1000);
				return SafeAllNodes(level);
			}
		}

		public abstract <186506e0-ff6d-4804-be67-c038ed9f82d7>YamlNodeType NodeType { get; }

		public <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode this[int index]
		{
			get
			{
				if (!(this is <fb7a5b62-7881-4a01-9e2d-8c75c2e3d466>YamlSequenceNode <fb7a5b62-7881-4a01-9e2d-8c75c2e3d466>YamlSequenceNode2))
				{
					throw new ArgumentException($"Accessed '{NodeType}' with an invalid index: {index}. Only Sequences can be indexed by number.");
				}
				return <fb7a5b62-7881-4a01-9e2d-8c75c2e3d466>YamlSequenceNode2.Children[index];
			}
		}

		public <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode this[<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode key]
		{
			get
			{
				if (!(this is <570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode <570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode2))
				{
					throw new ArgumentException($"Accessed '{NodeType}' with an invalid index: {key}. Only Mappings can be indexed by key.");
				}
				return <570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode2.Children[key];
			}
		}

		internal void Load(<1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent yamlEvent, <e74f579e-b8eb-4e33-8a88-8ed16f961c36>DocumentLoadingState state)
		{
			Tag = yamlEvent.Tag;
			if (!yamlEvent.Anchor.IsEmpty)
			{
				Anchor = yamlEvent.Anchor;
				state.AddAnchor(this);
			}
			Start = yamlEvent.Start;
			End = yamlEvent.End;
		}

		internal static <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode ParseNode(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, <e74f579e-b8eb-4e33-8a88-8ed16f961c36>DocumentLoadingState state)
		{
			if (parser.Accept<<1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar>(out var _))
			{
				return new <b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode(parser, state);
			}
			if (parser.Accept<<d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart>(out var _))
			{
				return new <fb7a5b62-7881-4a01-9e2d-8c75c2e3d466>YamlSequenceNode(parser, state);
			}
			if (parser.Accept<<3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart>(out var _))
			{
				return new <570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode(parser, state);
			}
			if (parser.TryConsume<<5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias>(out var event4))
			{
				if (!state.TryGetNode(event4.Value, out var node))
				{
					return new <cc5aeb82-e76f-4f7f-af52-9c339aed4cdf>YamlAliasNode(event4.Value);
				}
				return node;
			}
			throw new ArgumentException("The current event is of an unsupported type.", "parser");
		}

		internal abstract void ResolveAliases(<e74f579e-b8eb-4e33-8a88-8ed16f961c36>DocumentLoadingState state);

		internal void Save(<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter, <6ec76337-5db6-41b6-8976-cfb304c509c8>EmitterState state)
		{
			if (!Anchor.IsEmpty && !state.EmittedAnchors.Add(Anchor))
			{
				emitter.Emit(new <5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias(Anchor));
			}
			else
			{
				Emit(emitter, state);
			}
		}

		internal abstract void Emit(<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter, <6ec76337-5db6-41b6-8976-cfb304c509c8>EmitterState state);

		public abstract void Accept(<3f7d80b5-6201-4392-b1f2-0cbe5595782e>IYamlVisitor visitor);

		public override string ToString()
		{
			<c7b9cad7-9392-4689-a5f6-745ade406936>RecursionLevel <c7b9cad7-9392-4689-a5f6-745ade406936>RecursionLevel = new <c7b9cad7-9392-4689-a5f6-745ade406936>RecursionLevel(1000);
			return ToString(<c7b9cad7-9392-4689-a5f6-745ade406936>RecursionLevel);
		}

		internal abstract string ToString(<c7b9cad7-9392-4689-a5f6-745ade406936>RecursionLevel level);

		internal abstract IEnumerable<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> SafeAllNodes(<c7b9cad7-9392-4689-a5f6-745ade406936>RecursionLevel level);

		public static implicit operator <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode(string value)
		{
			return new <b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode(value);
		}

		public static implicit operator <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode(string[] sequence)
		{
			return new <fb7a5b62-7881-4a01-9e2d-8c75c2e3d466>YamlSequenceNode(((IEnumerable<string>)sequence).Select((Func<string, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode>)([<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] (string i) => i)));
		}

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public static explicit operator string(<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode node)
		{
			if (!(node is <b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode <b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode2))
			{
				throw new ArgumentException($"Attempted to convert a '{node.NodeType}' to string. This conversion is valid only for Scalars.");
			}
			return <b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode2.Value;
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <7968e03c-83e7-406d-be2b-edf38ec9f592>YamlNodeIdentityEqualityComparer : IEqualityComparer<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode>
	{
		public bool Equals([<0ef66e9f-f8f2-4d34-9dcc-35996d168209>AllowNull] <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode x, [<0ef66e9f-f8f2-4d34-9dcc-35996d168209>AllowNull] <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode y)
		{
			return x == y;
		}

		public int GetHashCode(<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode obj)
		{
			return obj.GetHashCode();
		}
	}
	internal enum <186506e0-ff6d-4804-be67-c038ed9f82d7>YamlNodeType
	{
		Alias,
		Mapping,
		Scalar,
		Sequence
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[DebuggerDisplay("{Value}")]
	internal sealed class <b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode : <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, <3e02419b-73d0-43d6-8614-b0bb250feb69>IYamlConvertible
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		[field: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public string Value
		{
			[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
			get;
			[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
			set;
		}

		public <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle Style { get; set; }

		public override <186506e0-ff6d-4804-be67-c038ed9f82d7>YamlNodeType NodeType => <186506e0-ff6d-4804-be67-c038ed9f82d7>YamlNodeType.Scalar;

		internal <b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, <e74f579e-b8eb-4e33-8a88-8ed16f961c36>DocumentLoadingState state)
		{
			Load(parser, state);
		}

		private void Load(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, <e74f579e-b8eb-4e33-8a88-8ed16f961c36>DocumentLoadingState state)
		{
			<1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar = parser.Consume<<1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar>();
			Load(<1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar, state);
			Value = <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar.Value;
			Style = <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar.Style;
		}

		public <b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode()
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
		public <b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode(string value)
		{
			Value = value;
		}

		internal override void ResolveAliases(<e74f579e-b8eb-4e33-8a88-8ed16f961c36>DocumentLoadingState state)
		{
			throw new NotSupportedException("Resolving an alias on a scalar node does not make sense");
		}

		internal override void Emit(<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter, <6ec76337-5db6-41b6-8976-cfb304c509c8>EmitterState state)
		{
			emitter.Emit(new <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar(base.Anchor, base.Tag, Value ?? string.Empty, Style, base.Tag.IsEmpty, isQuotedImplicit: false));
		}

		public override void Accept(<3f7d80b5-6201-4392-b1f2-0cbe5595782e>IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (obj is <b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode <b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode2 && object.Equals(base.Tag, <b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode2.Tag))
			{
				return object.Equals(Value, <b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode2.Value);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return <ca709e83-a9df-4fcf-9dd7-e6aed3e61227>HashCode.CombineHashCodes(base.Tag, Value);
		}

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public static explicit operator string(<b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode value)
		{
			return value.Value;
		}

		internal override string ToString(<c7b9cad7-9392-4689-a5f6-745ade406936>RecursionLevel level)
		{
			return Value ?? string.Empty;
		}

		internal override IEnumerable<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> SafeAllNodes(<c7b9cad7-9392-4689-a5f6-745ade406936>RecursionLevel level)
		{
			yield return this;
		}

		void <3e02419b-73d0-43d6-8614-b0bb250feb69>IYamlConvertible.Read(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, Type expectedType, <e75d04a3-617f-4e9f-93b7-e90dcd228b4c>ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new <e74f579e-b8eb-4e33-8a88-8ed16f961c36>DocumentLoadingState());
		}

		void <3e02419b-73d0-43d6-8614-b0bb250feb69>IYamlConvertible.Write(<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter, <dd379040-fcd6-4c71-bd11-b3912495c170>ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new <6ec76337-5db6-41b6-8976-cfb304c509c8>EmitterState());
		}
	}
	[DebuggerDisplay("Count = {children.Count}")]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <fb7a5b62-7881-4a01-9e2d-8c75c2e3d466>YamlSequenceNode : <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, IEnumerable<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode>, IEnumerable, <3e02419b-73d0-43d6-8614-b0bb250feb69>IYamlConvertible
	{
		private readonly IList<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> children = new List<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode>();

		public IList<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> Children => children;

		public <71ce5569-3f87-4b73-9e15-59e4c0c26f9f>SequenceStyle Style { get; set; }

		public override <186506e0-ff6d-4804-be67-c038ed9f82d7>YamlNodeType NodeType => <186506e0-ff6d-4804-be67-c038ed9f82d7>YamlNodeType.Sequence;

		internal <fb7a5b62-7881-4a01-9e2d-8c75c2e3d466>YamlSequenceNode(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, <e74f579e-b8eb-4e33-8a88-8ed16f961c36>DocumentLoadingState state)
		{
			Load(parser, state);
		}

		private void Load(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, <e74f579e-b8eb-4e33-8a88-8ed16f961c36>DocumentLoadingState state)
		{
			<d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart <d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart = parser.Consume<<d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart>();
			Load(<d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart, state);
			Style = <d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart.Style;
			bool flag = false;
			<1851bced-7720-45bc-a55f-1347cc414c40>SequenceEnd @event;
			while (!parser.TryConsume<<1851bced-7720-45bc-a55f-1347cc414c40>SequenceEnd>(out @event))
			{
				<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode2 = <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode.ParseNode(parser, state);
				children.Add(<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode2);
				flag = flag || <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode2 is <cc5aeb82-e76f-4f7f-af52-9c339aed4cdf>YamlAliasNode;
			}
			if (flag)
			{
				state.AddNodeWithUnresolvedAliases(this);
			}
		}

		public <fb7a5b62-7881-4a01-9e2d-8c75c2e3d466>YamlSequenceNode()
		{
		}

		public <fb7a5b62-7881-4a01-9e2d-8c75c2e3d466>YamlSequenceNode(params <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode[] children)
			: this((IEnumerable<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode>)children)
		{
		}

		public <fb7a5b62-7881-4a01-9e2d-8c75c2e3d466>YamlSequenceNode(IEnumerable<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> children)
		{
			foreach (<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode child in children)
			{
				this.children.Add(child);
			}
		}

		public void Add(<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode child)
		{
			children.Add(child);
		}

		public void Add(string child)
		{
			children.Add(new <b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode(child));
		}

		internal override void ResolveAliases(<e74f579e-b8eb-4e33-8a88-8ed16f961c36>DocumentLoadingState state)
		{
			for (int i = 0; i < children.Count; i++)
			{
				if (children[i] is <cc5aeb82-e76f-4f7f-af52-9c339aed4cdf>YamlAliasNode)
				{
					children[i] = state.GetNode(children[i].Anchor, children[i].Start, children[i].End);
				}
			}
		}

		internal override void Emit(<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter, <6ec76337-5db6-41b6-8976-cfb304c509c8>EmitterState state)
		{
			emitter.Emit(new <d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart(base.Anchor, base.Tag, base.Tag.IsEmpty, Style));
			foreach (<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode child in children)
			{
				child.Save(emitter, state);
			}
			emitter.Emit(new <1851bced-7720-45bc-a55f-1347cc414c40>SequenceEnd());
		}

		public override void Accept(<3f7d80b5-6201-4392-b1f2-0cbe5595782e>IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (!(obj is <fb7a5b62-7881-4a01-9e2d-8c75c2e3d466>YamlSequenceNode <fb7a5b62-7881-4a01-9e2d-8c75c2e3d466>YamlSequenceNode2) || !object.Equals(base.Tag, <fb7a5b62-7881-4a01-9e2d-8c75c2e3d466>YamlSequenceNode2.Tag) || children.Count != <fb7a5b62-7881-4a01-9e2d-8c75c2e3d466>YamlSequenceNode2.children.Count)
			{
				return false;
			}
			for (int i = 0; i < children.Count; i++)
			{
				if (!object.Equals(children[i], <fb7a5b62-7881-4a01-9e2d-8c75c2e3d466>YamlSequenceNode2.children[i]))
				{
					return false;
				}
			}
			return true;
		}

		public override int GetHashCode()
		{
			int h = 0;
			foreach (<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode child in children)
			{
				h = <ca709e83-a9df-4fcf-9dd7-e6aed3e61227>HashCode.CombineHashCodes(h, child);
			}
			return <ca709e83-a9df-4fcf-9dd7-e6aed3e61227>HashCode.CombineHashCodes(h, base.Tag);
		}

		internal override IEnumerable<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> SafeAllNodes(<c7b9cad7-9392-4689-a5f6-745ade406936>RecursionLevel level)
		{
			level.Increment();
			yield return this;
			foreach (<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode child in children)
			{
				foreach (<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode item in child.SafeAllNodes(level))
				{
					yield return item;
				}
			}
			level.Decrement();
		}

		internal override string ToString(<c7b9cad7-9392-4689-a5f6-745ade406936>RecursionLevel level)
		{
			if (!level.TryIncrement())
			{
				return "WARNING! INFINITE RECURSION!";
			}
			StringBuilder stringBuilder = new StringBuilder("[ ");
			foreach (<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode child in children)
			{
				if (stringBuilder.Length > 2)
				{
					stringBuilder.Append(", ");
				}
				stringBuilder.Append(child.ToString(level));
			}
			stringBuilder.Append(" ]");
			level.Decrement();
			return stringBuilder.ToString();
		}

		public IEnumerator<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> GetEnumerator()
		{
			return Children.GetEnumerator();
		}

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

		void <3e02419b-73d0-43d6-8614-b0bb250feb69>IYamlConvertible.Read(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, Type expectedType, <e75d04a3-617f-4e9f-93b7-e90dcd228b4c>ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new <e74f579e-b8eb-4e33-8a88-8ed16f961c36>DocumentLoadingState());
		}

		void <3e02419b-73d0-43d6-8614-b0bb250feb69>IYamlConvertible.Write(<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter, <dd379040-fcd6-4c71-bd11-b3912495c170>ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new <6ec76337-5db6-41b6-8976-cfb304c509c8>EmitterState());
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal class <c60f0e0b-3cab-4320-87a1-98918c9dac4d>YamlStream : IEnumerable<<b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument>, IEnumerable
	{
		private readonly IList<<b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument> documents = new List<<b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument>();

		public IList<<b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument> Documents => documents;

		public <c60f0e0b-3cab-4320-87a1-98918c9dac4d>YamlStream()
		{
		}

		public <c60f0e0b-3cab-4320-87a1-98918c9dac4d>YamlStream(params <b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument[] documents)
			: this((IEnumerable<<b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument>)documents)
		{
		}

		public <c60f0e0b-3cab-4320-87a1-98918c9dac4d>YamlStream(IEnumerable<<b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument> documents)
		{
			foreach (<b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument document in documents)
			{
				this.documents.Add(document);
			}
		}

		public void Add(<b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument document)
		{
			documents.Add(document);
		}

		public void Load(TextReader input)
		{
			Load(new <7af46315-d2cb-4c12-a8f4-c7dfa3fb4b89>Parser(input));
		}

		public void Load(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser)
		{
			documents.Clear();
			parser.Consume<<c6735cbe-6b41-41ed-9735-1c5651a9fd34>StreamStart>();
			<22699db6-dc9d-47cf-852e-e20a3076c7be>StreamEnd @event;
			while (!parser.TryConsume<<22699db6-dc9d-47cf-852e-e20a3076c7be>StreamEnd>(out @event))
			{
				<b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument item = new <b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument(parser);
				documents.Add(item);
			}
		}

		public void Save(TextWriter output)
		{
			Save(output, assignAnchors: true);
		}

		public void Save(TextWriter output, bool assignAnchors)
		{
			Save(new <b397acda-0b92-4004-a792-33a13435c7d5>Emitter(output), assignAnchors);
		}

		public void Save(<e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter emitter, bool assignAnchors)
		{
			emitter.Emit(new <c6735cbe-6b41-41ed-9735-1c5651a9fd34>StreamStart());
			foreach (<b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument document in documents)
			{
				document.Save(emitter, assignAnchors);
			}
			emitter.Emit(new <22699db6-dc9d-47cf-852e-e20a3076c7be>StreamEnd());
		}

		public void Accept(<3f7d80b5-6201-4392-b1f2-0cbe5595782e>IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public IEnumerator<<b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument> GetEnumerator()
		{
			return documents.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[Obsolete("Use YamlVisitorBase")]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal abstract class <8dac1f25-be33-45ff-a407-7d7064eea542>YamlVisitor : <3f7d80b5-6201-4392-b1f2-0cbe5595782e>IYamlVisitor
	{
		protected virtual void Visit(<c60f0e0b-3cab-4320-87a1-98918c9dac4d>YamlStream stream)
		{
		}

		protected virtual void Visited(<c60f0e0b-3cab-4320-87a1-98918c9dac4d>YamlStream stream)
		{
		}

		protected virtual void Visit(<b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument document)
		{
		}

		protected virtual void Visited(<b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument document)
		{
		}

		protected virtual void Visit(<b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode scalar)
		{
		}

		protected virtual void Visited(<b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode scalar)
		{
		}

		protected virtual void Visit(<fb7a5b62-7881-4a01-9e2d-8c75c2e3d466>YamlSequenceNode sequence)
		{
		}

		protected virtual void Visited(<fb7a5b62-7881-4a01-9e2d-8c75c2e3d466>YamlSequenceNode sequence)
		{
		}

		protected virtual void Visit(<570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode mapping)
		{
		}

		protected virtual void Visited(<570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode mapping)
		{
		}

		protected virtual void VisitChildren(<c60f0e0b-3cab-4320-87a1-98918c9dac4d>YamlStream stream)
		{
			foreach (<b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument document in stream.Documents)
			{
				document.Accept(this);
			}
		}

		protected virtual void VisitChildren(<b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument document)
		{
			if (document.RootNode != null)
			{
				document.RootNode.Accept(this);
			}
		}

		protected virtual void VisitChildren(<fb7a5b62-7881-4a01-9e2d-8c75c2e3d466>YamlSequenceNode sequence)
		{
			foreach (<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode child in sequence.Children)
			{
				child.Accept(this);
			}
		}

		protected virtual void VisitChildren(<570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode mapping)
		{
			foreach (KeyValuePair<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> child in mapping.Children)
			{
				child.Key.Accept(this);
				child.Value.Accept(this);
			}
		}

		void <3f7d80b5-6201-4392-b1f2-0cbe5595782e>IYamlVisitor.Visit(<c60f0e0b-3cab-4320-87a1-98918c9dac4d>YamlStream stream)
		{
			Visit(stream);
			VisitChildren(stream);
			Visited(stream);
		}

		void <3f7d80b5-6201-4392-b1f2-0cbe5595782e>IYamlVisitor.Visit(<b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument document)
		{
			Visit(document);
			VisitChildren(document);
			Visited(document);
		}

		void <3f7d80b5-6201-4392-b1f2-0cbe5595782e>IYamlVisitor.Visit(<b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode scalar)
		{
			Visit(scalar);
			Visited(scalar);
		}

		void <3f7d80b5-6201-4392-b1f2-0cbe5595782e>IYamlVisitor.Visit(<fb7a5b62-7881-4a01-9e2d-8c75c2e3d466>YamlSequenceNode sequence)
		{
			Visit(sequence);
			VisitChildren(sequence);
			Visited(sequence);
		}

		void <3f7d80b5-6201-4392-b1f2-0cbe5595782e>IYamlVisitor.Visit(<570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode mapping)
		{
			Visit(mapping);
			VisitChildren(mapping);
			Visited(mapping);
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal abstract class <66ac3a8e-5974-4236-9c7f-0ed2c9734182>YamlVisitorBase : <3f7d80b5-6201-4392-b1f2-0cbe5595782e>IYamlVisitor
	{
		public virtual void Visit(<c60f0e0b-3cab-4320-87a1-98918c9dac4d>YamlStream stream)
		{
			VisitChildren(stream);
		}

		public virtual void Visit(<b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument document)
		{
			VisitChildren(document);
		}

		public virtual void Visit(<b30fab9f-b409-4b9d-ac8d-f8a1d368ad0d>YamlScalarNode scalar)
		{
		}

		public virtual void Visit(<fb7a5b62-7881-4a01-9e2d-8c75c2e3d466>YamlSequenceNode sequence)
		{
			VisitChildren(sequence);
		}

		public virtual void Visit(<570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode mapping)
		{
			VisitChildren(mapping);
		}

		protected virtual void VisitPair(<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode key, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode value)
		{
			key.Accept(this);
			value.Accept(this);
		}

		protected virtual void VisitChildren(<c60f0e0b-3cab-4320-87a1-98918c9dac4d>YamlStream stream)
		{
			foreach (<b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument document in stream.Documents)
			{
				document.Accept(this);
			}
		}

		protected virtual void VisitChildren(<b99f4a17-0f91-44ba-912d-62b8ebdd7370>YamlDocument document)
		{
			if (document.RootNode != null)
			{
				document.RootNode.Accept(this);
			}
		}

		protected virtual void VisitChildren(<fb7a5b62-7881-4a01-9e2d-8c75c2e3d466>YamlSequenceNode sequence)
		{
			foreach (<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode child in sequence.Children)
			{
				child.Accept(this);
			}
		}

		protected virtual void VisitChildren(<570043b3-70c0-482b-8742-3c88c0d70121>YamlMappingNode mapping)
		{
			foreach (KeyValuePair<<5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode, <5c9206cb-8e60-49cb-b228-9df6f1e4abf3>YamlNode> child in mapping.Children)
			{
				VisitPair(child.Key, child.Value);
			}
		}
	}
}
namespace YamlDotNet.Helpers
{
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal static class <b78fbfa8-7538-4073-8c88-70abe52dcb8d>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: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		private static TMemberInfo TryGetMemberExpression<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] 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;
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
	internal sealed class <27544c65-9d5a-4beb-8b79-2465eef129b2>GenericCollectionToNonGenericAdapter<T> : IList, ICollection, IEnumerable
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)]
		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();
			}
		}

		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)]
		public object SyncRoot
		{
			[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
			get
			{
				throw new NotSupportedException();
			}
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <27544c65-9d5a-4beb-8b79-2465eef129b2>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();
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public void CopyTo(Array array, int index)
		{
			throw new NotSupportedException();
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public IEnumerator GetEnumerator()
		{
			return genericCollection.GetEnumerator();
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <2debfdfd-6eb0-4011-bf16-b461e83dd771>GenericDictionaryToNonGenericAdapter<TKey, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TValue> : IDictionary, ICollection, IEnumerable
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
		private class DictionaryEnumerator : IDictionaryEnumerator, IEnumerator
		{
			[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 0, 1, 1 })]
			private readonly IEnumerator<KeyValuePair<TKey, TValue>> enumerator;

			public DictionaryEntry Entry => new DictionaryEntry(Key, Value);

			public object Key => enumerator.Current.Key;

			[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
			public object Value
			{
				[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
				get
				{
					return enumerator.Current.Value;
				}
			}

			public object Current => Entry;

			public DictionaryEnumerator([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 0, 1, 1 })] 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();
			}
		}

		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public object this[object key]
		{
			[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
			get
			{
				throw new NotSupportedException();
			}
			[param: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
			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 <2debfdfd-6eb0-4011-bf16-b461e83dd771>GenericDictionaryToNonGenericAdapter(IDictionary<TKey, TValue> genericDictionary)
		{
			this.genericDictionary = genericDictionary ?? throw new ArgumentNullException("genericDictionary");
		}

		public void Add(object key, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] 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();
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal interface <66431b35-1bd5-4b79-9b70-e045c0d8726e>IOrderedDictionary<TKey, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 0, 1, 1 })]
		KeyValuePair<TKey, TValue> this[int index]
		{
			[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 0, 1, 1 })]
			get;
			[param: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 0, 1, 1 })]
			set;
		}

		void Insert(int index, TKey key, TValue value);

		void RemoveAt(int index);
	}
	internal static class <a6638e15-f63f-4db3-9daf-54151908f6f2>NumberExtensions
	{
		public static bool IsPowerOfTwo(this int value)
		{
			return (value & (value - 1)) == 0;
		}
	}
	[Serializable]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal class <9f3077b2-e211-4110-83ff-f05e67185325>OrderedDictionary<TKey, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TValue> : <66431b35-1bd5-4b79-9b70-e045c0d8726e>IOrderedDictionary<TKey, TValue>, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
		private class KeyCollection : ICollection<TKey>, IEnumerable<TKey>, IEnumerable
		{
			private readonly <9f3077b2-e211-4110-83ff-f05e67185325>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.Keys.Contains(item);
			}

			public KeyCollection(<9f3077b2-e211-4110-83ff-f05e67185325>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([<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] (KeyValuePair<TKey, TValue> kvp) => kvp.Key).GetEnumerator();
			}

			public bool Remove(TKey item)
			{
				throw new NotSupportedException();
			}

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

		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
		private class ValueCollection : ICollection<TValue>, IEnumerable<TValue>, IEnumerable
		{
			private readonly <9f3077b2-e211-4110-83ff-f05e67185325>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.Values.Contains(item);
			}

			public ValueCollection(<9f3077b2-e211-4110-83ff-f05e67185325>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([<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] (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;

		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 0, 1, 1 })]
		private readonly List<KeyValuePair<TKey, TValue>> list;

		private readonly IEqualityComparer<TKey> comparer;

		public TValue this[TKey key]
		{
			get
			{
				return dictionary[key];
			}
			set
			{
				if (dictionary.ContainsKey(key))
				{
					int index = list.FindIndex(([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 0, 1, 1 })] KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key));
					dictionary[key] = value;
					list[index] = new KeyValuePair<TKey, TValue>(key, value);
				}
				else
				{
					Add(key, value);
				}
			}
		}

		public ICollection<TKey> Keys => new KeyCollection(this);

		public ICollection<TValue> Values => new ValueCollection(this);

		public int Count => dictionary.Count;

		public bool IsReadOnly => false;

		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 0, 1, 1 })]
		public KeyValuePair<TKey, TValue> this[int index]
		{
			[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 0, 1, 1 })]
			get
			{
				return list[index];
			}
			[param: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 0, 1, 1 })]
			set
			{
				list[index] = value;
			}
		}

		public <9f3077b2-e211-4110-83ff-f05e67185325>OrderedDictionary()
			: this((IEqualityComparer<TKey>)EqualityComparer<TKey>.Default)
		{
		}

		public <9f3077b2-e211-4110-83ff-f05e67185325>OrderedDictionary(IEqualityComparer<TKey> comparer)
		{
			list = new List<KeyValuePair<TKey, TValue>>();
			dictionary = new Dictionary<TKey, TValue>(comparer);
			this.comparer = comparer;
		}

		public void Add(TKey key, TValue value)
		{
			Add(new KeyValuePair<TKey, TValue>(key, value));
		}

		public void Add([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 0, 1, 1 })] KeyValuePair<TKey, TValue> item)
		{
			dictionary.Add(item.Key, item.Value);
			list.Add(item);
		}

		public void Clear()
		{
			dictionary.Clear();
			list.Clear();
		}

		public bool Contains([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 0, 1, 1 })] KeyValuePair<TKey, TValue> item)
		{
			return dictionary.Contains(item);
		}

		public bool ContainsKey(TKey key)
		{
			return dictionary.ContainsKey(key);
		}

		public void CopyTo([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 0, 1, 1 })] KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			list.CopyTo(array, arrayIndex);
		}

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 0, 1, 1 })]
		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)
		{
			if (dictionary.ContainsKey(key))
			{
				int index = list.FindIndex(([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 0, 1, 1 })] KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key));
				list.RemoveAt(index);
				if (!dictionary.Remove(key))
				{
					throw new InvalidOperationException();
				}
				return true;
			}
			return false;
		}

		public bool Remove([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 0, 1, 1 })] 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, [<b3ae408d-452a-47a4-a4cd-28743506c159>MaybeNullWhen(false)] out TValue value)
		{
			return dictionary.TryGetValue(key, out value);
		}

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

		[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 <90115605-23be-4704-873a-54e0887d9ec7>Lazy
	{
		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public static Lazy<T> FromValue<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] T>(T value)
		{
			Lazy<T> lazy = new Lazy<T>(() => value, isThreadSafe: false);
			_ = lazy.Value;
			return lazy;
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal static class <4de7f8cf-be77-4f16-88c9-dff662cf737e>ReadOnlyCollectionExtensions
	{
		public static IReadOnlyList<T> AsReadonlyList<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] T>(this List<T> list)
		{
			return list;
		}

		public static IReadOnlyDictionary<TKey, TValue> AsReadonlyDictionary<TKey, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] TValue>(this Dictionary<TKey, TValue> dictionary)
		{
			return dictionary;
		}
	}
}
namespace YamlDotNet.Core
{
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal struct <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName : IEquatable<<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName>
	{
		public static readonly <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName Empty = default(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName);

		private static readonly Regex AnchorPattern = new Regex("^[^\\[\\]\\{\\},]+$", RegexOptions.Compiled);

		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		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 <be4a9aef-64f5-4469-b635-00fe21657f8b>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(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName other)
		{
			return object.Equals(value, other.value);
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (obj is <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return value?.GetHashCode() ?? 0;
		}

		public static bool operator ==(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName left, <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName left, <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName right)
		{
			return !(left == right);
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
		public static implicit operator <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName(string value)
		{
			if (value != null)
			{
				return new <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName(value);
			}
			return Empty;
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal class <6f9a9fe8-ee96-4d89-94b1-d3035acc9d78>AnchorNotFoundException : <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException
	{
		public <6f9a9fe8-ee96-4d89-94b1-d3035acc9d78>AnchorNotFoundException(string message)
			: base(message)
		{
		}

		public <6f9a9fe8-ee96-4d89-94b1-d3035acc9d78>AnchorNotFoundException(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end, string message)
			: base(start, end, message)
		{
		}

		public <6f9a9fe8-ee96-4d89-94b1-d3035acc9d78>AnchorNotFoundException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer<TBuffer> where TBuffer : class, <9e39d630-becb-4860-8a5d-e9f65de80826>ILookAheadBuffer
	{
		public TBuffer Buffer { get; }

		public bool EndOfInput => Buffer.EndOfInput;

		public <20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer(TBuffer buffer)
		{
			Buffer = buffer ?? throw new ArgumentNullException("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 value = Buffer.Peek(offset);
			return expectedCharacters.IndexOf(value) != -1;
		}
	}
	internal static class <841c4b63-3d9f-4d4b-9e0a-2bc380710311>Constants
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)]
		public static readonly <71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective[] DefaultTagDirectives = new <71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective[2]
		{
			new <71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective("!", "!"),
			new <71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective("!!", "tag:yaml.org,2002:")
		};

		public const int MajorVersion = 1;

		public const int MinorVersion = 3;
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <4c8a95a8-6f4a-46ea-88a7-286805c3eff5>Cursor
	{
		public int Index { get; private set; }

		public int Line { get; private set; }

		public int LineOffset { get; private set; }

		public <4c8a95a8-6f4a-46ea-88a7-286805c3eff5>Cursor()
		{
			Line = 1;
		}

		public <4c8a95a8-6f4a-46ea-88a7-286805c3eff5>Cursor(<4c8a95a8-6f4a-46ea-88a7-286805c3eff5>Cursor cursor)
		{
			Index = cursor.Index;
			Line = cursor.Line;
			LineOffset = cursor.LineOffset;
		}

		public <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark Mark()
		{
			return new <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark(Index, Line, LineOffset + 1);
		}

		public void Skip()
		{
			Index++;
			LineOffset++;
		}

		public void SkipLineByOffset(int offset)
		{
			Index += offset;
			Line++;
			LineOffset = 0;
		}

		public void ForceSkipLineAfterNonBreak()
		{
			if (LineOffset != 0)
			{
				Line++;
				LineOffset = 0;
			}
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal class <b397acda-0b92-4004-a792-33a13435c7d5>Emitter : <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter
	{
		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)]
		private class AnchorData
		{
			public <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName Anchor;

			public bool IsAlias;
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
		private class TagData
		{
			public string Handle;

			public string Suffix;
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)]
		private class ScalarData
		{
			[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)]
			public string Value = string.Empty;

			public bool IsMultiline;

			public bool IsFlowPlainAllowed;

			public bool IsBlockPlainAllowed;

			public bool IsSingleQuotedAllowed;

			public bool IsBlockAllowed;

			public bool HasSingleQuotes;

			public <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle Style;
		}

		private static readonly Regex UriReplacer = new Regex("[^0-9A-Za-z_\\-;?@=$~\\\\\\)\\]/:&+,\\.\\*\\(\\[!]", RegexOptions.Compiled | RegexOptions.Singleline);

		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 <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState state;

		private readonly Stack<<a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState> states = new Stack<<a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState>();

		private readonly Queue<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> events = new Queue<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent>();

		private readonly Stack<int> indents = new Stack<int>();

		private readonly <46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection tagDirectives = new <46eb9d4a-229c-4b2c-a13f-1be37c76564a>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 bool isDocumentEndWritten;

		private readonly AnchorData anchorData = new AnchorData();

		private readonly TagData tagData = new TagData();

		private readonly ScalarData scalarData = new ScalarData();

		public <b397acda-0b92-4004-a792-33a13435c7d5>Emitter(TextWriter output)
			: this(output, <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings.Default)
		{
		}

		public <b397acda-0b92-4004-a792-33a13435c7d5>Emitter(TextWriter output, int bestIndent)
			: this(output, bestIndent, int.MaxValue)
		{
		}

		public <b397acda-0b92-4004-a792-33a13435c7d5>Emitter(TextWriter output, int bestIndent, int bestWidth)
			: this(output, bestIndent, bestWidth, isCanonical: false)
		{
		}

		public <b397acda-0b92-4004-a792-33a13435c7d5>Emitter(TextWriter output, int bestIndent, int bestWidth, bool isCanonical)
			: this(output, new <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings(bestIndent, bestWidth, isCanonical, 1024))
		{
		}

		public <b397acda-0b92-4004-a792-33a13435c7d5>Emitter(TextWriter output, <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings settings)
		{
			bestIndent = settings.BestIndent;
			bestWidth = settings.BestWidth;
			isCanonical = settings.IsCanonical;
			maxSimpleKeyLength = settings.MaxSimpleKeyLength;
			skipAnchorName = settings.SkipAnchorName;
			forceIndentLess = !settings.IndentSequences;
			this.output = output;
			outputUsesUnicodeEncoding = IsUnicode(output.Encoding);
		}

		public void Emit(<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent @event)
		{
			events.Enqueue(@event);
			while (!NeedMoreEvents())
			{
				<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>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 <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.DocumentStart:
				num = 1;
				break;
			case <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.SequenceStart:
				num = 2;
				break;
			case <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.MappingStart:
				num = 3;
				break;
			default:
				return false;
			}
			if (events.Count > num)
			{
				return false;
			}
			int num2 = 0;
			using (Queue<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent>.Enumerator enumerator = events.GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					switch (enumerator.Current.Type)
					{
					case <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.DocumentStart:
					case <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.SequenceStart:
					case <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.MappingStart:
						num2++;
						break;
					case <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.DocumentEnd:
					case <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.SequenceEnd:
					case <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.MappingEnd:
						num2--;
						break;
					}
					if (num2 == 0)
					{
						return false;
					}
				}
			}
			return true;
		}

		private void AnalyzeEvent(<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent evt)
		{
			anchorData.Anchor = <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName.Empty;
			tagData.Handle = null;
			tagData.Suffix = null;
			if (evt is <5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias <5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias)
			{
				AnalyzeAnchor(<5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias.Value, isAlias: true);
			}
			else if (evt is <1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent <1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent)
			{
				if (evt is <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar scalar)
				{
					AnalyzeScalar(scalar);
				}
				AnalyzeAnchor(<1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent.Anchor, isAlias: false);
				if (!<1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent.Tag.IsEmpty && (isCanonical || <1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent.IsCanonical))
				{
					AnalyzeTag(<1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent.Tag);
				}
			}
		}

		private void AnalyzeAnchor(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName anchor, bool isAlias)
		{
			anchorData.Anchor = anchor;
			anchorData.IsAlias = isAlias;
		}

		private void AnalyzeScalar(<1281ad32-4e8c-4505-9607-ea15acf4a70d>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;
			}
			<20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer<<0fa5dd46-7d90-409b-a256-46a1f1ade723>StringLookAheadBuffer> <20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2 = new <20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer<<0fa5dd46-7d90-409b-a256-46a1f1ade723>StringLookAheadBuffer>(new <0fa5dd46-7d90-409b-a256-46a1f1ade723>StringLookAheadBuffer(value));
			bool flag3 = true;
			bool flag4 = <20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.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 (!<20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.EndOfInput)
			{
				if (flag19)
				{
					if (<20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.Check("#,[]{}&*!|>\\\"%@`'"))
					{
						flag = true;
						flag2 = true;
						flag9 = <20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.Check('\'');
						flag17 |= <20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.Check('\'');
					}
					if (<20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.Check("?:"))
					{
						flag = true;
						if (flag4)
						{
							flag2 = true;
						}
					}
					if (<20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.Check('-') && flag4)
					{
						flag = true;
						flag2 = true;
					}
				}
				else
				{
					if (<20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.Check(",?[]{}"))
					{
						flag = true;
					}
					if (<20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.Check(':'))
					{
						flag = true;
						if (flag4)
						{
							flag2 = true;
						}
					}
					if (<20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.Check('#') && flag3)
					{
						flag = true;
						flag2 = true;
					}
					flag17 |= <20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.Check('\'');
				}
				if (!flag16 && !<20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.IsPrintable())
				{
					flag16 = true;
				}
				if (<20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.IsBreak())
				{
					flag15 = true;
				}
				if (<20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.IsSpace())
				{
					if (flag19)
					{
						flag5 = true;
					}
					if (<20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.Buffer.Position >= <20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.Buffer.Length - 1)
					{
						flag7 = true;
					}
					if (flag13)
					{
						flag10 = true;
						flag14 = true;
					}
					flag12 = true;
					flag13 = false;
				}
				else if (<20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.IsBreak())
				{
					if (flag19)
					{
						flag6 = true;
					}
					if (<20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.Buffer.Position >= <20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.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 = <20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.IsWhiteBreakOrZero();
				<20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.Skip(1);
				if (!<20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.EndOfInput)
				{
					flag4 = <20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.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;
		}

		private bool ValueIsRepresentableInOutputEncoding(string value)
		{
			if (outputUsesUnicodeEncoding)
			{
				return true;
			}
			try
			{
				byte[] bytes = output.Encoding.GetBytes(value);
				return output.Encoding.GetString(bytes, 0, bytes.Length).Equals(value);
			}
			catch (EncoderFallbackException)
			{
				return false;
			}
			catch (ArgumentOutOfRangeException)
			{
				return false;
			}
		}

		private bool IsUnicode(Encoding encoding)
		{
			if (!(encoding is UTF8Encoding) && !(encoding is UnicodeEncoding))
			{
				return encoding is UTF7Encoding;
			}
			return true;
		}

		private void AnalyzeTag(<9b965c76-e42b-4be8-b468-b7eefab6d624>TagName tag)
		{
			tagData.Handle = tag.Value;
			foreach (<71c3f3b7-b4f6-4cab-80ac-72880aff85c8>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(<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent evt)
		{
			if (evt is <7d01ae39-3c87-4fa0-8b6c-f9a55cfe3ac0>Comment comment)
			{
				EmitComment(comment);
				return;
			}
			switch (state)
			{
			case <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.StreamStart:
				EmitStreamStart(evt);
				break;
			case <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.FirstDocumentStart:
				EmitDocumentStart(evt, isFirst: true);
				break;
			case <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.DocumentStart:
				EmitDocumentStart(evt, isFirst: false);
				break;
			case <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.DocumentContent:
				EmitDocumentContent(evt);
				break;
			case <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.DocumentEnd:
				EmitDocumentEnd(evt);
				break;
			case <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.FlowSequenceFirstItem:
				EmitFlowSequenceItem(evt, isFirst: true);
				break;
			case <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.FlowSequenceItem:
				EmitFlowSequenceItem(evt, isFirst: false);
				break;
			case <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.FlowMappingFirstKey:
				EmitFlowMappingKey(evt, isFirst: true);
				break;
			case <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.FlowMappingKey:
				EmitFlowMappingKey(evt, isFirst: false);
				break;
			case <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.FlowMappingSimpleValue:
				EmitFlowMappingValue(evt, isSimple: true);
				break;
			case <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.FlowMappingValue:
				EmitFlowMappingValue(evt, isSimple: false);
				break;
			case <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.BlockSequenceFirstItem:
				EmitBlockSequenceItem(evt, isFirst: true);
				break;
			case <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.BlockSequenceItem:
				EmitBlockSequenceItem(evt, isFirst: false);
				break;
			case <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.BlockMappingFirstKey:
				EmitBlockMappingKey(evt, isFirst: true);
				break;
			case <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.BlockMappingKey:
				EmitBlockMappingKey(evt, isFirst: false);
				break;
			case <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.BlockMappingSimpleValue:
				EmitBlockMappingValue(evt, isSimple: true);
				break;
			case <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.BlockMappingValue:
				EmitBlockMappingValue(evt, isSimple: false);
				break;
			case <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.StreamEnd:
				throw new <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException("Expected nothing after STREAM-END");
			default:
				throw new InvalidOperationException();
			}
		}

		private void EmitComment(<7d01ae39-3c87-4fa0-8b6c-f9a55cfe3ac0>Comment comment)
		{
			if (comment.IsInline)
			{
				Write(' ');
			}
			else
			{
				WriteIndent();
			}
			Write("# ");
			Write(comment.Value);
			WriteBreak();
			isIndentation = true;
		}

		private void EmitStreamStart(<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent evt)
		{
			if (!(evt is <c6735cbe-6b41-41ed-9735-1c5651a9fd34>StreamStart))
			{
				throw new ArgumentException("Expected STREAM-START.", "evt");
			}
			indent = -1;
			column = 0;
			isWhitespace = true;
			isIndentation = true;
			state = <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.FirstDocumentStart;
		}

		private void EmitDocumentStart(<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent evt, bool isFirst)
		{
			if (evt is <20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart <20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart)
			{
				bool flag = <20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart.IsImplicit && isFirst && !isCanonical;
				<46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection <46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection2 = NonDefaultTagsAmong(<20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart.Tags);
				if (!isFirst && !isDocumentEndWritten && (<20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart.Version != null || <46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection2.Count > 0))
				{
					isDocumentEndWritten = false;
					WriteIndicator("...", needWhitespace: true, whitespace: false, indentation: false);
					WriteIndent();
				}
				if (<20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart.Version != null)
				{
					AnalyzeVersionDirective(<20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart.Version);
					<9adf6b74-1cdc-49ae-a626-b628125e4102>Version version = <20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart.Version.Version;
					flag = false;
					WriteIndicator("%YAML", needWhitespace: true, whitespace: false, indentation: false);
					WriteIndicator(string.Format(CultureInfo.InvariantCulture, "{0}.{1}", new object[2] { version.Major, version.Minor }), needWhitespace: true, whitespace: false, indentation: false);
					WriteIndent();
				}
				foreach (<71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective item in <46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection2)
				{
					AppendTagDirectiveTo(item, allowDuplicates: false, tagDirectives);
				}
				<71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective[] defaultTagDirectives = <841c4b63-3d9f-4d4b-9e0a-2bc380710311>Constants.DefaultTagDirectives;
				for (int i = 0; i < defaultTagDirectives.Length; i++)
				{
					AppendTagDirectiveTo(defaultTagDirectives[i], allowDuplicates: true, tagDirectives);
				}
				if (<46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection2.Count > 0)
				{
					flag = false;
					defaultTagDirectives = <841c4b63-3d9f-4d4b-9e0a-2bc380710311>Constants.DefaultTagDirectives;
					for (int i = 0; i < defaultTagDirectives.Length; i++)
					{
						AppendTagDirectiveTo(defaultTagDirectives[i], allowDuplicates: true, <46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection2);
					}
					foreach (<71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective item2 in <46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection2)
					{
						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 = <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.DocumentContent;
			}
			else
			{
				if (!(evt is <22699db6-dc9d-47cf-852e-e20a3076c7be>StreamEnd))
				{
					throw new <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException("Expected DOCUMENT-START or STREAM-END");
				}
				state = <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.StreamEnd;
			}
		}

		private <46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection NonDefaultTagsAmong([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 2, 1 })] IEnumerable<<71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective> tagCollection)
		{
			<46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection <46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection2 = new <46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection();
			if (tagCollection == null)
			{
				return <46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection2;
			}
			foreach (<71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective item2 in tagCollection)
			{
				AppendTagDirectiveTo(item2, allowDuplicates: false, <46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection2);
			}
			<71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective[] defaultTagDirectives = <841c4b63-3d9f-4d4b-9e0a-2bc380710311>Constants.DefaultTagDirectives;
			foreach (<71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective item in defaultTagDirectives)
			{
				<46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection2.Remove(item);
			}
			return <46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection2;
		}

		private void AnalyzeVersionDirective(<e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective versionDirective)
		{
			if (versionDirective.Version.Major != 1 || versionDirective.Version.Minor > 3)
			{
				throw new <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException("Incompatible %YAML directive");
			}
		}

		private static void AppendTagDirectiveTo(<71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective value, bool allowDuplicates, <46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection tagDirectives)
		{
			if (tagDirectives.Contains(value))
			{
				if (!allowDuplicates)
				{
					throw new <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException("Duplicate %TAG directive.");
				}
			}
			else
			{
				tagDirectives.Add(value);
			}
		}

		private void EmitDocumentContent(<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent evt)
		{
			states.Push(<a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.DocumentEnd);
			EmitNode(evt, isMapping: false, isSimpleKey: false);
		}

		private void EmitNode(<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent evt, bool isMapping, bool isSimpleKey)
		{
			isMappingContext = isMapping;
			isSimpleKeyContext = isSimpleKey;
			switch (evt.Type)
			{
			case <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.Alias:
				EmitAlias();
				break;
			case <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.Scalar:
				EmitScalar(evt);
				break;
			case <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.SequenceStart:
				EmitSequenceStart(evt);
				break;
			case <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.MappingStart:
				EmitMappingStart(evt);
				break;
			default:
				throw new <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException($"Expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS, got {evt.Type}");
			}
		}

		private void EmitAlias()
		{
			ProcessAnchor();
			state = states.Pop();
		}

		private void EmitScalar(<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent evt)
		{
			SelectScalarStyle(evt);
			ProcessAnchor();
			ProcessTag();
			IncreaseIndent(isFlow: true, isIndentless: false);
			ProcessScalar();
			indent = indents.Pop();
			state = states.Pop();
		}

		private void SelectScalarStyle(<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent evt)
		{
			<1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar = (<1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar)evt;
			<4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle2 = <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar.Style;
			bool flag = tagData.Handle == null && tagData.Suffix == null;
			if (flag && !<1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar.IsPlainImplicit && !<1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar.IsQuotedImplicit)
			{
				throw new <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException("Neither tag nor isImplicit flags are specified.");
			}
			if (<4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle2 == <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Any)
			{
				<4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle2 = ((!scalarData.IsMultiline) ? <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Plain : <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Folded);
			}
			if (isCanonical)
			{
				<4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle2 = <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.DoubleQuoted;
			}
			if (isSimpleKeyContext && scalarData.IsMultiline)
			{
				<4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle2 = <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.DoubleQuoted;
			}
			if (<4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle2 == <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Plain)
			{
				if ((flowLevel != 0 && !scalarData.IsFlowPlainAllowed) || (flowLevel == 0 && !scalarData.IsBlockPlainAllowed))
				{
					<4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle2 = ((scalarData.IsSingleQuotedAllowed && !scalarData.HasSingleQuotes) ? <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.SingleQuoted : <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.DoubleQuoted);
				}
				if (string.IsNullOrEmpty(scalarData.Value) && (flowLevel != 0 || isSimpleKeyContext))
				{
					<4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle2 = <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.SingleQuoted;
				}
				if (flag && !<1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar.IsPlainImplicit)
				{
					<4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle2 = <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.SingleQuoted;
				}
			}
			if (<4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle2 == <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.SingleQuoted && !scalarData.IsSingleQuotedAllowed)
			{
				<4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle2 = <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.DoubleQuoted;
			}
			if ((<4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle2 == <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Literal || <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle2 == <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Folded) && (!scalarData.IsBlockAllowed || flowLevel != 0 || isSimpleKeyContext))
			{
				<4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle2 = <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.DoubleQuoted;
			}
			scalarData.Style = <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle2;
		}

		private void ProcessScalar()
		{
			switch (scalarData.Style)
			{
			case <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Plain:
				WritePlainScalar(scalarData.Value, !isSimpleKeyContext);
				break;
			case <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.SingleQuoted:
				WriteSingleQuotedScalar(scalarData.Value, !isSimpleKeyContext);
				break;
			case <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.DoubleQuoted:
				WriteDoubleQuotedScalar(scalarData.Value, !isSimpleKeyContext);
				break;
			case <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Literal:
				WriteLiteralScalar(scalarData.Value);
				break;
			case <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>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 <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException("While writing a quoted scalar, found an orphaned high surrogate.");
						}
						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 (!flag && !flag2 && c == '\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(<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent evt)
		{
			ProcessAnchor();
			ProcessTag();
			<d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart <d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart = (<d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart)evt;
			if (flowLevel != 0 || isCanonical || <d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart.Style == <71ce5569-3f87-4b73-9e15-59e4c0c26f9f>SequenceStyle.Flow || CheckEmptySequence())
			{
				state = <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.FlowSequenceFirstItem;
			}
			else
			{
				state = <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.BlockSequenceFirstItem;
			}
		}

		private void EmitMappingStart(<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent evt)
		{
			ProcessAnchor();
			ProcessTag();
			<3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart <3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart = (<3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart)evt;
			if (flowLevel != 0 || isCanonical || <3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart.Style == <bc2eacde-da96-4de8-a058-605c487b5916>MappingStyle.Flow || CheckEmptyMapping())
			{
				state = <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.FlowMappingFirstKey;
			}
			else
			{
				state = <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>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(<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent evt)
		{
			if (evt is <ce28eaa8-1705-4d9d-86ca-3aaeb4704887>DocumentEnd <ce28eaa8-1705-4d9d-86ca-3aaeb4704887>DocumentEnd)
			{
				WriteIndent();
				if (!<ce28eaa8-1705-4d9d-86ca-3aaeb4704887>DocumentEnd.IsImplicit)
				{
					WriteIndicator("...", needWhitespace: true, whitespace: false, indentation: false);
					WriteIndent();
					isDocumentEndWritten = true;
				}
				state = <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.DocumentStart;
				tagDirectives.Clear();
				return;
			}
			throw new <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException("Expected DOCUMENT-END.");
		}

		private void EmitFlowSequenceItem(<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				WriteIndicator("[", needWhitespace: true, whitespace: true, indentation: false);
				IncreaseIndent(isFlow: true, isIndentless: false);
				flowLevel++;
			}
			if (evt is <1851bced-7720-45bc-a55f-1347cc414c40>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(<a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.FlowSequenceItem);
				EmitNode(evt, isMapping: false, isSimpleKey: false);
			}
		}

		private void EmitFlowMappingKey(<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				WriteIndicator("{", needWhitespace: true, whitespace: true, indentation: false);
				IncreaseIndent(isFlow: true, isIndentless: false);
				flowLevel++;
			}
			if (evt is <05f36264-c97d-43b8-9e56-0f8741a6ea35>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(<a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.FlowMappingSimpleValue);
				EmitNode(evt, isMapping: true, isSimpleKey: true);
			}
			else
			{
				WriteIndicator("?", needWhitespace: true, whitespace: false, indentation: false);
				states.Push(<a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.FlowMappingValue);
				EmitNode(evt, isMapping: true, isSimpleKey: false);
			}
		}

		private void EmitFlowMappingValue(<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>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(<a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.FlowMappingKey);
			EmitNode(evt, isMapping: true, isSimpleKey: false);
		}

		private void EmitBlockSequenceItem(<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				IncreaseIndent(isFlow: false, isMappingContext && !isIndentation);
			}
			if (evt is <1851bced-7720-45bc-a55f-1347cc414c40>SequenceEnd)
			{
				indent = indents.Pop();
				state = states.Pop();
				return;
			}
			WriteIndent();
			WriteIndicator("-", needWhitespace: true, whitespace: false, indentation: true);
			states.Push(<a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.BlockSequenceItem);
			EmitNode(evt, isMapping: false, isSimpleKey: false);
		}

		private void EmitBlockMappingKey(<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				IncreaseIndent(isFlow: false, isIndentless: false);
			}
			if (evt is <05f36264-c97d-43b8-9e56-0f8741a6ea35>MappingEnd)
			{
				indent = indents.Pop();
				state = states.Pop();
				return;
			}
			WriteIndent();
			if (CheckSimpleKey())
			{
				states.Push(<a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.BlockMappingSimpleValue);
				EmitNode(evt, isMapping: true, isSimpleKey: true);
			}
			else
			{
				WriteIndicator("?", needWhitespace: true, whitespace: false, indentation: true);
				states.Push(<a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState.BlockMappingValue);
				EmitNode(evt, isMapping: true, isSimpleKey: false);
			}
		}

		private void EmitBlockMappingValue(<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent evt, bool isSimple)
		{
			if (isSimple)
			{
				WriteIndicator(":", needWhitespace: false, whitespace: false, indentation: false);
			}
			else
			{
				WriteIndent();
				WriteIndicator(":", needWhitespace: true, whitespace: false, indentation: true);
			}
			states.Push(<a8db59f5-640e-4146-866f-bc6ca9ae7ea6>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 (<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent @event in events)
			{
				num++;
				if (num == 2)
				{
					if (@event is <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar)
					{
						return string.IsNullOrEmpty(<1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar.Value);
					}
					break;
				}
			}
			return false;
		}

		private bool CheckSimpleKey()
		{
			if (events.Count < 1)
			{
				return false;
			}
			int num;
			switch (events.Peek().Type)
			{
			case <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.Alias:
				num = AnchorNameLength(anchorData.Anchor);
				break;
			case <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.Scalar:
				if (scalarData.IsMultiline)
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix) + SafeStringLength(scalarData.Value);
				break;
			case <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.SequenceStart:
				if (!CheckEmptySequence())
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix);
				break;
			case <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.MappingStart:
				if (!CheckEmptySequence())
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix);
				break;
			default:
				return false;
			}
			return num <= maxSimpleKeyLength;
		}

		private int AnchorNameLength(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName value)
		{
			if (!value.IsEmpty)
			{
				return value.Value.Length;
			}
			return 0;
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
		private int SafeStringLength(string value)
		{
			return value?.Length ?? 0;
		}

		private bool CheckEmptySequence()
		{
			return CheckEmptyStructure<<d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart, <1851bced-7720-45bc-a55f-1347cc414c40>SequenceEnd>();
		}

		private bool CheckEmptyMapping()
		{
			return CheckEmptyStructure<<3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart, <05f36264-c97d-43b8-9e56-0f8741a6ea35>MappingEnd>();
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)]
		private bool CheckEmptyStructure<TStart, TEnd>() where TStart : <1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent where TEnd : <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent
		{
			if (events.Count < 2)
			{
				return false;
			}
			using Queue<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent>.Enumerator enumerator = events.GetEnumerator();
			return enumerator.MoveNext() && enumerator.Current is TStart && enumerator.MoveNext() && enumerator.Current is TEnd;
		}

		private void WriteBlockScalarHints(string value)
		{
			<20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer<<0fa5dd46-7d90-409b-a256-46a1f1ade723>StringLookAheadBuffer> <20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2 = new <20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer<<0fa5dd46-7d90-409b-a256-46a1f1ade723>StringLookAheadBuffer>(new <0fa5dd46-7d90-409b-a256-46a1f1ade723>StringLookAheadBuffer(value));
			if (<20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.IsSpace() || <20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.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 || !<20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.IsBreak(value.Length - 1))
			{
				text = "-";
			}
			else if (value.Length >= 2 && <20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer2.IsBreak(value.Length - 2))
			{
				text = "+";
			}
			if (text != null)
			{
				WriteIndicator(text, needWhitespace: false, whitespace: false, indentation: false);
			}
		}

		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(<be4a9aef-64f5-4469-b635-00fe21657f8b>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 string UrlEncode(string text)
		{
			return UriReplacer.Replace(text, [<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] ([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)] Match match) =>
			{
				StringBuilder stringBuilder = new StringBuilder();
				byte[] bytes = Encoding.UTF8.GetBytes(match.Value);
				foreach (byte b in bytes)
				{
					stringBuilder.AppendFormat("%{0:X02}", b);
				}
				return stringBuilder.ToString();
			});
		}

		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;
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings
	{
		public static readonly <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings Default = new <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings();

		public int BestIndent { get; } = 2;


		public int BestWidth { get; } = int.MaxValue;


		public bool IsCanonical { get; }

		public bool SkipAnchorName { get; private set; }

		public int MaxSimpleKeyLength { get; } = 1024;


		public bool IndentSequences { get; }

		public <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings()
		{
		}

		public <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings(int bestIndent, int bestWidth, bool isCanonical, int maxSimpleKeyLength, bool skipAnchorName = false, bool indentSequences = 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;
		}

		public <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings WithBestIndent(int bestIndent)
		{
			return new <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings(bestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName);
		}

		public <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings WithBestWidth(int bestWidth)
		{
			return new <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings(BestIndent, bestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName);
		}

		public <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings WithMaxSimpleKeyLength(int maxSimpleKeyLength)
		{
			return new <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings(BestIndent, BestWidth, IsCanonical, maxSimpleKeyLength, SkipAnchorName);
		}

		public <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings Canonical()
		{
			return new <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings(BestIndent, BestWidth, isCanonical: true, MaxSimpleKeyLength, SkipAnchorName);
		}

		public <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings WithoutAnchorName()
		{
			return new <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, skipAnchorName: true);
		}

		public <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings WithIndentedSequences()
		{
			return new <83accf60-bd65-454a-8d67-3424a34552f8>EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, indentSequences: true);
		}
	}
	internal enum <a8db59f5-640e-4146-866f-bc6ca9ae7ea6>EmitterState
	{
		StreamStart,
		StreamEnd,
		FirstDocumentStart,
		DocumentStart,
		DocumentContent,
		DocumentEnd,
		FlowSequenceFirstItem,
		FlowSequenceItem,
		FlowMappingFirstKey,
		FlowMappingKey,
		FlowMappingSimpleValue,
		FlowMappingValue,
		BlockSequenceFirstItem,
		BlockSequenceItem,
		BlockMappingFirstKey,
		BlockMappingKey,
		BlockMappingSimpleValue,
		BlockMappingValue
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <8d566825-d19e-4f4e-bba8-65bf424c80ea>ForwardAnchorNotSupportedException : <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException
	{
		public <8d566825-d19e-4f4e-bba8-65bf424c80ea>ForwardAnchorNotSupportedException(string message)
			: base(message)
		{
		}

		public <8d566825-d19e-4f4e-bba8-65bf424c80ea>ForwardAnchorNotSupportedException(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end, string message)
			: base(start, end, message)
		{
		}

		public <8d566825-d19e-4f4e-bba8-65bf424c80ea>ForwardAnchorNotSupportedException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal static class <ca709e83-a9df-4fcf-9dd7-e6aed3e61227>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));
		}

		public static int CombineHashCodes(object first, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 1, 2 })] params object[] others)
		{
			int num = GetHashCode(first);
			foreach (object o in others)
			{
				num = CombineHashCodes(num, o);
			}
			return num;
		}

		private static int GetHashCode(object obj)
		{
			return obj?.GetHashCode() ?? 0;
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal interface <e1dd7872-6261-45fd-8d2f-add601861c41>IEmitter
	{
		void Emit(<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent @event);
	}
	internal interface <9e39d630-becb-4860-8a5d-e9f65de80826>ILookAheadBuffer
	{
		bool EndOfInput { get; }

		char Peek(int offset);

		void Skip(int length);
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <736c5c49-f376-432c-a5f4-5aca6e9edcab>InsertionQueue<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] 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 <736c5c49-f376-432c-a5f4-5aca6e9edcab>InsertionQueue(int initialCapacity = 128)
		{
			if (initialCapacity <= 0)
			{
				throw new ArgumentOutOfRangeException("initialCapacity", "The initial capacity must be a positive number.");
			}
			if (!<a6638e15-f63f-4db3-9daf-54151908f6f2>NumberExtensions.IsPowerOfTwo(initialCapacity))
			{
				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();
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
	internal interface <2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser
	{
		<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent Current { get; }

		bool MoveNext();
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal interface <3e8420bf-caa7-44ea-a97d-eeb7c3c5007e>IScanner
	{
		<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark CurrentPosition { get; }

		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token Current
		{
			[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
			get;
		}

		bool MoveNext();

		bool MoveNextWithoutConsuming();

		void ConsumeCurrent();
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <66026ed7-f1ba-4f21-bb74-d10a1e1a5fcf>LookAheadBuffer : <9e39d630-becb-4860-8a5d-e9f65de80826>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 <66026ed7-f1ba-4f21-bb74-d10a1e1a5fcf>LookAheadBuffer(TextReader input, int capacity)
		{
			if (capacity < 1)
			{
				throw new ArgumentOutOfRangeException("capacity", "The capacity must be positive.");
			}
			if (!<a6638e15-f63f-4db3-9daf-54151908f6f2>NumberExtensions.IsPowerOfTwo(capacity))
			{
				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;
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
	internal sealed class <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark : IEquatable<<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark>, IComparable<<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark>, IComparable
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)]
		public static readonly <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark Empty = new <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark();

		public int Index { get; }

		public int Line { get; }

		public int Column { get; }

		public <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark()
		{
			Line = 1;
			Column = 1;
		}

		public <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark(int index, int line, int column)
		{
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", "Index must be greater than or equal to zero.");
			}
			if (line < 1)
			{
				throw new ArgumentOutOfRangeException("line", "Line must be greater than or equal to 1.");
			}
			if (column < 1)
			{
				throw new ArgumentOutOfRangeException("column", "Column must be greater than or equal to 1.");
			}
			Index = index;
			Line = line;
			Column = column;
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public override string ToString()
		{
			return $"Line: {Line}, Col: {Column}, Idx: {Index}";
		}

		public override bool Equals(object obj)
		{
			return Equals(obj as <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark);
		}

		public bool Equals(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark other)
		{
			if (other != null && Index == other.Index && Line == other.Line)
			{
				return Column == other.Column;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return <ca709e83-a9df-4fcf-9dd7-e6aed3e61227>HashCode.CombineHashCodes(Index.GetHashCode(), <ca709e83-a9df-4fcf-9dd7-e6aed3e61227>HashCode.CombineHashCodes(Line.GetHashCode(), Column.GetHashCode()));
		}

		public int CompareTo(object obj)
		{
			if (obj == null)
			{
				throw new ArgumentNullException("obj");
			}
			return CompareTo(obj as <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark);
		}

		public int CompareTo(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark other)
		{
			if (other == null)
			{
				throw new ArgumentNullException("other");
			}
			int num = Line.CompareTo(other.Line);
			if (num == 0)
			{
				num = Column.CompareTo(other.Column);
			}
			return num;
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <84c979da-2a78-4796-94af-e7533b7b0006>MaximumRecursionLevelReachedException : <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException
	{
		public <84c979da-2a78-4796-94af-e7533b7b0006>MaximumRecursionLevelReachedException(string message)
			: base(message)
		{
		}

		public <84c979da-2a78-4796-94af-e7533b7b0006>MaximumRecursionLevelReachedException(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end, string message)
			: base(start, end, message)
		{
		}

		public <84c979da-2a78-4796-94af-e7533b7b0006>MaximumRecursionLevelReachedException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <7298c0b7-8479-46a4-a8e3-faca88e9a7b2>MergingParser : <2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
		private sealed class ParsingEventCollection : IEnumerable<LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent>>, IEnumerable
		{
			private readonly LinkedList<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> events;

			private readonly HashSet<LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent>> deleted;

			private readonly Dictionary<<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName, LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent>> references;

			public ParsingEventCollection()
			{
				events = new LinkedList<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent>();
				deleted = new HashSet<LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent>>();
				references = new Dictionary<<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName, LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent>>();
			}

			public void AddAfter(LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> node, IEnumerable<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> items)
			{
				foreach (<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent item in items)
				{
					node = events.AddAfter(node, item);
				}
			}

			public void Add(<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent item)
			{
				LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> node = events.AddLast(item);
				AddReference(item, node);
			}

			public void MarkDeleted(LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> node)
			{
				deleted.Add(node);
			}

			public void CleanMarked()
			{
				foreach (LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> item in deleted)
				{
					events.Remove(item);
				}
			}

			public IEnumerable<LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent>> FromAnchor(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName anchor)
			{
				LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> next = references[anchor].Next;
				return Enumerate(next);
			}

			public IEnumerator<LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent>> GetEnumerator()
			{
				return Enumerate(events.First).GetEnumerator();
			}

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

			private IEnumerable<LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent>> Enumerate([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 2, 1 })] LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> node)
			{
				while (node != null)
				{
					yield return node;
					node = node.Next;
				}
			}

			private void AddReference(<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent item, LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> node)
			{
				if (item is <3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart <3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart)
				{
					<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName anchor = <3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart.Anchor;
					if (!anchor.IsEmpty)
					{
						references[anchor] = node;
					}
				}
			}
		}

		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
		private sealed class ParsingEventCloner : <dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor
		{
			[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
			private <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent clonedEvent;

			public <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent Clone(<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent e)
			{
				e.Accept(this);
				if (clonedEvent == null)
				{
					throw new InvalidOperationException($"Could not clone event of type '{e.Type}'");
				}
				return clonedEvent;
			}

			void <dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor.Visit(<5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias e)
			{
				clonedEvent = new <5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias(e.Value, e.Start, e.End);
			}

			void <dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor.Visit(<c6735cbe-6b41-41ed-9735-1c5651a9fd34>StreamStart e)
			{
				throw new NotSupportedException();
			}

			void <dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor.Visit(<22699db6-dc9d-47cf-852e-e20a3076c7be>StreamEnd e)
			{
				throw new NotSupportedException();
			}

			void <dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor.Visit(<20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart e)
			{
				throw new NotSupportedException();
			}

			void <dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor.Visit(<ce28eaa8-1705-4d9d-86ca-3aaeb4704887>DocumentEnd e)
			{
				throw new NotSupportedException();
			}

			void <dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor.Visit(<1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar e)
			{
				clonedEvent = new <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName.Empty, e.Tag, e.Value, e.Style, e.IsPlainImplicit, e.IsQuotedImplicit, e.Start, e.End);
			}

			void <dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor.Visit(<d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart e)
			{
				clonedEvent = new <d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
			}

			void <dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor.Visit(<1851bced-7720-45bc-a55f-1347cc414c40>SequenceEnd e)
			{
				clonedEvent = new <1851bced-7720-45bc-a55f-1347cc414c40>SequenceEnd(e.Start, e.End);
			}

			void <dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor.Visit(<3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart e)
			{
				clonedEvent = new <3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
			}

			void <dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor.Visit(<05f36264-c97d-43b8-9e56-0f8741a6ea35>MappingEnd e)
			{
				clonedEvent = new <05f36264-c97d-43b8-9e56-0f8741a6ea35>MappingEnd(e.Start, e.End);
			}

			void <dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor.Visit(<7d01ae39-3c87-4fa0-8b6c-f9a55cfe3ac0>Comment e)
			{
				throw new NotSupportedException();
			}
		}

		private readonly ParsingEventCollection events;

		private readonly <2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser innerParser;

		private IEnumerator<LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent>> iterator;

		private bool merged;

		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent Current
		{
			[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
			get
			{
				return iterator.Current?.Value;
			}
		}

		public <7298c0b7-8479-46a4-a8e3-faca88e9a7b2>MergingParser(<2e81a95f-2819-48ee-ab4d-40df315a2a9c>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<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> @event in events)
			{
				if (IsMergeToken(@event))
				{
					events.MarkDeleted(@event);
					if (!HandleMerge(@event.Next))
					{
						throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(@event.Value.Start, @event.Value.End, "Unrecognized merge key pattern");
					}
				}
			}
		}

		private bool HandleMerge([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 2, 1 })] LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> node)
		{
			if (node == null)
			{
				return false;
			}
			if (node.Value is <5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias anchorAlias)
			{
				return HandleAnchorAlias(node, node, anchorAlias);
			}
			if (node.Value is <d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart)
			{
				return HandleSequence(node);
			}
			return false;
		}

		private bool HandleMergeSequence(LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> sequenceStart, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 2, 1 })] LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> node)
		{
			if (node == null)
			{
				return false;
			}
			if (node.Value is <5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias anchorAlias)
			{
				return HandleAnchorAlias(sequenceStart, node, anchorAlias);
			}
			if (node.Value is <d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart)
			{
				return HandleSequence(node);
			}
			return false;
		}

		private bool IsMergeToken(LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> node)
		{
			if (node.Value is <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar)
			{
				return <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar.Value == "<<";
			}
			return false;
		}

		private bool HandleAnchorAlias(LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> node, LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> anchorNode, <5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias anchorAlias)
		{
			IEnumerable<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> mappingEvents = GetMappingEvents(anchorAlias.Value);
			events.AddAfter(node, mappingEvents);
			events.MarkDeleted(anchorNode);
			return true;
		}

		private bool HandleSequence(LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> node)
		{
			events.MarkDeleted(node);
			LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> linkedListNode = node;
			while (linkedListNode != null)
			{
				if (linkedListNode.Value is <1851bced-7720-45bc-a55f-1347cc414c40>SequenceEnd)
				{
					events.MarkDeleted(linkedListNode);
					return true;
				}
				LinkedListNode<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> next = linkedListNode.Next;
				HandleMergeSequence(node, next);
				linkedListNode = next;
			}
			return true;
		}

		private IEnumerable<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> GetMappingEvents(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName anchor)
		{
			ParsingEventCloner cloner = new ParsingEventCloner();
			int nesting = 0;
			return from e in (from e in events.FromAnchor(anchor)
					select e.Value).TakeWhile([<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(0)] (<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent e) => (nesting += e.NestingIncrease) >= 0)
				select cloner.Clone(e);
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal class <7af46315-d2cb-4c12-a8f4-c7dfa3fb4b89>Parser : <2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
		private class EventQueue
		{
			private readonly Queue<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> highPriorityEvents = new Queue<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent>();

			private readonly Queue<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent> normalPriorityEvents = new Queue<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent>();

			public int Count => highPriorityEvents.Count + normalPriorityEvents.Count;

			public void Enqueue(<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent @event)
			{
				<f4498ea9-0998-4833-a113-6cccea8c58ca>EventType type = @event.Type;
				if (type == <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.StreamStart || type == <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.DocumentStart)
				{
					highPriorityEvents.Enqueue(@event);
				}
				else
				{
					normalPriorityEvents.Enqueue(@event);
				}
			}

			public <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent Dequeue()
			{
				if (highPriorityEvents.Count <= 0)
				{
					return normalPriorityEvents.Dequeue();
				}
				return highPriorityEvents.Dequeue();
			}
		}

		private readonly Stack<<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState> states = new Stack<<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState>();

		private readonly <46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection tagDirectives = new <46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection();

		private <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState state;

		private readonly <3e8420bf-caa7-44ea-a97d-eeb7c3c5007e>IScanner scanner;

		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		private <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token currentToken;

		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		private <e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective version;

		private readonly EventQueue pendingEvents = new EventQueue();

		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		[field: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent Current
		{
			[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
			get;
			[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
			private set;
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
		private <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token GetCurrentToken()
		{
			if (currentToken == null)
			{
				while (scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (!(currentToken is <fee736d1-2625-4930-8ec0-7a85005ed886>Comment <fee736d1-2625-4930-8ec0-7a85005ed886>Comment))
					{
						break;
					}
					pendingEvents.Enqueue(new <7d01ae39-3c87-4fa0-8b6c-f9a55cfe3ac0>Comment(<fee736d1-2625-4930-8ec0-7a85005ed886>Comment.Value, <fee736d1-2625-4930-8ec0-7a85005ed886>Comment.IsInline, <fee736d1-2625-4930-8ec0-7a85005ed886>Comment.Start, <fee736d1-2625-4930-8ec0-7a85005ed886>Comment.End));
					scanner.ConsumeCurrent();
				}
			}
			return currentToken;
		}

		public <7af46315-d2cb-4c12-a8f4-c7dfa3fb4b89>Parser(TextReader input)
			: this(new <90b24e2b-1e86-4de7-8a96-537c65d71fdd>Scanner(input))
		{
		}

		public <7af46315-d2cb-4c12-a8f4-c7dfa3fb4b89>Parser(<3e8420bf-caa7-44ea-a97d-eeb7c3c5007e>IScanner scanner)
		{
			this.scanner = scanner;
		}

		public bool MoveNext()
		{
			if (state == <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.StreamEnd)
			{
				Current = null;
				return false;
			}
			if (pendingEvents.Count == 0)
			{
				pendingEvents.Enqueue(StateMachine());
			}
			Current = pendingEvents.Dequeue();
			return true;
		}

		private <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent StateMachine()
		{
			return state switch
			{
				<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.StreamStart => ParseStreamStart(), 
				<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.ImplicitDocumentStart => ParseDocumentStart(isImplicit: true), 
				<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.DocumentStart => ParseDocumentStart(isImplicit: false), 
				<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.DocumentContent => ParseDocumentContent(), 
				<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.DocumentEnd => ParseDocumentEnd(), 
				<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.BlockNode => ParseNode(isBlock: true, isIndentlessSequence: false), 
				<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.BlockNodeOrIndentlessSequence => ParseNode(isBlock: true, isIndentlessSequence: true), 
				<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowNode => ParseNode(isBlock: false, isIndentlessSequence: false), 
				<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.BlockSequenceFirstEntry => ParseBlockSequenceEntry(isFirst: true), 
				<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.BlockSequenceEntry => ParseBlockSequenceEntry(isFirst: false), 
				<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.IndentlessSequenceEntry => ParseIndentlessSequenceEntry(), 
				<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.BlockMappingFirstKey => ParseBlockMappingKey(isFirst: true), 
				<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.BlockMappingKey => ParseBlockMappingKey(isFirst: false), 
				<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.BlockMappingValue => ParseBlockMappingValue(), 
				<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowSequenceFirstEntry => ParseFlowSequenceEntry(isFirst: true), 
				<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowSequenceEntry => ParseFlowSequenceEntry(isFirst: false), 
				<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowSequenceEntryMappingKey => ParseFlowSequenceEntryMappingKey(), 
				<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowSequenceEntryMappingValue => ParseFlowSequenceEntryMappingValue(), 
				<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowSequenceEntryMappingEnd => ParseFlowSequenceEntryMappingEnd(), 
				<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowMappingFirstKey => ParseFlowMappingKey(isFirst: true), 
				<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowMappingKey => ParseFlowMappingKey(isFirst: false), 
				<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowMappingValue => ParseFlowMappingValue(isEmpty: false), 
				<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowMappingEmptyValue => ParseFlowMappingValue(isEmpty: true), 
				_ => throw new InvalidOperationException(), 
			};
		}

		private void Skip()
		{
			if (currentToken != null)
			{
				currentToken = null;
				scanner.ConsumeCurrent();
			}
		}

		private <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent ParseStreamStart()
		{
			<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken();
			if (!(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <0c143349-e8ac-43ce-94f2-6e904605633e>StreamStart <0c143349-e8ac-43ce-94f2-6e904605633e>StreamStart))
			{
				throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token?.Start ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token?.End ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, "Did not find expected <stream-start>.");
			}
			Skip();
			state = <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.ImplicitDocumentStart;
			return new <c6735cbe-6b41-41ed-9735-1c5651a9fd34>StreamStart(<0c143349-e8ac-43ce-94f2-6e904605633e>StreamStart.Start, <0c143349-e8ac-43ce-94f2-6e904605633e>StreamStart.End);
		}

		private <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent ParseDocumentStart(bool isImplicit)
		{
			if (currentToken is <e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective)
			{
				throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException("While parsing a document start node, could not find document end marker before version directive.");
			}
			<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken();
			if (!isImplicit)
			{
				while (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <fdd48936-da79-498a-9a60-cdc7b3c5de1e>DocumentEnd)
				{
					Skip();
					<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken();
				}
			}
			if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token == null)
			{
				throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException("Reached the end of the stream while parsing a document start.");
			}
			if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <59bc0526-7926-43e3-8d44-f81d57983c50>Scalar && (state == <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.ImplicitDocumentStart || state == <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.DocumentStart))
			{
				isImplicit = true;
			}
			if ((isImplicit && !(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective) && !(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective) && !(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <d3392cd4-8bef-4da2-ae6e-42a42f997801>DocumentStart) && !(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <aaed5440-61c4-43e2-95a5-1da2fefcf451>StreamEnd) && !(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <fdd48936-da79-498a-9a60-cdc7b3c5de1e>DocumentEnd)) || <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <cc07463c-e471-478b-845b-eb93577727f0>BlockMappingStart)
			{
				<46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection tags = new <46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection();
				ProcessDirectives(tags);
				states.Push(<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.DocumentEnd);
				state = <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.BlockNode;
				return new <20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart(null, tags, isImplicit: true, <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token.Start, <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token.End);
			}
			if (!(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <aaed5440-61c4-43e2-95a5-1da2fefcf451>StreamEnd) && !(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <fdd48936-da79-498a-9a60-cdc7b3c5de1e>DocumentEnd))
			{
				<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start = <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token.Start;
				<46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection tags2 = new <46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection();
				<e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective <e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective = ProcessDirectives(tags2);
				<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken() ?? throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException("Reached the end of the stream while parsing a document start");
				if (!(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <d3392cd4-8bef-4da2-ae6e-42a42f997801>DocumentStart))
				{
					throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token.Start, <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token.End, "Did not find expected <document start>.");
				}
				states.Push(<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.DocumentEnd);
				state = <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.DocumentContent;
				<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end = <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token.End;
				Skip();
				return new <20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart(<e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective, tags2, isImplicit: false, start, end);
			}
			if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <fdd48936-da79-498a-9a60-cdc7b3c5de1e>DocumentEnd)
			{
				Skip();
			}
			state = <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.StreamEnd;
			<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken() ?? throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException("Reached the end of the stream while parsing a document start");
			<22699db6-dc9d-47cf-852e-e20a3076c7be>StreamEnd result = new <22699db6-dc9d-47cf-852e-e20a3076c7be>StreamEnd(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token.Start, <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token.End);
			if (scanner.MoveNextWithoutConsuming())
			{
				throw new InvalidOperationException("The scanner should contain no more tokens.");
			}
			return result;
		}

		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		private <e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective ProcessDirectives(<46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection tags)
		{
			bool flag = false;
			<e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective result = null;
			while (true)
			{
				if (GetCurrentToken() is <e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective <e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective)
				{
					if (version != null)
					{
						throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(<e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective.Start, <e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective.End, "Found duplicate %YAML directive.");
					}
					if (<e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective.Version.Major != 1 || <e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective.Version.Minor > 3)
					{
						throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(<e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective.Start, <e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective.End, "Found incompatible YAML document.");
					}
					result = (version = <e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective);
					flag = true;
				}
				else
				{
					if (!(GetCurrentToken() is <71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective <71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective))
					{
						break;
					}
					if (tags.Contains(<71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective.Handle))
					{
						throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(<71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective.Start, <71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective.End, "Found duplicate %TAG directive.");
					}
					tags.Add(<71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective);
					flag = true;
				}
				Skip();
			}
			if (GetCurrentToken() is <d3392cd4-8bef-4da2-ae6e-42a42f997801>DocumentStart && (version == null || (version.Version.Major == 1 && version.Version.Minor > 1)))
			{
				if (GetCurrentToken() is <d3392cd4-8bef-4da2-ae6e-42a42f997801>DocumentStart && version == null)
				{
					version = new <e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective(new <9adf6b74-1cdc-49ae-a626-b628125e4102>Version(1, 2));
				}
				flag = true;
			}
			AddTagDirectives(tags, <841c4b63-3d9f-4d4b-9e0a-2bc380710311>Constants.DefaultTagDirectives);
			if (flag)
			{
				tagDirectives.Clear();
			}
			AddTagDirectives(tagDirectives, tags);
			return result;
		}

		private static void AddTagDirectives(<46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection directives, IEnumerable<<71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective> source)
		{
			foreach (<71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective item in source)
			{
				if (!directives.Contains(item))
				{
					directives.Add(item);
				}
			}
		}

		private <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent ParseDocumentContent()
		{
			if (GetCurrentToken() is <e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective || GetCurrentToken() is <71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective || GetCurrentToken() is <d3392cd4-8bef-4da2-ae6e-42a42f997801>DocumentStart || GetCurrentToken() is <fdd48936-da79-498a-9a60-cdc7b3c5de1e>DocumentEnd || GetCurrentToken() is <aaed5440-61c4-43e2-95a5-1da2fefcf451>StreamEnd)
			{
				state = states.Pop();
				return ProcessEmptyScalar(scanner.CurrentPosition);
			}
			return ParseNode(isBlock: true, isIndentlessSequence: false);
		}

		private static <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent ProcessEmptyScalar(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark position)
		{
			return new <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName.Empty, <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName.Empty, string.Empty, <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Plain, isPlainImplicit: true, isQuotedImplicit: false, position, position);
		}

		private <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent ParseNode(bool isBlock, bool isIndentlessSequence)
		{
			if (GetCurrentToken() is <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error)
			{
				throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(<6f81fd05-c989-4e61-a86c-eefb303bec2c>Error.Start, <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error.End, <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error.Value);
			}
			<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken() ?? throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException("Reached the end of the stream while parsing a node");
			if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <54e5670b-898a-48cc-a602-f86f188e1415>AnchorAlias <54e5670b-898a-48cc-a602-f86f188e1415>AnchorAlias)
			{
				state = states.Pop();
				<5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias result = new <5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias(<54e5670b-898a-48cc-a602-f86f188e1415>AnchorAlias.Value, <54e5670b-898a-48cc-a602-f86f188e1415>AnchorAlias.Start, <54e5670b-898a-48cc-a602-f86f188e1415>AnchorAlias.End);
				Skip();
				return result;
			}
			<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start = <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token.Start;
			<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName anchor = <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName.Empty;
			<9b965c76-e42b-4be8-b468-b7eefab6d624>TagName tag = <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName.Empty;
			<81c9981d-61ad-4343-a7f8-7e07bfdb0222>Anchor <81c9981d-61ad-4343-a7f8-7e07bfdb0222>Anchor = null;
			<0de3b70d-5685-4444-bd63-fcc634fd9344>Tag <0de3b70d-5685-4444-bd63-fcc634fd9344>Tag = null;
			while (true)
			{
				if (anchor.IsEmpty && <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <81c9981d-61ad-4343-a7f8-7e07bfdb0222>Anchor <81c9981d-61ad-4343-a7f8-7e07bfdb0222>Anchor2)
				{
					<81c9981d-61ad-4343-a7f8-7e07bfdb0222>Anchor = <81c9981d-61ad-4343-a7f8-7e07bfdb0222>Anchor2;
					anchor = <81c9981d-61ad-4343-a7f8-7e07bfdb0222>Anchor2.Value;
					Skip();
				}
				else
				{
					if (!tag.IsEmpty || !(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <0de3b70d-5685-4444-bd63-fcc634fd9344>Tag <0de3b70d-5685-4444-bd63-fcc634fd9344>Tag2))
					{
						if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <81c9981d-61ad-4343-a7f8-7e07bfdb0222>Anchor <81c9981d-61ad-4343-a7f8-7e07bfdb0222>Anchor3)
						{
							throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(<81c9981d-61ad-4343-a7f8-7e07bfdb0222>Anchor3.Start, <81c9981d-61ad-4343-a7f8-7e07bfdb0222>Anchor3.End, "While parsing a node, found more than one anchor.");
						}
						if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <54e5670b-898a-48cc-a602-f86f188e1415>AnchorAlias <54e5670b-898a-48cc-a602-f86f188e1415>AnchorAlias2)
						{
							throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(<54e5670b-898a-48cc-a602-f86f188e1415>AnchorAlias2.Start, <54e5670b-898a-48cc-a602-f86f188e1415>AnchorAlias2.End, "While parsing a node, did not find expected token.");
						}
						if (!(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error2))
						{
							break;
						}
						if (<0de3b70d-5685-4444-bd63-fcc634fd9344>Tag != null && <81c9981d-61ad-4343-a7f8-7e07bfdb0222>Anchor != null && !anchor.IsEmpty)
						{
							return new <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar(anchor, default(<9b965c76-e42b-4be8-b468-b7eefab6d624>TagName), string.Empty, <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Any, isPlainImplicit: false, isQuotedImplicit: false, <81c9981d-61ad-4343-a7f8-7e07bfdb0222>Anchor.Start, <81c9981d-61ad-4343-a7f8-7e07bfdb0222>Anchor.End);
						}
						throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(<6f81fd05-c989-4e61-a86c-eefb303bec2c>Error2.Start, <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error2.End, <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error2.Value);
					}
					<0de3b70d-5685-4444-bd63-fcc634fd9344>Tag = <0de3b70d-5685-4444-bd63-fcc634fd9344>Tag2;
					if (string.IsNullOrEmpty(<0de3b70d-5685-4444-bd63-fcc634fd9344>Tag2.Handle))
					{
						tag = new <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName(<0de3b70d-5685-4444-bd63-fcc634fd9344>Tag2.Suffix);
					}
					else
					{
						if (!tagDirectives.Contains(<0de3b70d-5685-4444-bd63-fcc634fd9344>Tag2.Handle))
						{
							throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(<0de3b70d-5685-4444-bd63-fcc634fd9344>Tag2.Start, <0de3b70d-5685-4444-bd63-fcc634fd9344>Tag2.End, "While parsing a node, found undefined tag handle.");
						}
						tag = new <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName(tagDirectives[<0de3b70d-5685-4444-bd63-fcc634fd9344>Tag2.Handle].Prefix + <0de3b70d-5685-4444-bd63-fcc634fd9344>Tag2.Suffix);
					}
					Skip();
				}
				<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken() ?? throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException("Reached the end of the stream while parsing a node");
			}
			bool isEmpty = tag.IsEmpty;
			if (isIndentlessSequence && GetCurrentToken() is <1133f355-cbce-4fdc-b83c-f4a9447c1965>BlockEntry)
			{
				state = <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.IndentlessSequenceEntry;
				return new <d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart(anchor, tag, isEmpty, <71ce5569-3f87-4b73-9e15-59e4c0c26f9f>SequenceStyle.Block, start, <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token.End);
			}
			if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <59bc0526-7926-43e3-8d44-f81d57983c50>Scalar <59bc0526-7926-43e3-8d44-f81d57983c50>Scalar)
			{
				bool isPlainImplicit = false;
				bool isQuotedImplicit = false;
				if ((<59bc0526-7926-43e3-8d44-f81d57983c50>Scalar.Style == <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Plain && tag.IsEmpty) || tag.IsNonSpecific)
				{
					isPlainImplicit = true;
				}
				else if (tag.IsEmpty)
				{
					isQuotedImplicit = true;
				}
				state = states.Pop();
				Skip();
				<1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar result2 = new <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar(anchor, tag, <59bc0526-7926-43e3-8d44-f81d57983c50>Scalar.Value, <59bc0526-7926-43e3-8d44-f81d57983c50>Scalar.Style, isPlainImplicit, isQuotedImplicit, start, <59bc0526-7926-43e3-8d44-f81d57983c50>Scalar.End);
				if (!anchor.IsEmpty && scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (currentToken is <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error)
					{
						<6f81fd05-c989-4e61-a86c-eefb303bec2c>Error <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error3 = currentToken as <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error;
						throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(<6f81fd05-c989-4e61-a86c-eefb303bec2c>Error3.Start, <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error3.End, <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error3.Value);
					}
				}
				if (state == <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowMappingKey && scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (currentToken != null && !(currentToken is <f5af023c-6714-4e11-bae3-bab1db71ea0d>FlowEntry) && !(currentToken is <ee152654-f658-4559-8caf-f046fdb2b393>FlowMappingEnd))
					{
						throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(currentToken.Start, currentToken.End, "While parsing a flow mapping, did not find expected ',' or '}'.");
					}
				}
				return result2;
			}
			if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <33bff82c-cdce-433e-ba84-891545635237>FlowSequenceStart <33bff82c-cdce-433e-ba84-891545635237>FlowSequenceStart)
			{
				state = <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowSequenceFirstEntry;
				return new <d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart(anchor, tag, isEmpty, <71ce5569-3f87-4b73-9e15-59e4c0c26f9f>SequenceStyle.Flow, start, <33bff82c-cdce-433e-ba84-891545635237>FlowSequenceStart.End);
			}
			if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <05048b10-3a91-4e92-903b-49ed1acc3d28>FlowMappingStart <05048b10-3a91-4e92-903b-49ed1acc3d28>FlowMappingStart)
			{
				state = <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowMappingFirstKey;
				return new <3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart(anchor, tag, isEmpty, <bc2eacde-da96-4de8-a058-605c487b5916>MappingStyle.Flow, start, <05048b10-3a91-4e92-903b-49ed1acc3d28>FlowMappingStart.End);
			}
			if (isBlock)
			{
				if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <0c4cf1de-e8ef-441f-9b26-fcd2154b8bf7>BlockSequenceStart <0c4cf1de-e8ef-441f-9b26-fcd2154b8bf7>BlockSequenceStart)
				{
					state = <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.BlockSequenceFirstEntry;
					return new <d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart(anchor, tag, isEmpty, <71ce5569-3f87-4b73-9e15-59e4c0c26f9f>SequenceStyle.Block, start, <0c4cf1de-e8ef-441f-9b26-fcd2154b8bf7>BlockSequenceStart.End);
				}
				if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <cc07463c-e471-478b-845b-eb93577727f0>BlockMappingStart <cc07463c-e471-478b-845b-eb93577727f0>BlockMappingStart)
				{
					state = <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.BlockMappingFirstKey;
					return new <3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart(anchor, tag, isEmpty, <bc2eacde-da96-4de8-a058-605c487b5916>MappingStyle.Block, start, <cc07463c-e471-478b-845b-eb93577727f0>BlockMappingStart.End);
				}
			}
			if (!anchor.IsEmpty || !tag.IsEmpty)
			{
				state = states.Pop();
				return new <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar(anchor, tag, string.Empty, <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Plain, isEmpty, isQuotedImplicit: false, start, <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token.End);
			}
			throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token.Start, <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token.End, "While parsing a node, did not find expected node content.");
		}

		private <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent ParseDocumentEnd()
		{
			<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken() ?? throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException("Reached the end of the stream while parsing a document end");
			bool isImplicit = true;
			<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start = <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token.Start;
			<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end = start;
			if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <fdd48936-da79-498a-9a60-cdc7b3c5de1e>DocumentEnd)
			{
				end = <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token.End;
				Skip();
				isImplicit = false;
			}
			else if (!(currentToken is <aaed5440-61c4-43e2-95a5-1da2fefcf451>StreamEnd) && !(currentToken is <d3392cd4-8bef-4da2-ae6e-42a42f997801>DocumentStart) && !(currentToken is <2ac58229-08bc-405a-9c73-9134bc343d7a>FlowSequenceEnd) && !(currentToken is <e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective) && (!(Current is <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar) || !(currentToken is <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error)))
			{
				throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(start, end, "Did not find expected <document end>.");
			}
			if (version != null && version.Version.Major == 1 && version.Version.Minor > 1)
			{
				version = null;
			}
			state = <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.DocumentStart;
			return new <ce28eaa8-1705-4d9d-86ca-3aaeb4704887>DocumentEnd(isImplicit, start, end);
		}

		private <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent ParseBlockSequenceEntry(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken();
			if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <1133f355-cbce-4fdc-b83c-f4a9447c1965>BlockEntry <1133f355-cbce-4fdc-b83c-f4a9447c1965>BlockEntry)
			{
				<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end = <1133f355-cbce-4fdc-b83c-f4a9447c1965>BlockEntry.End;
				Skip();
				<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken();
				if (!(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <1133f355-cbce-4fdc-b83c-f4a9447c1965>BlockEntry) && !(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <9ccf1c73-1400-452a-b6de-58471d7bb397>BlockEnd))
				{
					states.Push(<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.BlockSequenceEntry);
					return ParseNode(isBlock: true, isIndentlessSequence: false);
				}
				state = <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.BlockSequenceEntry;
				return ProcessEmptyScalar(end);
			}
			if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <9ccf1c73-1400-452a-b6de-58471d7bb397>BlockEnd <9ccf1c73-1400-452a-b6de-58471d7bb397>BlockEnd)
			{
				state = states.Pop();
				<1851bced-7720-45bc-a55f-1347cc414c40>SequenceEnd result = new <1851bced-7720-45bc-a55f-1347cc414c40>SequenceEnd(<9ccf1c73-1400-452a-b6de-58471d7bb397>BlockEnd.Start, <9ccf1c73-1400-452a-b6de-58471d7bb397>BlockEnd.End);
				Skip();
				return result;
			}
			throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token?.Start ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token?.End ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, "While parsing a block collection, did not find expected '-' indicator.");
		}

		private <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent ParseIndentlessSequenceEntry()
		{
			<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken();
			if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <1133f355-cbce-4fdc-b83c-f4a9447c1965>BlockEntry <1133f355-cbce-4fdc-b83c-f4a9447c1965>BlockEntry)
			{
				<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end = <1133f355-cbce-4fdc-b83c-f4a9447c1965>BlockEntry.End;
				Skip();
				<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken();
				if (!(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <1133f355-cbce-4fdc-b83c-f4a9447c1965>BlockEntry) && !(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <04bd4490-3a0a-4e31-a34b-c0fc268d8569>Key) && !(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <ad24bda1-8f67-4473-a03e-b0061c481608>Value) && !(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <9ccf1c73-1400-452a-b6de-58471d7bb397>BlockEnd))
				{
					states.Push(<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.IndentlessSequenceEntry);
					return ParseNode(isBlock: true, isIndentlessSequence: false);
				}
				state = <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.IndentlessSequenceEntry;
				return ProcessEmptyScalar(end);
			}
			state = states.Pop();
			return new <1851bced-7720-45bc-a55f-1347cc414c40>SequenceEnd(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token?.Start ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token?.End ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty);
		}

		private <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent ParseBlockMappingKey(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken();
			if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <04bd4490-3a0a-4e31-a34b-c0fc268d8569>Key <04bd4490-3a0a-4e31-a34b-c0fc268d8569>Key)
			{
				<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end = <04bd4490-3a0a-4e31-a34b-c0fc268d8569>Key.End;
				Skip();
				<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken();
				if (!(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <04bd4490-3a0a-4e31-a34b-c0fc268d8569>Key) && !(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <ad24bda1-8f67-4473-a03e-b0061c481608>Value) && !(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <9ccf1c73-1400-452a-b6de-58471d7bb397>BlockEnd))
				{
					states.Push(<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.BlockMappingValue);
					return ParseNode(isBlock: true, isIndentlessSequence: true);
				}
				state = <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.BlockMappingValue;
				return ProcessEmptyScalar(end);
			}
			if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <ad24bda1-8f67-4473-a03e-b0061c481608>Value <ad24bda1-8f67-4473-a03e-b0061c481608>Value)
			{
				Skip();
				return ProcessEmptyScalar(<ad24bda1-8f67-4473-a03e-b0061c481608>Value.End);
			}
			if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <54e5670b-898a-48cc-a602-f86f188e1415>AnchorAlias <54e5670b-898a-48cc-a602-f86f188e1415>AnchorAlias)
			{
				Skip();
				return new <5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias(<54e5670b-898a-48cc-a602-f86f188e1415>AnchorAlias.Value, <54e5670b-898a-48cc-a602-f86f188e1415>AnchorAlias.Start, <54e5670b-898a-48cc-a602-f86f188e1415>AnchorAlias.End);
			}
			if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <9ccf1c73-1400-452a-b6de-58471d7bb397>BlockEnd <9ccf1c73-1400-452a-b6de-58471d7bb397>BlockEnd)
			{
				state = states.Pop();
				<05f36264-c97d-43b8-9e56-0f8741a6ea35>MappingEnd result = new <05f36264-c97d-43b8-9e56-0f8741a6ea35>MappingEnd(<9ccf1c73-1400-452a-b6de-58471d7bb397>BlockEnd.Start, <9ccf1c73-1400-452a-b6de-58471d7bb397>BlockEnd.End);
				Skip();
				return result;
			}
			if (GetCurrentToken() is <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error)
			{
				throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(<6f81fd05-c989-4e61-a86c-eefb303bec2c>Error.Start, <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error.End, <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error.Value);
			}
			throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token?.Start ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token?.End ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, "While parsing a block mapping, did not find expected key.");
		}

		private <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent ParseBlockMappingValue()
		{
			<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken();
			if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <ad24bda1-8f67-4473-a03e-b0061c481608>Value <ad24bda1-8f67-4473-a03e-b0061c481608>Value)
			{
				<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end = <ad24bda1-8f67-4473-a03e-b0061c481608>Value.End;
				Skip();
				<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken();
				if (!(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <04bd4490-3a0a-4e31-a34b-c0fc268d8569>Key) && !(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <ad24bda1-8f67-4473-a03e-b0061c481608>Value) && !(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <9ccf1c73-1400-452a-b6de-58471d7bb397>BlockEnd))
				{
					states.Push(<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.BlockMappingKey);
					return ParseNode(isBlock: true, isIndentlessSequence: true);
				}
				state = <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.BlockMappingKey;
				return ProcessEmptyScalar(end);
			}
			if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error)
			{
				throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(<6f81fd05-c989-4e61-a86c-eefb303bec2c>Error.Start, <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error.End, <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error.Value);
			}
			state = <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.BlockMappingKey;
			return ProcessEmptyScalar(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token?.Start ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty);
		}

		private <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent ParseFlowSequenceEntry(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken();
			if (!(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <2ac58229-08bc-405a-9c73-9134bc343d7a>FlowSequenceEnd))
			{
				if (!isFirst)
				{
					if (!(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <f5af023c-6714-4e11-bae3-bab1db71ea0d>FlowEntry))
					{
						throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token?.Start ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token?.End ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, "While parsing a flow sequence, did not find expected ',' or ']'.");
					}
					Skip();
					<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken();
				}
				if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <04bd4490-3a0a-4e31-a34b-c0fc268d8569>Key)
				{
					state = <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowSequenceEntryMappingKey;
					<3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart result = new <3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName.Empty, <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName.Empty, isImplicit: true, <bc2eacde-da96-4de8-a058-605c487b5916>MappingStyle.Flow);
					Skip();
					return result;
				}
				if (!(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <2ac58229-08bc-405a-9c73-9134bc343d7a>FlowSequenceEnd))
				{
					states.Push(<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowSequenceEntry);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = states.Pop();
			<1851bced-7720-45bc-a55f-1347cc414c40>SequenceEnd result2 = new <1851bced-7720-45bc-a55f-1347cc414c40>SequenceEnd(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token?.Start ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token?.End ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty);
			Skip();
			return result2;
		}

		private <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent ParseFlowSequenceEntryMappingKey()
		{
			<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken();
			if (!(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <ad24bda1-8f67-4473-a03e-b0061c481608>Value) && !(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <f5af023c-6714-4e11-bae3-bab1db71ea0d>FlowEntry) && !(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <2ac58229-08bc-405a-9c73-9134bc343d7a>FlowSequenceEnd))
			{
				states.Push(<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowSequenceEntryMappingValue);
				return ParseNode(isBlock: false, isIndentlessSequence: false);
			}
			<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark position = <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token?.End ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty;
			Skip();
			state = <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowSequenceEntryMappingValue;
			return ProcessEmptyScalar(position);
		}

		private <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent ParseFlowSequenceEntryMappingValue()
		{
			<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken();
			if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <ad24bda1-8f67-4473-a03e-b0061c481608>Value)
			{
				Skip();
				<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken();
				if (!(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <f5af023c-6714-4e11-bae3-bab1db71ea0d>FlowEntry) && !(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <2ac58229-08bc-405a-9c73-9134bc343d7a>FlowSequenceEnd))
				{
					states.Push(<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowSequenceEntryMappingEnd);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowSequenceEntryMappingEnd;
			return ProcessEmptyScalar(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token?.Start ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty);
		}

		private <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent ParseFlowSequenceEntryMappingEnd()
		{
			state = <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowSequenceEntry;
			<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken();
			return new <05f36264-c97d-43b8-9e56-0f8741a6ea35>MappingEnd(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token?.Start ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token?.End ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty);
		}

		private <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent ParseFlowMappingKey(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken();
			if (!(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <ee152654-f658-4559-8caf-f046fdb2b393>FlowMappingEnd))
			{
				if (!isFirst)
				{
					if (!(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <f5af023c-6714-4e11-bae3-bab1db71ea0d>FlowEntry))
					{
						throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token?.Start ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token?.End ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, "While parsing a flow mapping,  did not find expected ',' or '}'.");
					}
					Skip();
					<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken();
				}
				if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <04bd4490-3a0a-4e31-a34b-c0fc268d8569>Key)
				{
					Skip();
					<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken();
					if (!(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <ad24bda1-8f67-4473-a03e-b0061c481608>Value) && !(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <f5af023c-6714-4e11-bae3-bab1db71ea0d>FlowEntry) && !(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <ee152654-f658-4559-8caf-f046fdb2b393>FlowMappingEnd))
					{
						states.Push(<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowMappingValue);
						return ParseNode(isBlock: false, isIndentlessSequence: false);
					}
					state = <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowMappingValue;
					return ProcessEmptyScalar(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token?.Start ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty);
				}
				if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <59bc0526-7926-43e3-8d44-f81d57983c50>Scalar)
				{
					states.Push(<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowMappingValue);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
				if (!(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <ee152654-f658-4559-8caf-f046fdb2b393>FlowMappingEnd))
				{
					states.Push(<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowMappingEmptyValue);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = states.Pop();
			Skip();
			return new <05f36264-c97d-43b8-9e56-0f8741a6ea35>MappingEnd(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token?.Start ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token?.End ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty);
		}

		private <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent ParseFlowMappingValue(bool isEmpty)
		{
			<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken();
			if (isEmpty)
			{
				state = <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowMappingKey;
				return ProcessEmptyScalar(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token?.Start ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty);
			}
			if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <ad24bda1-8f67-4473-a03e-b0061c481608>Value)
			{
				Skip();
				<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = GetCurrentToken();
				if (!(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <f5af023c-6714-4e11-bae3-bab1db71ea0d>FlowEntry) && !(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token is <ee152654-f658-4559-8caf-f046fdb2b393>FlowMappingEnd))
				{
					states.Push(<2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowMappingKey);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = <2d5ecdbc-8350-47fb-ba99-37c5699f3706>ParserState.FlowMappingKey;
			return ProcessEmptyScalar(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token?.Start ?? <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty);
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal static class <a72ce7e3-3475-484b-9e93-56593fb500e6>ParserExtensions
	{
		public static T Consume<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] T>(this <2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser) where T : <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent
		{
			T result = parser.Require<T>();
			parser.MoveNext();
			return result;
		}

		public static bool TryConsume<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] T>(this <2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, [<b3ae408d-452a-47a4-a4cd-28743506c159>MaybeNullWhen(false)] out T @event) where T : <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent
		{
			if (parser.Accept<T>(out @event))
			{
				parser.MoveNext();
				return true;
			}
			return false;
		}

		public static T Require<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] T>(this <2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser) where T : <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent
		{
			if (!parser.Accept<T>(out var @event))
			{
				<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent current = parser.Current;
				if (current == null)
				{
					throw new <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException("Expected '" + typeof(T).Name + "', got nothing.");
				}
				throw new <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException(current.Start, current.End, $"Expected '{typeof(T).Name}', got '{current.GetType().Name}' (at {current.Start}).");
			}
			return @event;
		}

		public static bool Accept<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] T>(this <2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser, [<b3ae408d-452a-47a4-a4cd-28743506c159>MaybeNullWhen(false)] out T @event) where T : <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>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 <2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser)
		{
			int num = 0;
			do
			{
				<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent = parser.Consume<<4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent>();
				num += <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent.NestingIncrease;
			}
			while (num > 0);
		}

		[Obsolete("Please use Consume<T>() instead")]
		public static T Expect<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] T>(this <2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser) where T : <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent
		{
			return parser.Consume<T>();
		}

		[Obsolete("Please use TryConsume<T>(out var evt) instead")]
		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public static T Allow<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] T>(this <2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser) where T : <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent
		{
			if (!parser.TryConsume<T>(out var @event))
			{
				return null;
			}
			return @event;
		}

		[Obsolete("Please use Accept<T>(out var evt) instead")]
		[return: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public static T Peek<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] T>(this <2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser) where T : <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>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<[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)] T>(this <2e81a95f-2819-48ee-ab4d-40df315a2a9c>IParser parser) where T : <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent
		{
			T @event;
			return parser.Accept<T>(out @event);
		}
	}
	internal enum <2d5ecdbc-8350-47fb-ba99-37c5699f3706>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 <c7b9cad7-9392-4689-a5f6-745ade406936>RecursionLevel
	{
		private int current;

		public int Maximum { get; }

		public <c7b9cad7-9392-4689-a5f6-745ade406936>RecursionLevel(int maximum)
		{
			Maximum = maximum;
		}

		public void Increment()
		{
			if (!TryIncrement())
			{
				throw new <84c979da-2a78-4796-94af-e7533b7b0006>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--;
		}
	}
	internal enum <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle
	{
		Any,
		Plain,
		SingleQuoted,
		DoubleQuoted,
		Literal,
		Folded
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal class <90b24e2b-1e86-4de7-8a96-537c65d71fdd>Scanner : <3e8420bf-caa7-44ea-a97d-eeb7c3c5007e>IScanner
	{
		private const int MaxVersionNumberLength = 9;

		private static readonly IDictionary<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<int> indents = new Stack<int>();

		private readonly <736c5c49-f376-432c-a5f4-5aca6e9edcab>InsertionQueue<<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token> tokens = new <736c5c49-f376-432c-a5f4-5aca6e9edcab>InsertionQueue<<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token>();

		private readonly Stack<<19621959-3e0a-47ea-912c-717e879a2297>SimpleKey> simpleKeys = new Stack<<19621959-3e0a-47ea-912c-717e879a2297>SimpleKey>();

		private readonly <20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer<<66026ed7-f1ba-4f21-bb74-d10a1e1a5fcf>LookAheadBuffer> analyzer;

		private readonly <4c8a95a8-6f4a-46ea-88a7-286805c3eff5>Cursor cursor;

		private bool streamStartProduced;

		private bool streamEndProduced;

		private bool plainScalarFollowedByComment;

		private int flowSequenceStartLine;

		private int indent = -1;

		private bool simpleKeyAllowed;

		private int flowLevel;

		private int tokensParsed;

		private bool tokenAvailable;

		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		private <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token previous;

		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		private <81c9981d-61ad-4343-a7f8-7e07bfdb0222>Anchor previousAnchor;

		private static readonly byte[] EmptyBytes = new byte[0];

		public bool SkipComments { get; private set; }

		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		[field: <928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		public <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token Current
		{
			[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
			get;
			[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
			private set;
		}

		public <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark CurrentPosition => cursor.Mark();

		private bool IsDocumentStart()
		{
			if (!analyzer.EndOfInput && cursor.LineOffset == 0 && analyzer.Check('-') && analyzer.Check('-', 1) && analyzer.Check('-', 2))
			{
				return analyzer.IsWhiteBreakOrZero(3);
			}
			return false;
		}

		private bool IsDocumentEnd()
		{
			if (!analyzer.EndOfInput && cursor.LineOffset == 0 && analyzer.Check('.') && analyzer.Check('.', 1) && analyzer.Check('.', 2))
			{
				return analyzer.IsWhiteBreakOrZero(3);
			}
			return false;
		}

		private bool IsDocumentIndicator()
		{
			if (!IsDocumentStart())
			{
				return IsDocumentEnd();
			}
			return true;
		}

		public <90b24e2b-1e86-4de7-8a96-537c65d71fdd>Scanner(TextReader input, bool skipComments = true)
		{
			analyzer = new <20a553ff-eccc-45f4-ac98-04fa4a124a6f>CharacterAnalyzer<<66026ed7-f1ba-4f21-bb74-d10a1e1a5fcf>LookAheadBuffer>(new <66026ed7-f1ba-4f21-bb74-d10a1e1a5fcf>LookAheadBuffer(input, 1024));
			cursor = new <4c8a95a8-6f4a-46ea-88a7-286805c3eff5>Cursor();
			SkipComments = skipComments;
		}

		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 (<19621959-3e0a-47ea-912c-717e879a2297>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 (<19621959-3e0a-47ea-912c-717e879a2297>SimpleKey simpleKey in simpleKeys)
			{
				if (simpleKey.IsPossible && (simpleKey.Line < cursor.Line || simpleKey.Index + 1024 < cursor.Index))
				{
					if (simpleKey.IsRequired)
					{
						<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2 = cursor.Mark();
						tokens.Enqueue(new <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error("While scanning a simple key, could not find expected ':'.", <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2));
					}
					simpleKey.MarkAsImpossible();
				}
			}
		}

		private void FetchNextToken()
		{
			if (!streamStartProduced)
			{
				FetchStreamStart();
				return;
			}
			ScanToNextToken();
			StaleSimpleKeys();
			UnrollIndent(cursor.LineOffset);
			analyzer.Buffer.Cache(4);
			if (analyzer.Buffer.EndOfInput)
			{
				FetchStreamEnd();
				return;
			}
			if (cursor.LineOffset == 0 && analyzer.Check('%'))
			{
				FetchDirective();
				return;
			}
			if (IsDocumentStart())
			{
				FetchDocumentIndicator(isStartToken: true);
				return;
			}
			if (IsDocumentEnd())
			{
				FetchDocumentIndicator(isStartToken: false);
				return;
			}
			if (analyzer.Check('['))
			{
				FetchFlowCollectionStart(isSequenceToken: true);
				return;
			}
			if (analyzer.Check('{'))
			{
				FetchFlowCollectionStart(isSequenceToken: false);
				return;
			}
			if (analyzer.Check(']'))
			{
				FetchFlowCollectionEnd(isSequenceToken: true);
				return;
			}
			if (analyzer.Check('}'))
			{
				FetchFlowCollectionEnd(isSequenceToken: false);
				return;
			}
			if (analyzer.Check(','))
			{
				FetchFlowEntry();
				return;
			}
			if (analyzer.Check('-') && analyzer.IsWhiteBreakOrZero(1))
			{
				FetchBlockEntry();
				return;
			}
			if (analyzer.Check('?') && (flowLevel > 0 || analyzer.IsWhiteBreakOrZero(1)))
			{
				FetchKey();
				return;
			}
			if (analyzer.Check(':') && (flowLevel > 0 || analyzer.IsWhiteBreakOrZero(1)) && (!simpleKeyAllowed || flowLevel <= 0))
			{
				FetchValue();
				return;
			}
			if (analyzer.Check('*'))
			{
				FetchAnchor(isAlias: true);
				return;
			}
			if (analyzer.Check('&'))
			{
				FetchAnchor(isAlias: false);
				return;
			}
			if (analyzer.Check('!'))
			{
				FetchTag();
				return;
			}
			if (analyzer.Check('|') && flowLevel == 0)
			{
				FetchBlockScalar(isLiteral: true);
				return;
			}
			if (analyzer.Check('>') && flowLevel == 0)
			{
				FetchBlockScalar(isLiteral: false);
				return;
			}
			if (analyzer.Check('\''))
			{
				FetchFlowScalar(isSingleQuoted: true);
				return;
			}
			if (analyzer.Check('"'))
			{
				FetchFlowScalar(isSingleQuoted: false);
				return;
			}
			if ((!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("-?:,[]{}#&*!|>'\"%@`")) || (analyzer.Check('-') && !analyzer.IsWhite(1)) || (flowLevel == 0 && analyzer.Check("?:") && !analyzer.IsWhiteBreakOrZero(1)) || (simpleKeyAllowed && flowLevel > 0 && analyzer.Check("?:")))
			{
				if (plainScalarFollowedByComment)
				{
					<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2 = cursor.Mark();
					tokens.Enqueue(new <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error("While scanning plain scalar, found a comment between adjacent scalars.", <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2));
				}
				plainScalarFollowedByComment = false;
				FetchPlainScalar();
				return;
			}
			if (simpleKeyAllowed && indent >= cursor.LineOffset && analyzer.IsTab())
			{
				throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException("While scanning a mapping, found invalid tab as indentation.");
			}
			if (analyzer.IsWhiteBreakOrZero())
			{
				Skip();
				return;
			}
			<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start = cursor.Mark();
			Skip();
			<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end = cursor.Mark();
			throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, end, "While scanning for the next token, found character that cannot start any token.");
		}

		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('#'))
			{
				<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2 = cursor.Mark();
				Skip();
				while (analyzer.IsSpace())
				{
					Skip();
				}
				StringBuilder stringBuilder = new StringBuilder();
				while (!analyzer.IsBreakOrZero())
				{
					stringBuilder.Append(ReadCurrentCharacter());
				}
				if (!SkipComments)
				{
					bool isInline = previous != null && previous.End.Line == <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2.Line && previous.End.Column != 1 && !(previous is <0c143349-e8ac-43ce-94f2-6e904605633e>StreamStart);
					tokens.Enqueue(new <fee736d1-2625-4930-8ec0-7a85005ed886>Comment(stringBuilder.ToString(), isInline, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2, cursor.Mark()));
				}
			}
		}

		private void FetchStreamStart()
		{
			simpleKeys.Push(new <19621959-3e0a-47ea-912c-717e879a2297>SimpleKey());
			simpleKeyAllowed = true;
			streamStartProduced = true;
			<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2 = cursor.Mark();
			tokens.Enqueue(new <0c143349-e8ac-43ce-94f2-6e904605633e>StreamStart(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2));
		}

		private void UnrollIndent(int column)
		{
			if (flowLevel == 0)
			{
				while (indent > column)
				{
					<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2 = cursor.Mark();
					tokens.Enqueue(new <9ccf1c73-1400-452a-b6de-58471d7bb397>BlockEnd(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2));
					indent = indents.Pop();
				}
			}
		}

		private void FetchStreamEnd()
		{
			cursor.ForceSkipLineAfterNonBreak();
			UnrollIndent(-1);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			streamEndProduced = true;
			<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2 = cursor.Mark();
			tokens.Enqueue(new <aaed5440-61c4-43e2-95a5-1da2fefcf451>StreamEnd(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2));
		}

		private void FetchDirective()
		{
			UnrollIndent(-1);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = ScanDirective();
			if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token != null)
			{
				tokens.Enqueue(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token);
			}
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
		private <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token ScanDirective()
		{
			<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start = cursor.Mark();
			Skip();
			string text = ScanDirectiveName(start);
			<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token result;
			if (!(text == "YAML"))
			{
				if (!(text == "TAG"))
				{
					while (!analyzer.Check('#') && !analyzer.IsBreak())
					{
						Skip();
					}
					return null;
				}
				result = ScanTagDirectiveValue(start);
			}
			else
			{
				if (!(previous is <d3392cd4-8bef-4da2-ae6e-42a42f997801>DocumentStart) && !(previous is <0c143349-e8ac-43ce-94f2-6e904605633e>StreamStart) && !(previous is <fdd48936-da79-498a-9a60-cdc7b3c5de1e>DocumentEnd))
				{
					throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(start, cursor.Mark(), "While scanning a version directive, did not find preceding <document end>.");
				}
				result = ScanVersionDirectiveValue(start);
			}
			while (analyzer.IsWhite())
			{
				Skip();
			}
			ProcessComment();
			if (!analyzer.IsBreakOrZero())
			{
				throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "While scanning a directive, did not find expected comment or line break.");
			}
			if (analyzer.IsBreak())
			{
				SkipLine();
			}
			return result;
		}

		private void FetchDocumentIndicator(bool isStartToken)
		{
			UnrollIndent(-1);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2 = cursor.Mark();
			Skip();
			Skip();
			Skip();
			if (isStartToken)
			{
				tokens.Enqueue(new <d3392cd4-8bef-4da2-ae6e-42a42f997801>DocumentStart(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2, cursor.Mark()));
				return;
			}
			<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = null;
			while (!analyzer.EndOfInput && !analyzer.IsBreak() && !analyzer.Check('#'))
			{
				if (!analyzer.IsWhite())
				{
					<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = new <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error("While scanning a document end, found invalid content after '...' marker.", <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2, cursor.Mark());
					break;
				}
				Skip();
			}
			tokens.Enqueue(new <fdd48936-da79-498a-9a60-cdc7b3c5de1e>DocumentEnd(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2));
			if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token != null)
			{
				tokens.Enqueue(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token);
			}
		}

		private void FetchFlowCollectionStart(bool isSequenceToken)
		{
			SaveSimpleKey();
			IncreaseFlowLevel();
			simpleKeyAllowed = true;
			<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2 = cursor.Mark();
			Skip();
			<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token;
			if (isSequenceToken)
			{
				<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = new <33bff82c-cdce-433e-ba84-891545635237>FlowSequenceStart(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2);
				flowSequenceStartLine = <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token.Start.Line;
			}
			else
			{
				<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = new <05048b10-3a91-4e92-903b-49ed1acc3d28>FlowMappingStart(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2);
			}
			tokens.Enqueue(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token);
		}

		private void IncreaseFlowLevel()
		{
			simpleKeys.Push(new <19621959-3e0a-47ea-912c-717e879a2297>SimpleKey());
			flowLevel++;
		}

		private void FetchFlowCollectionEnd(bool isSequenceToken)
		{
			RemoveSimpleKey();
			DecreaseFlowLevel();
			simpleKeyAllowed = false;
			<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2 = cursor.Mark();
			Skip();
			<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = null;
			<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token item;
			if (isSequenceToken)
			{
				if (analyzer.Check('#'))
				{
					<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token = new <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error("While scanning a flow sequence end, found invalid comment after ']'.", <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2);
				}
				if (previous is <0c143349-e8ac-43ce-94f2-6e904605633e>StreamStart && flowSequenceStartLine != <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2.Line)
				{
					tokens.Enqueue(new <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error("While scanning a flow sequence end, found mapping key spanning across multiple lines.", <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2));
				}
				item = new <2ac58229-08bc-405a-9c73-9134bc343d7a>FlowSequenceEnd(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2);
			}
			else
			{
				item = new <ee152654-f658-4559-8caf-f046fdb2b393>FlowMappingEnd(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2);
			}
			tokens.Enqueue(item);
			if (<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token != null)
			{
				tokens.Enqueue(<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token);
			}
		}

		private void DecreaseFlowLevel()
		{
			if (flowLevel > 0)
			{
				flowLevel--;
				simpleKeys.Pop();
			}
		}

		private void FetchFlowEntry()
		{
			RemoveSimpleKey();
			simpleKeyAllowed = true;
			<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start = cursor.Mark();
			Skip();
			<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end = cursor.Mark();
			if (analyzer.Check('#'))
			{
				tokens.Enqueue(new <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error("While scanning a flow entry, found invalid comment after comma.", start, end));
			}
			else
			{
				tokens.Enqueue(new <f5af023c-6714-4e11-bae3-bab1db71ea0d>FlowEntry(start, end));
			}
		}

		private void FetchBlockEntry()
		{
			if (flowLevel == 0)
			{
				if (!simpleKeyAllowed)
				{
					if (previousAnchor != null && previousAnchor.End.Line == cursor.Line)
					{
						throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(previousAnchor.Start, previousAnchor.End, "Anchor before sequence entry on same line is not allowed.");
					}
					<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2 = cursor.Mark();
					tokens.Enqueue(new <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error("Block sequence entries are not allowed in this context.", <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2));
				}
				RollIndent(cursor.LineOffset, -1, isSequence: true, cursor.Mark());
			}
			RemoveSimpleKey();
			simpleKeyAllowed = true;
			<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start = cursor.Mark();
			Skip();
			tokens.Enqueue(new <1133f355-cbce-4fdc-b83c-f4a9447c1965>BlockEntry(start, cursor.Mark()));
		}

		private void FetchKey()
		{
			if (flowLevel == 0)
			{
				if (!simpleKeyAllowed)
				{
					<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark obj = cursor.Mark();
					throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(obj, obj, "Mapping keys are not allowed in this context.");
				}
				RollIndent(cursor.LineOffset, -1, isSequence: false, cursor.Mark());
			}
			RemoveSimpleKey();
			simpleKeyAllowed = flowLevel == 0;
			<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start = cursor.Mark();
			Skip();
			tokens.Enqueue(new <04bd4490-3a0a-4e31-a34b-c0fc268d8569>Key(start, cursor.Mark()));
		}

		private void FetchValue()
		{
			<19621959-3e0a-47ea-912c-717e879a2297>SimpleKey <19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2 = simpleKeys.Peek();
			if (<19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2.IsPossible)
			{
				tokens.Insert(<19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2.TokenNumber - tokensParsed, new <04bd4490-3a0a-4e31-a34b-c0fc268d8569>Key(<19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2.Mark, <19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2.Mark));
				RollIndent(<19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2.LineOffset, <19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2.TokenNumber, isSequence: false, <19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2.Mark);
				<19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2.MarkAsImpossible();
				simpleKeyAllowed = false;
			}
			else
			{
				bool flag = flowLevel == 0;
				if (flag)
				{
					if (!simpleKeyAllowed)
					{
						<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2 = cursor.Mark();
						tokens.Enqueue(new <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error("Mapping values are not allowed in this context.", <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2));
						return;
					}
					RollIndent(cursor.LineOffset, -1, isSequence: false, cursor.Mark());
					if (cursor.LineOffset == 0 && <19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2.LineOffset == 0)
					{
						tokens.Insert(tokens.Count, new <04bd4490-3a0a-4e31-a34b-c0fc268d8569>Key(<19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2.Mark, <19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2.Mark));
						flag = false;
					}
				}
				simpleKeyAllowed = flag;
			}
			<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start = cursor.Mark();
			Skip();
			tokens.Enqueue(new <ad24bda1-8f67-4473-a03e-b0061c481608>Value(start, cursor.Mark()));
		}

		private void RollIndent(int column, int number, bool isSequence, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark position)
		{
			if (flowLevel <= 0 && indent < column)
			{
				indents.Push(indent);
				indent = column;
				<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token item = ((!isSequence) ? ((<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token)new <cc07463c-e471-478b-845b-eb93577727f0>BlockMappingStart(position, position)) : ((<34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token)new <0c4cf1de-e8ef-441f-9b26-fcd2154b8bf7>BlockSequenceStart(position, 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 <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token ScanAnchor(bool isAlias)
		{
			<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start = cursor.Mark();
			Skip();
			bool flag = false;
			if (isAlias)
			{
				<19621959-3e0a-47ea-912c-717e879a2297>SimpleKey <19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2 = simpleKeys.Peek();
				flag = <19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2.IsRequired && <19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2.IsPossible;
			}
			StringBuilder stringBuilder = new StringBuilder();
			while (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("[]{},") && (!flag || !analyzer.Check(':') || !analyzer.IsWhiteBreakOrZero(1)))
			{
				stringBuilder.Append(ReadCurrentCharacter());
			}
			if (stringBuilder.Length == 0 || (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("?:,]}%@`")))
			{
				throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "While scanning an anchor or alias, found value containing disallowed: []{},");
			}
			<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName value = new <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName(stringBuilder.ToString());
			if (isAlias)
			{
				return new <54e5670b-898a-48cc-a602-f86f188e1415>AnchorAlias(value, start, cursor.Mark());
			}
			return previousAnchor = new <81c9981d-61ad-4343-a7f8-7e07bfdb0222>Anchor(value, start, cursor.Mark());
		}

		private void FetchTag()
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			tokens.Enqueue(ScanTag());
		}

		private <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token ScanTag()
		{
			<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start = cursor.Mark();
			string text;
			string text2;
			if (analyzer.Check('<', 1))
			{
				text = string.Empty;
				Skip();
				Skip();
				text2 = ScanTagUri(null, start);
				if (!analyzer.Check('>'))
				{
					throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "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(','))
			{
				throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "While scanning a tag, did not find expected whitespace, comma or line break.");
			}
			return new <0de3b70d-5685-4444-bd63-fcc634fd9344>Tag(text, text2, start, cursor.Mark());
		}

		private void FetchBlockScalar(bool isLiteral)
		{
			RemoveSimpleKey();
			simpleKeyAllowed = true;
			tokens.Enqueue(ScanBlockScalar(isLiteral));
		}

		private <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token ScanBlockScalar(bool isLiteral)
		{
			StringBuilder stringBuilder = new StringBuilder();
			StringBuilder stringBuilder2 = new StringBuilder();
			StringBuilder stringBuilder3 = new StringBuilder();
			int num = 0;
			int num2 = 0;
			int currentIndent = 0;
			bool flag = false;
			bool? isFirstLine = null;
			<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start = cursor.Mark();
			Skip();
			if (analyzer.Check("+-"))
			{
				num = (analyzer.Check('+') ? 1 : (-1));
				Skip();
				if (analyzer.IsDigit())
				{
					if (analyzer.Check('0'))
					{
						throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "While scanning a block scalar, found an indentation indicator equal to 0.");
					}
					num2 = analyzer.AsDigit();
					Skip();
				}
			}
			else if (analyzer.IsDigit())
			{
				if (analyzer.Check('0'))
				{
					throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "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('#'))
			{
				throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "While scanning a block scalar, found a comment without whtespace after '>' indicator.");
			}
			while (analyzer.IsWhite())
			{
				Skip();
			}
			ProcessComment();
			if (!analyzer.IsBreakOrZero())
			{
				throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "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 == true)
				{
					isFirstLine = false;
				}
			}
			<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end = cursor.Mark();
			if (num2 != 0)
			{
				currentIndent = ((indent >= 0) ? (indent + num2) : num2);
			}
			currentIndent = ScanBlockScalarBreaks(currentIndent, stringBuilder3, isLiteral, ref end, ref isFirstLine);
			isFirstLine = false;
			while (cursor.LineOffset == currentIndent && !analyzer.IsZero() && !IsDocumentEnd())
			{
				bool flag2 = analyzer.IsWhite();
				if (!isLiteral && StartsWith(stringBuilder2, '\n') && !flag && !flag2)
				{
					if (stringBuilder3.Length == 0)
					{
						stringBuilder.Append(' ');
					}
					stringBuilder2.Length = 0;
				}
				else
				{
					stringBuilder.Append(stringBuilder2.ToString());
					stringBuilder2.Length = 0;
				}
				stringBuilder.Append(stringBuilder3.ToString());
				stringBuilder3.Length = 0;
				flag = analyzer.IsWhite();
				while (!analyzer.IsBreakOrZero())
				{
					stringBuilder.Append(ReadCurrentCharacter());
				}
				char c = ReadLine();
				if (c != 0)
				{
					stringBuilder2.Append(c);
				}
				currentIndent = ScanBlockScalarBreaks(currentIndent, stringBuilder3, isLiteral, ref end, ref isFirstLine);
			}
			if (num != -1)
			{
				stringBuilder.Append((object?)stringBuilder2);
			}
			if (num == 1)
			{
				stringBuilder.Append((object?)stringBuilder3);
			}
			<4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle style = (isLiteral ? <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Literal : <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Folded);
			return new <59bc0526-7926-43e3-8d44-f81d57983c50>Scalar(stringBuilder.ToString(), style, start, end);
		}

		private int ScanBlockScalarBreaks(int currentIndent, StringBuilder breaks, bool isLiteral, ref <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end, ref bool? isFirstLine)
		{
			int num = 0;
			int num2 = -1;
			end = cursor.Mark();
			while (true)
			{
				if ((currentIndent == 0 || cursor.LineOffset < currentIndent) && analyzer.IsSpace())
				{
					Skip();
					continue;
				}
				if (cursor.LineOffset > num)
				{
					num = cursor.LineOffset;
				}
				if (!analyzer.IsBreak())
				{
					break;
				}
				if (isFirstLine == true)
				{
					isFirstLine = false;
					num2 = cursor.LineOffset;
				}
				breaks.Append(ReadLine());
				end = cursor.Mark();
			}
			if (isLiteral && isFirstLine == true)
			{
				int 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)
			{
				throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(end, cursor.Mark(), "While scanning a literal block scalar, found extra spaces in first line.");
			}
			if (!isLiteral && num > cursor.LineOffset && num2 > -1)
			{
				throw new <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(end, cursor.Mark(), "While scanning a literal block scalar, found more spaces in lines above first content line.");
			}
			if (currentIndent == 0 && (cursor.LineOffset > 0 || indent > -1))
			{
				currentIndent = Math.Max(num, Math.Max(indent + 1, 1));
			}
			return currentIndent;
		}

		private void FetchFlowScalar(bool isSingleQuoted)
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			tokens.Enqueue(ScanFlowScalar(isSingleQuoted));
			if (!isSingleQuoted && analyzer.Check('#'))
			{
				<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2 = cursor.Mark();
				tokens.Enqueue(new <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error("While scanning a flow sequence end, found invalid comment after double-quoted scalar.", <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2));
			}
		}

		private <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token ScanFlowScalar(bool isSingleQuoted)
		{
			<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start = cursor.Mark();
			Skip();
			StringBuilder stringBuilder = new StringBuilder();
			StringBuilder stringBuilder2 = new StringBuilder();
			StringBuilder stringBuilder3 = new StringBuilder();
			StringBuilder stringBuilder4 = new StringBuilder();
			bool flag = false;
			while (true)
			{
				if (IsDocumentIndicator())
				{
					throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "While scanning a quoted scalar, found unexpected document indicator.");
				}
				if (analyzer.IsZero())
				{
					throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "While scanning a quoted scalar, found unexpected end of stream.");
				}
				if (flag && !isSingleQuoted && indent >= cursor.LineOffset)
				{
					throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "While scanning a multi-line double-quoted scalar, found wrong indentation.");
				}
				flag = false;
				while (!analyzer.IsWhiteBreakOrZero())
				{
					if (isSingleQuoted && analyzer.Check('\'') && analyzer.Check('\'', 1))
					{
						stringBuilder.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))
							{
								stringBuilder.Append(value);
								break;
							}
							throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "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))
							{
								throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "While scanning a quoted scalar, did not find expected hexadecimal number.");
							}
							num2 = (num2 << 4) + analyzer.AsHex(i);
						}
						if ((num2 >= 55296 && num2 <= 57343) || num2 > 1114111)
						{
							throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "While scanning a quoted scalar, found invalid Unicode character escape code.");
						}
						stringBuilder.Append(char.ConvertFromUtf32(num2));
						for (int j = 0; j < num; j++)
						{
							Skip();
						}
					}
					else
					{
						stringBuilder.Append(ReadCurrentCharacter());
					}
				}
				if (analyzer.Check(isSingleQuoted ? '\'' : '"'))
				{
					break;
				}
				while (analyzer.IsWhite() || analyzer.IsBreak())
				{
					if (analyzer.IsWhite())
					{
						if (!flag)
						{
							stringBuilder2.Append(ReadCurrentCharacter());
						}
						else
						{
							Skip();
						}
					}
					else if (!flag)
					{
						stringBuilder2.Length = 0;
						stringBuilder3.Append(ReadLine());
						flag = true;
					}
					else
					{
						stringBuilder4.Append(ReadLine());
					}
				}
				if (flag)
				{
					if (StartsWith(stringBuilder3, '\n'))
					{
						if (stringBuilder4.Length == 0)
						{
							stringBuilder.Append(' ');
						}
						else
						{
							stringBuilder.Append(stringBuilder4.ToString());
						}
					}
					else
					{
						stringBuilder.Append(stringBuilder3.ToString());
						stringBuilder.Append(stringBuilder4.ToString());
					}
					stringBuilder3.Length = 0;
					stringBuilder4.Length = 0;
				}
				else
				{
					stringBuilder.Append(stringBuilder2.ToString());
					stringBuilder2.Length = 0;
				}
			}
			Skip();
			return new <59bc0526-7926-43e3-8d44-f81d57983c50>Scalar(stringBuilder.ToString(), isSingleQuoted ? <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.SingleQuoted : <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.DoubleQuoted, start, cursor.Mark());
		}

		private void FetchPlainScalar()
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			bool isMultiline = false;
			<59bc0526-7926-43e3-8d44-f81d57983c50>Scalar item = ScanPlainScalar(ref isMultiline);
			if (isMultiline && analyzer.Check(':') && flowLevel == 0 && indent < cursor.LineOffset)
			{
				tokens.Enqueue(new <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error("While scanning a multiline plain scalar, found invalid mapping.", cursor.Mark(), cursor.Mark()));
			}
			tokens.Enqueue(item);
		}

		private <59bc0526-7926-43e3-8d44-f81d57983c50>Scalar ScanPlainScalar(ref bool isMultiline)
		{
			StringBuilder stringBuilder = new StringBuilder();
			StringBuilder stringBuilder2 = new StringBuilder();
			StringBuilder stringBuilder3 = new StringBuilder();
			StringBuilder stringBuilder4 = new StringBuilder();
			bool flag = false;
			int num = indent + 1;
			<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2 = cursor.Mark();
			<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end = <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2;
			<19621959-3e0a-47ea-912c-717e879a2297>SimpleKey <19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2 = simpleKeys.Peek();
			while (!IsDocumentIndicator())
			{
				if (analyzer.Check('#'))
				{
					if (indent < 0 && flowLevel == 0)
					{
						plainScalarFollowedByComment = true;
					}
					break;
				}
				bool flag2 = analyzer.Check('*') && (!<19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2.IsPossible || !<19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2.IsRequired);
				while (!analyzer.IsWhiteBreakOrZero())
				{
					if ((analyzer.Check(':') && !flag2 && (analyzer.IsWhiteBreakOrZero(1) || (flowLevel > 0 && analyzer.Check(',', 1)))) || (flowLevel > 0 && analyzer.Check(",?[]{}")))
					{
						if (flowLevel == 0 && !<19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2.IsPossible)
						{
							tokens.Enqueue(new <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error("While scanning a plain scalar value, found invalid mapping.", cursor.Mark(), cursor.Mark()));
						}
						break;
					}
					if (flag || stringBuilder2.Length > 0)
					{
						if (flag)
						{
							if (StartsWith(stringBuilder3, '\n'))
							{
								if (stringBuilder4.Length == 0)
								{
									stringBuilder.Append(' ');
								}
								else
								{
									stringBuilder.Append((object?)stringBuilder4);
								}
							}
							else
							{
								stringBuilder.Append((object?)stringBuilder3);
								stringBuilder.Append((object?)stringBuilder4);
							}
							stringBuilder3.Length = 0;
							stringBuilder4.Length = 0;
							flag = false;
						}
						else
						{
							stringBuilder.Append((object?)stringBuilder2);
							stringBuilder2.Length = 0;
						}
					}
					if (flowLevel > 0 && cursor.LineOffset < num)
					{
						throw new Exception();
					}
					stringBuilder.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())
						{
							throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2, cursor.Mark(), "While scanning a plain scalar, found a tab character that violate indentation.");
						}
						if (!flag)
						{
							stringBuilder2.Append(ReadCurrentCharacter());
						}
						else
						{
							Skip();
						}
					}
					else
					{
						isMultiline = true;
						if (!flag)
						{
							stringBuilder2.Length = 0;
							stringBuilder3.Append(ReadLine());
							flag = true;
						}
						else
						{
							stringBuilder4.Append(ReadLine());
						}
					}
				}
				if (flowLevel == 0 && cursor.LineOffset < num)
				{
					break;
				}
			}
			if (flag)
			{
				simpleKeyAllowed = true;
			}
			return new <59bc0526-7926-43e3-8d44-f81d57983c50>Scalar(stringBuilder.ToString(), <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Plain, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark2, end);
		}

		private void RemoveSimpleKey()
		{
			<19621959-3e0a-47ea-912c-717e879a2297>SimpleKey <19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2 = simpleKeys.Peek();
			if (<19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2.IsPossible && <19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2.IsRequired)
			{
				throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(<19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2.Mark, <19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2.Mark, "While scanning a simple key, could not find expected ':'.");
			}
			<19621959-3e0a-47ea-912c-717e879a2297>SimpleKey2.MarkAsImpossible();
		}

		private string ScanDirectiveName(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start)
		{
			StringBuilder stringBuilder = new StringBuilder();
			while (analyzer.IsAlphaNumericDashOrUnderscore())
			{
				stringBuilder.Append(ReadCurrentCharacter());
			}
			if (stringBuilder.Length == 0)
			{
				throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "While scanning a directive, could not find expected directive name.");
			}
			if (!analyzer.IsWhiteBreakOrZero())
			{
				throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "While scanning a directive, found unexpected non-alphabetical character.");
			}
			return stringBuilder.ToString();
		}

		private void SkipWhitespaces()
		{
			while (analyzer.IsWhite())
			{
				Skip();
			}
		}

		private <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token ScanVersionDirectiveValue(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start)
		{
			SkipWhitespaces();
			int major = ScanVersionDirectiveNumber(start);
			if (!analyzer.Check('.'))
			{
				throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "While scanning a %YAML directive, did not find expected digit or '.' character.");
			}
			Skip();
			int minor = ScanVersionDirectiveNumber(start);
			return new <e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective(new <9adf6b74-1cdc-49ae-a626-b628125e4102>Version(major, minor), start, start);
		}

		private <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token ScanTagDirectiveValue(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start)
		{
			SkipWhitespaces();
			string handle = ScanTagHandle(isDirective: true, start);
			if (!analyzer.IsWhite())
			{
				throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "While scanning a %TAG directive, did not find expected whitespace.");
			}
			SkipWhitespaces();
			string prefix = ScanTagUri(null, start);
			if (!analyzer.IsWhiteBreakOrZero())
			{
				throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "While scanning a %TAG directive, did not find expected whitespace or line break.");
			}
			return new <71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective(handle, prefix, start, start);
		}

		private string ScanTagUri([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] string head, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start)
		{
			StringBuilder stringBuilder = new StringBuilder();
			if (head != null && head.Length > 1)
			{
				stringBuilder.Append(head.Substring(1));
			}
			while (analyzer.IsAlphaNumericDashOrUnderscore() || analyzer.Check(";/?:@&=+$.!~*'()[]%") || (analyzer.Check(',') && !analyzer.IsBreak(1)))
			{
				if (analyzer.Check('%'))
				{
					stringBuilder.Append(ScanUriEscapes(start));
				}
				else if (analyzer.Check('+'))
				{
					stringBuilder.Append(' ');
					Skip();
				}
				else
				{
					stringBuilder.Append(ReadCurrentCharacter());
				}
			}
			if (stringBuilder.Length == 0)
			{
				return string.Empty;
			}
			return stringBuilder.ToString();
		}

		private string ScanUriEscapes(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start)
		{
			byte[] array = EmptyBytes;
			int count = 0;
			int num = 0;
			do
			{
				if (!analyzer.Check('%') || !analyzer.IsHex(1) || !analyzer.IsHex(2))
				{
					throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "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)
					{
						throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "While scanning a tag, found an incorrect leading UTF-8 octet.");
					}
					array = new byte[num];
				}
				else if ((num2 & 0xC0) != 128)
				{
					throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "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)
			{
				throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "While scanning a tag, found an incorrect UTF-8 sequence.");
			}
			return @string;
		}

		private string ScanTagHandle(bool isDirective, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start)
		{
			if (!analyzer.Check('!'))
			{
				throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "While scanning a tag, did not find expected '!'.");
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(ReadCurrentCharacter());
			while (analyzer.IsAlphaNumericDashOrUnderscore())
			{
				stringBuilder.Append(ReadCurrentCharacter());
			}
			if (analyzer.Check('!'))
			{
				stringBuilder.Append(ReadCurrentCharacter());
			}
			else if (isDirective && (stringBuilder.Length != 1 || stringBuilder[0] != '!'))
			{
				throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "While scanning a tag directive, did not find expected '!'.");
			}
			return stringBuilder.ToString();
		}

		private int ScanVersionDirectiveNumber(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start)
		{
			int num = 0;
			int num2 = 0;
			while (analyzer.IsDigit())
			{
				if (++num2 > 9)
				{
					throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "While scanning a %YAML directive, found extremely long version number.");
				}
				num = num * 10 + analyzer.AsDigit();
				Skip();
			}
			if (num2 == 0)
			{
				throw new <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(start, cursor.Mark(), "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)
			{
				<19621959-3e0a-47ea-912c-717e879a2297>SimpleKey item = new <19621959-3e0a-47ea-912c-717e879a2297>SimpleKey(isRequired, tokensParsed + tokens.Count, cursor);
				RemoveSimpleKey();
				simpleKeys.Pop();
				simpleKeys.Push(item);
			}
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal class <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException : <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException
	{
		public <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(string message)
			: base(message)
		{
		}

		public <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end, string message)
			: base(start, end, message)
		{
		}

		public <e0787cd9-3ec8-4f8d-8ef7-727754f21d14>SemanticErrorException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <19621959-3e0a-47ea-912c-717e879a2297>SimpleKey
	{
		private readonly <4c8a95a8-6f4a-46ea-88a7-286805c3eff5>Cursor cursor;

		public bool IsPossible { get; private set; }

		public bool IsRequired { get; }

		public int TokenNumber { get; }

		public int Index => cursor.Index;

		public int Line => cursor.Line;

		public int LineOffset => cursor.LineOffset;

		public <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark Mark => cursor.Mark();

		public void MarkAsImpossible()
		{
			IsPossible = false;
		}

		public <19621959-3e0a-47ea-912c-717e879a2297>SimpleKey()
		{
			cursor = new <4c8a95a8-6f4a-46ea-88a7-286805c3eff5>Cursor();
		}

		public <19621959-3e0a-47ea-912c-717e879a2297>SimpleKey(bool isRequired, int tokenNumber, <4c8a95a8-6f4a-46ea-88a7-286805c3eff5>Cursor cursor)
		{
			IsPossible = true;
			IsRequired = isRequired;
			TokenNumber = tokenNumber;
			this.cursor = new <4c8a95a8-6f4a-46ea-88a7-286805c3eff5>Cursor(cursor);
		}
	}
	internal sealed class <0fa5dd46-7d90-409b-a256-46a1f1ade723>StringLookAheadBuffer : <9e39d630-becb-4860-8a5d-e9f65de80826>ILookAheadBuffer
	{
		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(1)]
		private readonly string value;

		public int Position { get; private set; }

		public int Length => value.Length;

		public bool EndOfInput => IsOutside(Position);

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <0fa5dd46-7d90-409b-a256-46a1f1ade723>StringLookAheadBuffer(string value)
		{
			this.value = value;
		}

		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;
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException : <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException
	{
		public <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(string message)
			: base(message)
		{
		}

		public <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end, string message)
			: base(start, end, message)
		{
		}

		public <da6cc224-5c35-4f06-b5f9-b51d0f3e0064>SyntaxErrorException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(new byte[] { 0, 1, 1 })]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection : KeyedCollection<string, <71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective>
	{
		public <46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection()
		{
		}

		public <46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection(IEnumerable<<71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective> tagDirectives)
		{
			foreach (<71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective tagDirective in tagDirectives)
			{
				Add(tagDirective);
			}
		}

		protected override string GetKeyForItem(<71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective item)
		{
			return item.Handle;
		}

		public new bool Contains(<71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective directive)
		{
			return Contains(GetKeyForItem(directive));
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal struct <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName : IEquatable<<9b965c76-e42b-4be8-b468-b7eefab6d624>TagName>
	{
		public static readonly <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName Empty;

		[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)]
		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 <9b965c76-e42b-4be8-b468-b7eefab6d624>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(<9b965c76-e42b-4be8-b468-b7eefab6d624>TagName other)
		{
			return object.Equals(value, other.value);
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (obj is <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return value?.GetHashCode() ?? 0;
		}

		public static bool operator ==(<9b965c76-e42b-4be8-b468-b7eefab6d624>TagName left, <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(<9b965c76-e42b-4be8-b468-b7eefab6d624>TagName left, <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName right)
		{
			return !(left == right);
		}

		public static bool operator ==(<9b965c76-e42b-4be8-b468-b7eefab6d624>TagName left, string right)
		{
			return object.Equals(left.value, right);
		}

		public static bool operator !=(<9b965c76-e42b-4be8-b468-b7eefab6d624>TagName left, string right)
		{
			return !(left == right);
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
		public static implicit operator <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName(string value)
		{
			if (value != null)
			{
				return new <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName(value);
			}
			return Empty;
		}
	}
	internal sealed class <9adf6b74-1cdc-49ae-a626-b628125e4102>Version
	{
		public int Major { get; }

		public int Minor { get; }

		public <9adf6b74-1cdc-49ae-a626-b628125e4102>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;
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (obj is <9adf6b74-1cdc-49ae-a626-b628125e4102>Version <9adf6b74-1cdc-49ae-a626-b628125e4102>Version2 && Major == <9adf6b74-1cdc-49ae-a626-b628125e4102>Version2.Major)
			{
				return Minor == <9adf6b74-1cdc-49ae-a626-b628125e4102>Version2.Minor;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return <ca709e83-a9df-4fcf-9dd7-e6aed3e61227>HashCode.CombineHashCodes(Major.GetHashCode(), Minor.GetHashCode());
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal class <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException : Exception
	{
		public <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark Start { get; }

		public <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark End { get; }

		public <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException(string message)
			: this(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, message)
		{
		}

		public <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end, string message)
			: this(start, end, message, null)
		{
		}

		public <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end, string message, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] Exception innerException)
			: base($"({start}) - ({end}): {message}", innerException)
		{
			Start = start;
			End = end;
		}

		public <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException(string message, Exception inner)
			: this(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, message, inner)
		{
		}
	}
}
namespace YamlDotNet.Core.Tokens
{
	internal class <81c9981d-61ad-4343-a7f8-7e07bfdb0222>Anchor : <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token
	{
		public <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName Value { get; }

		public <81c9981d-61ad-4343-a7f8-7e07bfdb0222>Anchor(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName value)
			: this(value, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <81c9981d-61ad-4343-a7f8-7e07bfdb0222>Anchor(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName value, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
			if (value.IsEmpty)
			{
				throw new ArgumentNullException("value");
			}
			Value = value;
		}
	}
	internal sealed class <54e5670b-898a-48cc-a602-f86f188e1415>AnchorAlias : <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token
	{
		public <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName Value { get; }

		public <54e5670b-898a-48cc-a602-f86f188e1415>AnchorAlias(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName value)
			: this(value, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <54e5670b-898a-48cc-a602-f86f188e1415>AnchorAlias(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName value, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
			if (value.IsEmpty)
			{
				throw new ArgumentNullException("value");
			}
			Value = value;
		}
	}
	internal sealed class <9ccf1c73-1400-452a-b6de-58471d7bb397>BlockEnd : <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token
	{
		public <9ccf1c73-1400-452a-b6de-58471d7bb397>BlockEnd()
			: this(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <9ccf1c73-1400-452a-b6de-58471d7bb397>BlockEnd(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class <1133f355-cbce-4fdc-b83c-f4a9447c1965>BlockEntry : <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token
	{
		public <1133f355-cbce-4fdc-b83c-f4a9447c1965>BlockEntry()
			: this(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <1133f355-cbce-4fdc-b83c-f4a9447c1965>BlockEntry(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class <cc07463c-e471-478b-845b-eb93577727f0>BlockMappingStart : <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token
	{
		public <cc07463c-e471-478b-845b-eb93577727f0>BlockMappingStart()
			: this(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <cc07463c-e471-478b-845b-eb93577727f0>BlockMappingStart(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class <0c4cf1de-e8ef-441f-9b26-fcd2154b8bf7>BlockSequenceStart : <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token
	{
		public <0c4cf1de-e8ef-441f-9b26-fcd2154b8bf7>BlockSequenceStart()
			: this(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <0c4cf1de-e8ef-441f-9b26-fcd2154b8bf7>BlockSequenceStart(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <fee736d1-2625-4930-8ec0-7a85005ed886>Comment : <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token
	{
		public string Value { get; }

		public bool IsInline { get; }

		public <fee736d1-2625-4930-8ec0-7a85005ed886>Comment(string value, bool isInline)
			: this(value, isInline, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		public <fee736d1-2625-4930-8ec0-7a85005ed886>Comment(string value, bool isInline, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
			Value = value ?? throw new ArgumentNullException("value");
			IsInline = isInline;
		}
	}
	internal sealed class <fdd48936-da79-498a-9a60-cdc7b3c5de1e>DocumentEnd : <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token
	{
		public <fdd48936-da79-498a-9a60-cdc7b3c5de1e>DocumentEnd()
			: this(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <fdd48936-da79-498a-9a60-cdc7b3c5de1e>DocumentEnd(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class <d3392cd4-8bef-4da2-ae6e-42a42f997801>DocumentStart : <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token
	{
		public <d3392cd4-8bef-4da2-ae6e-42a42f997801>DocumentStart()
			: this(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <d3392cd4-8bef-4da2-ae6e-42a42f997801>DocumentStart(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal class <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error : <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token
	{
		internal string Value { get; }

		internal <6f81fd05-c989-4e61-a86c-eefb303bec2c>Error(string value, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
			Value = value;
		}
	}
	internal sealed class <f5af023c-6714-4e11-bae3-bab1db71ea0d>FlowEntry : <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token
	{
		public <f5af023c-6714-4e11-bae3-bab1db71ea0d>FlowEntry()
			: this(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <f5af023c-6714-4e11-bae3-bab1db71ea0d>FlowEntry(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class <ee152654-f658-4559-8caf-f046fdb2b393>FlowMappingEnd : <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token
	{
		public <ee152654-f658-4559-8caf-f046fdb2b393>FlowMappingEnd()
			: this(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <ee152654-f658-4559-8caf-f046fdb2b393>FlowMappingEnd(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class <05048b10-3a91-4e92-903b-49ed1acc3d28>FlowMappingStart : <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token
	{
		public <05048b10-3a91-4e92-903b-49ed1acc3d28>FlowMappingStart()
			: this(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <05048b10-3a91-4e92-903b-49ed1acc3d28>FlowMappingStart(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class <2ac58229-08bc-405a-9c73-9134bc343d7a>FlowSequenceEnd : <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token
	{
		public <2ac58229-08bc-405a-9c73-9134bc343d7a>FlowSequenceEnd()
			: this(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <2ac58229-08bc-405a-9c73-9134bc343d7a>FlowSequenceEnd(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class <33bff82c-cdce-433e-ba84-891545635237>FlowSequenceStart : <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token
	{
		public <33bff82c-cdce-433e-ba84-891545635237>FlowSequenceStart()
			: this(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <33bff82c-cdce-433e-ba84-891545635237>FlowSequenceStart(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class <04bd4490-3a0a-4e31-a34b-c0fc268d8569>Key : <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token
	{
		public <04bd4490-3a0a-4e31-a34b-c0fc268d8569>Key()
			: this(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <04bd4490-3a0a-4e31-a34b-c0fc268d8569>Key(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <59bc0526-7926-43e3-8d44-f81d57983c50>Scalar : <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token
	{
		public string Value { get; }

		public <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle Style { get; }

		public <59bc0526-7926-43e3-8d44-f81d57983c50>Scalar(string value)
			: this(value, <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Any)
		{
		}

		public <59bc0526-7926-43e3-8d44-f81d57983c50>Scalar(string value, <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle style)
			: this(value, style, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		public <59bc0526-7926-43e3-8d44-f81d57983c50>Scalar(string value, <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle style, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
			Value = value ?? throw new ArgumentNullException("value");
			Style = style;
		}
	}
	internal sealed class <aaed5440-61c4-43e2-95a5-1da2fefcf451>StreamEnd : <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token
	{
		public <aaed5440-61c4-43e2-95a5-1da2fefcf451>StreamEnd()
			: this(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <aaed5440-61c4-43e2-95a5-1da2fefcf451>StreamEnd(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class <0c143349-e8ac-43ce-94f2-6e904605633e>StreamStart : <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token
	{
		public <0c143349-e8ac-43ce-94f2-6e904605633e>StreamStart()
			: this(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <0c143349-e8ac-43ce-94f2-6e904605633e>StreamStart(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <0de3b70d-5685-4444-bd63-fcc634fd9344>Tag : <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token
	{
		public string Handle { get; }

		public string Suffix { get; }

		public <0de3b70d-5685-4444-bd63-fcc634fd9344>Tag(string handle, string suffix)
			: this(handle, suffix, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		public <0de3b70d-5685-4444-bd63-fcc634fd9344>Tag(string handle, string suffix, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
			Handle = handle ?? throw new ArgumentNullException("handle");
			Suffix = suffix ?? throw new ArgumentNullException("suffix");
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal class <71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective : <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token
	{
		private static readonly Regex TagHandlePattern = new Regex("^!([0-9A-Za-z_\\-]*!)?$", RegexOptions.Compiled);

		public string Handle { get; }

		public string Prefix { get; }

		public <71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective(string handle, string prefix)
			: this(handle, prefix, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		public <71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective(string handle, string prefix, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, 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;
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (obj is <71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective <71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective2 && Handle.Equals(<71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective2.Handle))
			{
				return Prefix.Equals(<71c3f3b7-b4f6-4cab-80ac-72880aff85c8>TagDirective2.Prefix);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Handle.GetHashCode() ^ Prefix.GetHashCode();
		}

		public override string ToString()
		{
			return Handle + " => " + Prefix;
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal abstract class <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token
	{
		public <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark Start { get; }

		public <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark End { get; }

		protected <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
		{
			Start = start ?? throw new ArgumentNullException("start");
			End = end ?? throw new ArgumentNullException("end");
		}
	}
	internal sealed class <ad24bda1-8f67-4473-a03e-b0061c481608>Value : <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token
	{
		public <ad24bda1-8f67-4473-a03e-b0061c481608>Value()
			: this(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <ad24bda1-8f67-4473-a03e-b0061c481608>Value(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective : <34a5d198-1d3b-49ed-a3f6-9cd37f346651>Token
	{
		public <9adf6b74-1cdc-49ae-a626-b628125e4102>Version Version { get; }

		public <e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective(<9adf6b74-1cdc-49ae-a626-b628125e4102>Version version)
			: this(version, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		public <e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective(<9adf6b74-1cdc-49ae-a626-b628125e4102>Version version, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
			Version = version;
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (obj is <e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective <e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective2)
			{
				return Version.Equals(<e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective2.Version);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Version.GetHashCode();
		}
	}
}
namespace YamlDotNet.Core.Events
{
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias : <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent
	{
		internal override <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType Type => <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.Alias;

		public <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName Value { get; }

		public <5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName value, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
			if (value.IsEmpty)
			{
				throw new <c5e64590-eb88-4d3b-ba7a-74b0f4e38bd9>YamlException(start, end, "Anchor value must not be empty.");
			}
			Value = value;
		}

		public <5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName value)
			: this(value, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Alias [value = {Value}]";
		}

		public override void Accept(<dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <7d01ae39-3c87-4fa0-8b6c-f9a55cfe3ac0>Comment : <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent
	{
		public string Value { get; }

		public bool IsInline { get; }

		internal override <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType Type => <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.Comment;

		public <7d01ae39-3c87-4fa0-8b6c-f9a55cfe3ac0>Comment(string value, bool isInline)
			: this(value, isInline, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		public <7d01ae39-3c87-4fa0-8b6c-f9a55cfe3ac0>Comment(string value, bool isInline, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
			Value = value;
			IsInline = isInline;
		}

		public override void Accept(<dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override string ToString()
		{
			return (IsInline ? "Inline" : "Block") + " Comment [" + Value + "]";
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <ce28eaa8-1705-4d9d-86ca-3aaeb4704887>DocumentEnd : <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType Type => <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.DocumentEnd;

		public bool IsImplicit { get; }

		public <ce28eaa8-1705-4d9d-86ca-3aaeb4704887>DocumentEnd(bool isImplicit, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
			IsImplicit = isImplicit;
		}

		public <ce28eaa8-1705-4d9d-86ca-3aaeb4704887>DocumentEnd(bool isImplicit)
			: this(isImplicit, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Document end [isImplicit = {IsImplicit}]";
		}

		public override void Accept(<dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(2)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart : <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent
	{
		public override int NestingIncrease => 1;

		internal override <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType Type => <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.DocumentStart;

		public <46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection Tags { get; }

		public <e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective Version { get; }

		public bool IsImplicit { get; }

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart([<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] <e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective version, [<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(2)] <46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection tags, bool isImplicit, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
			Version = version;
			Tags = tags;
			IsImplicit = isImplicit;
		}

		public <20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart(<e95ccd8b-6f1d-4194-9256-bcc391b65345>VersionDirective version, <46eb9d4a-229c-4b2c-a13f-1be37c76564a>TagDirectiveCollection tags, bool isImplicit)
			: this(version, tags, isImplicit, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public <20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: this(null, null, isImplicit: true, start, end)
		{
		}

		public <20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart()
			: this(null, null, isImplicit: true, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public override string ToString()
		{
			return $"Document start [isImplicit = {IsImplicit}]";
		}

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		public override void Accept(<dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType
	{
		None,
		StreamStart,
		StreamEnd,
		DocumentStart,
		DocumentEnd,
		Alias,
		Scalar,
		SequenceStart,
		SequenceEnd,
		MappingStart,
		MappingEnd,
		Comment
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal interface <dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor
	{
		void Visit(<5c69e3ec-21af-445a-ac93-12786d7b3fe6>AnchorAlias e);

		void Visit(<c6735cbe-6b41-41ed-9735-1c5651a9fd34>StreamStart e);

		void Visit(<22699db6-dc9d-47cf-852e-e20a3076c7be>StreamEnd e);

		void Visit(<20bfd7d2-73a3-4734-a461-c29efd8550b3>DocumentStart e);

		void Visit(<ce28eaa8-1705-4d9d-86ca-3aaeb4704887>DocumentEnd e);

		void Visit(<1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar e);

		void Visit(<d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart e);

		void Visit(<1851bced-7720-45bc-a55f-1347cc414c40>SequenceEnd e);

		void Visit(<3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart e);

		void Visit(<05f36264-c97d-43b8-9e56-0f8741a6ea35>MappingEnd e);

		void Visit(<7d01ae39-3c87-4fa0-8b6c-f9a55cfe3ac0>Comment e);
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal class <05f36264-c97d-43b8-9e56-0f8741a6ea35>MappingEnd : <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType Type => <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.MappingEnd;

		public <05f36264-c97d-43b8-9e56-0f8741a6ea35>MappingEnd(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
		}

		public <05f36264-c97d-43b8-9e56-0f8741a6ea35>MappingEnd()
			: this(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		public override string ToString()
		{
			return "Mapping end";
		}

		public override void Accept(<dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart : <1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent
	{
		public override int NestingIncrease => 1;

		internal override <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType Type => <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.MappingStart;

		public bool IsImplicit { get; }

		public override bool IsCanonical => !IsImplicit;

		public <bc2eacde-da96-4de8-a058-605c487b5916>MappingStyle Style { get; }

		public <3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName anchor, <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName tag, bool isImplicit, <bc2eacde-da96-4de8-a058-605c487b5916>MappingStyle style, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(anchor, tag, start, end)
		{
			IsImplicit = isImplicit;
			Style = style;
		}

		public <3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName anchor, <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName tag, bool isImplicit, <bc2eacde-da96-4de8-a058-605c487b5916>MappingStyle style)
			: this(anchor, tag, isImplicit, style, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		public <3eb4b14e-d340-477d-b5dc-f1f6a8a9d762>MappingStart()
			: this(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName.Empty, <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName.Empty, isImplicit: true, <bc2eacde-da96-4de8-a058-605c487b5916>MappingStyle.Any, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Mapping start [anchor = {base.Anchor}, tag = {base.Tag}, isImplicit = {IsImplicit}, style = {Style}]";
		}

		public override void Accept(<dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum <bc2eacde-da96-4de8-a058-605c487b5916>MappingStyle
	{
		Any,
		Block,
		Flow
	}
	internal abstract class <1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent : <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent
	{
		public <be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName Anchor { get; }

		public <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName Tag { get; }

		public abstract bool IsCanonical { get; }

		[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
		protected <1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName anchor, <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName tag, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
			Anchor = anchor;
			Tag = tag;
		}

		protected <1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName anchor, <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName tag)
			: this(anchor, tag, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal abstract class <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent
	{
		public virtual int NestingIncrease => 0;

		internal abstract <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType Type { get; }

		public <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark Start { get; }

		public <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark End { get; }

		public abstract void Accept(<dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor visitor);

		internal <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
		{
			Start = start ?? throw new ArgumentNullException("start");
			End = end ?? throw new ArgumentNullException("end");
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar : <1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent
	{
		internal override <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType Type => <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.Scalar;

		public string Value { get; }

		public <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle Style { get; }

		public bool IsPlainImplicit { get; }

		public bool IsQuotedImplicit { get; }

		public override bool IsCanonical
		{
			get
			{
				if (!IsPlainImplicit)
				{
					return !IsQuotedImplicit;
				}
				return false;
			}
		}

		public <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName anchor, <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName tag, string value, <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle style, bool isPlainImplicit, bool isQuotedImplicit, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(anchor, tag, start, end)
		{
			Value = value;
			Style = style;
			IsPlainImplicit = isPlainImplicit;
			IsQuotedImplicit = isQuotedImplicit;
		}

		public <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName anchor, <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName tag, string value, <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle style, bool isPlainImplicit, bool isQuotedImplicit)
			: this(anchor, tag, value, style, isPlainImplicit, isQuotedImplicit, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		public <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar(string value)
			: this(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName.Empty, <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName.Empty, value, <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		public <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar(<9b965c76-e42b-4be8-b468-b7eefab6d624>TagName tag, string value)
			: this(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName.Empty, tag, value, <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		public <1281ad32-4e8c-4505-9607-ea15acf4a70d>Scalar(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName anchor, <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName tag, string value)
			: this(anchor, tag, value, <4162f11c-a9f7-4c52-93eb-9ee5ef5eb44f>ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>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(<dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <1851bced-7720-45bc-a55f-1347cc414c40>SequenceEnd : <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType Type => <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.SequenceEnd;

		public <1851bced-7720-45bc-a55f-1347cc414c40>SequenceEnd(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
		}

		public <1851bced-7720-45bc-a55f-1347cc414c40>SequenceEnd()
			: this(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		public override string ToString()
		{
			return "Sequence end";
		}

		public override void Accept(<dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	internal sealed class <d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart : <1532194c-e40d-420a-9a09-3cfeb36413b0>NodeEvent
	{
		public override int NestingIncrease => 1;

		internal override <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType Type => <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.SequenceStart;

		public bool IsImplicit { get; }

		public override bool IsCanonical => !IsImplicit;

		public <71ce5569-3f87-4b73-9e15-59e4c0c26f9f>SequenceStyle Style { get; }

		public <d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName anchor, <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName tag, bool isImplicit, <71ce5569-3f87-4b73-9e15-59e4c0c26f9f>SequenceStyle style, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(anchor, tag, start, end)
		{
			IsImplicit = isImplicit;
			Style = style;
		}

		public <d29613b6-6ecf-4d98-8221-c74dcd47b986>SequenceStart(<be4a9aef-64f5-4469-b635-00fe21657f8b>AnchorName anchor, <9b965c76-e42b-4be8-b468-b7eefab6d624>TagName tag, bool isImplicit, <71ce5569-3f87-4b73-9e15-59e4c0c26f9f>SequenceStyle style)
			: this(anchor, tag, isImplicit, style, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Sequence start [anchor = {base.Anchor}, tag = {base.Tag}, isImplicit = {IsImplicit}, style = {Style}]";
		}

		public override void Accept(<dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum <71ce5569-3f87-4b73-9e15-59e4c0c26f9f>SequenceStyle
	{
		Any,
		Block,
		Flow
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <22699db6-dc9d-47cf-852e-e20a3076c7be>StreamEnd : <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType Type => <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.StreamEnd;

		public <22699db6-dc9d-47cf-852e-e20a3076c7be>StreamEnd(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
		}

		public <22699db6-dc9d-47cf-852e-e20a3076c7be>StreamEnd()
			: this(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		public override string ToString()
		{
			return "Stream end";
		}

		public override void Accept(<dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<928a8975-a5bb-4379-8af9-f23309a66ace>Nullable(0)]
	[<0bcdf301-db66-425d-9b87-ea4eea3fbd40>NullableContext(1)]
	internal sealed class <c6735cbe-6b41-41ed-9735-1c5651a9fd34>StreamStart : <4bc414b4-1d1f-4eae-9084-0210dd9f02c0>ParsingEvent
	{
		public override int NestingIncrease => 1;

		internal override <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType Type => <f4498ea9-0998-4833-a113-6cccea8c58ca>EventType.StreamStart;

		public <c6735cbe-6b41-41ed-9735-1c5651a9fd34>StreamStart()
			: this(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark.Empty)
		{
		}

		public <c6735cbe-6b41-41ed-9735-1c5651a9fd34>StreamStart(<2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark start, <2d8f5f7d-5836-47b7-9426-9b4648621a44>Mark end)
			: base(start, end)
		{
		}

		public override string ToString()
		{
			return "Stream start";
		}

		public override void Accept(<dfd55613-a661-49f4-b3b1-5528731a2c7e>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<81a3499d-e248-4dab-bda2-e3bceb8a7163>Embedded]
	internal sealed class <81a3499d-e248-4dab-bda2-e3bceb8a7163>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[<81a3499d-e248-4dab-bda2-e3bceb8a7163>Embedded]
	[CompilerGenerated]
	internal sealed class <f5de3dd1-492f-4a0b-9ec5-49658172eecf>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <f5de3dd1-492f-4a0b-9ec5-49658172eecf>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <f5de3dd1-492f-4a0b-9ec5-49658172eecf>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[<81a3499d-e248-4dab-bda2-e3bceb8a7163>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class <6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	internal sealed class AllowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	internal sealed class DisallowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	internal sealed class DoesNotReturnAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	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)]
	internal sealed class MaybeNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class MaybeNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public MaybeNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	internal sealed class NotNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal sealed class NotNullIfNotNullAttribute : Attribute
	{
		public string ParameterName { get; }

		public NotNullIfNotNullAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class NotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public NotNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
}
namespace System.Collections.Generic
{
	internal static class DeconstructionExtensions
	{
		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public static void Deconstruct<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TKey, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TValue>([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 0, 1, 1 })] this KeyValuePair<TKey, TValue> pair, out TKey key, out TValue value)
		{
			key = pair.Key;
			value = pair.Value;
		}
	}
}
namespace YamlDotNet
{
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class CultureInfoAdapter : CultureInfo
	{
		private readonly IFormatProvider provider;

		public CultureInfoAdapter(CultureInfo baseCulture, IFormatProvider provider)
			: base(baseCulture.LCID)
		{
			this.provider = provider;
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
		public override object GetFormat(Type formatType)
		{
			return provider.GetFormat(formatType);
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal static class ReflectionExtensions
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		private static readonly FieldInfo RemoteStackTraceField = typeof(Exception).GetField("_remoteStackTraceString", BindingFlags.Instance | BindingFlags.NonPublic);

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public static Type BaseType(this Type type)
		{
			return type.BaseType;
		}

		public static bool IsValueType(this Type type)
		{
			return type.IsValueType;
		}

		public static bool IsGenericType(this Type type)
		{
			return type.IsGenericType;
		}

		public static bool IsGenericTypeDefinition(this Type type)
		{
			return type.IsGenericTypeDefinition;
		}

		public static bool IsInterface(this Type type)
		{
			return type.IsInterface;
		}

		public static bool IsEnum(this Type type)
		{
			return type.IsEnum;
		}

		public static bool IsDbNull(this object value)
		{
			return value is DBNull;
		}

		public static bool HasDefaultConstructor(this Type type)
		{
			if (!type.IsValueType)
			{
				return type.GetConstructor(BindingFlags.Instance | BindingFlags.Public, null, Type.EmptyTypes, null) != null;
			}
			return true;
		}

		public static TypeCode GetTypeCode(this Type type)
		{
			return Type.GetTypeCode(type);
		}

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public static PropertyInfo GetPublicProperty(this Type type, string name)
		{
			return type.GetProperty(name);
		}

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public static FieldInfo GetPublicStaticField(this Type type, string name)
		{
			return type.GetField(name, BindingFlags.Static | BindingFlags.Public);
		}

		public static IEnumerable<PropertyInfo> GetProperties(this Type type, bool includeNonPublic)
		{
			BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public;
			if (includeNonPublic)
			{
				bindingFlags |= BindingFlags.NonPublic;
			}
			if (!type.IsInterface)
			{
				return type.GetProperties(bindingFlags);
			}
			return new Type[1] { type }.Concat(type.GetInterfaces()).SelectMany([<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] (Type i) => i.GetProperties(bindingFlags));
		}

		public static IEnumerable<PropertyInfo> GetPublicProperties(this Type type)
		{
			return GetProperties(type, includeNonPublic: false);
		}

		public static IEnumerable<FieldInfo> GetPublicFields(this Type type)
		{
			return type.GetFields(BindingFlags.Instance | BindingFlags.Public);
		}

		public static IEnumerable<MethodInfo> GetPublicStaticMethods(this Type type)
		{
			return type.GetMethods(BindingFlags.Static | BindingFlags.Public);
		}

		public static MethodInfo GetPrivateStaticMethod(this Type type, string name)
		{
			return type.GetMethod(name, BindingFlags.Static | BindingFlags.NonPublic) ?? throw new MissingMethodException("Expected to find a method named '" + name + "' in '" + type.FullName + "'.");
		}

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public static MethodInfo GetPublicStaticMethod(this Type type, string name, params Type[] parameterTypes)
		{
			return type.GetMethod(name, BindingFlags.Static | BindingFlags.Public, null, parameterTypes, null);
		}

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public static MethodInfo GetPublicInstanceMethod(this Type type, string name)
		{
			return type.GetMethod(name, BindingFlags.Instance | BindingFlags.Public);
		}

		public static Exception Unwrap(this TargetInvocationException ex)
		{
			Exception innerException = ex.InnerException;
			if (innerException == null)
			{
				return ex;
			}
			if (RemoteStackTraceField != null)
			{
				RemoteStackTraceField.SetValue(innerException, innerException.StackTrace + "\r\n");
			}
			return innerException;
		}

		public static bool IsInstanceOf(this Type type, object o)
		{
			return type.IsInstanceOfType(o);
		}

		public static Attribute[] GetAllCustomAttributes<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TAttribute>(this PropertyInfo property)
		{
			return Attribute.GetCustomAttributes(property, typeof(TAttribute));
		}
	}
	internal static class PropertyInfoExtensions
	{
		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public static object ReadValue(this PropertyInfo property, object target)
		{
			return property.GetValue(target, null);
		}
	}
	internal static class StandardRegexOptions
	{
		public const RegexOptions Compiled = RegexOptions.Compiled;
	}
}
namespace YamlDotNet.Serialization
{
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal abstract class BuilderSkeleton<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] TBuilder> where TBuilder : BuilderSkeleton<TBuilder>
	{
		internal INamingConvention namingConvention = NullNamingConvention.Instance;

		internal ITypeResolver typeResolver;

		internal readonly YamlAttributeOverrides overrides;

		internal readonly LazyComponentRegistrationList<Nothing, IYamlTypeConverter> typeConverterFactories;

		internal readonly LazyComponentRegistrationList<ITypeInspector, ITypeInspector> typeInspectorFactories;

		private bool ignoreFields;

		private bool includeNonPublicProperties;

		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");
		}

		internal ITypeInspector BuildTypeInspector()
		{
			ITypeInspector typeInspector = new ReadablePropertiesTypeInspector(typeResolver, includeNonPublicProperties);
			if (!ignoreFields)
			{
				typeInspector = new CompositeTypeInspector(new ReadableFieldsTypeInspector(typeResolver), typeInspector);
			}
			return typeInspectorFactories.BuildComponentChain(typeInspector);
		}

		public TBuilder IgnoreFields()
		{
			ignoreFields = true;
			return Self;
		}

		public TBuilder IncludeNonPublicProperties()
		{
			includeNonPublicProperties = true;
			return Self;
		}

		public TBuilder WithNamingConvention(INamingConvention namingConvention)
		{
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
			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<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] 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)
		{
			if (typeConverter == null)
			{
				throw new ArgumentNullException("typeConverter");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter.GetType(), (Nothing _) => typeConverter));
			return Self;
		}

		public TBuilder WithTypeConverter<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] TYamlTypeConverter>(WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where) where TYamlTypeConverter : IYamlTypeConverter
		{
			if (typeConverterFactory == null)
			{
				throw new ArgumentNullException("typeConverterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (IYamlTypeConverter wrapped, Nothing _) => typeConverterFactory(wrapped)));
			return Self;
		}

		public TBuilder WithoutTypeConverter<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] 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<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : ITypeInspector
		{
			return WithTypeInspector(typeInspectorFactory, delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeInspector<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory, Action<IRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			if (typeInspectorFactory == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector inner) => typeInspectorFactory(inner)));
			return Self;
		}

		public TBuilder WithTypeInspector<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] TTypeInspector>(WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			if (typeInspectorFactory == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector wrapped, ITypeInspector inner) => typeInspectorFactory(wrapped, inner)));
			return Self;
		}

		public TBuilder WithoutTypeInspector<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] 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;
		}

		protected IEnumerable<IYamlTypeConverter> BuildTypeConverters()
		{
			return typeConverterFactories.BuildComponentList();
		}
	}
	internal delegate TComponent WrapperFactory<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TComponentBase, TComponent>(TComponentBase wrapped) where TComponent : TComponentBase;
	internal delegate TComponent WrapperFactory<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TArgument, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TComponentBase, TComponent>(TComponentBase wrapped, TArgument argument) where TComponent : TComponentBase;
	[Flags]
	internal enum DefaultValuesHandling
	{
		Preserve = 0,
		OmitNull = 1,
		OmitDefaults = 2,
		OmitEmptyCollections = 4
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal 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<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] T>(string input)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize<T>(input2);
		}

		public T Deserialize<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] T>(TextReader input)
		{
			return Deserialize<T>(new Parser(input));
		}

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public object Deserialize(TextReader input)
		{
			return Deserialize(input, typeof(object));
		}

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public object Deserialize(string input, Type type)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize(input2, type);
		}

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public object Deserialize(TextReader input, Type type)
		{
			return Deserialize(new Parser(input), type);
		}

		public T Deserialize<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] T>(IParser parser)
		{
			return (T)Deserialize(parser, typeof(T));
		}

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public object Deserialize(IParser parser)
		{
			return Deserialize(parser, typeof(object));
		}

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		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;
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 0, 1 })]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal 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 bool ignoreUnmatched;

		protected override DeserializerBuilder Self => this;

		public DeserializerBuilder()
			: base((ITypeResolver)new StaticTypeResolver())
		{
			typeMappings = new Dictionary<Type, Type>();
			objectFactory = new Lazy<IObjectFactory>(() => new DefaultObjectFactory(typeMappings), 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()
				},
				{
					typeof(ArrayNodeDeserializer),
					(Nothing _) => new ArrayNodeDeserializer()
				},
				{
					typeof(DictionaryNodeDeserializer),
					(Nothing _) => new DictionaryNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(CollectionNodeDeserializer),
					(Nothing _) => new CollectionNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(EnumerableNodeDeserializer),
					(Nothing _) => new EnumerableNodeDeserializer()
				},
				{
					typeof(ObjectNodeDeserializer),
					(Nothing _) => new ObjectNodeDeserializer(objectFactory.Value, BuildTypeInspector(), ignoreUnmatched)
				}
			};
			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()
				}
			};
		}

		public DeserializerBuilder WithObjectFactory(IObjectFactory objectFactory)
		{
			if (objectFactory == null)
			{
				throw new ArgumentNullException("objectFactory");
			}
			this.objectFactory = new Lazy<IObjectFactory>(() => objectFactory, 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)
		{
			if (nodeDeserializer == null)
			{
				throw new ArgumentNullException("nodeDeserializer");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer.GetType(), (Nothing _) => nodeDeserializer));
			return this;
		}

		public DeserializerBuilder WithNodeDeserializer<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] TNodeDeserializer>(WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeDeserializer>> where) where TNodeDeserializer : INodeDeserializer
		{
			if (nodeDeserializerFactory == null)
			{
				throw new ArgumentNullException("nodeDeserializerFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (INodeDeserializer wrapped, Nothing _) => nodeDeserializerFactory(wrapped)));
			return this;
		}

		public DeserializerBuilder WithoutNodeDeserializer<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] 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 WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver)
		{
			return WithNodeTypeResolver(nodeTypeResolver, delegate(IRegistrationLocationSelectionSyntax<INodeTypeResolver> w)
			{
				w.OnTop();
			});
		}

		public DeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver, Action<IRegistrationLocationSelectionSyntax<INodeTypeResolver>> where)
		{
			if (nodeTypeResolver == null)
			{
				throw new ArgumentNullException("nodeTypeResolver");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver.GetType(), (Nothing _) => nodeTypeResolver));
			return this;
		}

		public DeserializerBuilder WithNodeTypeResolver<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] TNodeTypeResolver>(WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeTypeResolver>> where) where TNodeTypeResolver : INodeTypeResolver
		{
			if (nodeTypeResolverFactory == null)
			{
				throw new ArgumentNullException("nodeTypeResolverFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (INodeTypeResolver wrapped, Nothing _) => nodeTypeResolverFactory(wrapped)));
			return this;
		}

		public DeserializerBuilder WithoutNodeTypeResolver<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] 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 var 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<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TInterface, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] 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 (typeMappings.ContainsKey(typeFromHandle))
			{
				typeMappings[typeFromHandle] = typeFromHandle2;
			}
			else
			{
				typeMappings.Add(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 IDeserializer Build()
		{
			return Deserializer.FromValueDeserializer(BuildValueDeserializer());
		}

		public IValueDeserializer BuildValueDeserializer()
		{
			return new AliasValueDeserializer(new NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList()));
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal 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<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] T>() where T : IObjectGraphVisitor<Nothing>
		{
			return preProcessingPhaseVisitors.OfType<T>().Single();
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal abstract class EventInfo
	{
		public IObjectDescriptor Source { get; }

		protected EventInfo(IObjectDescriptor source)
		{
			Source = source ?? throw new ArgumentNullException("source");
		}
	}
	internal class AliasEventInfo : EventInfo
	{
		public AnchorName Alias { get; }

		public bool NeedsExpansion { get; set; }

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public AliasEventInfo(IObjectDescriptor source, AnchorName alias)
			: base(source)
		{
			if (alias.IsEmpty)
			{
				throw new ArgumentNullException("alias");
			}
			Alias = alias;
		}
	}
	internal class ObjectEventInfo : EventInfo
	{
		public AnchorName Anchor { get; set; }

		public TagName Tag { get; set; }

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		protected ObjectEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal 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;
		}
	}
	internal sealed class MappingStartEventInfo : ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public MappingStyle Style { get; set; }

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public MappingStartEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class MappingEndEventInfo : EventInfo
	{
		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public MappingEndEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class SequenceStartEventInfo : ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public SequenceStyle Style { get; set; }

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public SequenceStartEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class SequenceEndEventInfo : EventInfo
	{
		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public SequenceEndEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal interface IAliasProvider
	{
		AnchorName GetAlias(object target);
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal interface IDeserializer
	{
		T Deserialize<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] T>(string input);

		T Deserialize<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] T>(TextReader input);

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		object Deserialize(TextReader input);

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		object Deserialize(string input, Type type);

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		object Deserialize(TextReader input, Type type);

		T Deserialize<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] T>(IParser parser);

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		object Deserialize(IParser parser);

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		object Deserialize(IParser parser, Type type);
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal 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);
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal interface INamingConvention
	{
		string Apply(string value);
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal interface INodeDeserializer
	{
		bool Deserialize(IParser reader, Type expectedType, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] out object value);
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal interface INodeTypeResolver
	{
		bool Resolve([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] NodeEvent nodeEvent, ref Type currentType);
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal interface IObjectDescriptor
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		object Value
		{
			[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
			get;
		}

		Type Type { get; }

		Type StaticType { get; }

		ScalarStyle ScalarStyle { get; }
	}
	internal static class ObjectDescriptorExtensions
	{
		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		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.");
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal interface IObjectFactory
	{
		object Create(Type type);
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal interface IObjectGraphTraversalStrategy
	{
		void Traverse<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context);
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal interface IObjectGraphVisitor<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TContext>
	{
		bool Enter(IObjectDescriptor value, TContext context);

		bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, TContext context);

		bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, TContext context);

		void VisitScalar(IObjectDescriptor scalar, TContext context);

		void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, TContext context);

		void VisitMappingEnd(IObjectDescriptor mapping, TContext context);

		void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, TContext context);

		void VisitSequenceEnd(IObjectDescriptor sequence, TContext context);
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal interface IPropertyDescriptor
	{
		string Name { get; }

		bool CanWrite { get; }

		Type Type { get; }

		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		Type TypeOverride
		{
			[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
			get;
			[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
			set;
		}

		int Order { get; set; }

		ScalarStyle ScalarStyle { get; set; }

		T GetCustomAttribute<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] T>() where T : Attribute;

		IObjectDescriptor Read(object target);

		void Write(object target, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object value);
	}
	internal interface IRegistrationLocationSelectionSyntax<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;

		void Before<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;

		void After<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;

		void OnTop();

		void OnBottom();
	}
	internal interface ITrackingRegistrationLocationSelectionSyntax<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal interface ISerializer
	{
		void Serialize(TextWriter writer, object graph);

		string Serialize(object graph);

		void Serialize(TextWriter writer, object graph, Type type);

		void Serialize(IEmitter emitter, object graph);

		void Serialize(IEmitter emitter, object graph, Type type);
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal interface ITypeInspector
	{
		IEnumerable<IPropertyDescriptor> GetProperties(Type type, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object container);

		IPropertyDescriptor GetProperty(Type type, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object container, string name, [MaybeNullWhen(true)] bool ignoreUnmatched);
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal interface ITypeResolver
	{
		Type Resolve(Type staticType, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object actualValue);
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal interface IValueDeserializer
	{
		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		object DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer);
	}
	internal interface IValuePromise
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 2 })]
		event Action<object> ValueAvailable;
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
	internal interface IValueSerializer
	{
		void SerializeValue([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)] IEmitter emitter, object value, Type type);
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal interface IYamlConvertible
	{
		void Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer);

		void Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer);
	}
	[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
	internal delegate object ObjectDeserializer(Type type);
	internal delegate void ObjectSerializer(object value, Type type = null);
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[Obsolete("Please use IYamlConvertible instead")]
	internal interface IYamlSerializable
	{
		void ReadYaml(IParser parser);

		void WriteYaml(IEmitter emitter);
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal interface IYamlTypeConverter
	{
		bool Accepts(Type type);

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		object ReadYaml(IParser parser, Type type);

		void WriteYaml(IEmitter emitter, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object value, Type type);
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal sealed class LazyComponentRegistrationList<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TArgument, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TComponent> : IEnumerable<Func<TArgument, TComponent>>, IEnumerable
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
		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;
			}
		}

		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
		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;
			}
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)]
		private class RegistrationLocationSelector : IRegistrationLocationSelectionSyntax<TComponent>
		{
			[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)]
			private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;

			[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 0, 0 })]
			private readonly LazyComponentRegistration newRegistration;

			[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
			public RegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 0, 0 })] 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);
			}
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)]
		private class TrackingRegistrationLocationSelector : ITrackingRegistrationLocationSelectionSyntax<TComponent>
		{
			[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)]
			private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;

			[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 0, 0 })]
			private readonly TrackingLazyComponentRegistration newRegistration;

			[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
			public TrackingRegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 0, 0 })] 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, [<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)] (TArgument arg) => newRegistration.Factory(innerComponentFactory(arg), arg));
			}
		}

		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 1, 0, 0 })]
		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 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([<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] (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.");
			}
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
		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;
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal static class LazyComponentRegistrationListExtensions
	{
		public static TComponent BuildComponentChain<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TComponent>(this LazyComponentRegistrationList<TComponent, TComponent> registrations, TComponent innerComponent)
		{
			return registrations.InReverseOrder.Aggregate(innerComponent, [<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] (TComponent inner, Func<TComponent, TComponent> factory) => factory(inner));
		}

		public static TComponent BuildComponentChain<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TArgument, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TComponent innerComponent, Func<TComponent, TArgument> argumentBuilder)
		{
			return registrations.InReverseOrder.Aggregate(innerComponent, [<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] (TComponent inner, Func<TArgument, TComponent> factory) => factory(argumentBuilder(inner)));
		}

		public static List<TComponent> BuildComponentList<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TComponent>(this LazyComponentRegistrationList<Nothing, TComponent> registrations)
		{
			return registrations.Select([<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] (Func<Nothing, TComponent> factory) => factory(default(Nothing))).ToList();
		}

		public static List<TComponent> BuildComponentList<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TArgument, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TArgument argument)
		{
			return registrations.Select([<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] (Func<TArgument, TComponent> factory) => factory(argument)).ToList();
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	internal struct Nothing
	{
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class ObjectDescriptor : IObjectDescriptor
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		[field: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public object Value
		{
			[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
			get;
			[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
			private set;
		}

		public Type Type { get; private set; }

		public Type StaticType { get; private set; }

		public ScalarStyle ScalarStyle { get; private set; }

		public ObjectDescriptor([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object value, Type type, Type staticType)
			: this(value, type, staticType, ScalarStyle.Any)
		{
		}

		public ObjectDescriptor([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object value, Type type, Type staticType, ScalarStyle scalarStyle)
		{
			Value = value;
			Type = type ?? throw new ArgumentNullException("type");
			StaticType = staticType ?? throw new ArgumentNullException("staticType");
			ScalarStyle = scalarStyle;
		}
	}
	internal delegate IObjectGraphTraversalStrategy ObjectGraphTraversalStrategyFactory(ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion);
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class PropertyDescriptor : IPropertyDescriptor
	{
		private readonly IPropertyDescriptor baseDescriptor;

		public string Name { get; set; }

		public Type Type => baseDescriptor.Type;

		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public Type TypeOverride
		{
			[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
			get
			{
				return baseDescriptor.TypeOverride;
			}
			[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
			set
			{
				baseDescriptor.TypeOverride = value;
			}
		}

		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, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object value)
		{
			baseDescriptor.Write(target, value);
		}

		public T GetCustomAttribute<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] T>() where T : Attribute
		{
			return baseDescriptor.GetCustomAttribute<T>();
		}

		public IObjectDescriptor Read(object target)
		{
			return baseDescriptor.Read(target);
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal 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 void Serialize(TextWriter writer, object graph)
		{
			Serialize(new Emitter(writer, emitterSettings), graph);
		}

		public string Serialize(object graph)
		{
			using StringWriter stringWriter = new StringWriter();
			Serialize(stringWriter, graph);
			return stringWriter.ToString();
		}

		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, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] 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());
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 0, 1 })]
	internal sealed class SerializerBuilder : BuilderSkeleton<SerializerBuilder>
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
		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;
			}

			[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
			public void SerializeValue([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)] IEmitter emitter, object value, Type type)
			{
				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));
				}
				IObjectGraphVisitor<IEmitter> visitor = emissionPhaseObjectGraphVisitorFactories.BuildComponentChain(new EmittingObjectGraphVisitor(eventEmitter), [<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] (IObjectGraphVisitor<IEmitter> inner) => new EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
				traversalStrategy.Traverse(graph, visitor, emitter);
				[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
				void NestedObjectSerializer(object v, Type t)
				{
					SerializeValue(emitter, 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 IDictionary<Type, TagName> tagMappings = new Dictionary<Type, TagName>();

		private int maximumRecursion = 50;

		private EmitterSettings emitterSettings = EmitterSettings.Default;

		private DefaultValuesHandling defaultValuesHandlingConfiguration;

		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)
				},
				{
					typeof(CommentsObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new CommentsObjectGraphVisitor(args.InnerVisitor)
				}
			};
			eventEmitterFactories = new LazyComponentRegistrationList<IEventEmitter, IEventEmitter> { 
			{
				typeof(TypeAssigningEventEmitter),
				(IEventEmitter inner) => new TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: false, tagMappings)
			} };
			objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new FullObjectGraphTraversalStrategy(typeInspector, typeResolver, maximumRecursion, namingConvention);
		}

		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<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithEventEmitter<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			if (eventEmitterFactory == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter inner) => eventEmitterFactory(inner)));
			return Self;
		}

		public SerializerBuilder WithEventEmitter<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] TEventEmitter>(WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			if (eventEmitterFactory == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateTrackingRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter wrapped, IEventEmitter inner) => eventEmitterFactory(wrapped, inner)));
			return Self;
		}

		public SerializerBuilder WithoutEventEmitter<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] 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);
			WithEventEmitter([<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] ([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)] IEventEmitter inner) => new TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: true, tagMappings), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
			return WithTypeInspector([<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] ([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)] 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();
			return WithTypeConverter(new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: true), delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.InsteadOf<YamlDotNet.Serialization.Converters.GuidConverter>();
			}).WithEventEmitter([<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] ([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)] IEventEmitter inner) => new JsonEventEmitter(inner), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			if (objectGraphVisitor == null)
			{
				throw new ArgumentNullException("objectGraphVisitor");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> _) => objectGraphVisitor));
			return this;
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] TObjectGraphVisitor>(WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> _) => objectGraphVisitorFactory(wrapped)));
			return this;
		}

		public SerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] 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<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(args)));
			return this;
		}

		public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] TObjectGraphVisitor>(WrapperFactory<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<IEmitter> wrapped, EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(wrapped, args)));
			return this;
		}

		public SerializerBuilder WithoutEmissionPhaseObjectGraphVisitor<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] 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()
		{
			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());
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal 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);
			}
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class TagMappings
	{
		private readonly IDictionary<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);
		}

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		internal Type GetMapping(string tag)
		{
			if (!mappings.TryGetValue(tag, out var value))
			{
				return null;
			}
			return value;
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class YamlAttributeOverrides
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
		private struct AttributeKey
		{
			public readonly Type AttributeType;

			public readonly string PropertyName;

			public AttributeKey(Type attributeType, string propertyName)
			{
				AttributeType = attributeType;
				PropertyName = propertyName;
			}

			[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
			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());
			}
		}

		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
		private sealed class AttributeMapping
		{
			public readonly Type RegisteredType;

			public readonly Attribute Attribute;

			public AttributeMapping(Type registeredType, Attribute attribute)
			{
				RegisteredType = registeredType;
				Attribute = attribute;
			}

			[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
			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 = ReflectionExtensions.BaseType(type);
				}
				if (matchType.GetInterfaces().Contains(RegisteredType))
				{
					return num;
				}
				return 0;
			}
		}

		private readonly Dictionary<AttributeKey, List<AttributeMapping>> overrides = new Dictionary<AttributeKey, List<AttributeMapping>>();

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public T GetAttribute<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] T>(Type type, string member) where T : Attribute
		{
			if (overrides.TryGetValue(new AttributeKey(typeof(T), member), out var 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 var 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<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
		{
			PropertyInfo propertyInfo = ExpressionExtensions.AsProperty(propertyAccessor);
			Add(typeof(TClass), propertyInfo.Name, attribute);
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class YamlAttributeOverridesInspector : TypeInspectorSkeleton
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
		public sealed class OverridePropertyDescriptor : IPropertyDescriptor
		{
			private readonly IPropertyDescriptor baseDescriptor;

			private readonly YamlAttributeOverrides overrides;

			private readonly Type classType;

			public string Name => baseDescriptor.Name;

			public bool CanWrite => baseDescriptor.CanWrite;

			public Type Type => baseDescriptor.Type;

			[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
			public Type TypeOverride
			{
				[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
				get
				{
					return baseDescriptor.TypeOverride;
				}
				[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
				set
				{
					baseDescriptor.TypeOverride = value;
				}
			}

			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, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object value)
			{
				baseDescriptor.Write(target, value);
			}

			public T GetCustomAttribute<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] T>() where T : Attribute
			{
				return overrides.GetAttribute<T>(classType, Name) ?? 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, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object container)
		{
			IEnumerable<IPropertyDescriptor> enumerable = innerTypeDescriptor.GetProperties(type, container);
			if (overrides != null)
			{
				enumerable = enumerable.Select((Func<IPropertyDescriptor, IPropertyDescriptor>)([<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] (IPropertyDescriptor p) => new OverridePropertyDescriptor(p, overrides, type)));
			}
			return enumerable;
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal sealed class YamlAttributesTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

		public YamlAttributesTypeInspector(ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor;
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object container)
		{
			return from p in (from p in innerTypeDescriptor.GetProperties(type, container)
					where p.GetCustomAttribute<YamlIgnoreAttribute>() == null
					select p).Select((Func<IPropertyDescriptor, IPropertyDescriptor>)([<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] (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;
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal static class YamlFormatter
	{
		public static readonly NumberFormatInfo NumberFormat = 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 static string FormatNumber(object number)
		{
			return Convert.ToString(number, NumberFormat);
		}

		public static string FormatNumber(double number)
		{
			return number.ToString("G17", NumberFormat);
		}

		public static string FormatNumber(float number)
		{
			return number.ToString("G17", NumberFormat);
		}

		public static string FormatBoolean(object boolean)
		{
			if (!boolean.Equals(true))
			{
				return "false";
			}
			return "true";
		}

		public static string FormatDateTime(object dateTime)
		{
			return ((DateTime)dateTime).ToString("o", CultureInfo.InvariantCulture);
		}

		public static string FormatTimeSpan(object timeSpan)
		{
			return ((TimeSpan)timeSpan).ToString();
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	internal sealed class YamlIgnoreAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
	internal 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;
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public YamlMemberAttribute(Type serializeAs)
			: this()
		{
			SerializeAs = serializeAs ?? throw new ArgumentNullException("serializeAs");
		}
	}
}
namespace YamlDotNet.Serialization.ValueDeserializers
{
	internal sealed class AliasValueDeserializer : IValueDeserializer
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 0, 1 })]
		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;
						throw new AnchorNotFoundException(alias.Start, alias.End, $"Anchor '{alias.Value}' not found");
					}
				}
			}
		}

		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
		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;

			[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
			public ValuePromise(YamlDotNet.Core.Events.AnchorAlias alias)
			{
				Alias = alias;
			}

			public ValuePromise(object value)
			{
				HasValue = true;
				this.value = value;
			}
		}

		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)]
		private readonly IValueDeserializer innerDeserializer;

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public AliasValueDeserializer(IValueDeserializer innerDeserializer)
		{
			this.innerDeserializer = innerDeserializer ?? throw new ArgumentNullException("innerDeserializer");
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public object DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
		{
			if (parser.TryConsume<YamlDotNet.Core.Events.AnchorAlias>(out var @event))
			{
				if (!state.Get<AliasState>().TryGetValue(@event.Value, out var value))
				{
					throw new AnchorNotFoundException(@event.Start, @event.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 aliasState = state.Get<AliasState>();
				if (!aliasState.ContainsKey(anchorName))
				{
					aliasState[anchorName] = new ValuePromise(new YamlDotNet.Core.Events.AnchorAlias(anchorName));
				}
			}
			object obj = innerDeserializer.DeserializeValue(parser, expectedType, state, nestedObjectDeserializer);
			if (!anchorName.IsEmpty)
			{
				AliasState aliasState2 = state.Get<AliasState>();
				if (!aliasState2.TryGetValue(anchorName, out var value2))
				{
					aliasState2.Add(anchorName, new ValuePromise(obj));
				}
				else if (!value2.HasValue)
				{
					value2.Value = obj;
				}
				else
				{
					aliasState2[anchorName] = new ValuePromise(obj);
				}
			}
			return obj;
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal sealed class NodeValueDeserializer : IValueDeserializer
	{
		private readonly IList<INodeDeserializer> deserializers;

		private readonly IList<INodeTypeResolver> typeResolvers;

		public NodeValueDeserializer(IList<INodeDeserializer> deserializers, IList<INodeTypeResolver> typeResolvers)
		{
			this.deserializers = deserializers ?? throw new ArgumentNullException("deserializers");
			this.typeResolvers = typeResolvers ?? throw new ArgumentNullException("typeResolvers");
		}

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public object DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
		{
			parser.Accept<NodeEvent>(out var @event);
			Type typeFromEvent = GetTypeFromEvent(@event, expectedType);
			try
			{
				foreach (INodeDeserializer deserializer in deserializers)
				{
					if (deserializer.Deserialize(parser, typeFromEvent, [return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] (IParser r, Type t) => nestedObjectDeserializer.DeserializeValue(r, t, state, nestedObjectDeserializer), out var value))
					{
						return YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(value, expectedType);
					}
				}
			}
			catch (YamlException)
			{
				throw;
			}
			catch (Exception innerException)
			{
				throw new YamlException(@event?.Start ?? Mark.Empty, @event?.End ?? Mark.Empty, "Exception during deserialization", innerException);
			}
			throw new YamlException(@event?.Start ?? Mark.Empty, @event?.End ?? Mark.Empty, "No node deserializer was able to deserialize the node into type " + expectedType.AssemblyQualifiedName);
		}

		private Type GetTypeFromEvent([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] NodeEvent nodeEvent, Type currentType)
		{
			using (IEnumerator<INodeTypeResolver> enumerator = typeResolvers.GetEnumerator())
			{
				while (enumerator.MoveNext() && !enumerator.Current.Resolve(nodeEvent, ref currentType))
				{
				}
			}
			return currentType;
		}
	}
}
namespace YamlDotNet.Serialization.Utilities
{
	internal interface IPostDeserializationCallback
	{
		void OnDeserialization();
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class ObjectAnchorCollection
	{
		private readonly IDictionary<string, object> objectsByAnchor = new Dictionary<string, object>();

		private readonly IDictionary<object, string> anchorsByObject = new Dictionary<object, string>();

		public object this[string anchor]
		{
			get
			{
				if (objectsByAnchor.TryGetValue(anchor, out var 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, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)][MaybeNullWhen(false)] out string anchor)
		{
			return anchorsByObject.TryGetValue(@object, out anchor);
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal static class ReflectionUtility
	{
		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public static Type GetImplementedGenericInterface(Type type, Type genericInterfaceType)
		{
			foreach (Type implementedInterface in GetImplementedInterfaces(type))
			{
				if (ReflectionExtensions.IsGenericType(implementedInterface) && implementedInterface.GetGenericTypeDefinition() == genericInterfaceType)
				{
					return implementedInterface;
				}
			}
			return null;
		}

		public static IEnumerable<Type> GetImplementedInterfaces(Type type)
		{
			if (ReflectionExtensions.IsInterface(type))
			{
				yield return type;
			}
			Type[] interfaces = type.GetInterfaces();
			for (int i = 0; i < interfaces.Length; i++)
			{
				yield return interfaces[i];
			}
		}
	}
	internal sealed class SerializerState : IDisposable
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)]
		private readonly IDictionary<Type, object> items = new Dictionary<Type, object>();

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public T Get<T>() where T : class, new()
		{
			if (!items.TryGetValue(typeof(T), out var 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();
			}
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal static class StringExtensions
	{
		private static string ToCamelOrPascalCase(string str, Func<char, char> firstLetterTransform)
		{
			string text = Regex.Replace(str, "([_\\-])(?<char>[a-z])", [<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] (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)
		{
			str = char.ToLower(str[0]) + str.Substring(1);
			str = Regex.Replace(ToCamelCase(str), "(?<char>[A-Z])", [<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] (Match match) => separator + match.Groups["char"].Value.ToLowerInvariant());
			return str;
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal static class TypeConverter
	{
		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)]
		public static T ChangeType<T>(object value)
		{
			return (T)ChangeType(value, typeof(T));
		}

		public static T ChangeType<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] T>([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object value, IFormatProvider provider)
		{
			return (T)ChangeType(value, typeof(T), provider);
		}

		public static T ChangeType<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] T>([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object value, CultureInfo culture)
		{
			return (T)ChangeType(value, typeof(T), culture);
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
		public static object ChangeType(object value, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)] Type destinationType)
		{
			return ChangeType(value, destinationType, CultureInfo.InvariantCulture);
		}

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public static object ChangeType([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object value, Type destinationType, IFormatProvider provider)
		{
			return ChangeType(value, destinationType, new CultureInfoAdapter(CultureInfo.CurrentCulture, provider));
		}

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public static object ChangeType([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object value, Type destinationType, CultureInfo culture)
		{
			if (value == null || ReflectionExtensions.IsDbNull(value))
			{
				if (!ReflectionExtensions.IsValueType(destinationType))
				{
					return null;
				}
				return Activator.CreateInstance(destinationType);
			}
			Type type = value.GetType();
			if (destinationType == type || destinationType.IsAssignableFrom(type))
			{
				return value;
			}
			if (ReflectionExtensions.IsGenericType(destinationType) && destinationType.GetGenericTypeDefinition() == typeof(Nullable<>))
			{
				Type destinationType2 = destinationType.GetGenericArguments()[0];
				object obj = ChangeType(value, destinationType2, culture);
				return Activator.CreateInstance(destinationType, obj);
			}
			if (ReflectionExtensions.IsEnum(destinationType))
			{
				if (!(value is string value2))
				{
					return value;
				}
				return Enum.Parse(destinationType, value2, ignoreCase: true);
			}
			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 };
			for (int i = 0; i < array.Length; i++)
			{
				foreach (MethodInfo publicStaticMethod2 in ReflectionExtensions.GetPublicStaticMethods(array[i]))
				{
					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 ReflectionExtensions.Unwrap(ex);
						}
					}
				}
			}
			if (type == typeof(string))
			{
				try
				{
					MethodInfo publicStaticMethod = ReflectionExtensions.GetPublicStaticMethod(destinationType, "Parse", typeof(string), typeof(IFormatProvider));
					if (publicStaticMethod != null)
					{
						return publicStaticMethod.Invoke(null, new object[2] { value, culture });
					}
					publicStaticMethod = ReflectionExtensions.GetPublicStaticMethod(destinationType, "Parse", typeof(string));
					if (publicStaticMethod != null)
					{
						return publicStaticMethod.Invoke(null, new object[1] { value });
					}
				}
				catch (TargetInvocationException ex2)
				{
					throw ReflectionExtensions.Unwrap(ex2);
				}
			}
			if (destinationType == typeof(TimeSpan))
			{
				return TimeSpan.Parse((string)ChangeType(value, typeof(string), CultureInfo.InvariantCulture));
			}
			return Convert.ChangeType(value, destinationType, CultureInfo.InvariantCulture);
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)]
		[PermissionSet(SecurityAction.LinkDemand, Name = "FullTrust")]
		public static void RegisterTypeConverter<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TConvertible, TConverter>() where TConverter : System.ComponentModel.TypeConverter
		{
			if (!TypeDescriptor.GetAttributes(typeof(TConvertible)).OfType<TypeConverterAttribute>().Any([<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] (TypeConverterAttribute a) => a.ConverterTypeName == typeof(TConverter).AssemblyQualifiedName))
			{
				TypeDescriptor.AddAttributes(typeof(TConvertible), new TypeConverterAttribute(typeof(TConverter)));
			}
		}
	}
}
namespace YamlDotNet.Serialization.TypeResolvers
{
	internal sealed class DynamicTypeResolver : ITypeResolver
	{
		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public Type Resolve(Type staticType, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object actualValue)
		{
			if (actualValue == null)
			{
				return staticType;
			}
			return actualValue.GetType();
		}
	}
	internal sealed class StaticTypeResolver : ITypeResolver
	{
		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public Type Resolve(Type staticType, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object actualValue)
		{
			return staticType;
		}
	}
}
namespace YamlDotNet.Serialization.TypeInspectors
{
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class CachedTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

		private readonly ConcurrentDictionary<Type, List<IPropertyDescriptor>> cache = new ConcurrentDictionary<Type, List<IPropertyDescriptor>>();

		public CachedTypeInspector(ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object container)
		{
			return cache.GetOrAdd(type, (Type t) => innerTypeDescriptor.GetProperties(t, container).ToList());
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal sealed 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 IEnumerable<IPropertyDescriptor> GetProperties(Type type, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object container)
		{
			return typeInspectors.SelectMany([<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] (ITypeInspector i) => i.GetProperties(type, container));
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed 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 IEnumerable<IPropertyDescriptor> GetProperties(Type type, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object container)
		{
			return innerTypeDescriptor.GetProperties(type, container).Select([<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] (IPropertyDescriptor p) =>
			{
				YamlMemberAttribute customAttribute = p.GetCustomAttribute<YamlMemberAttribute>();
				return (customAttribute != null && !customAttribute.ApplyNamingConventions) ? p : new PropertyDescriptor(p)
				{
					Name = namingConvention.Apply(p.Name)
				};
			});
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class ReadableAndWritablePropertiesTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

		public ReadableAndWritablePropertiesTypeInspector(ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object container)
		{
			return from p in innerTypeDescriptor.GetProperties(type, container)
				where p.CanWrite
				select p;
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal sealed class ReadableFieldsTypeInspector : TypeInspectorSkeleton
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
		private sealed class ReflectionFieldDescriptor : IPropertyDescriptor
		{
			private readonly FieldInfo fieldInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => fieldInfo.Name;

			public Type Type => fieldInfo.FieldType;

			[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
			[field: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
			public Type TypeOverride
			{
				[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
				get;
				[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
				set;
			}

			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;
				ScalarStyle = ScalarStyle.Any;
			}

			public void Write(object target, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object value)
			{
				fieldInfo.SetValue(target, value);
			}

			public T GetCustomAttribute<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] T>() where T : Attribute
			{
				return (T)fieldInfo.GetCustomAttributes(typeof(T), inherit: true).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, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object container)
		{
			return ReflectionExtensions.GetPublicFields(type).Select((Func<FieldInfo, IPropertyDescriptor>)([<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] (FieldInfo p) => new ReflectionFieldDescriptor(p, typeResolver)));
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class ReadablePropertiesTypeInspector : TypeInspectorSkeleton
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
		private sealed class ReflectionPropertyDescriptor : IPropertyDescriptor
		{
			private readonly PropertyInfo propertyInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => propertyInfo.Name;

			public Type Type => propertyInfo.PropertyType;

			[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
			[field: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
			public Type TypeOverride
			{
				[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
				get;
				[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
				set;
			}

			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;
			}

			public void Write(object target, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object value)
			{
				propertyInfo.SetValue(target, value, null);
			}

			public T GetCustomAttribute<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] T>() where T : Attribute
			{
				return (T)ReflectionExtensions.GetAllCustomAttributes<T>(propertyInfo).FirstOrDefault();
			}

			public IObjectDescriptor Read(object target)
			{
				object obj = PropertyInfoExtensions.ReadValue(propertyInfo, 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, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object container)
		{
			return ReflectionExtensions.GetProperties(type, includeNonPublicProperties).Where(IsValidProperty).Select((Func<PropertyInfo, IPropertyDescriptor>)([<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] (PropertyInfo p) => new ReflectionPropertyDescriptor(p, typeResolver)));
		}
	}
	internal abstract class TypeInspectorSkeleton : ITypeInspector
	{
		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public abstract IEnumerable<IPropertyDescriptor> GetProperties(Type type, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object container);

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public IPropertyDescriptor GetProperty(Type type, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object container, string name, [MaybeNullWhen(true)] bool ignoreUnmatched)
		{
			IEnumerable<IPropertyDescriptor> enumerable = from p in GetProperties(type, container)
				where p.Name == name
				select p;
			using IEnumerator<IPropertyDescriptor> enumerator = enumerable.GetEnumerator();
			if (!enumerator.MoveNext())
			{
				if (ignoreUnmatched)
				{
					return null;
				}
				throw new SerializationException("Property '" + name + "' not found on type '" + type.FullName + "'.");
			}
			IPropertyDescriptor current = enumerator.Current;
			if (enumerator.MoveNext())
			{
				throw new SerializationException("Multiple properties with the name/alias '" + name + "' 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;
		}
	}
}
namespace YamlDotNet.Serialization.Schemas
{
	internal 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");
		}
	}
	internal 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");
		}
	}
	internal sealed class CoreSchema
	{
		public static class Tags
		{
		}
	}
	internal sealed class DefaultSchema
	{
		public static class Tags
		{
			public static readonly TagName Timestamp = new TagName("tag:yaml.org,2002:timestamp");
		}
	}
}
namespace YamlDotNet.Serialization.ObjectGraphVisitors
{
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class AnchorAssigner : PreProcessingPhaseObjectGraphVisitorSkeleton, IAliasProvider
	{
		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)]
		private class AnchorAssignment
		{
			public AnchorName Anchor;
		}

		private readonly IDictionary<object, AnchorAssignment> assignments = new Dictionary<object, AnchorAssignment>();

		private uint nextId;

		public AnchorAssigner(IEnumerable<IYamlTypeConverter> typeConverters)
			: base(typeConverters)
		{
		}

		protected override bool Enter(IObjectDescriptor value)
		{
			if (value.Value != null && assignments.TryGetValue(value.Value, out var 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)
		{
			return true;
		}

		protected override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value)
		{
			return true;
		}

		protected override void VisitScalar(IObjectDescriptor scalar)
		{
		}

		protected override void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType)
		{
			VisitObject(mapping);
		}

		protected override void VisitMappingEnd(IObjectDescriptor mapping)
		{
		}

		protected override void VisitSequenceStart(IObjectDescriptor sequence, Type elementType)
		{
			VisitObject(sequence);
		}

		protected override void VisitSequenceEnd(IObjectDescriptor sequence)
		{
		}

		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 var value))
			{
				return value.Anchor;
			}
			return AnchorName.Empty;
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal 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(IObjectDescriptor value, IEmitter context)
		{
			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(value, context);
		}

		public override void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context)
		{
			AnchorName alias = aliasProvider.GetAlias(mapping.NonNullValue());
			eventEmitter.Emit(new MappingStartEventInfo(mapping)
			{
				Anchor = alias
			}, context);
		}

		public override void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context)
		{
			AnchorName alias = aliasProvider.GetAlias(sequence.NonNullValue());
			eventEmitter.Emit(new SequenceStartEventInfo(sequence)
			{
				Anchor = alias
			}, context);
		}

		public override void VisitScalar(IObjectDescriptor scalar, IEmitter context)
		{
			ScalarEventInfo scalarEventInfo = new ScalarEventInfo(scalar);
			if (scalar.Value != null)
			{
				scalarEventInfo.Anchor = aliasProvider.GetAlias(scalar.Value);
			}
			eventEmitter.Emit(scalarEventInfo, context);
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal abstract class ChainedObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
	{
		private readonly IObjectGraphVisitor<IEmitter> nextVisitor;

		protected ChainedObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
		{
			this.nextVisitor = nextVisitor;
		}

		public virtual bool Enter(IObjectDescriptor value, IEmitter context)
		{
			return nextVisitor.Enter(value, context);
		}

		public virtual bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context)
		{
			return nextVisitor.EnterMapping(key, value, context);
		}

		public virtual bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context)
		{
			return nextVisitor.EnterMapping(key, value, context);
		}

		public virtual void VisitScalar(IObjectDescriptor scalar, IEmitter context)
		{
			nextVisitor.VisitScalar(scalar, context);
		}

		public virtual void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context)
		{
			nextVisitor.VisitMappingStart(mapping, keyType, valueType, context);
		}

		public virtual void VisitMappingEnd(IObjectDescriptor mapping, IEmitter context)
		{
			nextVisitor.VisitMappingEnd(mapping, context);
		}

		public virtual void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context)
		{
			nextVisitor.VisitSequenceStart(sequence, elementType, context);
		}

		public virtual void VisitSequenceEnd(IObjectDescriptor sequence, IEmitter context)
		{
			nextVisitor.VisitSequenceEnd(sequence, context);
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal sealed class CommentsObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		public CommentsObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context)
		{
			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);
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class CustomSerializationObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		private readonly IEnumerable<IYamlTypeConverter> typeConverters;

		private readonly ObjectSerializer nestedObjectSerializer;

		public CustomSerializationObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor, IEnumerable<IYamlTypeConverter> typeConverters, ObjectSerializer nestedObjectSerializer)
			: base(nextVisitor)
		{
			IEnumerable<IYamlTypeConverter> enumerable;
			if (typeConverters == null)
			{
				enumerable = Enumerable.Empty<IYamlTypeConverter>();
			}
			else
			{
				IEnumerable<IYamlTypeConverter> enumerable2 = typeConverters.ToList();
				enumerable = enumerable2;
			}
			this.typeConverters = enumerable;
			this.nestedObjectSerializer = nestedObjectSerializer;
		}

		public override bool Enter(IObjectDescriptor value, IEmitter context)
		{
			IYamlTypeConverter yamlTypeConverter = typeConverters.FirstOrDefault([<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] (IYamlTypeConverter t) => t.Accepts(value.Type));
			if (yamlTypeConverter != null)
			{
				yamlTypeConverter.WriteYaml(context, value.Value, value.Type);
				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(value, context);
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal sealed class DefaultExclusiveObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		public DefaultExclusiveObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		private static object GetDefault(Type type)
		{
			if (!ReflectionExtensions.IsValueType(type))
			{
				return null;
			}
			return Activator.CreateInstance(type);
		}

		public override bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context)
		{
			if (!object.Equals(value.Value, GetDefault(value.Type)))
			{
				return base.EnterMapping(key, value, context);
			}
			return false;
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context)
		{
			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);
			}
			return false;
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal sealed class DefaultValuesObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		private readonly DefaultValuesHandling handling;

		public DefaultValuesObjectGraphVisitor(DefaultValuesHandling handling, IObjectGraphVisitor<IEmitter> nextVisitor)
			: base(nextVisitor)
		{
			this.handling = handling;
		}

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		private static object GetDefault(Type type)
		{
			if (!ReflectionExtensions.IsValueType(type))
			{
				return null;
			}
			return Activator.CreateInstance(type);
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context)
		{
			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);
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class EmittingObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
	{
		private readonly IEventEmitter eventEmitter;

		public EmittingObjectGraphVisitor(IEventEmitter eventEmitter)
		{
			this.eventEmitter = eventEmitter;
		}

		bool IObjectGraphVisitor<IEmitter>.Enter(IObjectDescriptor value, IEmitter context)
		{
			return true;
		}

		bool IObjectGraphVisitor<IEmitter>.EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context)
		{
			return true;
		}

		bool IObjectGraphVisitor<IEmitter>.EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context)
		{
			return true;
		}

		void IObjectGraphVisitor<IEmitter>.VisitScalar(IObjectDescriptor scalar, IEmitter context)
		{
			eventEmitter.Emit(new ScalarEventInfo(scalar), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context)
		{
			eventEmitter.Emit(new MappingStartEventInfo(mapping), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitMappingEnd(IObjectDescriptor mapping, IEmitter context)
		{
			eventEmitter.Emit(new MappingEndEventInfo(mapping), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context)
		{
			eventEmitter.Emit(new SequenceStartEventInfo(sequence), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitSequenceEnd(IObjectDescriptor sequence, IEmitter context)
		{
			eventEmitter.Emit(new SequenceEndEventInfo(sequence), context);
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal abstract class PreProcessingPhaseObjectGraphVisitorSkeleton : IObjectGraphVisitor<Nothing>
	{
		protected readonly IEnumerable<IYamlTypeConverter> typeConverters;

		public PreProcessingPhaseObjectGraphVisitorSkeleton(IEnumerable<IYamlTypeConverter> typeConverters)
		{
			IEnumerable<IYamlTypeConverter> enumerable;
			if (typeConverters == null)
			{
				enumerable = Enumerable.Empty<IYamlTypeConverter>();
			}
			else
			{
				IEnumerable<IYamlTypeConverter> enumerable2 = typeConverters.ToList();
				enumerable = enumerable2;
			}
			this.typeConverters = enumerable;
		}

		bool IObjectGraphVisitor<Nothing>.Enter(IObjectDescriptor value, Nothing context)
		{
			if (typeConverters.FirstOrDefault([<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] (IYamlTypeConverter t) => t.Accepts(value.Type)) != null)
			{
				return false;
			}
			if (value.Value is IYamlConvertible)
			{
				return false;
			}
			if (value.Value is IYamlSerializable)
			{
				return false;
			}
			return Enter(value);
		}

		bool IObjectGraphVisitor<Nothing>.EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, Nothing context)
		{
			return EnterMapping(key, value);
		}

		bool IObjectGraphVisitor<Nothing>.EnterMapping(IObjectDescriptor key, IObjectDescriptor value, Nothing context)
		{
			return EnterMapping(key, value);
		}

		void IObjectGraphVisitor<Nothing>.VisitMappingEnd(IObjectDescriptor mapping, Nothing context)
		{
			VisitMappingEnd(mapping);
		}

		void IObjectGraphVisitor<Nothing>.VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, Nothing context)
		{
			VisitMappingStart(mapping, keyType, valueType);
		}

		void IObjectGraphVisitor<Nothing>.VisitScalar(IObjectDescriptor scalar, Nothing context)
		{
			VisitScalar(scalar);
		}

		void IObjectGraphVisitor<Nothing>.VisitSequenceEnd(IObjectDescriptor sequence, Nothing context)
		{
			VisitSequenceEnd(sequence);
		}

		void IObjectGraphVisitor<Nothing>.VisitSequenceStart(IObjectDescriptor sequence, Type elementType, Nothing context)
		{
			VisitSequenceStart(sequence, elementType);
		}

		protected abstract bool Enter(IObjectDescriptor value);

		protected abstract bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value);

		protected abstract bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value);

		protected abstract void VisitMappingEnd(IObjectDescriptor mapping);

		protected abstract void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType);

		protected abstract void VisitScalar(IObjectDescriptor scalar);

		protected abstract void VisitSequenceEnd(IObjectDescriptor sequence);

		protected abstract void VisitSequenceStart(IObjectDescriptor sequence, Type elementType);
	}
}
namespace YamlDotNet.Serialization.ObjectGraphTraversalStrategies
{
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal class FullObjectGraphTraversalStrategy : IObjectGraphTraversalStrategy
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
		protected 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;

		public FullObjectGraphTraversalStrategy(ITypeInspector typeDescriptor, ITypeResolver typeResolver, int maxRecursion, INamingConvention namingConvention)
		{
			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");
		}

		void IObjectGraphTraversalStrategy.Traverse<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context)
		{
			Traverse("<root>", graph, visitor, context, new Stack<ObjectPathSegment>(maxRecursion));
		}

		protected virtual void Traverse<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TContext>(object name, IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
		{
			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 = YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType<string>(item.Name);
					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(value, context))
			{
				return;
			}
			path.Push(new ObjectPathSegment(name, value));
			try
			{
				TypeCode typeCode = ReflectionExtensions.GetTypeCode(value.Type);
				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);
					return;
				case TypeCode.Empty:
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
				if (ReflectionExtensions.IsDbNull(value))
				{
					visitor.VisitScalar(new ObjectDescriptor(null, typeof(object), typeof(object)), context);
				}
				if (value.Value == null || value.Type == typeof(TimeSpan))
				{
					visitor.VisitScalar(value, context);
					return;
				}
				Type underlyingType = Nullable.GetUnderlyingType(value.Type);
				if (underlyingType != null)
				{
					Traverse("Value", new ObjectDescriptor(value.Value, underlyingType, value.Type, value.ScalarStyle), visitor, context, path);
				}
				else
				{
					TraverseObject(value, visitor, context, path);
				}
			}
			finally
			{
				path.Pop();
			}
		}

		protected virtual void TraverseObject<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
		{
			if (typeof(IDictionary).IsAssignableFrom(value.Type))
			{
				TraverseDictionary(value, visitor, typeof(object), typeof(object), context, path);
				return;
			}
			Type implementedGenericInterface = ReflectionUtility.GetImplementedGenericInterface(value.Type, typeof(IDictionary<, >));
			if (implementedGenericInterface != null)
			{
				Type[] genericArguments = implementedGenericInterface.GetGenericArguments();
				object value2 = Activator.CreateInstance(typeof(GenericDictionaryToNonGenericAdapter<, >).MakeGenericType(genericArguments), value.Value);
				TraverseDictionary(new ObjectDescriptor(value2, value.Type, value.StaticType, value.ScalarStyle), visitor, genericArguments[0], genericArguments[1], context, path);
			}
			else if (typeof(IEnumerable).IsAssignableFrom(value.Type))
			{
				TraverseList(value, visitor, context, path);
			}
			else
			{
				TraverseProperties(value, visitor, context, path);
			}
		}

		protected virtual void TraverseDictionary<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TContext>(IObjectDescriptor dictionary, IObjectGraphVisitor<TContext> visitor, Type keyType, Type valueType, TContext context, Stack<ObjectPathSegment> path)
		{
			visitor.VisitMappingStart(dictionary, keyType, valueType, context);
			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);
				IObjectDescriptor objectDescriptor = GetObjectDescriptor(obj, keyType);
				IObjectDescriptor objectDescriptor2 = GetObjectDescriptor(value.Value, valueType);
				if (visitor.EnterMapping(objectDescriptor, objectDescriptor2, context))
				{
					Traverse(obj, objectDescriptor, visitor, context, path);
					Traverse(obj, objectDescriptor2, visitor, context, path);
				}
			}
			visitor.VisitMappingEnd(dictionary, context);
		}

		private void TraverseList<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
		{
			Type implementedGenericInterface = ReflectionUtility.GetImplementedGenericInterface(value.Type, typeof(IEnumerable<>));
			Type type = ((implementedGenericInterface != null) ? implementedGenericInterface.GetGenericArguments()[0] : typeof(object));
			visitor.VisitSequenceStart(value, type, context);
			int num = 0;
			foreach (object item in (IEnumerable)value.NonNullValue())
			{
				Traverse(num, GetObjectDescriptor(item, type), visitor, context, path);
				num++;
			}
			visitor.VisitSequenceEnd(value, context);
		}

		protected virtual void TraverseProperties<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
		{
			visitor.VisitMappingStart(value, typeof(string), typeof(object), context);
			object obj = value.NonNullValue();
			foreach (IPropertyDescriptor property in typeDescriptor.GetProperties(value.Type, obj))
			{
				IObjectDescriptor value2 = property.Read(obj);
				if (visitor.EnterMapping(property, value2, context))
				{
					Traverse(property.Name, new ObjectDescriptor(property.Name, typeof(string), typeof(string)), visitor, context, path);
					Traverse(property.Name, value2, visitor, context, path);
				}
			}
			visitor.VisitMappingEnd(value, context);
		}

		private IObjectDescriptor GetObjectDescriptor([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object value, Type staticType)
		{
			return new ObjectDescriptor(value, typeResolver.Resolve(staticType, value), staticType);
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal class RoundtripObjectGraphTraversalStrategy : FullObjectGraphTraversalStrategy
	{
		private readonly IEnumerable<IYamlTypeConverter> converters;

		public RoundtripObjectGraphTraversalStrategy(IEnumerable<IYamlTypeConverter> converters, ITypeInspector typeDescriptor, ITypeResolver typeResolver, int maxRecursion, INamingConvention namingConvention)
			: base(typeDescriptor, typeResolver, maxRecursion, namingConvention)
		{
			this.converters = converters;
		}

		protected override void TraverseProperties<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
		{
			if (!ReflectionExtensions.HasDefaultConstructor(value.Type) && !converters.Any([<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] (IYamlTypeConverter c) => c.Accepts(value.Type)))
			{
				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);
		}
	}
}
namespace YamlDotNet.Serialization.ObjectFactories
{
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal sealed class DefaultObjectFactory : IObjectFactory
	{
		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>)
			}
		};

		public DefaultObjectFactory()
		{
		}

		public DefaultObjectFactory(IDictionary<Type, Type> 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}'.");
				}
				DefaultNonGenericInterfaceImplementations.Add(mapping.Key, mapping.Value);
			}
		}

		public object Create(Type type)
		{
			if (ReflectionExtensions.IsInterface(type))
			{
				Type value2;
				if (ReflectionExtensions.IsGenericType(type))
				{
					if (DefaultGenericInterfaceImplementations.TryGetValue(type.GetGenericTypeDefinition(), out var value))
					{
						type = value.MakeGenericType(type.GetGenericArguments());
					}
				}
				else if (DefaultNonGenericInterfaceImplementations.TryGetValue(type, out value2))
				{
					type = value2;
				}
			}
			try
			{
				return Activator.CreateInstance(type);
			}
			catch (Exception innerException)
			{
				throw new InvalidOperationException("Failed to create an instance of type '" + type.FullName + "'.", innerException);
			}
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal sealed class LambdaObjectFactory : IObjectFactory
	{
		private readonly Func<Type, object> factory;

		public LambdaObjectFactory(Func<Type, object> factory)
		{
			this.factory = factory ?? throw new ArgumentNullException("factory");
		}

		public object Create(Type type)
		{
			return factory(type);
		}
	}
}
namespace YamlDotNet.Serialization.NodeTypeResolvers
{
	internal sealed class DefaultContainersNodeTypeResolver : INodeTypeResolver
	{
		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		bool INodeTypeResolver.Resolve([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] 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;
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal 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}'.");
				}
			}
			_mappings = mappings;
		}

		public bool Resolve([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] NodeEvent nodeEvent, ref Type currentType)
		{
			if (_mappings.TryGetValue(currentType, out var value))
			{
				currentType = value;
				return true;
			}
			return false;
		}
	}
	internal class PreventUnknownTagsNodeTypeResolver : INodeTypeResolver
	{
		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		bool INodeTypeResolver.Resolve([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] NodeEvent nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty)
			{
				throw new YamlException(nodeEvent.Start, nodeEvent.End, $"Encountered an unresolved tag '{nodeEvent.Tag}'");
			}
			return false;
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal 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([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] NodeEvent nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty && tagMappings.TryGetValue(nodeEvent.Tag, out var 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.")]
	internal sealed class TypeNameInTagNodeTypeResolver : INodeTypeResolver
	{
		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		bool INodeTypeResolver.Resolve([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] 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;
		}
	}
	internal sealed class YamlConvertibleTypeResolver : INodeTypeResolver
	{
		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public bool Resolve([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] NodeEvent nodeEvent, ref Type currentType)
		{
			return typeof(IYamlConvertible).IsAssignableFrom(currentType);
		}
	}
	internal sealed class YamlSerializableTypeResolver : INodeTypeResolver
	{
		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public bool Resolve([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] NodeEvent nodeEvent, ref Type currentType)
		{
			return typeof(IYamlSerializable).IsAssignableFrom(currentType);
		}
	}
}
namespace YamlDotNet.Serialization.NodeDeserializers
{
	internal sealed class ArrayNodeDeserializer : INodeDeserializer
	{
		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
		private sealed class ArrayList : IList, ICollection, IEnumerable
		{
			[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 2 })]
			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;

			[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)]
			public object SyncRoot
			{
				[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
				get
				{
					return 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();
			}

			[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
			public void CopyTo(Array array, int index)
			{
				Array.Copy(data, 0, array, index, Count);
			}

			[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
			public IEnumerator GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return data[i];
					int num = i + 1;
					i = num;
				}
			}
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		bool INodeDeserializer.Deserialize(IParser parser, Type expectedType, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] out object value)
		{
			if (!expectedType.IsArray)
			{
				value = false;
				return false;
			}
			Type? elementType = expectedType.GetElementType();
			ArrayList arrayList = new ArrayList();
			CollectionNodeDeserializer.DeserializeHelper(elementType, parser, nestedObjectDeserializer, arrayList, canUpdate: true);
			Array array = Array.CreateInstance(elementType, arrayList.Count);
			arrayList.CopyTo(array, 0);
			value = array;
			return true;
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal sealed class CollectionNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public CollectionNodeDeserializer(IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		bool INodeDeserializer.Deserialize(IParser parser, Type expectedType, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] out object value)
		{
			bool canUpdate = true;
			Type implementedGenericInterface = ReflectionUtility.GetImplementedGenericInterface(expectedType, typeof(ICollection<>));
			Type type;
			IList list;
			if (implementedGenericInterface != null)
			{
				type = implementedGenericInterface.GetGenericArguments()[0];
				value = objectFactory.Create(expectedType);
				list = value as IList;
				if (list == null)
				{
					canUpdate = ReflectionUtility.GetImplementedGenericInterface(expectedType, typeof(IList<>)) != 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);
			return true;
		}

		internal static void DeserializeHelper(Type tItem, IParser parser, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, IList result, bool canUpdate)
		{
			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)
					{
						throw new ForwardAnchorNotSupportedException(current?.Start ?? Mark.Empty, current?.End ?? Mark.Empty, "Forward alias references are not allowed because this type does not implement IList<>");
					}
					int index = result.Add(ReflectionExtensions.IsValueType(tItem) ? Activator.CreateInstance(tItem) : null);
					valuePromise.ValueAvailable += [<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)] (object v) =>
					{
						result[index] = YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(v, tItem);
					};
				}
				else
				{
					result.Add(YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(obj, tItem));
				}
			}
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal sealed class DictionaryNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public DictionaryNodeDeserializer(IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		bool INodeDeserializer.Deserialize(IParser parser, Type expectedType, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] out object value)
		{
			Type implementedGenericInterface = ReflectionUtility.GetImplementedGenericInterface(expectedType, typeof(IDictionary<, >));
			Type type;
			Type type2;
			IDictionary dictionary;
			if (implementedGenericInterface != null)
			{
				Type[] genericArguments = implementedGenericInterface.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;
			}
			DeserializeHelper(type, type2, parser, nestedObjectDeserializer, dictionary);
			return true;
		}

		private static void DeserializeHelper(Type tKey, Type tValue, IParser parser, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, IDictionary result)
		{
			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 += [<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)] (object v) =>
						{
							result[v] = value;
						};
						continue;
					}
					bool hasFirstPart = false;
					valuePromise2.ValueAvailable += [<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)] (object v) =>
					{
						if (hasFirstPart)
						{
							result[v] = value;
						}
						else
						{
							key = v;
							hasFirstPart = true;
						}
					};
					valuePromise.ValueAvailable += [<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)] (object v) =>
					{
						if (hasFirstPart)
						{
							result[key] = v;
						}
						else
						{
							value = v;
							hasFirstPart = true;
						}
					};
				}
				else if (valuePromise == null)
				{
					result[key] = value;
				}
				else
				{
					valuePromise.ValueAvailable += [<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)] (object v) =>
					{
						result[key] = v;
					};
				}
			}
		}
	}
	internal sealed class EnumerableNodeDeserializer : INodeDeserializer
	{
		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		bool INodeDeserializer.Deserialize(IParser parser, Type expectedType, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] out object value)
		{
			Type type;
			if (expectedType == typeof(IEnumerable))
			{
				type = typeof(object);
			}
			else
			{
				Type implementedGenericInterface = ReflectionUtility.GetImplementedGenericInterface(expectedType, typeof(IEnumerable<>));
				if (implementedGenericInterface != expectedType)
				{
					value = null;
					return false;
				}
				type = implementedGenericInterface.GetGenericArguments()[0];
			}
			Type arg = typeof(List<>).MakeGenericType(type);
			value = nestedObjectDeserializer(parser, arg);
			return true;
		}
	}
	internal sealed class NullNodeDeserializer : INodeDeserializer
	{
		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		bool INodeDeserializer.Deserialize(IParser parser, Type expectedType, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] out object value)
		{
			value = null;
			if (parser.Accept<NodeEvent>(out var @event) && NodeIsNull(@event))
			{
				parser.SkipThisAndNestedEvents();
				return true;
			}
			return false;
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		private 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)
			{
				string value = scalar.Value;
				switch (value)
				{
				default:
					return value == "NULL";
				case "":
				case "~":
				case "null":
				case "Null":
					return true;
				}
			}
			return false;
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal sealed class ObjectNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		private readonly ITypeInspector typeDescriptor;

		private readonly bool ignoreUnmatched;

		public ObjectNodeDeserializer(IObjectFactory objectFactory, ITypeInspector typeDescriptor, bool ignoreUnmatched)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
			this.typeDescriptor = typeDescriptor ?? throw new ArgumentNullException("typeDescriptor");
			this.ignoreUnmatched = ignoreUnmatched;
		}

		bool INodeDeserializer.Deserialize(IParser parser, Type expectedType, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] out object value)
		{
			if (!parser.TryConsume<MappingStart>(out var _))
			{
				value = null;
				return false;
			}
			Type type = Nullable.GetUnderlyingType(expectedType) ?? expectedType;
			value = objectFactory.Create(type);
			MappingEnd event2;
			while (!parser.TryConsume<MappingEnd>(out event2))
			{
				YamlDotNet.Core.Events.Scalar scalar = parser.Consume<YamlDotNet.Core.Events.Scalar>();
				IPropertyDescriptor property = typeDescriptor.GetProperty(type, null, scalar.Value, ignoreUnmatched);
				if (property == null)
				{
					parser.SkipThisAndNestedEvents();
					continue;
				}
				object obj = nestedObjectDeserializer(parser, property.Type);
				if (obj is IValuePromise valuePromise)
				{
					object valueRef = value;
					valuePromise.ValueAvailable += [<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)] (object v) =>
					{
						object value3 = YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(v, property.Type);
						property.Write(valueRef, value3);
					};
				}
				else
				{
					object value2 = YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(obj, property.Type);
					property.Write(value, value2);
				}
			}
			return true;
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal sealed class ScalarNodeDeserializer : INodeDeserializer
	{
		private const string BooleanTruePattern = "^(true|y|yes|on)$";

		private const string BooleanFalsePattern = "^(false|n|no|off)$";

		bool INodeDeserializer.Deserialize(IParser parser, Type expectedType, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] out object value)
		{
			if (!parser.TryConsume<YamlDotNet.Core.Events.Scalar>(out var @event))
			{
				value = null;
				return false;
			}
			Type type = Nullable.GetUnderlyingType(expectedType) ?? expectedType;
			if (ReflectionExtensions.IsEnum(type))
			{
				value = Enum.Parse(type, @event.Value, ignoreCase: true);
				return true;
			}
			TypeCode typeCode = ReflectionExtensions.GetTypeCode(type);
			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, YamlFormatter.NumberFormat);
				break;
			case TypeCode.Double:
				value = double.Parse(@event.Value, YamlFormatter.NumberFormat);
				break;
			case TypeCode.Decimal:
				value = decimal.Parse(@event.Value, YamlFormatter.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))
				{
					value = @event.Value;
				}
				else
				{
					value = YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(@event.Value, expectedType);
				}
				break;
			}
			return true;
		}

		private object DeserializeBooleanHelper(string value)
		{
			bool flag;
			if (Regex.IsMatch(value, "^(true|y|yes|on)$", RegexOptions.IgnoreCase))
			{
				flag = true;
			}
			else
			{
				if (!Regex.IsMatch(value, "^(false|n|no|off)$", RegexOptions.IgnoreCase))
				{
					throw new FormatException("The value \"" + value + "\" is not a valid YAML Boolean");
				}
				flag = false;
			}
			return flag;
		}

		private object DeserializeIntegerHelper(TypeCode typeCode, string value)
		{
			StringBuilder stringBuilder = new StringBuilder();
			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] != '_')
					{
						stringBuilder.Append(value[i]);
					}
				}
				switch (num2)
				{
				case 2:
				case 8:
					num = Convert.ToUInt64(stringBuilder.ToString(), num2);
					break;
				case 16:
					num = ulong.Parse(stringBuilder.ToString(), NumberStyles.HexNumber, YamlFormatter.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("_", ""));
				}
			}
			if (flag)
			{
				return CastInteger(checked(-(long)num), typeCode);
			}
			return CastInteger(num, typeCode);
		}

		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, 
			});
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal sealed class TypeConverterNodeDeserializer : INodeDeserializer
	{
		private readonly IEnumerable<IYamlTypeConverter> converters;

		public TypeConverterNodeDeserializer(IEnumerable<IYamlTypeConverter> converters)
		{
			this.converters = converters ?? throw new ArgumentNullException("converters");
		}

		bool INodeDeserializer.Deserialize(IParser parser, Type expectedType, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] out object value)
		{
			IYamlTypeConverter yamlTypeConverter = converters.FirstOrDefault([<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] (IYamlTypeConverter c) => c.Accepts(expectedType));
			if (yamlTypeConverter == null)
			{
				value = null;
				return false;
			}
			value = yamlTypeConverter.ReadYaml(parser, expectedType);
			return true;
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class YamlConvertibleNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public YamlConvertibleNodeDeserializer(IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(IParser parser, Type expectedType, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] out object value)
		{
			if (typeof(IYamlConvertible).IsAssignableFrom(expectedType))
			{
				IYamlConvertible yamlConvertible = (IYamlConvertible)objectFactory.Create(expectedType);
				yamlConvertible.Read(parser, expectedType, [return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] (Type type) => nestedObjectDeserializer(parser, type));
				value = yamlConvertible;
				return true;
			}
			value = null;
			return false;
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal sealed class YamlSerializableNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public YamlSerializableNodeDeserializer(IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(IParser parser, Type expectedType, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] out object value)
		{
			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
{
	internal sealed class CamelCaseNamingConvention : INamingConvention
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)]
		public static readonly INamingConvention Instance = new CamelCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public CamelCaseNamingConvention()
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public string Apply(string value)
		{
			return StringExtensions.ToCamelCase(value);
		}
	}
	internal sealed class HyphenatedNamingConvention : INamingConvention
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)]
		public static readonly INamingConvention Instance = new HyphenatedNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public HyphenatedNamingConvention()
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public string Apply(string value)
		{
			return StringExtensions.FromCamelCase(value, "-");
		}
	}
	internal sealed class LowerCaseNamingConvention : INamingConvention
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)]
		public static readonly INamingConvention Instance = new LowerCaseNamingConvention();

		private LowerCaseNamingConvention()
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public string Apply(string value)
		{
			return StringExtensions.ToCamelCase(value).ToLower();
		}
	}
	internal sealed class NullNamingConvention : INamingConvention
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)]
		public static readonly INamingConvention Instance = new NullNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public NullNamingConvention()
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public string Apply(string value)
		{
			return value;
		}
	}
	internal sealed class PascalCaseNamingConvention : INamingConvention
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)]
		public static readonly INamingConvention Instance = new PascalCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public PascalCaseNamingConvention()
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public string Apply(string value)
		{
			return StringExtensions.ToPascalCase(value);
		}
	}
	internal sealed class UnderscoredNamingConvention : INamingConvention
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)]
		public static readonly INamingConvention Instance = new UnderscoredNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public UnderscoredNamingConvention()
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public string Apply(string value)
		{
			return StringExtensions.FromCamelCase(value, "_");
		}
	}
}
namespace YamlDotNet.Serialization.EventEmitters
{
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal 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);
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class JsonEventEmitter : ChainedEventEmitter
	{
		public JsonEventEmitter(IEventEmitter nextEmitter)
			: base(nextEmitter)
		{
		}

		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 = ReflectionExtensions.GetTypeCode(eventInfo.Source.Type);
				switch (typeCode)
				{
				case TypeCode.Boolean:
					eventInfo.RenderedValue = YamlFormatter.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 (ReflectionExtensions.IsEnum(eventInfo.Source.Type))
					{
						eventInfo.RenderedValue = value.ToString();
						eventInfo.Style = ScalarStyle.DoubleQuoted;
					}
					else
					{
						eventInfo.RenderedValue = YamlFormatter.FormatNumber(value);
					}
					break;
				case TypeCode.Single:
				case TypeCode.Double:
				case TypeCode.Decimal:
					eventInfo.RenderedValue = YamlFormatter.FormatNumber(value);
					break;
				case TypeCode.Char:
				case TypeCode.String:
					eventInfo.RenderedValue = value.ToString();
					eventInfo.Style = ScalarStyle.DoubleQuoted;
					break;
				case TypeCode.DateTime:
					eventInfo.RenderedValue = YamlFormatter.FormatDateTime(value);
					break;
				case TypeCode.Empty:
					eventInfo.RenderedValue = "null";
					break;
				default:
					if (eventInfo.Source.Type == typeof(TimeSpan))
					{
						eventInfo.RenderedValue = YamlFormatter.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);
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class TypeAssigningEventEmitter : ChainedEventEmitter
	{
		private readonly bool requireTagWhenStaticAndActualTypesAreDifferent;

		private readonly IDictionary<Type, TagName> tagMappings;

		public TypeAssigningEventEmitter(IEventEmitter nextEmitter, bool requireTagWhenStaticAndActualTypesAreDifferent, IDictionary<Type, TagName> tagMappings)
			: base(nextEmitter)
		{
			this.requireTagWhenStaticAndActualTypesAreDifferent = requireTagWhenStaticAndActualTypesAreDifferent;
			this.tagMappings = tagMappings ?? throw new ArgumentNullException("tagMappings");
		}

		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 = ReflectionExtensions.GetTypeCode(eventInfo.Source.Type);
				switch (typeCode)
				{
				case TypeCode.Boolean:
					eventInfo.Tag = JsonSchema.Tags.Bool;
					eventInfo.RenderedValue = YamlFormatter.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:
					eventInfo.Tag = JsonSchema.Tags.Int;
					eventInfo.RenderedValue = YamlFormatter.FormatNumber(value);
					break;
				case TypeCode.Single:
					eventInfo.Tag = JsonSchema.Tags.Float;
					eventInfo.RenderedValue = YamlFormatter.FormatNumber((float)value);
					break;
				case TypeCode.Double:
					eventInfo.Tag = JsonSchema.Tags.Float;
					eventInfo.RenderedValue = YamlFormatter.FormatNumber((double)value);
					break;
				case TypeCode.Decimal:
					eventInfo.Tag = JsonSchema.Tags.Float;
					eventInfo.RenderedValue = YamlFormatter.FormatNumber(value);
					break;
				case TypeCode.Char:
				case TypeCode.String:
					eventInfo.Tag = FailsafeSchema.Tags.Str;
					eventInfo.RenderedValue = value.ToString();
					style = ScalarStyle.Any;
					break;
				case TypeCode.DateTime:
					eventInfo.Tag = DefaultSchema.Tags.Timestamp;
					eventInfo.RenderedValue = YamlFormatter.FormatDateTime(value);
					break;
				case TypeCode.Empty:
					eventInfo.Tag = JsonSchema.Tags.Null;
					eventInfo.RenderedValue = "";
					break;
				default:
					if (eventInfo.Source.Type == typeof(TimeSpan))
					{
						eventInfo.RenderedValue = YamlFormatter.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;
			}
			else if (requireTagWhenStaticAndActualTypesAreDifferent && eventInfo.Source.Value != null && eventInfo.Source.Type != eventInfo.Source.StaticType)
			{
				throw new YamlException("Cannot serialize type '" + eventInfo.Source.Type.FullName + "' where a '" + eventInfo.Source.StaticType.FullName + "' was expected because no tag mapping has been registered for '" + eventInfo.Source.Type.FullName + "', which means that it won't be possible to deserialize the document.\nRegister a tag mapping using the SerializerBuilder.WithTagMapping method.\n\nE.g: builder.WithTagMapping(\"!" + eventInfo.Source.Type.Name + "\", typeof(" + eventInfo.Source.Type.FullName + "));");
			}
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal 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
{
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal class DateTimeConverter : IYamlTypeConverter
	{
		private readonly DateTimeKind kind;

		private readonly IFormatProvider provider;

		private readonly string[] formats;

		public DateTimeConverter(DateTimeKind kind = DateTimeKind.Utc, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] IFormatProvider provider = null, params string[] formats)
		{
			this.kind = ((kind == DateTimeKind.Unspecified) ? DateTimeKind.Utc : kind);
			this.provider = provider ?? CultureInfo.InvariantCulture;
			this.formats = formats.DefaultIfEmpty("G").ToArray();
		}

		public bool Accepts(Type type)
		{
			return type == typeof(DateTime);
		}

		public object ReadYaml(IParser parser, Type type)
		{
			return EnsureDateTimeKind(DateTime.ParseExact(parser.Consume<YamlDotNet.Core.Events.Scalar>().Value, style: (kind == DateTimeKind.Local) ? DateTimeStyles.AssumeLocal : DateTimeStyles.AssumeUniversal, formats: formats, provider: provider), kind);
		}

		public void WriteYaml(IEmitter emitter, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object value, Type type)
		{
			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, 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;
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal 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)
		{
			return new Guid(parser.Consume<YamlDotNet.Core.Events.Scalar>().Value);
		}

		public void WriteYaml(IEmitter emitter, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object value, Type type)
		{
			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));
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal class SystemTypeConverter : IYamlTypeConverter
	{
		public bool Accepts(Type type)
		{
			return typeof(Type).IsAssignableFrom(type);
		}

		public object ReadYaml(IParser parser, Type type)
		{
			return Type.GetType(parser.Consume<YamlDotNet.Core.Events.Scalar>().Value, throwOnError: true);
		}

		public void WriteYaml(IEmitter emitter, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] object value, Type type)
		{
			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.RepresentationModel
{
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal class DocumentLoadingState
	{
		private readonly IDictionary<AnchorName, YamlNode> anchors = new Dictionary<AnchorName, YamlNode>();

		private readonly IList<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");
			}
			if (anchors.ContainsKey(node.Anchor))
			{
				anchors[node.Anchor] = node;
			}
			else
			{
				anchors.Add(node.Anchor, node);
			}
		}

		public YamlNode GetNode(AnchorName anchor, Mark start, Mark end)
		{
			if (anchors.TryGetValue(anchor, out var value))
			{
				return value;
			}
			throw new AnchorNotFoundException(start, end, $"The anchor '{anchor}' does not exists");
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
		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);
			}
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal class EmitterState
	{
		public HashSet<AnchorName> EmittedAnchors { get; } = new HashSet<AnchorName>();

	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal interface IYamlVisitor
	{
		void Visit(YamlStream stream);

		void Visit(YamlDocument document);

		void Visit(YamlScalarNode scalar);

		void Visit(YamlSequenceNode sequence);

		void Visit(YamlMappingNode mapping);
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal 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 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(">");
			}
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	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.");
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
		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.ToString();
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			yield return this;
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal class YamlDocument
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
		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()
		{
			new 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);
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class YamlMappingNode : YamlNode, IEnumerable<KeyValuePair<YamlNode, YamlNode>>, IEnumerable, IYamlConvertible
	{
		private readonly IOrderedDictionary<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);
				try
				{
					children.Add(yamlNode, yamlNode2);
				}
				catch (ArgumentException innerException)
				{
					throw new YamlException(yamlNode.Start, yamlNode.End, "Duplicate key", innerException);
				}
				flag = flag || yamlNode is YamlAliasNode || yamlNode2 is YamlAliasNode;
			}
			if (flag)
			{
				state.AddNodeWithUnresolvedAliases(this);
			}
		}

		public YamlMappingNode()
		{
		}

		public YamlMappingNode([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 0, 1, 1 })] params KeyValuePair<YamlNode, YamlNode>[] children)
			: this((IEnumerable<KeyValuePair<YamlNode, YamlNode>>)children)
		{
		}

		public YamlMappingNode([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 0, 1, 1 })] 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);
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
		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 var 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 = YamlDotNet.Core.HashCode.CombineHashCodes(num, child.Value);
			}
			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!";
			}
			StringBuilder stringBuilder = new StringBuilder("{ ");
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				if (stringBuilder.Length > 2)
				{
					stringBuilder.Append(", ");
				}
				stringBuilder.Append("{ ").Append(child.Key.ToString(level)).Append(", ")
					.Append(child.Value.ToString(level))
					.Append(" }");
			}
			stringBuilder.Append(" }");
			level.Decrement();
			return stringBuilder.ToString();
		}

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 0, 1, 1 })]
		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 ReflectionExtensions.GetPublicProperties(mapping.GetType()))
			{
				if (publicProperty.CanRead && publicProperty.GetGetMethod(nonPublic: false).GetParameters().Length == 0)
				{
					object value = publicProperty.GetValue(mapping, null);
					YamlNode yamlNode = value as YamlNode;
					if (yamlNode == null)
					{
						yamlNode = Convert.ToString(value) ?? string.Empty;
					}
					yamlMappingNode.Add(publicProperty.Name, yamlNode);
				}
			}
			return yamlMappingNode;
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal 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 var 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>)([<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] (string i) => i)));
		}

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		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;
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal 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();
		}
	}
	internal enum YamlNodeType
	{
		Alias,
		Mapping,
		Scalar,
		Sequence
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[DebuggerDisplay("{Value}")]
	internal sealed class YamlScalarNode : YamlNode, IYamlConvertible
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		[field: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public string Value
		{
			[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
			get;
			[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
			set;
		}

		public ScalarStyle Style { get; set; }

		public override YamlNodeType NodeType => YamlNodeType.Scalar;

		internal YamlScalarNode(IParser parser, DocumentLoadingState state)
		{
			Load(parser, state);
		}

		private void Load(IParser parser, DocumentLoadingState state)
		{
			YamlDotNet.Core.Events.Scalar scalar = parser.Consume<YamlDotNet.Core.Events.Scalar>();
			Load(scalar, state);
			Value = scalar.Value;
			Style = scalar.Style;
		}

		public YamlScalarNode()
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
		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)
		{
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(base.Anchor, base.Tag, Value ?? string.Empty, Style, base.Tag.IsEmpty, isQuotedImplicit: false));
		}

		public override void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
		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, Value);
		}

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		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}")]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal sealed class YamlSequenceNode : YamlNode, IEnumerable<YamlNode>, IEnumerable, IYamlConvertible
	{
		private readonly IList<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);
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
		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!";
			}
			StringBuilder stringBuilder = new StringBuilder("[ ");
			foreach (YamlNode child in children)
			{
				if (stringBuilder.Length > 2)
				{
					stringBuilder.Append(", ");
				}
				stringBuilder.Append(child.ToString(level));
			}
			stringBuilder.Append(" ]");
			level.Decrement();
			return stringBuilder.ToString();
		}

		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());
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal class YamlStream : IEnumerable<YamlDocument>, IEnumerable
	{
		private readonly IList<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();
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[Obsolete("Use YamlVisitorBase")]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal 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);
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal 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
{
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal 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: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		private static TMemberInfo TryGetMemberExpression<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] 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;
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
	internal sealed class GenericCollectionToNonGenericAdapter<T> : IList, ICollection, IEnumerable
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)]
		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();
			}
		}

		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)]
		public object SyncRoot
		{
			[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
			get
			{
				throw new NotSupportedException();
			}
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		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();
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public void CopyTo(Array array, int index)
		{
			throw new NotSupportedException();
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public IEnumerator GetEnumerator()
		{
			return genericCollection.GetEnumerator();
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class GenericDictionaryToNonGenericAdapter<TKey, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TValue> : IDictionary, ICollection, IEnumerable
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
		private class DictionaryEnumerator : IDictionaryEnumerator, IEnumerator
		{
			[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 0, 1, 1 })]
			private readonly IEnumerator<KeyValuePair<TKey, TValue>> enumerator;

			public DictionaryEntry Entry => new DictionaryEntry(Key, Value);

			public object Key => enumerator.Current.Key;

			[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
			public object Value
			{
				[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
				get
				{
					return enumerator.Current.Value;
				}
			}

			public object Current => Entry;

			public DictionaryEnumerator([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 0, 1, 1 })] 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();
			}
		}

		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public object this[object key]
		{
			[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
			get
			{
				throw new NotSupportedException();
			}
			[param: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
			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, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] 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();
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal interface IOrderedDictionary<TKey, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 0, 1, 1 })]
		KeyValuePair<TKey, TValue> this[int index]
		{
			[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 0, 1, 1 })]
			get;
			[param: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 0, 1, 1 })]
			set;
		}

		void Insert(int index, TKey key, TValue value);

		void RemoveAt(int index);
	}
	internal static class NumberExtensions
	{
		public static bool IsPowerOfTwo(this int value)
		{
			return (value & (value - 1)) == 0;
		}
	}
	[Serializable]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal class OrderedDictionary<TKey, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TValue> : IOrderedDictionary<TKey, TValue>, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
		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.Keys.Contains(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([<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] (KeyValuePair<TKey, TValue> kvp) => kvp.Key).GetEnumerator();
			}

			public bool Remove(TKey item)
			{
				throw new NotSupportedException();
			}

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

		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
		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.Values.Contains(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([<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] (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;

		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 0, 1, 1 })]
		private readonly List<KeyValuePair<TKey, TValue>> list;

		private readonly IEqualityComparer<TKey> comparer;

		public TValue this[TKey key]
		{
			get
			{
				return dictionary[key];
			}
			set
			{
				if (dictionary.ContainsKey(key))
				{
					int index = list.FindIndex(([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 0, 1, 1 })] KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key));
					dictionary[key] = value;
					list[index] = new KeyValuePair<TKey, TValue>(key, value);
				}
				else
				{
					Add(key, value);
				}
			}
		}

		public ICollection<TKey> Keys => new KeyCollection(this);

		public ICollection<TValue> Values => new ValueCollection(this);

		public int Count => dictionary.Count;

		public bool IsReadOnly => false;

		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 0, 1, 1 })]
		public KeyValuePair<TKey, TValue> this[int index]
		{
			[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 0, 1, 1 })]
			get
			{
				return list[index];
			}
			[param: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 0, 1, 1 })]
			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(TKey key, TValue value)
		{
			Add(new KeyValuePair<TKey, TValue>(key, value));
		}

		public void Add([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 0, 1, 1 })] KeyValuePair<TKey, TValue> item)
		{
			dictionary.Add(item.Key, item.Value);
			list.Add(item);
		}

		public void Clear()
		{
			dictionary.Clear();
			list.Clear();
		}

		public bool Contains([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 0, 1, 1 })] KeyValuePair<TKey, TValue> item)
		{
			return dictionary.Contains(item);
		}

		public bool ContainsKey(TKey key)
		{
			return dictionary.ContainsKey(key);
		}

		public void CopyTo([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 0, 1, 1 })] KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			list.CopyTo(array, arrayIndex);
		}

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 0, 1, 1 })]
		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)
		{
			if (dictionary.ContainsKey(key))
			{
				int index = list.FindIndex(([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 0, 1, 1 })] KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key));
				list.RemoveAt(index);
				if (!dictionary.Remove(key))
				{
					throw new InvalidOperationException();
				}
				return true;
			}
			return false;
		}

		public bool Remove([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 0, 1, 1 })] 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();
		}

		[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 Lazy
	{
		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public static Lazy<T> FromValue<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] T>(T value)
		{
			Lazy<T> lazy = new Lazy<T>(() => value, isThreadSafe: false);
			_ = lazy.Value;
			return lazy;
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal static class ReadOnlyCollectionExtensions
	{
		public static IReadOnlyList<T> AsReadonlyList<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] T>(this List<T> list)
		{
			return list;
		}

		public static IReadOnlyDictionary<TKey, TValue> AsReadonlyDictionary<TKey, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TValue>(this Dictionary<TKey, TValue> dictionary)
		{
			return dictionary;
		}
	}
}
namespace YamlDotNet.Core
{
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal struct AnchorName : IEquatable<AnchorName>
	{
		public static readonly AnchorName Empty = default(AnchorName);

		private static readonly Regex AnchorPattern = new Regex("^[^\\[\\]\\{\\},]+$", RegexOptions.Compiled);

		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		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);
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
		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);
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
		public static implicit operator AnchorName(string value)
		{
			if (value != null)
			{
				return new AnchorName(value);
			}
			return Empty;
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal class AnchorNotFoundException : YamlException
	{
		public AnchorNotFoundException(string message)
			: base(message)
		{
		}

		public AnchorNotFoundException(Mark start, Mark end, string message)
			: base(start, end, message)
		{
		}

		public AnchorNotFoundException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal sealed class CharacterAnalyzer<TBuffer> where TBuffer : class, ILookAheadBuffer
	{
		public TBuffer Buffer { get; }

		public bool EndOfInput => Buffer.EndOfInput;

		public CharacterAnalyzer(TBuffer buffer)
		{
			Buffer = buffer ?? throw new ArgumentNullException("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 value = Buffer.Peek(offset);
			return expectedCharacters.IndexOf(value) != -1;
		}
	}
	internal static class Constants
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)]
		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;
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal sealed class Cursor
	{
		public int Index { get; private set; }

		public int Line { get; private set; }

		public int LineOffset { get; private set; }

		public Cursor()
		{
			Line = 1;
		}

		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 = 0;
		}

		public void ForceSkipLineAfterNonBreak()
		{
			if (LineOffset != 0)
			{
				Line++;
				LineOffset = 0;
			}
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal class Emitter : IEmitter
	{
		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)]
		private class AnchorData
		{
			public AnchorName Anchor;

			public bool IsAlias;
		}

		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
		private class TagData
		{
			public string Handle;

			public string Suffix;
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)]
		private class ScalarData
		{
			[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)]
			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 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 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;
			this.output = output;
			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;
			using (Queue<ParsingEvent>.Enumerator enumerator = events.GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					switch (enumerator.Current.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;
			}
			CharacterAnalyzer<StringLookAheadBuffer> characterAnalyzer = new CharacterAnalyzer<StringLookAheadBuffer>(new StringLookAheadBuffer(value));
			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;
		}

		private bool ValueIsRepresentableInOutputEncoding(string value)
		{
			if (outputUsesUnicodeEncoding)
			{
				return true;
			}
			try
			{
				byte[] bytes = output.Encoding.GetBytes(value);
				return output.Encoding.GetString(bytes, 0, bytes.Length).Equals(value);
			}
			catch (EncoderFallbackException)
			{
				return false;
			}
			catch (ArgumentOutOfRangeException)
			{
				return false;
			}
		}

		private 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 (comment.IsInline)
			{
				Write(' ');
			}
			else
			{
				WriteIndent();
			}
			Write("# ");
			Write(comment.Value);
			WriteBreak();
			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}", new object[2] { 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;
				for (int i = 0; i < defaultTagDirectives.Length; i++)
				{
					AppendTagDirectiveTo(defaultTagDirectives[i], allowDuplicates: true, tagDirectives);
				}
				if (tagDirectiveCollection.Count > 0)
				{
					flag = false;
					defaultTagDirectives = Constants.DefaultTagDirectives;
					for (int i = 0; i < defaultTagDirectives.Length; i++)
					{
						AppendTagDirectiveTo(defaultTagDirectives[i], 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 TagDirectiveCollection NonDefaultTagsAmong([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 2, 1 })] 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 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;
			}
			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.");
						}
						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 (!flag && !flag2 && c == '\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);
			}
			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)
			{
				WriteIndicator(":", needWhitespace: false, whitespace: false, indentation: false);
			}
			else
			{
				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 int AnchorNameLength(AnchorName value)
		{
			if (!value.IsEmpty)
			{
				return value.Value.Length;
			}
			return 0;
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
		private int SafeStringLength(string value)
		{
			return value?.Length ?? 0;
		}

		private bool CheckEmptySequence()
		{
			return CheckEmptyStructure<SequenceStart, SequenceEnd>();
		}

		private bool CheckEmptyMapping()
		{
			return CheckEmptyStructure<MappingStart, MappingEnd>();
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)]
		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)
		{
			CharacterAnalyzer<StringLookAheadBuffer> characterAnalyzer = new CharacterAnalyzer<StringLookAheadBuffer>(new StringLookAheadBuffer(value));
			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);
			}
		}

		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 string UrlEncode(string text)
		{
			return UriReplacer.Replace(text, [<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] ([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)] Match match) =>
			{
				StringBuilder stringBuilder = new StringBuilder();
				byte[] bytes = Encoding.UTF8.GetBytes(match.Value);
				foreach (byte b in bytes)
				{
					stringBuilder.AppendFormat("%{0:X02}", b);
				}
				return stringBuilder.ToString();
			});
		}

		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;
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class EmitterSettings
	{
		public static readonly EmitterSettings Default = new EmitterSettings();

		public int BestIndent { get; } = 2;


		public int BestWidth { get; } = int.MaxValue;


		public bool IsCanonical { get; }

		public bool SkipAnchorName { get; private set; }

		public int MaxSimpleKeyLength { get; } = 1024;


		public bool IndentSequences { get; }

		public EmitterSettings()
		{
		}

		public EmitterSettings(int bestIndent, int bestWidth, bool isCanonical, int maxSimpleKeyLength, bool skipAnchorName = false, bool indentSequences = 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;
		}

		public EmitterSettings WithBestIndent(int bestIndent)
		{
			return new EmitterSettings(bestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName);
		}

		public EmitterSettings WithBestWidth(int bestWidth)
		{
			return new EmitterSettings(BestIndent, bestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName);
		}

		public EmitterSettings WithMaxSimpleKeyLength(int maxSimpleKeyLength)
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, maxSimpleKeyLength, SkipAnchorName);
		}

		public EmitterSettings Canonical()
		{
			return new EmitterSettings(BestIndent, BestWidth, isCanonical: true, MaxSimpleKeyLength, SkipAnchorName);
		}

		public EmitterSettings WithoutAnchorName()
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, skipAnchorName: true);
		}

		public EmitterSettings WithIndentedSequences()
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, indentSequences: true);
		}
	}
	internal enum EmitterState
	{
		StreamStart,
		StreamEnd,
		FirstDocumentStart,
		DocumentStart,
		DocumentContent,
		DocumentEnd,
		FlowSequenceFirstItem,
		FlowSequenceItem,
		FlowMappingFirstKey,
		FlowMappingKey,
		FlowMappingSimpleValue,
		FlowMappingValue,
		BlockSequenceFirstItem,
		BlockSequenceItem,
		BlockMappingFirstKey,
		BlockMappingKey,
		BlockMappingSimpleValue,
		BlockMappingValue
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal sealed class ForwardAnchorNotSupportedException : YamlException
	{
		public ForwardAnchorNotSupportedException(string message)
			: base(message)
		{
		}

		public ForwardAnchorNotSupportedException(Mark start, Mark end, string message)
			: base(start, end, message)
		{
		}

		public ForwardAnchorNotSupportedException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	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));
		}

		public static int CombineHashCodes(object first, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 1, 2 })] params object[] others)
		{
			int num = GetHashCode(first);
			foreach (object o in others)
			{
				num = CombineHashCodes(num, o);
			}
			return num;
		}

		private static int GetHashCode(object obj)
		{
			return obj?.GetHashCode() ?? 0;
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal interface IEmitter
	{
		void Emit(ParsingEvent @event);
	}
	internal interface ILookAheadBuffer
	{
		bool EndOfInput { get; }

		char Peek(int offset);

		void Skip(int length);
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class InsertionQueue<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] 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 (!NumberExtensions.IsPowerOfTwo(initialCapacity))
			{
				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();
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
	internal interface IParser
	{
		ParsingEvent Current { get; }

		bool MoveNext();
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal interface IScanner
	{
		Mark CurrentPosition { get; }

		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		Token Current
		{
			[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
			get;
		}

		bool MoveNext();

		bool MoveNextWithoutConsuming();

		void ConsumeCurrent();
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal 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 (!NumberExtensions.IsPowerOfTwo(capacity))
			{
				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;
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class Mark : IEquatable<Mark>, IComparable<Mark>, IComparable
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)]
		public static readonly Mark Empty = new Mark();

		public int Index { get; }

		public int Line { get; }

		public int Column { get; }

		public Mark()
		{
			Line = 1;
			Column = 1;
		}

		public Mark(int index, int line, int column)
		{
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", "Index must be greater than or equal to zero.");
			}
			if (line < 1)
			{
				throw new ArgumentOutOfRangeException("line", "Line must be greater than or equal to 1.");
			}
			if (column < 1)
			{
				throw new ArgumentOutOfRangeException("column", "Column must be greater than or equal to 1.");
			}
			Index = index;
			Line = line;
			Column = column;
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public override string ToString()
		{
			return $"Line: {Line}, Col: {Column}, Idx: {Index}";
		}

		public override bool Equals(object obj)
		{
			return Equals(obj as Mark);
		}

		public bool Equals(Mark other)
		{
			if (other != null && 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)
		{
			if (obj == null)
			{
				throw new ArgumentNullException("obj");
			}
			return CompareTo(obj as Mark);
		}

		public int CompareTo(Mark other)
		{
			if (other == null)
			{
				throw new ArgumentNullException("other");
			}
			int num = Line.CompareTo(other.Line);
			if (num == 0)
			{
				num = Column.CompareTo(other.Column);
			}
			return num;
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal sealed class MaximumRecursionLevelReachedException : YamlException
	{
		public MaximumRecursionLevelReachedException(string message)
			: base(message)
		{
		}

		public MaximumRecursionLevelReachedException(Mark start, Mark end, string message)
			: base(start, end, message)
		{
		}

		public MaximumRecursionLevelReachedException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal sealed class MergingParser : IParser
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
		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 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 IEnumerable<LinkedListNode<ParsingEvent>> Enumerate([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 2, 1 })] 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;
					}
				}
			}
		}

		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
		private sealed class ParsingEventCloner : IParsingEventVisitor
		{
			[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
			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)
			{
				clonedEvent = new SequenceEnd(e.Start, e.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)
			{
				clonedEvent = new MappingEnd(e.Start, e.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;

		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public ParsingEvent Current
		{
			[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
			get
			{
				return 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))
					{
						throw new SemanticErrorException(@event.Value.Start, @event.Value.End, "Unrecognized merge key pattern");
					}
				}
			}
		}

		private bool HandleMerge([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 2, 1 })] 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, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 2, 1 })] 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 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 cloner = new ParsingEventCloner();
			int nesting = 0;
			return from e in (from e in events.FromAnchor(anchor)
					select e.Value).TakeWhile([<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(0)] (ParsingEvent e) => (nesting += e.NestingIncrease) >= 0)
				select cloner.Clone(e);
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal class Parser : IParser
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
		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;

		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		private Token currentToken;

		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		private VersionDirective version;

		private readonly EventQueue pendingEvents = new EventQueue();

		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		[field: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public ParsingEvent Current
		{
			[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
			get;
			[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
			private set;
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
		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 ParsingEvent ParseStreamStart()
		{
			Token token = GetCurrentToken();
			if (!(token is YamlDotNet.Core.Tokens.StreamStart streamStart))
			{
				throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "Did not find expected <stream-start>.");
			}
			Skip();
			state = ParserState.ImplicitDocumentStart;
			return new YamlDotNet.Core.Events.StreamStart(streamStart.Start, streamStart.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);
			}
			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))
				{
					throw new SemanticErrorException(token.Start, token.End, "Did not find expected <document start>.");
				}
				states.Push(ParserState.DocumentEnd);
				state = ParserState.DocumentContent;
				Mark end = token.End;
				Skip();
				return new YamlDotNet.Core.Events.DocumentStart(versionDirective, tags2, isImplicit: false, start, end);
			}
			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");
			YamlDotNet.Core.Events.StreamEnd result = new YamlDotNet.Core.Events.StreamEnd(token.Start, token.End);
			if (scanner.MoveNextWithoutConsuming())
			{
				throw new InvalidOperationException("The scanner should contain no more tokens.");
			}
			return result;
		}

		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		private VersionDirective ProcessDirectives(TagDirectiveCollection tags)
		{
			bool flag = false;
			VersionDirective result = null;
			while (true)
			{
				if (GetCurrentToken() is VersionDirective versionDirective)
				{
					if (version != null)
					{
						throw new SemanticErrorException(versionDirective.Start, versionDirective.End, "Found duplicate %YAML directive.");
					}
					if (versionDirective.Version.Major != 1 || versionDirective.Version.Minor > 3)
					{
						throw new SemanticErrorException(versionDirective.Start, versionDirective.End, "Found incompatible YAML document.");
					}
					result = (version = versionDirective);
					flag = true;
				}
				else
				{
					if (!(GetCurrentToken() is TagDirective tagDirective))
					{
						break;
					}
					if (tags.Contains(tagDirective.Handle))
					{
						throw new SemanticErrorException(tagDirective.Start, tagDirective.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();
				return ProcessEmptyScalar(scanner.CurrentPosition);
			}
			return ParseNode(isBlock: true, isIndentlessSequence: false);
		}

		private static ParsingEvent ProcessEmptyScalar(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)
		{
			if (GetCurrentToken() is Error error)
			{
				throw new SemanticErrorException(error.Start, error.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();
				YamlDotNet.Core.Events.AnchorAlias result = new YamlDotNet.Core.Events.AnchorAlias(anchorAlias.Value, anchorAlias.Start, anchorAlias.End);
				Skip();
				return result;
			}
			Mark start = 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)
						{
							throw new SemanticErrorException(anchor4.Start, anchor4.End, "While parsing a node, found more than one anchor.");
						}
						if (token is YamlDotNet.Core.Tokens.AnchorAlias anchorAlias2)
						{
							throw new SemanticErrorException(anchorAlias2.Start, anchorAlias2.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);
						}
						throw new SemanticErrorException(error2.Start, error2.End, error2.Value);
					}
					tag2 = tag3;
					if (string.IsNullOrEmpty(tag3.Handle))
					{
						tag = new TagName(tag3.Suffix);
					}
					else
					{
						if (!tagDirectives.Contains(tag3.Handle))
						{
							throw new SemanticErrorException(tag3.Start, tag3.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, start, 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();
				YamlDotNet.Core.Events.Scalar result2 = new YamlDotNet.Core.Events.Scalar(anchor, tag, scalar.Value, scalar.Style, isPlainImplicit, isQuotedImplicit, start, scalar.End);
				if (!anchor.IsEmpty && scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (currentToken is Error)
					{
						Error error3 = currentToken as Error;
						throw new SemanticErrorException(error3.Start, error3.End, error3.Value);
					}
				}
				if (state == ParserState.FlowMappingKey && scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (currentToken != null && !(currentToken is FlowEntry) && !(currentToken is FlowMappingEnd))
					{
						throw new SemanticErrorException(currentToken.Start, currentToken.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, start, flowSequenceStart.End);
			}
			if (token is FlowMappingStart flowMappingStart)
			{
				state = ParserState.FlowMappingFirstKey;
				return new MappingStart(anchor, tag, isEmpty, MappingStyle.Flow, start, flowMappingStart.End);
			}
			if (isBlock)
			{
				if (token is BlockSequenceStart blockSequenceStart)
				{
					state = ParserState.BlockSequenceFirstEntry;
					return new SequenceStart(anchor, tag, isEmpty, SequenceStyle.Block, start, blockSequenceStart.End);
				}
				if (token is BlockMappingStart blockMappingStart)
				{
					state = ParserState.BlockMappingFirstKey;
					return new MappingStart(anchor, tag, isEmpty, MappingStyle.Block, start, 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, start, token.End);
			}
			throw new SemanticErrorException(token.Start, token.End, "While parsing a node, did not find expected node content.");
		}

		private ParsingEvent 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(start, 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 end = 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(end);
			}
			if (token is BlockEnd blockEnd)
			{
				state = states.Pop();
				SequenceEnd result = new SequenceEnd(blockEnd.Start, blockEnd.End);
				Skip();
				return result;
			}
			throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "While parsing a block collection, did not find expected '-' indicator.");
		}

		private ParsingEvent ParseIndentlessSequenceEntry()
		{
			Token token = GetCurrentToken();
			if (token is BlockEntry blockEntry)
			{
				Mark end = 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(end);
			}
			state = states.Pop();
			return new SequenceEnd(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty);
		}

		private ParsingEvent ParseBlockMappingKey(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			if (token is Key key)
			{
				Mark end = 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(end);
			}
			if (token is Value value)
			{
				Skip();
				return ProcessEmptyScalar(value.End);
			}
			if (token is YamlDotNet.Core.Tokens.AnchorAlias anchorAlias)
			{
				Skip();
				return new YamlDotNet.Core.Events.AnchorAlias(anchorAlias.Value, anchorAlias.Start, anchorAlias.End);
			}
			if (token is BlockEnd blockEnd)
			{
				state = states.Pop();
				MappingEnd result = new MappingEnd(blockEnd.Start, blockEnd.End);
				Skip();
				return result;
			}
			if (GetCurrentToken() is Error error)
			{
				throw new SyntaxErrorException(error.Start, error.End, error.Value);
			}
			throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "While parsing a block mapping, did not find expected key.");
		}

		private ParsingEvent ParseBlockMappingValue()
		{
			Token token = GetCurrentToken();
			if (token is Value value)
			{
				Mark end = 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(end);
			}
			if (token is Error error)
			{
				throw new SemanticErrorException(error.Start, error.End, error.Value);
			}
			state = ParserState.BlockMappingKey;
			return ProcessEmptyScalar(token?.Start ?? Mark.Empty);
		}

		private ParsingEvent ParseFlowSequenceEntry(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			if (!(token is FlowSequenceEnd))
			{
				if (!isFirst)
				{
					if (!(token is FlowEntry))
					{
						throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "While parsing a flow sequence, did not find expected ',' or ']'.");
					}
					Skip();
					token = GetCurrentToken();
				}
				if (token is Key)
				{
					state = ParserState.FlowSequenceEntryMappingKey;
					MappingStart 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();
			SequenceEnd result2 = new SequenceEnd(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty);
			Skip();
			return result2;
		}

		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(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;
			return ProcessEmptyScalar(token?.Start ?? Mark.Empty);
		}

		private ParsingEvent ParseFlowSequenceEntryMappingEnd()
		{
			state = ParserState.FlowSequenceEntry;
			Token token = GetCurrentToken();
			return new MappingEnd(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty);
		}

		private ParsingEvent ParseFlowMappingKey(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			if (!(token is FlowMappingEnd))
			{
				if (!isFirst)
				{
					if (!(token is FlowEntry))
					{
						throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "While parsing a flow mapping,  did not find expected ',' or '}'.");
					}
					Skip();
					token = GetCurrentToken();
				}
				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;
					return ProcessEmptyScalar(token?.Start ?? Mark.Empty);
				}
				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();
			return new MappingEnd(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty);
		}

		private ParsingEvent ParseFlowMappingValue(bool isEmpty)
		{
			Token token = GetCurrentToken();
			if (isEmpty)
			{
				state = ParserState.FlowMappingKey;
				return ProcessEmptyScalar(token?.Start ?? Mark.Empty);
			}
			if (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;
			return ProcessEmptyScalar(token?.Start ?? Mark.Empty);
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal static class ParserExtensions
	{
		public static T Consume<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] T>(this IParser parser) where T : ParsingEvent
		{
			T result = parser.Require<T>();
			parser.MoveNext();
			return result;
		}

		public static bool TryConsume<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] 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<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] 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.");
				}
				throw new YamlException(current.Start, current.End, $"Expected '{typeof(T).Name}', got '{current.GetType().Name}' (at {current.Start}).");
			}
			return @event;
		}

		public static bool Accept<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] 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<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] T>(this IParser parser) where T : ParsingEvent
		{
			return parser.Consume<T>();
		}

		[Obsolete("Please use TryConsume<T>(out var evt) instead")]
		[return: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public static T Allow<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] 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: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public static T Peek<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] 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<[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)] T>(this IParser parser) where T : ParsingEvent
		{
			T @event;
			return parser.Accept<T>(out @event);
		}
	}
	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--;
		}
	}
	internal enum ScalarStyle
	{
		Any,
		Plain,
		SingleQuoted,
		DoubleQuoted,
		Literal,
		Folded
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal class Scanner : IScanner
	{
		private const int MaxVersionNumberLength = 9;

		private static readonly IDictionary<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<int> indents = new Stack<int>();

		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 int flowSequenceStartLine;

		private int indent = -1;

		private bool simpleKeyAllowed;

		private int flowLevel;

		private int tokensParsed;

		private bool tokenAvailable;

		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		private Token previous;

		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		private Anchor previousAnchor;

		private static readonly byte[] EmptyBytes = new byte[0];

		public bool SkipComments { get; private set; }

		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		[field: <f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		public Token Current
		{
			[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
			get;
			[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
			private set;
		}

		public Mark CurrentPosition => cursor.Mark();

		private bool IsDocumentStart()
		{
			if (!analyzer.EndOfInput && cursor.LineOffset == 0 && analyzer.Check('-') && analyzer.Check('-', 1) && analyzer.Check('-', 2))
			{
				return analyzer.IsWhiteBreakOrZero(3);
			}
			return false;
		}

		private bool IsDocumentEnd()
		{
			if (!analyzer.EndOfInput && cursor.LineOffset == 0 && 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)
		{
			analyzer = new CharacterAnalyzer<LookAheadBuffer>(new LookAheadBuffer(input, 1024));
			cursor = new Cursor();
			SkipComments = skipComments;
		}

		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 + 1024 < 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)
			{
				FetchStreamEnd();
				return;
			}
			if (cursor.LineOffset == 0 && analyzer.Check('%'))
			{
				FetchDirective();
				return;
			}
			if (IsDocumentStart())
			{
				FetchDocumentIndicator(isStartToken: true);
				return;
			}
			if (IsDocumentEnd())
			{
				FetchDocumentIndicator(isStartToken: false);
				return;
			}
			if (analyzer.Check('['))
			{
				FetchFlowCollectionStart(isSequenceToken: true);
				return;
			}
			if (analyzer.Check('{'))
			{
				FetchFlowCollectionStart(isSequenceToken: false);
				return;
			}
			if (analyzer.Check(']'))
			{
				FetchFlowCollectionEnd(isSequenceToken: true);
				return;
			}
			if (analyzer.Check('}'))
			{
				FetchFlowCollectionEnd(isSequenceToken: false);
				return;
			}
			if (analyzer.Check(','))
			{
				FetchFlowEntry();
				return;
			}
			if (analyzer.Check('-') && analyzer.IsWhiteBreakOrZero(1))
			{
				FetchBlockEntry();
				return;
			}
			if (analyzer.Check('?') && (flowLevel > 0 || analyzer.IsWhiteBreakOrZero(1)))
			{
				FetchKey();
				return;
			}
			if (analyzer.Check(':') && (flowLevel > 0 || analyzer.IsWhiteBreakOrZero(1)) && (!simpleKeyAllowed || flowLevel <= 0))
			{
				FetchValue();
				return;
			}
			if (analyzer.Check('*'))
			{
				FetchAnchor(isAlias: true);
				return;
			}
			if (analyzer.Check('&'))
			{
				FetchAnchor(isAlias: false);
				return;
			}
			if (analyzer.Check('!'))
			{
				FetchTag();
				return;
			}
			if (analyzer.Check('|') && flowLevel == 0)
			{
				FetchBlockScalar(isLiteral: true);
				return;
			}
			if (analyzer.Check('>') && flowLevel == 0)
			{
				FetchBlockScalar(isLiteral: false);
				return;
			}
			if (analyzer.Check('\''))
			{
				FetchFlowScalar(isSingleQuoted: true);
				return;
			}
			if (analyzer.Check('"'))
			{
				FetchFlowScalar(isSingleQuoted: false);
				return;
			}
			if ((!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("-?:,[]{}#&*!|>'\"%@`")) || (analyzer.Check('-') && !analyzer.IsWhite(1)) || (flowLevel == 0 && analyzer.Check("?:") && !analyzer.IsWhiteBreakOrZero(1)) || (simpleKeyAllowed && flowLevel > 0 && analyzer.Check("?:")))
			{
				if (plainScalarFollowedByComment)
				{
					Mark mark = cursor.Mark();
					tokens.Enqueue(new Error("While scanning plain scalar, found a comment between adjacent scalars.", mark, mark));
				}
				plainScalarFollowedByComment = false;
				FetchPlainScalar();
				return;
			}
			if (simpleKeyAllowed && indent >= cursor.LineOffset && analyzer.IsTab())
			{
				throw new SyntaxErrorException("While scanning a mapping, found invalid tab as indentation.");
			}
			if (analyzer.IsWhiteBreakOrZero())
			{
				Skip();
				return;
			}
			Mark start = cursor.Mark();
			Skip();
			Mark end = cursor.Mark();
			throw new SyntaxErrorException(start, end, "While scanning for the next token, found character that cannot start any token.");
		}

		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('#'))
			{
				Mark mark = cursor.Mark();
				Skip();
				while (analyzer.IsSpace())
				{
					Skip();
				}
				StringBuilder stringBuilder = new StringBuilder();
				while (!analyzer.IsBreakOrZero())
				{
					stringBuilder.Append(ReadCurrentCharacter());
				}
				if (!SkipComments)
				{
					bool isInline = previous != null && previous.End.Line == mark.Line && previous.End.Column != 1 && !(previous is YamlDotNet.Core.Tokens.StreamStart);
					tokens.Enqueue(new YamlDotNet.Core.Tokens.Comment(stringBuilder.ToString(), isInline, mark, cursor.Mark()));
				}
			}
		}

		private void FetchStreamStart()
		{
			simpleKeys.Push(new SimpleKey());
			simpleKeyAllowed = true;
			streamStartProduced = true;
			Mark mark = cursor.Mark();
			tokens.Enqueue(new YamlDotNet.Core.Tokens.StreamStart(mark, mark));
		}

		private void UnrollIndent(int column)
		{
			if (flowLevel == 0)
			{
				while (indent > column)
				{
					Mark mark = cursor.Mark();
					tokens.Enqueue(new BlockEnd(mark, mark));
					indent = indents.Pop();
				}
			}
		}

		private void FetchStreamEnd()
		{
			cursor.ForceSkipLineAfterNonBreak();
			UnrollIndent(-1);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			streamEndProduced = true;
			Mark mark = cursor.Mark();
			tokens.Enqueue(new YamlDotNet.Core.Tokens.StreamEnd(mark, mark));
		}

		private void FetchDirective()
		{
			UnrollIndent(-1);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			Token token = ScanDirective();
			if (token != null)
			{
				tokens.Enqueue(token);
			}
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
		private Token ScanDirective()
		{
			Mark start = cursor.Mark();
			Skip();
			string text = ScanDirectiveName(start);
			Token result;
			if (!(text == "YAML"))
			{
				if (!(text == "TAG"))
				{
					while (!analyzer.Check('#') && !analyzer.IsBreak())
					{
						Skip();
					}
					return null;
				}
				result = ScanTagDirectiveValue(start);
			}
			else
			{
				if (!(previous is YamlDotNet.Core.Tokens.DocumentStart) && !(previous is YamlDotNet.Core.Tokens.StreamStart) && !(previous is YamlDotNet.Core.Tokens.DocumentEnd))
				{
					throw new SemanticErrorException(start, cursor.Mark(), "While scanning a version directive, did not find preceding <document end>.");
				}
				result = ScanVersionDirectiveValue(start);
			}
			while (analyzer.IsWhite())
			{
				Skip();
			}
			ProcessComment();
			if (!analyzer.IsBreakOrZero())
			{
				throw new SyntaxErrorException(start, cursor.Mark(), "While scanning a directive, did not find expected comment or line break.");
			}
			if (analyzer.IsBreak())
			{
				SkipLine();
			}
			return result;
		}

		private void FetchDocumentIndicator(bool isStartToken)
		{
			UnrollIndent(-1);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			Mark mark = cursor.Mark();
			Skip();
			Skip();
			Skip();
			if (isStartToken)
			{
				tokens.Enqueue(new YamlDotNet.Core.Tokens.DocumentStart(mark, cursor.Mark()));
				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.", mark, cursor.Mark());
					break;
				}
				Skip();
			}
			tokens.Enqueue(new YamlDotNet.Core.Tokens.DocumentEnd(mark, mark));
			if (token != null)
			{
				tokens.Enqueue(token);
			}
		}

		private void FetchFlowCollectionStart(bool isSequenceToken)
		{
			SaveSimpleKey();
			IncreaseFlowLevel();
			simpleKeyAllowed = true;
			Mark mark = cursor.Mark();
			Skip();
			Token token;
			if (isSequenceToken)
			{
				token = new FlowSequenceStart(mark, mark);
				flowSequenceStartLine = token.Start.Line;
			}
			else
			{
				token = new FlowMappingStart(mark, mark);
			}
			tokens.Enqueue(token);
		}

		private void IncreaseFlowLevel()
		{
			simpleKeys.Push(new SimpleKey());
			flowLevel++;
		}

		private void FetchFlowCollectionEnd(bool isSequenceToken)
		{
			RemoveSimpleKey();
			DecreaseFlowLevel();
			simpleKeyAllowed = false;
			Mark mark = 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 ']'.", mark, mark);
				}
				if (previous is YamlDotNet.Core.Tokens.StreamStart && flowSequenceStartLine != mark.Line)
				{
					tokens.Enqueue(new Error("While scanning a flow sequence end, found mapping key spanning across multiple lines.", mark, mark));
				}
				item = new FlowSequenceEnd(mark, mark);
			}
			else
			{
				item = new FlowMappingEnd(mark, mark);
			}
			tokens.Enqueue(item);
			if (token != null)
			{
				tokens.Enqueue(token);
			}
		}

		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(start, end));
			}
		}

		private void FetchBlockEntry()
		{
			if (flowLevel == 0)
			{
				if (!simpleKeyAllowed)
				{
					if (previousAnchor != null && previousAnchor.End.Line == cursor.Line)
					{
						throw new SemanticErrorException(previousAnchor.Start, previousAnchor.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 start = cursor.Mark();
			Skip();
			tokens.Enqueue(new BlockEntry(start, cursor.Mark()));
		}

		private void FetchKey()
		{
			if (flowLevel == 0)
			{
				if (!simpleKeyAllowed)
				{
					Mark mark = cursor.Mark();
					throw new SyntaxErrorException(mark, mark, "Mapping keys are not allowed in this context.");
				}
				RollIndent(cursor.LineOffset, -1, isSequence: false, cursor.Mark());
			}
			RemoveSimpleKey();
			simpleKeyAllowed = flowLevel == 0;
			Mark start = cursor.Mark();
			Skip();
			tokens.Enqueue(new Key(start, cursor.Mark()));
		}

		private void FetchValue()
		{
			SimpleKey simpleKey = simpleKeys.Peek();
			if (simpleKey.IsPossible)
			{
				tokens.Insert(simpleKey.TokenNumber - tokensParsed, new Key(simpleKey.Mark, simpleKey.Mark));
				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 == 0 && simpleKey.LineOffset == 0)
					{
						tokens.Insert(tokens.Count, new Key(simpleKey.Mark, simpleKey.Mark));
						flag = false;
					}
				}
				simpleKeyAllowed = flag;
			}
			Mark start = cursor.Mark();
			Skip();
			tokens.Enqueue(new Value(start, cursor.Mark()));
		}

		private void RollIndent(int column, int number, bool isSequence, Mark position)
		{
			if (flowLevel <= 0 && indent < column)
			{
				indents.Push(indent);
				indent = column;
				Token item = ((!isSequence) ? ((Token)new BlockMappingStart(position, position)) : ((Token)new BlockSequenceStart(position, 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;
			}
			StringBuilder stringBuilder = new StringBuilder();
			while (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("[]{},") && (!flag || !analyzer.Check(':') || !analyzer.IsWhiteBreakOrZero(1)))
			{
				stringBuilder.Append(ReadCurrentCharacter());
			}
			if (stringBuilder.Length == 0 || (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("?:,]}%@`")))
			{
				throw new SyntaxErrorException(start, cursor.Mark(), "While scanning an anchor or alias, found value containing disallowed: []{},");
			}
			AnchorName value = new AnchorName(stringBuilder.ToString());
			if (isAlias)
			{
				return new YamlDotNet.Core.Tokens.AnchorAlias(value, start, cursor.Mark());
			}
			return previousAnchor = new Anchor(value, start, cursor.Mark());
		}

		private void FetchTag()
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			tokens.Enqueue(ScanTag());
		}

		private Token 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('>'))
				{
					throw new SyntaxErrorException(start, cursor.Mark(), "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(','))
			{
				throw new SyntaxErrorException(start, cursor.Mark(), "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)
		{
			RemoveSimpleKey();
			simpleKeyAllowed = true;
			tokens.Enqueue(ScanBlockScalar(isLiteral));
		}

		private Token ScanBlockScalar(bool isLiteral)
		{
			StringBuilder stringBuilder = new StringBuilder();
			StringBuilder stringBuilder2 = new StringBuilder();
			StringBuilder stringBuilder3 = new StringBuilder();
			int num = 0;
			int num2 = 0;
			int currentIndent = 0;
			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'))
					{
						throw new SyntaxErrorException(start, cursor.Mark(), "While scanning a block scalar, found an indentation indicator equal to 0.");
					}
					num2 = analyzer.AsDigit();
					Skip();
				}
			}
			else if (analyzer.IsDigit())
			{
				if (analyzer.Check('0'))
				{
					throw new SyntaxErrorException(start, cursor.Mark(), "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('#'))
			{
				throw new SyntaxErrorException(start, cursor.Mark(), "While scanning a block scalar, found a comment without whtespace after '>' indicator.");
			}
			while (analyzer.IsWhite())
			{
				Skip();
			}
			ProcessComment();
			if (!analyzer.IsBreakOrZero())
			{
				throw new SyntaxErrorException(start, cursor.Mark(), "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 == true)
				{
					isFirstLine = false;
				}
			}
			Mark end = cursor.Mark();
			if (num2 != 0)
			{
				currentIndent = ((indent >= 0) ? (indent + num2) : num2);
			}
			currentIndent = ScanBlockScalarBreaks(currentIndent, stringBuilder3, isLiteral, ref end, ref isFirstLine);
			isFirstLine = false;
			while (cursor.LineOffset == currentIndent && !analyzer.IsZero() && !IsDocumentEnd())
			{
				bool flag2 = analyzer.IsWhite();
				if (!isLiteral && StartsWith(stringBuilder2, '\n') && !flag && !flag2)
				{
					if (stringBuilder3.Length == 0)
					{
						stringBuilder.Append(' ');
					}
					stringBuilder2.Length = 0;
				}
				else
				{
					stringBuilder.Append(stringBuilder2.ToString());
					stringBuilder2.Length = 0;
				}
				stringBuilder.Append(stringBuilder3.ToString());
				stringBuilder3.Length = 0;
				flag = analyzer.IsWhite();
				while (!analyzer.IsBreakOrZero())
				{
					stringBuilder.Append(ReadCurrentCharacter());
				}
				char c = ReadLine();
				if (c != 0)
				{
					stringBuilder2.Append(c);
				}
				currentIndent = ScanBlockScalarBreaks(currentIndent, stringBuilder3, isLiteral, ref end, ref isFirstLine);
			}
			if (num != -1)
			{
				stringBuilder.Append((object?)stringBuilder2);
			}
			if (num == 1)
			{
				stringBuilder.Append((object?)stringBuilder3);
			}
			ScalarStyle style = (isLiteral ? ScalarStyle.Literal : ScalarStyle.Folded);
			return new YamlDotNet.Core.Tokens.Scalar(stringBuilder.ToString(), style, start, end);
		}

		private int ScanBlockScalarBreaks(int currentIndent, StringBuilder breaks, bool isLiteral, ref Mark end, ref bool? isFirstLine)
		{
			int num = 0;
			int num2 = -1;
			end = cursor.Mark();
			while (true)
			{
				if ((currentIndent == 0 || cursor.LineOffset < currentIndent) && analyzer.IsSpace())
				{
					Skip();
					continue;
				}
				if (cursor.LineOffset > num)
				{
					num = cursor.LineOffset;
				}
				if (!analyzer.IsBreak())
				{
					break;
				}
				if (isFirstLine == true)
				{
					isFirstLine = false;
					num2 = cursor.LineOffset;
				}
				breaks.Append(ReadLine());
				end = cursor.Mark();
			}
			if (isLiteral && isFirstLine == true)
			{
				int 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)
			{
				throw new SemanticErrorException(end, cursor.Mark(), "While scanning a literal block scalar, found extra spaces in first line.");
			}
			if (!isLiteral && num > cursor.LineOffset && num2 > -1)
			{
				throw new SemanticErrorException(end, cursor.Mark(), "While scanning a literal block scalar, found more spaces in lines above first content line.");
			}
			if (currentIndent == 0 && (cursor.LineOffset > 0 || indent > -1))
			{
				currentIndent = Math.Max(num, Math.Max(indent + 1, 1));
			}
			return currentIndent;
		}

		private void FetchFlowScalar(bool isSingleQuoted)
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			tokens.Enqueue(ScanFlowScalar(isSingleQuoted));
			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 Token ScanFlowScalar(bool isSingleQuoted)
		{
			Mark start = cursor.Mark();
			Skip();
			StringBuilder stringBuilder = new StringBuilder();
			StringBuilder stringBuilder2 = new StringBuilder();
			StringBuilder stringBuilder3 = new StringBuilder();
			StringBuilder stringBuilder4 = new StringBuilder();
			bool flag = false;
			while (true)
			{
				if (IsDocumentIndicator())
				{
					throw new SyntaxErrorException(start, cursor.Mark(), "While scanning a quoted scalar, found unexpected document indicator.");
				}
				if (analyzer.IsZero())
				{
					throw new SyntaxErrorException(start, cursor.Mark(), "While scanning a quoted scalar, found unexpected end of stream.");
				}
				if (flag && !isSingleQuoted && indent >= cursor.LineOffset)
				{
					throw new SyntaxErrorException(start, cursor.Mark(), "While scanning a multi-line double-quoted scalar, found wrong indentation.");
				}
				flag = false;
				while (!analyzer.IsWhiteBreakOrZero())
				{
					if (isSingleQuoted && analyzer.Check('\'') && analyzer.Check('\'', 1))
					{
						stringBuilder.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))
							{
								stringBuilder.Append(value);
								break;
							}
							throw new SyntaxErrorException(start, cursor.Mark(), "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))
							{
								throw new SyntaxErrorException(start, cursor.Mark(), "While scanning a quoted scalar, did not find expected hexadecimal number.");
							}
							num2 = (num2 << 4) + analyzer.AsHex(i);
						}
						if ((num2 >= 55296 && num2 <= 57343) || num2 > 1114111)
						{
							throw new SyntaxErrorException(start, cursor.Mark(), "While scanning a quoted scalar, found invalid Unicode character escape code.");
						}
						stringBuilder.Append(char.ConvertFromUtf32(num2));
						for (int j = 0; j < num; j++)
						{
							Skip();
						}
					}
					else
					{
						stringBuilder.Append(ReadCurrentCharacter());
					}
				}
				if (analyzer.Check(isSingleQuoted ? '\'' : '"'))
				{
					break;
				}
				while (analyzer.IsWhite() || analyzer.IsBreak())
				{
					if (analyzer.IsWhite())
					{
						if (!flag)
						{
							stringBuilder2.Append(ReadCurrentCharacter());
						}
						else
						{
							Skip();
						}
					}
					else if (!flag)
					{
						stringBuilder2.Length = 0;
						stringBuilder3.Append(ReadLine());
						flag = true;
					}
					else
					{
						stringBuilder4.Append(ReadLine());
					}
				}
				if (flag)
				{
					if (StartsWith(stringBuilder3, '\n'))
					{
						if (stringBuilder4.Length == 0)
						{
							stringBuilder.Append(' ');
						}
						else
						{
							stringBuilder.Append(stringBuilder4.ToString());
						}
					}
					else
					{
						stringBuilder.Append(stringBuilder3.ToString());
						stringBuilder.Append(stringBuilder4.ToString());
					}
					stringBuilder3.Length = 0;
					stringBuilder4.Length = 0;
				}
				else
				{
					stringBuilder.Append(stringBuilder2.ToString());
					stringBuilder2.Length = 0;
				}
			}
			Skip();
			return new YamlDotNet.Core.Tokens.Scalar(stringBuilder.ToString(), isSingleQuoted ? ScalarStyle.SingleQuoted : ScalarStyle.DoubleQuoted, start, cursor.Mark());
		}

		private void FetchPlainScalar()
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			bool isMultiline = false;
			YamlDotNet.Core.Tokens.Scalar item = 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)
		{
			StringBuilder stringBuilder = new StringBuilder();
			StringBuilder stringBuilder2 = new StringBuilder();
			StringBuilder stringBuilder3 = new StringBuilder();
			StringBuilder stringBuilder4 = new StringBuilder();
			bool flag = false;
			int num = indent + 1;
			Mark mark = cursor.Mark();
			Mark end = mark;
			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 || stringBuilder2.Length > 0)
					{
						if (flag)
						{
							if (StartsWith(stringBuilder3, '\n'))
							{
								if (stringBuilder4.Length == 0)
								{
									stringBuilder.Append(' ');
								}
								else
								{
									stringBuilder.Append((object?)stringBuilder4);
								}
							}
							else
							{
								stringBuilder.Append((object?)stringBuilder3);
								stringBuilder.Append((object?)stringBuilder4);
							}
							stringBuilder3.Length = 0;
							stringBuilder4.Length = 0;
							flag = false;
						}
						else
						{
							stringBuilder.Append((object?)stringBuilder2);
							stringBuilder2.Length = 0;
						}
					}
					if (flowLevel > 0 && cursor.LineOffset < num)
					{
						throw new Exception();
					}
					stringBuilder.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())
						{
							throw new SyntaxErrorException(mark, cursor.Mark(), "While scanning a plain scalar, found a tab character that violate indentation.");
						}
						if (!flag)
						{
							stringBuilder2.Append(ReadCurrentCharacter());
						}
						else
						{
							Skip();
						}
					}
					else
					{
						isMultiline = true;
						if (!flag)
						{
							stringBuilder2.Length = 0;
							stringBuilder3.Append(ReadLine());
							flag = true;
						}
						else
						{
							stringBuilder4.Append(ReadLine());
						}
					}
				}
				if (flowLevel == 0 && cursor.LineOffset < num)
				{
					break;
				}
			}
			if (flag)
			{
				simpleKeyAllowed = true;
			}
			return new YamlDotNet.Core.Tokens.Scalar(stringBuilder.ToString(), ScalarStyle.Plain, mark, end);
		}

		private void RemoveSimpleKey()
		{
			SimpleKey simpleKey = simpleKeys.Peek();
			if (simpleKey.IsPossible && simpleKey.IsRequired)
			{
				throw new SyntaxErrorException(simpleKey.Mark, simpleKey.Mark, "While scanning a simple key, could not find expected ':'.");
			}
			simpleKey.MarkAsImpossible();
		}

		private string ScanDirectiveName(Mark start)
		{
			StringBuilder stringBuilder = new StringBuilder();
			while (analyzer.IsAlphaNumericDashOrUnderscore())
			{
				stringBuilder.Append(ReadCurrentCharacter());
			}
			if (stringBuilder.Length == 0)
			{
				throw new SyntaxErrorException(start, cursor.Mark(), "While scanning a directive, could not find expected directive name.");
			}
			if (!analyzer.IsWhiteBreakOrZero())
			{
				throw new SyntaxErrorException(start, cursor.Mark(), "While scanning a directive, found unexpected non-alphabetical character.");
			}
			return stringBuilder.ToString();
		}

		private void SkipWhitespaces()
		{
			while (analyzer.IsWhite())
			{
				Skip();
			}
		}

		private Token ScanVersionDirectiveValue(Mark start)
		{
			SkipWhitespaces();
			int major = ScanVersionDirectiveNumber(start);
			if (!analyzer.Check('.'))
			{
				throw new SyntaxErrorException(start, cursor.Mark(), "While scanning a %YAML directive, did not find expected digit or '.' character.");
			}
			Skip();
			int minor = ScanVersionDirectiveNumber(start);
			return new VersionDirective(new Version(major, minor), start, start);
		}

		private Token ScanTagDirectiveValue(Mark start)
		{
			SkipWhitespaces();
			string handle = ScanTagHandle(isDirective: true, start);
			if (!analyzer.IsWhite())
			{
				throw new SyntaxErrorException(start, cursor.Mark(), "While scanning a %TAG directive, did not find expected whitespace.");
			}
			SkipWhitespaces();
			string prefix = ScanTagUri(null, start);
			if (!analyzer.IsWhiteBreakOrZero())
			{
				throw new SyntaxErrorException(start, cursor.Mark(), "While scanning a %TAG directive, did not find expected whitespace or line break.");
			}
			return new TagDirective(handle, prefix, start, start);
		}

		private string ScanTagUri([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] string head, Mark start)
		{
			StringBuilder stringBuilder = new StringBuilder();
			if (head != null && head.Length > 1)
			{
				stringBuilder.Append(head.Substring(1));
			}
			while (analyzer.IsAlphaNumericDashOrUnderscore() || analyzer.Check(";/?:@&=+$.!~*'()[]%") || (analyzer.Check(',') && !analyzer.IsBreak(1)))
			{
				if (analyzer.Check('%'))
				{
					stringBuilder.Append(ScanUriEscapes(start));
				}
				else if (analyzer.Check('+'))
				{
					stringBuilder.Append(' ');
					Skip();
				}
				else
				{
					stringBuilder.Append(ReadCurrentCharacter());
				}
			}
			if (stringBuilder.Length == 0)
			{
				return string.Empty;
			}
			return stringBuilder.ToString();
		}

		private string ScanUriEscapes(Mark start)
		{
			byte[] array = EmptyBytes;
			int count = 0;
			int num = 0;
			do
			{
				if (!analyzer.Check('%') || !analyzer.IsHex(1) || !analyzer.IsHex(2))
				{
					throw new SyntaxErrorException(start, cursor.Mark(), "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)
					{
						throw new SyntaxErrorException(start, cursor.Mark(), "While scanning a tag, found an incorrect leading UTF-8 octet.");
					}
					array = new byte[num];
				}
				else if ((num2 & 0xC0) != 128)
				{
					throw new SyntaxErrorException(start, cursor.Mark(), "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)
			{
				throw new SyntaxErrorException(start, cursor.Mark(), "While scanning a tag, found an incorrect UTF-8 sequence.");
			}
			return @string;
		}

		private string ScanTagHandle(bool isDirective, Mark start)
		{
			if (!analyzer.Check('!'))
			{
				throw new SyntaxErrorException(start, cursor.Mark(), "While scanning a tag, did not find expected '!'.");
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(ReadCurrentCharacter());
			while (analyzer.IsAlphaNumericDashOrUnderscore())
			{
				stringBuilder.Append(ReadCurrentCharacter());
			}
			if (analyzer.Check('!'))
			{
				stringBuilder.Append(ReadCurrentCharacter());
			}
			else if (isDirective && (stringBuilder.Length != 1 || stringBuilder[0] != '!'))
			{
				throw new SyntaxErrorException(start, cursor.Mark(), "While scanning a tag directive, did not find expected '!'.");
			}
			return stringBuilder.ToString();
		}

		private int ScanVersionDirectiveNumber(Mark start)
		{
			int num = 0;
			int num2 = 0;
			while (analyzer.IsDigit())
			{
				if (++num2 > 9)
				{
					throw new SyntaxErrorException(start, cursor.Mark(), "While scanning a %YAML directive, found extremely long version number.");
				}
				num = num * 10 + analyzer.AsDigit();
				Skip();
			}
			if (num2 == 0)
			{
				throw new SyntaxErrorException(start, cursor.Mark(), "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);
			}
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal class SemanticErrorException : YamlException
	{
		public SemanticErrorException(string message)
			: base(message)
		{
		}

		public SemanticErrorException(Mark start, Mark end, string message)
			: base(start, end, message)
		{
		}

		public SemanticErrorException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class SimpleKey
	{
		private readonly Cursor cursor;

		public bool IsPossible { get; private set; }

		public bool IsRequired { get; }

		public int TokenNumber { get; }

		public int Index => cursor.Index;

		public int Line => cursor.Line;

		public int 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
	{
		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(1)]
		private readonly string value;

		public int Position { get; private set; }

		public int Length => value.Length;

		public bool EndOfInput => IsOutside(Position);

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public StringLookAheadBuffer(string value)
		{
			this.value = value;
		}

		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;
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class SyntaxErrorException : YamlException
	{
		public SyntaxErrorException(string message)
			: base(message)
		{
		}

		public SyntaxErrorException(Mark start, Mark end, string message)
			: base(start, end, message)
		{
		}

		public SyntaxErrorException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(new byte[] { 0, 1, 1 })]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal 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));
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal struct TagName : IEquatable<TagName>
	{
		public static readonly TagName Empty;

		[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)]
		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);
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
		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);
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
		public static implicit operator TagName(string value)
		{
			if (value != null)
			{
				return new TagName(value);
			}
			return Empty;
		}
	}
	internal 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;
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
		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());
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal class YamlException : Exception
	{
		public Mark Start { get; }

		public Mark End { get; }

		public YamlException(string message)
			: this(Mark.Empty, Mark.Empty, message)
		{
		}

		public YamlException(Mark start, Mark end, string message)
			: this(start, end, message, null)
		{
		}

		public YamlException(Mark start, Mark end, string message, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] Exception innerException)
			: base($"({start}) - ({end}): {message}", innerException)
		{
			Start = start;
			End = end;
		}

		public YamlException(string message, Exception inner)
			: this(Mark.Empty, Mark.Empty, message, inner)
		{
		}
	}
}
namespace YamlDotNet.Core.Tokens
{
	internal class Anchor : Token
	{
		public AnchorName Value { get; }

		public Anchor(AnchorName value)
			: this(value, Mark.Empty, Mark.Empty)
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public Anchor(AnchorName value, Mark start, Mark end)
			: base(start, end)
		{
			if (value.IsEmpty)
			{
				throw new ArgumentNullException("value");
			}
			Value = value;
		}
	}
	internal sealed class AnchorAlias : Token
	{
		public AnchorName Value { get; }

		public AnchorAlias(AnchorName value)
			: this(value, Mark.Empty, Mark.Empty)
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public AnchorAlias(AnchorName value, Mark start, Mark end)
			: base(start, end)
		{
			if (value.IsEmpty)
			{
				throw new ArgumentNullException("value");
			}
			Value = value;
		}
	}
	internal sealed class BlockEnd : Token
	{
		public BlockEnd()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public BlockEnd(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class BlockEntry : Token
	{
		public BlockEntry()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public BlockEntry(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class BlockMappingStart : Token
	{
		public BlockMappingStart()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public BlockMappingStart(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class BlockSequenceStart : Token
	{
		public BlockSequenceStart()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public BlockSequenceStart(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal 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(start, end)
		{
			Value = value ?? throw new ArgumentNullException("value");
			IsInline = isInline;
		}
	}
	internal sealed class DocumentEnd : Token
	{
		public DocumentEnd()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public DocumentEnd(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class DocumentStart : Token
	{
		public DocumentStart()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public DocumentStart(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal class Error : Token
	{
		internal string Value { get; }

		internal Error(string value, Mark start, Mark end)
			: base(start, end)
		{
			Value = value;
		}
	}
	internal sealed class FlowEntry : Token
	{
		public FlowEntry()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public FlowEntry(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class FlowMappingEnd : Token
	{
		public FlowMappingEnd()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public FlowMappingEnd(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class FlowMappingStart : Token
	{
		public FlowMappingStart()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public FlowMappingStart(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class FlowSequenceEnd : Token
	{
		public FlowSequenceEnd()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public FlowSequenceEnd(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class FlowSequenceStart : Token
	{
		public FlowSequenceStart()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public FlowSequenceStart(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class Key : Token
	{
		public Key()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public Key(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class Scalar : Token
	{
		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(start, end)
		{
			Value = value ?? throw new ArgumentNullException("value");
			Style = style;
		}
	}
	internal sealed class StreamEnd : Token
	{
		public StreamEnd()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public StreamEnd(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class StreamStart : Token
	{
		public StreamStart()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public StreamStart(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal 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(start, end)
		{
			Handle = handle ?? throw new ArgumentNullException("handle");
			Suffix = suffix ?? throw new ArgumentNullException("suffix");
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal 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(start, 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;
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
		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;
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal abstract class Token
	{
		public Mark Start { get; }

		public Mark End { get; }

		protected Token(Mark start, Mark end)
		{
			Start = start ?? throw new ArgumentNullException("start");
			End = end ?? throw new ArgumentNullException("end");
		}
	}
	internal sealed class Value : Token
	{
		public Value()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public Value(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal 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(start, end)
		{
			Version = version;
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
		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.Events
{
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class AnchorAlias : ParsingEvent
	{
		internal override EventType Type => EventType.Alias;

		public AnchorName Value { get; }

		public AnchorAlias(AnchorName value, Mark start, Mark end)
			: base(start, end)
		{
			if (value.IsEmpty)
			{
				throw new YamlException(start, 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);
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal 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(start, end)
		{
			Value = value;
			IsInline = isInline;
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override string ToString()
		{
			return (IsInline ? "Inline" : "Block") + " Comment [" + Value + "]";
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal 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(start, 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);
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(2)]
	internal 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; }

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public DocumentStart([<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] VersionDirective version, [<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(2)] TagDirectiveCollection tags, bool isImplicit, Mark start, Mark end)
			: base(start, end)
		{
			Version = version;
			Tags = tags;
			IsImplicit = isImplicit;
		}

		public DocumentStart(VersionDirective version, TagDirectiveCollection tags, bool isImplicit)
			: this(version, tags, isImplicit, Mark.Empty, Mark.Empty)
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public DocumentStart(Mark start, Mark end)
			: this(null, null, isImplicit: true, start, end)
		{
		}

		public DocumentStart()
			: this(null, null, isImplicit: true, Mark.Empty, Mark.Empty)
		{
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public override string ToString()
		{
			return $"Document start [isImplicit = {IsImplicit}]";
		}

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum EventType
	{
		None,
		StreamStart,
		StreamEnd,
		DocumentStart,
		DocumentEnd,
		Alias,
		Scalar,
		SequenceStart,
		SequenceEnd,
		MappingStart,
		MappingEnd,
		Comment
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal 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);
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal class MappingEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.MappingEnd;

		public MappingEnd(Mark start, Mark end)
			: base(start, end)
		{
		}

		public MappingEnd()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return "Mapping end";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal 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);
		}
	}
	internal enum MappingStyle
	{
		Any,
		Block,
		Flow
	}
	internal abstract class NodeEvent : ParsingEvent
	{
		public AnchorName Anchor { get; }

		public TagName Tag { get; }

		public abstract bool IsCanonical { get; }

		[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
		protected NodeEvent(AnchorName anchor, TagName tag, Mark start, Mark end)
			: base(start, end)
		{
			Anchor = anchor;
			Tag = tag;
		}

		protected NodeEvent(AnchorName anchor, TagName tag)
			: this(anchor, tag, Mark.Empty, Mark.Empty)
		{
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal 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(Mark start, Mark end)
		{
			Start = start ?? throw new ArgumentNullException("start");
			End = end ?? throw new ArgumentNullException("end");
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal 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 Scalar(AnchorName anchor, TagName tag, string value, ScalarStyle style, bool isPlainImplicit, bool isQuotedImplicit, Mark start, Mark end)
			: base(anchor, tag, start, end)
		{
			Value = value;
			Style = style;
			IsPlainImplicit = isPlainImplicit;
			IsQuotedImplicit = isQuotedImplicit;
		}

		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);
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class SequenceEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.SequenceEnd;

		public SequenceEnd(Mark start, Mark end)
			: base(start, end)
		{
		}

		public SequenceEnd()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return "Sequence end";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	internal 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);
		}
	}
	internal enum SequenceStyle
	{
		Any,
		Block,
		Flow
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class StreamEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.StreamEnd;

		public StreamEnd(Mark start, Mark end)
			: base(start, end)
		{
		}

		public StreamEnd()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return "Stream end";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<6a228067-6cff-4e51-b339-a18d8b96e09a>NullableContext(1)]
	[<f5de3dd1-492f-4a0b-9ec5-49658172eecf>Nullable(0)]
	internal sealed class StreamStart : ParsingEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.StreamStart;

		public StreamStart()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		public StreamStart(Mark start, Mark end)
			: base(start, end)
		{
		}

		public override string ToString()
		{
			return "Stream start";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<9614e7ae-2bcf-4bfa-9f38-fb323784f783>Embedded]
	internal sealed class <9614e7ae-2bcf-4bfa-9f38-fb323784f783>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	[<9614e7ae-2bcf-4bfa-9f38-fb323784f783>Embedded]
	internal sealed class <82a1631b-0574-48ea-9154-6530a461483e>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <82a1631b-0574-48ea-9154-6530a461483e>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <82a1631b-0574-48ea-9154-6530a461483e>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[<9614e7ae-2bcf-4bfa-9f38-fb323784f783>Embedded]
	[CompilerGenerated]
	internal sealed class <38959417-0b4b-413a-a929-3b218fab2835>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <38959417-0b4b-413a-a929-3b218fab2835>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	[<9614e7ae-2bcf-4bfa-9f38-fb323784f783>Embedded]
	internal sealed class <3b3909e1-76c1-4f82-bb7d-844f0cc176db>RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public <3b3909e1-76c1-4f82-bb7d-844f0cc176db>RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ItemManager
{
	[PublicAPI]
	internal enum CraftingTable
	{
		Disabled,
		Inventory,
		[InternalName("piece_workbench")]
		Workbench,
		[InternalName("piece_cauldron")]
		Cauldron,
		[InternalName("piece_MeadCauldron")]
		MeadCauldron,
		[InternalName("forge")]
		Forge,
		[InternalName("piece_artisanstation")]
		ArtisanTable,
		[InternalName("piece_stonecutter")]
		StoneCutter,
		[InternalName("piece_magetable")]
		MageTable,
		[InternalName("piece_preptable")]
		PrepTable,
		[InternalName("blackforge")]
		BlackForge,
		Custom
	}
	[PublicAPI]
	internal enum ConversionPiece
	{
		Disabled,
		[InternalName("smelter")]
		Smelter,
		[InternalName("charcoal_kiln")]
		CharcoalKiln,
		[InternalName("blastfurnace")]
		BlastFurnace,
		[InternalName("windmill")]
		Windmill,
		[InternalName("piece_spinningwheel")]
		SpinningWheel,
		[InternalName("eitrrefinery")]
		EitrRefinery,
		Custom
	}
	[<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(1)]
	[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(0)]
	internal class InternalName : Attribute
	{
		public readonly string internalName;

		public InternalName(string internalName)
		{
			this.internalName = internalName;
		}
	}
	[<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(1)]
	[PublicAPI]
	[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(0)]
	internal class RequiredResourceList
	{
		public readonly List<Requirement> Requirements = new List<Requirement>();

		public bool Free;

		public void Add(string itemName, int amount, int quality = 0)
		{
			Requirements.Add(new Requirement
			{
				itemName = itemName,
				amount = amount,
				quality = quality
			});
		}

		public void Add(string itemName, ConfigEntry<int> amountConfig, int quality = 0)
		{
			Requirements.Add(new Requirement
			{
				itemName = itemName,
				amountConfig = amountConfig,
				quality = quality
			});
		}
	}
	[<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(1)]
	[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(0)]
	[PublicAPI]
	internal class CraftingStationList
	{
		public readonly List<CraftingStationConfig> Stations = new List<CraftingStationConfig>();

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

		public void Add(string customTable, int level)
		{
			Stations.Add(new CraftingStationConfig
			{
				Table = CraftingTable.Custom,
				level = level,
				custom = customTable
			});
		}
	}
	[<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(1)]
	[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(0)]
	[PublicAPI]
	internal class ItemRecipe
	{
		public readonly RequiredResourceList RequiredItems = new RequiredResourceList();

		public readonly RequiredResourceList RequiredUpgradeItems = new RequiredResourceList();

		public readonly CraftingStationList Crafting = new CraftingStationList();

		public int CraftAmount = 1;

		public bool RequireOnlyOneIngredient;

		public float QualityResultAmountMultiplier = 1f;

		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(2)]
		public ConfigEntryBase RecipeIsActive;
	}
	[PublicAPI]
	internal class Trade
	{
		public Trader Trader;

		public uint Price;

		public uint Stack = 1u;

		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(2)]
		public string RequiredGlobalKey;
	}
	[Flags]
	[PublicAPI]
	internal enum Trader
	{
		None = 0,
		Haldor = 1,
		Hildir = 2
	}
	internal struct Requirement
	{
		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(1)]
		public string itemName;

		public int amount;

		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(2)]
		public ConfigEntry<int> amountConfig;

		[Description("Set to a non-zero value to apply the requirement only for a specific quality")]
		public int quality;
	}
	internal struct CraftingStationConfig
	{
		public CraftingTable Table;

		public int level;

		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(2)]
		public string custom;
	}
	[Flags]
	internal enum Configurability
	{
		Disabled = 0,
		Recipe = 1,
		Stats = 2,
		Drop = 4,
		Trader = 8,
		Full = 0xF
	}
	[<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(1)]
	[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(0)]
	[PublicAPI]
	internal class DropTargets
	{
		public readonly List<DropTarget> Drops = new List<DropTarget>();

		public void Add(string creatureName, float chance, int min = 1, int? max = null, bool levelMultiplier = true)
		{
			Drops.Add(new DropTarget
			{
				creature = creatureName,
				chance = chance,
				min = min,
				max = max.GetValueOrDefault(min),
				levelMultiplier = levelMultiplier
			});
		}
	}
	internal struct DropTarget
	{
		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(1)]
		public string creature;

		public int min;

		public int max;

		public float chance;

		public bool levelMultiplier;
	}
	internal enum Toggle
	{
		On = 1,
		Off = 0
	}
	[<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(1)]
	[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(0)]
	[PublicAPI]
	internal class Item
	{
		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(0)]
		private class ItemConfig
		{
			[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(new byte[] { 2, 1 })]
			public ConfigEntry<string> craft;

			[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(new byte[] { 2, 1 })]
			public ConfigEntry<string> upgrade;

			public ConfigEntry<CraftingTable> table;

			public ConfigEntry<int> tableLevel;

			public ConfigEntry<string> customTable;

			[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(2)]
			public ConfigEntry<int> maximumTableLevel;

			public ConfigEntry<Toggle> requireOneIngredient;

			public ConfigEntry<float> qualityResultAmountMultiplier;
		}

		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(0)]
		private class TraderConfig
		{
			public ConfigEntry<Trader> trader;

			public ConfigEntry<uint> price;

			public ConfigEntry<uint> stack;

			public ConfigEntry<string> requiredGlobalKey;
		}

		[<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)]
		private class RequirementQuality
		{
			public int quality;
		}

		[<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(2)]
		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(0)]
		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public int? Order;

			[UsedImplicitly]
			public bool? Browsable;

			[UsedImplicitly]
			public string Category;

			[UsedImplicitly]
			[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(new byte[] { 2, 1 })]
			public Action<ConfigEntryBase> CustomDrawer;

			public Func<bool> browsability;
		}

		[PublicAPI]
		[<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)]
		public enum DamageModifier
		{
			Normal,
			Resistant,
			Weak,
			Immune,
			Ignore,
			VeryResistant,
			VeryWeak,
			None
		}

		[<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)]
		private delegate void setDmgFunc(ref DamageTypes dmg, float value);

		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(0)]
		private class SerializedRequirements
		{
			public readonly List<Requirement> Reqs;

			public SerializedRequirements(List<Requirement> reqs)
			{
				Reqs = reqs;
			}

			public SerializedRequirements(string reqs)
				: this(reqs.Split(new char[1] { ',' }).Select([<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (string r) =>
				{
					string[] array = r.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);
					result.quality = ((array.Length > 2 && int.TryParse(array[2], out var result3)) ? result3 : 0);
					return result;
				}).ToList())
			{
			}

			public override string ToString()
			{
				return string.Join(",", Reqs.Select([<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (Requirement r) => $"{r.itemName}:{r.amount}" + ((r.quality > 0) ? $":{r.quality}" : "")));
			}

			[return: <82a1631b-0574-48ea-9154-6530a461483e>Nullable(2)]
			public static ItemDrop fetchByName(ObjectDB objectDB, string name)
			{
				GameObject itemPrefab = objectDB.GetItemPrefab(name);
				ItemDrop obj = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
				if ((Object)(object)obj == (Object)null)
				{
					Debug.LogWarning((object)("The required item '" + name + "' does not exist."));
				}
				return obj;
			}

			public static Requirement[] toPieceReqs(ObjectDB objectDB, SerializedRequirements craft, SerializedRequirements upgrade)
			{
				//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f5: 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_0178: Unknown result type (might be due to invalid IL or missing references)
				//IL_017d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0185: Unknown result type (might be due to invalid IL or missing references)
				//IL_018c: Unknown result type (might be due to invalid IL or missing references)
				//IL_018f: Expected O, but got Unknown
				//IL_0194: Expected O, but got Unknown
				//IL_011c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Expected O, but got Unknown
				Dictionary<string, Requirement> dictionary = craft.Reqs.Where((Requirement r) => r.itemName != "").ToDictionary((Func<Requirement, string>)([<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (Requirement r) => r.itemName), (Func<Requirement, Requirement>)([<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (Requirement r) =>
				{
					//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_002f: 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)
					//IL_003e: Expected O, but got Unknown
					ItemDrop val6 = ResItem(r);
					return (val6 != null) ? new Requirement
					{
						m_amount = (r.amountConfig?.Value ?? r.amount),
						m_resItem = val6,
						m_amountPerLevel = 0
					} : ((Requirement)null);
				}));
				List<Requirement> list = dictionary.Values.Where([<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (Requirement v) => v != null).ToList();
				foreach (Requirement item in upgrade.Reqs.Where((Requirement r) => r.itemName != ""))
				{
					if (item.quality > 0)
					{
						ItemDrop val = ResItem(item);
						if (val != null)
						{
							Requirement val2 = new Requirement
							{
								m_resItem = val,
								m_amountPerLevel = (item.amountConfig?.Value ?? item.amount),
								m_amount = 0
							};
							list.Add(val2);
							requirementQuality.Add(val2, new RequirementQuality
							{
								quality = item.quality
							});
						}
						continue;
					}
					if (!dictionary.TryGetValue(item.itemName, out var value) || value == null)
					{
						ItemDrop val3 = ResItem(item);
						if (val3 != null)
						{
							string itemName = item.itemName;
							Requirement val4 = new Requirement
							{
								m_resItem = val3,
								m_amount = 0
							};
							Requirement val5 = val4;
							dictionary[itemName] = val4;
							value = val5;
							list.Add(value);
						}
					}
					if (value != null)
					{
						value.m_amountPerLevel = item.amountConfig?.Value ?? item.amount;
					}
				}
				return list.ToArray();
				[<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(2)]
				ItemDrop ResItem(Requirement r)
				{
					return fetchByName(objectDB, r.itemName);
				}
			}
		}

		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(0)]
		private class SerializedDrop
		{
			public readonly List<DropTarget> Drops;

			public SerializedDrop(List<DropTarget> drops)
			{
				Drops = drops;
			}

			public SerializedDrop(string drops)
			{
				Drops = ((drops == "") ? ((IEnumerable<string>)Array.Empty<string>()) : ((IEnumerable<string>)drops.Split(new char[1] { ',' }))).Select([<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (string r) =>
				{
					string[] array = r.Split(new char[1] { ':' });
					if (array.Length <= 2 || !int.TryParse(array[2], out var result))
					{
						result = 1;
					}
					if (array.Length <= 3 || !int.TryParse(array[3], out var result2))
					{
						result2 = result;
					}
					bool levelMultiplier = array.Length <= 4 || array[4] != "0";
					DropTarget result3 = default(DropTarget);
					result3.creature = array[0];
					result3.chance = ((array.Length > 1 && float.TryParse(array[1], out var result4)) ? result4 : 1f);
					result3.min = result;
					result3.max = result2;
					result3.levelMultiplier = levelMultiplier;
					return result3;
				}).ToList();
			}

			public override string ToString()
			{
				return string.Join(",", Drops.Select([<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (DropTarget r) => $"{r.creature}:{r.chance.ToString(CultureInfo.InvariantCulture)}:{r.min}:" + ((r.min == r.max) ? "" : $"{r.max}") + (r.levelMultiplier ? "" : ":0")));
			}

			[return: <82a1631b-0574-48ea-9154-6530a461483e>Nullable(2)]
			private static Character fetchByName(ZNetScene netScene, string name)
			{
				GameObject prefab = netScene.GetPrefab(name);
				Character obj = ((prefab != null) ? prefab.GetComponent<Character>() : null);
				if ((Object)(object)obj == (Object)null)
				{
					Debug.LogWarning((object)("The drop target character '" + name + "' does not exist."));
				}
				return obj;
			}

			public Dictionary<Character, Drop> toCharacterDrops(ZNetScene netScene, GameObject item)
			{
				//IL_002e: 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_003a: 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_0052: 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_006f: Expected O, but got Unknown
				Dictionary<Character, Drop> dictionary = new Dictionary<Character, Drop>();
				foreach (DropTarget drop in Drops)
				{
					Character val = fetchByName(netScene, drop.creature);
					if (val != null)
					{
						dictionary[val] = new Drop
						{
							m_prefab = item,
							m_amountMin = drop.min,
							m_amountMax = drop.max,
							m_chance = drop.chance,
							m_levelMultiplier = drop.levelMultiplier
						};
					}
				}
				return dictionary;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass83_0
		{
			public Quaternion? cameraRotation;

			public float lightIntensity;

			[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(0)]
			public ItemDrop item;

			public Quaternion? itemRotation;
		}

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

			private CodeInstruction <>2__current;

			private int <>l__initialThreadId;

			[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(new byte[] { 0, 1 })]
			private IEnumerable<CodeInstruction> instructions;

			[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(new byte[] { 0, 1 })]
			public IEnumerable<CodeInstruction> <>3__instructions;

			[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(new byte[] { 0, 1 })]
			private List<CodeInstruction> <instrs>5__2;

			[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(0)]
			private FieldInfo <amountField>5__3;

			private int <i>5__4;

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

			object IEnumerator.Current
			{
				[DebuggerHidden]
				[return: <82a1631b-0574-48ea-9154-6530a461483e>Nullable(0)]
				get
				{
					return <>2__current;
				}
			}

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<instrs>5__2 = null;
				<amountField>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0162: Unknown result type (might be due to invalid IL or missing references)
				//IL_016c: Expected O, but got Unknown
				//IL_0198: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a2: Expected O, but got Unknown
				//IL_012c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: Expected O, but got Unknown
				int num;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<instrs>5__2 = instructions.ToList();
					<amountField>5__3 = AccessTools.DeclaredField(typeof(Recipe), "m_amount");
					<i>5__4 = 0;
					break;
				case 1:
					<>1__state = -1;
					if (<i>5__4 > 1 && <instrs>5__2[<i>5__4 - 2].opcode == OpCodes.Ldfld && CodeInstructionExtensions.OperandIs(<instrs>5__2[<i>5__4 - 2], (MemberInfo)<amountField>5__3) && <instrs>5__2[<i>5__4 - 1].opcode == OpCodes.Ldc_I4_1 && <instrs>5__2[<i>5__4].operand is Label)
					{
						<>2__current = new CodeInstruction(OpCodes.Ldarg_0, (object)null);
						<>1__state = 2;
						return true;
					}
					goto IL_01b2;
				case 2:
					<>1__state = -1;
					<>2__current = new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(Item), "CheckItemIsUpgrade", (Type[])null, (Type[])null));
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = new CodeInstruction(OpCodes.Brtrue, <instrs>5__2[<i>5__4].operand);
					<>1__state = 4;
					return true;
				case 4:
					{
						<>1__state = -1;
						goto IL_01b2;
					}
					IL_01b2:
					num = <i>5__4 + 1;
					<i>5__4 = num;
					break;
				}
				if (<i>5__4 < <instrs>5__2.Count)
				{
					<>2__current = <instrs>5__2[<i>5__4];
					<>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]
			[return: <82a1631b-0574-48ea-9154-6530a461483e>Nullable(0)]
			IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
			{
				<Transpile_InventoryGui>d__85 <Transpile_InventoryGui>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Transpile_InventoryGui>d__ = this;
				}
				else
				{
					<Transpile_InventoryGui>d__ = new <Transpile_InventoryGui>d__85(0);
				}
				<Transpile_InventoryGui>d__.instructions = <>3__instructions;
				return <Transpile_InventoryGui>d__;
			}

			[DebuggerHidden]
			[return: <82a1631b-0574-48ea-9154-6530a461483e>Nullable(0)]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
			}
		}

		private static readonly List<Item> registeredItems = new List<Item>();

		private static readonly Dictionary<ItemDrop, Item> itemDropMap = new Dictionary<ItemDrop, Item>();

		private static Dictionary<Item, Dictionary<string, List<Recipe>>> activeRecipes = new Dictionary<Item, Dictionary<string, List<Recipe>>>();

		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(new byte[] { 1, 1, 2 })]
		private static Dictionary<Recipe, ConfigEntryBase> hiddenCraftRecipes = new Dictionary<Recipe, ConfigEntryBase>();

		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(new byte[] { 1, 1, 2 })]
		private static Dictionary<Recipe, ConfigEntryBase> hiddenUpgradeRecipes = new Dictionary<Recipe, ConfigEntryBase>();

		private static Dictionary<Item, Dictionary<string, ItemConfig>> itemCraftConfigs = new Dictionary<Item, Dictionary<string, ItemConfig>>();

		private static Dictionary<Item, ConfigEntry<string>> itemDropConfigs = new Dictionary<Item, ConfigEntry<string>>();

		private Dictionary<CharacterDrop, Drop> characterDrops = new Dictionary<CharacterDrop, Drop>();

		private readonly Dictionary<ConfigEntryBase, Action> statsConfigs = new Dictionary<ConfigEntryBase, Action>();

		private static readonly ConditionalWeakTable<Requirement, RequirementQuality> requirementQuality = new ConditionalWeakTable<Requirement, RequirementQuality>();

		public static Configurability DefaultConfigurability = Configurability.Full;

		public Configurability? Configurable;

		private Configurability configurationVisible = Configurability.Full;

		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(2)]
		private TraderConfig traderConfig;

		public readonly GameObject Prefab;

		[Description("Specifies the maximum required crafting station level to upgrade and repair the item.\nDefault is calculated from crafting station level and maximum quality.")]
		public int MaximumRequiredStationLevel = int.MaxValue;

		[Description("Assigns the item as a drop item to a creature.\nUses a creature name, a drop chance and a minimum and maximum amount.")]
		public readonly DropTargets DropsFrom = new DropTargets();

		[Description("Configures whether the item can be bought at the trader.\nDon't forget to set cost to something above 0 or the item will be sold for free.")]
		public readonly Trade Trade = new Trade();

		internal List<Conversion> Conversions = new List<Conversion>();

		internal List<ItemConversion> conversions = new List<ItemConversion>();

		public Dictionary<string, ItemRecipe> Recipes = new Dictionary<string, ItemRecipe>();

		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(2)]
		private LocalizeKey _name;

		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(2)]
		private LocalizeKey _description;

		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(2)]
		private static object configManager;

		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(2)]
		private static Localization _english;

		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(2)]
		private static BaseUnityPlugin _plugin;

		private static bool hasConfigSync = true;

		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(2)]
		private static object _configSync;

		private Configurability configurability => Configurable ?? DefaultConfigurability;

		[Description("Specifies the resources needed to craft the item.\nUse .Add to add resources with their internal ID and an amount.\nUse one .Add for each resource type the item should need.")]
		public RequiredResourceList RequiredItems => this[""].RequiredItems;

		[Description("Specifies the resources needed to upgrade the item.\nUse .Add to add resources with their internal ID and an amount. This amount will be multipled by the item quality level.\nUse one .Add for each resource type the upgrade should need.")]
		public RequiredResourceList RequiredUpgradeItems => this[""].RequiredUpgradeItems;

		[Description("Specifies the crafting station needed to craft the item.\nUse .Add to add a crafting station, using the CraftingTable enum and a minimum level for the crafting station.\nUse one .Add for each crafting station.")]
		public CraftingStationList Crafting => this[""].Crafting;

		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(2)]
		[Description("Specifies a config entry which toggles whether a recipe is active.")]
		public ConfigEntryBase RecipeIsActive
		{
			[<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(2)]
			get
			{
				return this[""].RecipeIsActive;
			}
			[<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(2)]
			set
			{
				this[""].RecipeIsActive = value;
			}
		}

		[Description("Specifies the number of items that should be given to the player with a single craft of the item.\nDefaults to 1.")]
		public int CraftAmount
		{
			get
			{
				return this[""].CraftAmount;
			}
			set
			{
				this[""].CraftAmount = value;
			}
		}

		public bool RequireOnlyOneIngredient
		{
			get
			{
				return this[""].RequireOnlyOneIngredient;
			}
			set
			{
				this[""].RequireOnlyOneIngredient = value;
			}
		}

		public float QualityResultAmountMultiplier
		{
			get
			{
				return this[""].QualityResultAmountMultiplier;
			}
			set
			{
				this[""].QualityResultAmountMultiplier = value;
			}
		}

		public ItemRecipe this[string name]
		{
			get
			{
				if (Recipes.TryGetValue(name, out var value))
				{
					return value;
				}
				return Recipes[name] = new ItemRecipe();
			}
		}

		public LocalizeKey Name
		{
			get
			{
				LocalizeKey name = _name;
				if (name != null)
				{
					return name;
				}
				SharedData shared = Prefab.GetComponent<ItemDrop>().m_itemData.m_shared;
				if (shared.m_name.StartsWith("$"))
				{
					_name = new LocalizeKey(shared.m_name);
				}
				else
				{
					string text = "$item_" + ((Object)Prefab).name.Replace(" ", "_");
					_name = new LocalizeKey(text).English(shared.m_name);
					shared.m_name = text;
				}
				return _name;
			}
		}

		public LocalizeKey Description
		{
			get
			{
				LocalizeKey description = _description;
				if (description != null)
				{
					return description;
				}
				SharedData shared = Prefab.GetComponent<ItemDrop>().m_itemData.m_shared;
				if (shared.m_description.StartsWith("$"))
				{
					_description = new LocalizeKey(shared.m_description);
				}
				else
				{
					string text = "$itemdesc_" + ((Object)Prefab).name.Replace(" ", "_");
					_description = new LocalizeKey(text).English(shared.m_description);
					shared.m_description = text;
				}
				return _description;
			}
		}

		private static Localization english => _english ?? (_english = LocalizationCache.ForLanguage("English"));

		private static BaseUnityPlugin plugin
		{
			get
			{
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: 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([<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
				}
				return _plugin;
			}
		}

		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(2)]
		private static object configSync
		{
			[<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(2)]
			get
			{
				if (_configSync == null && hasConfigSync)
				{
					Type type = Assembly.GetExecutingAssembly().GetType("ServerSync.ConfigSync");
					if ((object)type != null)
					{
						_configSync = Activator.CreateInstance(type, plugin.Info.Metadata.GUID + " ItemManager");
						type.GetField("CurrentVersion").SetValue(_configSync, plugin.Info.Metadata.Version.ToString());
						type.GetProperty("IsLocked").SetValue(_configSync, true);
					}
					else
					{
						hasConfigSync = false;
					}
				}
				return _configSync;
			}
		}

		public Item(string assetBundleFileName, string prefabName, string folderName = "assets")
			: this(PrefabManager.RegisterAssetBundle(assetBundleFileName, folderName), prefabName)
		{
		}

		public Item(AssetBundle bundle, string prefabName)
			: this(PrefabManager.RegisterPrefab(bundle, prefabName, addToObjectDb: true), skipRegistering: true)
		{
		}

		public Item(GameObject prefab, bool skipRegistering = false)
		{
			if (!skipRegistering)
			{
				PrefabManager.RegisterPrefab(prefab, addToObjectDb: true);
			}
			Prefab = prefab;
			registeredItems.Add(this);
			itemDropMap[Prefab.GetComponent<ItemDrop>()] = this;
			Prefab.GetComponent<ItemDrop>().m_itemData.m_dropPrefab = Prefab;
		}

		public void ToggleConfigurationVisibility(Configurability visible)
		{
			configurationVisible = visible;
			if (itemDropConfigs.TryGetValue(this, out var value))
			{
				Toggle((ConfigEntryBase)(object)value, Configurability.Drop);
			}
			if (itemCraftConfigs.TryGetValue(this, out var value2))
			{
				foreach (ItemConfig value4 in value2.Values)
				{
					ToggleObj(value4, Configurability.Recipe);
				}
			}
			foreach (Conversion conversion in Conversions)
			{
				if (conversion.config != null)
				{
					ToggleObj(conversion.config, Configurability.Recipe);
				}
			}
			foreach (KeyValuePair<ConfigEntryBase, Action> statsConfig in statsConfigs)
			{
				Toggle(statsConfig.Key, Configurability.Stats);
				if ((visible & Configurability.Stats) != 0)
				{
					statsConfig.Value();
				}
			}
			reloadConfigDisplay();
			void Toggle(ConfigEntryBase cfg, Configurability check)
			{
				object[] tags = cfg.Description.Tags;
				for (int j = 0; j < tags.Length; j++)
				{
					if (tags[j] is ConfigurationManagerAttributes configurationManagerAttributes)
					{
						configurationManagerAttributes.Browsable = (visible & check) != 0 && (configurationManagerAttributes.browsability == null || configurationManagerAttributes.browsability());
					}
				}
			}
			void ToggleObj(object obj, Configurability check)
			{
				FieldInfo[] fields = obj.GetType().GetFields();
				for (int i = 0; i < fields.Length; i++)
				{
					object? value3 = fields[i].GetValue(obj);
					ConfigEntryBase val = (ConfigEntryBase)((value3 is ConfigEntryBase) ? value3 : null);
					if (val != null)
					{
						Toggle(val, check);
					}
				}
			}
		}

		internal static void reloadConfigDisplay()
		{
			object obj = configManager?.GetType().GetProperty("DisplayingWindow").GetValue(configManager);
			if (obj is bool && (bool)obj)
			{
				configManager.GetType().GetMethod("BuildSettingList").Invoke(configManager, Array.Empty<object>());
			}
		}

		private void UpdateItemTableConfig(string recipeKey, CraftingTable table, string customTableValue)
		{
			if (activeRecipes.ContainsKey(this) && activeRecipes[this].TryGetValue(recipeKey, out var value))
			{
				value.First().m_enabled = table != CraftingTable.Disabled;
				if ((uint)table <= 1u)
				{
					value.First().m_craftingStation = null;
				}
				else if (table == CraftingTable.Custom)
				{
					Recipe obj = value.First();
					GameObject prefab = ZNetScene.instance.GetPrefab(customTableValue);
					obj.m_craftingStation = ((prefab != null) ? prefab.GetComponent<CraftingStation>() : null);
				}
				else
				{
					value.First().m_craftingStation = ZNetScene.instance.GetPrefab(getInternalName(table)).GetComponent<CraftingStation>();
				}
			}
		}

		private void UpdateCraftConfig(string recipeKey, SerializedRequirements craftRequirements, SerializedRequirements upgradeRequirements)
		{
			if (!Object.op_Implicit((Object)(object)ObjectDB.instance) || !activeRecipes.ContainsKey(this) || !activeRecipes[this].TryGetValue(recipeKey, out var value))
			{
				return;
			}
			foreach (Recipe item in value)
			{
				item.m_resources = SerializedRequirements.toPieceReqs(ObjectDB.instance, craftRequirements, upgradeRequirements);
			}
		}

		internal static void Patch_FejdStartup()
		{
			//IL_0e99: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e9e: Unknown result type (might be due to invalid IL or missing references)
			//IL_2164: Unknown result type (might be due to invalid IL or missing references)
			//IL_216e: Expected O, but got Unknown
			//IL_0f62: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f65: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fbb: Expected I4, but got Unknown
			//IL_0b88: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b92: Expected O, but got Unknown
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Expected O, but got Unknown
			//IL_10ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_10f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_10f4: Invalid comparison between Unknown and I4
			//IL_10f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_10fa: Invalid comparison between Unknown and I4
			//IL_0cab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cb5: Expected O, but got Unknown
			//IL_0d56: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d60: Expected O, but got Unknown
			//IL_10fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_1100: Invalid comparison between Unknown and I4
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0408: Expected O, but got Unknown
			//IL_0e0a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e14: Expected O, but got Unknown
			//IL_12fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_12fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_1300: Invalid comparison between Unknown and I4
			//IL_1302: Unknown result type (might be due to invalid IL or missing references)
			//IL_1306: Unknown result type (might be due to invalid IL or missing references)
			//IL_1308: Invalid comparison between Unknown and I4
			//IL_0539: Unknown result type (might be due to invalid IL or missing references)
			//IL_0543: Expected O, but got Unknown
			//IL_130a: Unknown result type (might be due to invalid IL or missing references)
			//IL_130e: Invalid comparison between Unknown and I4
			//IL_13e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_13e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_13ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_13ed: Invalid comparison between Unknown and I4
			//IL_13ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_13f3: Invalid comparison between Unknown and I4
			//IL_06f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fa: Expected O, but got Unknown
			//IL_0651: Unknown result type (might be due to invalid IL or missing references)
			//IL_065b: Expected O, but got Unknown
			//IL_1462: Unknown result type (might be due to invalid IL or missing references)
			//IL_1465: Unknown result type (might be due to invalid IL or missing references)
			//IL_1467: Invalid comparison between Unknown and I4
			//IL_07fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0804: Expected O, but got Unknown
			//IL_1469: Unknown result type (might be due to invalid IL or missing references)
			//IL_146d: Unknown result type (might be due to invalid IL or missing references)
			//IL_146f: Invalid comparison between Unknown and I4
			//IL_1471: Unknown result type (might be due to invalid IL or missing references)
			//IL_1475: Invalid comparison between Unknown and I4
			//IL_15b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_15b5: Invalid comparison between Unknown and I4
			//IL_17b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_17b9: Invalid comparison between Unknown and I4
			//IL_1882: Unknown result type (might be due to invalid IL or missing references)
			//IL_1887: Unknown result type (might be due to invalid IL or missing references)
			//IL_1889: Unknown result type (might be due to invalid IL or missing references)
			//IL_188d: Unknown result type (might be due to invalid IL or missing references)
			//IL_188f: Invalid comparison between Unknown and I4
			//IL_18fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_1901: Unknown result type (might be due to invalid IL or missing references)
			//IL_1903: Invalid comparison between Unknown and I4
			//IL_1528: Unknown result type (might be due to invalid IL or missing references)
			//IL_152d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1905: Unknown result type (might be due to invalid IL or missing references)
			//IL_1909: Invalid comparison between Unknown and I4
			//IL_190b: Unknown result type (might be due to invalid IL or missing references)
			//IL_190f: Invalid comparison between Unknown and I4
			//IL_1d7c: Unknown result type (might be due to invalid IL or missing references)
			//IL_1d7f: Invalid comparison between Unknown and I4
			Type type = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault([<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (Assembly a) => a.GetName().Name == "ConfigurationManager")?.GetType("ConfigurationManager.ConfigurationManager");
			if (DefaultConfigurability != 0)
			{
				bool saveOnConfigSet = plugin.Config.SaveOnConfigSet;
				plugin.Config.SaveOnConfigSet = false;
				foreach (Item item4 in registeredItems.Where([<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (Item i) => i.configurability != Configurability.Disabled))
				{
					Item item3 = item4;
					string name2 = item3.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_name;
					string englishName = new Regex("[=\\n\\t\\\\\"\\'\\[\\]]*").Replace(english.Localize(name2), "").Trim();
					string localizedName = Localization.instance.Localize(name2).Trim();
					int order = 0;
					if ((item3.configurability & Configurability.Recipe) != 0)
					{
						itemCraftConfigs[item3] = new Dictionary<string, ItemConfig>();
						foreach (string item5 in item3.Recipes.Keys.DefaultIfEmpty(""))
						{
							string configKey = item5;
							string text = ((configKey == "") ? "" : (" (" + configKey + ")"));
							if (!item3.Recipes.ContainsKey(configKey) || item3.Recipes[configKey].Crafting.Stations.Count <= 0)
							{
								continue;
							}
							ItemConfig itemConfig2 = (itemCraftConfigs[item3][configKey] = new ItemConfig());
							ItemConfig cfg = itemConfig2;
							List<ConfigurationManagerAttributes> hideWhenNoneAttributes = new List<ConfigurationManagerAttributes>();
							cfg.table = config(englishName, "Crafting Station" + text, item3.Recipes[configKey].Crafting.Stations.First().Table, new ConfigDescription("Crafting station where " + englishName + " is available.", (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									Order = (order -= 1),
									Browsable = ((item3.configurationVisible & Configurability.Recipe) != 0),
									Category = localizedName
								}
							}));
							ConfigurationManagerAttributes customTableAttributes = new ConfigurationManagerAttributes
							{
								Order = (order -= 1),
								browsability = CustomTableBrowsability,
								Browsable = (CustomTableBrowsability() && (item3.configurationVisible & Configurability.Recipe) != 0),
								Category = localizedName
							};
							cfg.customTable = config(englishName, "Custom Crafting Station" + text, item3.Recipes[configKey].Crafting.Stations.First().custom ?? "", new ConfigDescription("", (AcceptableValueBase)null, new object[1] { customTableAttributes }));
							cfg.table.SettingChanged += TableConfigChanged;
							cfg.customTable.SettingChanged += TableConfigChanged;
							ConfigurationManagerAttributes configurationManagerAttributes = new ConfigurationManagerAttributes
							{
								Order = (order -= 1),
								browsability = TableLevelBrowsability,
								Browsable = (TableLevelBrowsability() && (item3.configurationVisible & Configurability.Recipe) != 0),
								Category = localizedName
							};
							hideWhenNoneAttributes.Add(configurationManagerAttributes);
							cfg.tableLevel = config(englishName, "Crafting Station Level" + text, item3.Recipes[configKey].Crafting.Stations.First().level, new ConfigDescription("Required crafting station level to craft " + englishName + ".", (AcceptableValueBase)null, new object[1] { configurationManagerAttributes }));
							cfg.tableLevel.SettingChanged += [<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (object _, EventArgs _) =>
							{
								if (activeRecipes.ContainsKey(item3) && activeRecipes[item3].TryGetValue(configKey, out var value6))
								{
									value6.First().m_minStationLevel = cfg.tableLevel.Value;
								}
							};
							if (item3.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_maxQuality > 1)
							{
								cfg.maximumTableLevel = config(englishName, "Maximum Crafting Station Level" + text, (item3.MaximumRequiredStationLevel == int.MaxValue) ? (item3.Recipes[configKey].Crafting.Stations.First().level + item3.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_maxQuality - 1) : item3.MaximumRequiredStationLevel, new ConfigDescription("Maximum crafting station level to upgrade and repair " + englishName + ".", (AcceptableValueBase)null, new object[1] { configurationManagerAttributes }));
							}
							cfg.requireOneIngredient = config(englishName, "Require only one resource" + text, item3.Recipes[configKey].RequireOnlyOneIngredient ? Toggle.On : Toggle.Off, new ConfigDescription("Whether only one of the ingredients is needed to craft " + englishName, (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									Order = (order -= 1),
									Category = localizedName
								}
							}));
							ConfigurationManagerAttributes qualityResultAttributes = new ConfigurationManagerAttributes
							{
								Order = (order -= 1),
								browsability = QualityResultBrowsability,
								Browsable = (QualityResultBrowsability() && (item3.configurationVisible & Configurability.Recipe) != 0),
								Category = localizedName
							};
							cfg.requireOneIngredient.SettingChanged += [<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (object _, EventArgs _) =>
							{
								if (activeRecipes.ContainsKey(item3) && activeRecipes[item3].TryGetValue(configKey, out var value5))
								{
									foreach (Recipe item6 in value5)
									{
										item6.m_requireOnlyOneIngredient = cfg.requireOneIngredient.Value == Toggle.On;
									}
								}
								qualityResultAttributes.Browsable = QualityResultBrowsability();
								reloadConfigDisplay();
							};
							cfg.qualityResultAmountMultiplier = config(englishName, "Quality Multiplier" + text, item3.Recipes[configKey].QualityResultAmountMultiplier, new ConfigDescription("Multiplies the crafted amount based on the quality of the resources when crafting " + englishName + ". Only works, if Require Only One Resource is true.", (AcceptableValueBase)null, new object[1] { qualityResultAttributes }));
							cfg.qualityResultAmountMultiplier.SettingChanged += [<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (object _, EventArgs _) =>
							{
								if (activeRecipes.ContainsKey(item3) && activeRecipes[item3].TryGetValue(configKey, out var value4))
								{
									foreach (Recipe item7 in value4)
									{
										item7.m_qualityResultAmountMultiplier = cfg.qualityResultAmountMultiplier.Value;
									}
								}
							};
							if ((!item3.Recipes[configKey].RequiredItems.Free || item3.Recipes[configKey].RequiredItems.Requirements.Count > 0) && item3.Recipes[configKey].RequiredItems.Requirements.All((Requirement r) => r.amountConfig == null))
							{
								cfg.craft = itemConfig("Crafting Costs" + text, new SerializedRequirements(item3.Recipes[configKey].RequiredItems.Requirements).ToString(), "Item costs to craft " + englishName, isUpgrade: false);
							}
							if (item3.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_maxQuality > 1 && (!item3.Recipes[configKey].RequiredUpgradeItems.Free || item3.Recipes[configKey].RequiredUpgradeItems.Requirements.Count > 0) && item3.Recipes[configKey].RequiredUpgradeItems.Requirements.All((Requirement r) => r.amountConfig == null))
							{
								cfg.upgrade = itemConfig("Upgrading Costs" + text, new SerializedRequirements(item3.Recipes[configKey].RequiredUpgradeItems.Requirements).ToString(), "Item costs per level to upgrade " + englishName, isUpgrade: true);
							}
							if (cfg.craft != null)
							{
								cfg.craft.SettingChanged += ConfigChanged;
							}
							if (cfg.upgrade != null)
							{
								cfg.upgrade.SettingChanged += ConfigChanged;
							}
							void ConfigChanged(object o, EventArgs e)
							{
								item3.UpdateCraftConfig(configKey, new SerializedRequirements(cfg.craft?.Value ?? ""), new SerializedRequirements(cfg.upgrade?.Value ?? ""));
							}
							bool CustomTableBrowsability()
							{
								return cfg.table.Value == CraftingTable.Custom;
							}
							bool ItemBrowsability()
							{
								return cfg.table.Value != CraftingTable.Disabled;
							}
							bool QualityResultBrowsability()
							{
								return cfg.requireOneIngredient.Value == Toggle.On;
							}
							void TableConfigChanged(object o, EventArgs e)
							{
								item3.UpdateItemTableConfig(configKey, cfg.table.Value, cfg.customTable.Value);
								customTableAttributes.Browsable = cfg.table.Value == CraftingTable.Custom;
								foreach (ConfigurationManagerAttributes item8 in hideWhenNoneAttributes)
								{
									item8.Browsable = cfg.table.Value != CraftingTable.Disabled;
								}
								reloadConfigDisplay();
							}
							bool TableLevelBrowsability()
							{
								return cfg.table.Value != CraftingTable.Disabled;
							}
							ConfigEntry<string> itemConfig(string name, string value, string desc, bool isUpgrade)
							{
								//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
								//IL_00b1: Expected O, but got Unknown
								ConfigurationManagerAttributes configurationManagerAttributes3 = new ConfigurationManagerAttributes
								{
									CustomDrawer = drawRequirementsConfigTable(item3, isUpgrade),
									Order = (order -= 1),
									browsability = ItemBrowsability,
									Browsable = (ItemBrowsability() && (item3.configurationVisible & Configurability.Recipe) != 0),
									Category = localizedName
								};
								hideWhenNoneAttributes.Add(configurationManagerAttributes3);
								return config(englishName, name, value, new ConfigDescription(desc, (AcceptableValueBase)null, new object[1] { configurationManagerAttributes3 }));
							}
						}
						if ((item3.configurability & Configurability.Drop) != 0)
						{
							ConfigEntry<string> val3 = (itemDropConfigs[item3] = config(englishName, "Drops from", new SerializedDrop(item3.DropsFrom.Drops).ToString(), new ConfigDescription(englishName + " drops from this creature.", (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									CustomDrawer = drawDropsConfigTable,
									Category = localizedName,
									Browsable = ((item3.configurationVisible & Configurability.Drop) != 0)
								}
							})));
							val3.SettingChanged += [<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (object _, EventArgs _) =>
							{
								item3.UpdateCharacterDrop();
							};
						}
						for (int j = 0; j < item3.Conversions.Count; j++)
						{
							string text2 = ((item3.Conversions.Count > 1) ? $"{j + 1}. " : "");
							Conversion conversion = item3.Conversions[j];
							conversion.config = new Conversion.ConversionConfig();
							int index = j;
							conversion.config.input = config(englishName, text2 + "Conversion Input Item", conversion.Input, new ConfigDescription("Input item to create " + englishName, (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									Category = localizedName,
									Browsable = ((item3.configurationVisible & Configurability.Recipe) != 0)
								}
							}));
							conversion.config.input.SettingChanged += [<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (object _, EventArgs _) =>
							{
								if (index < item3.conversions.Count)
								{
									ObjectDB instance = ObjectDB.instance;
									if (instance != null)
									{
										ItemDrop from = SerializedRequirements.fetchByName(instance, conversion.config.input.Value);
										item3.conversions[index].m_from = from;
										UpdatePiece();
									}
								}
							};
							conversion.config.piece = config(englishName, text2 + "Conversion Piece", conversion.Piece, new ConfigDescription("Conversion piece used to create " + englishName, (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									Category = localizedName,
									Browsable = ((item3.configurationVisible & Configurability.Recipe) != 0)
								}
							}));
							conversion.config.piece.SettingChanged += [<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (object _, EventArgs _) =>
							{
								UpdatePiece();
							};
							conversion.config.customPiece = config(englishName, text2 + "Conversion Custom Piece", conversion.customPiece ?? "", new ConfigDescription("Custom conversion piece to create " + englishName, (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									Category = localizedName,
									Browsable = ((item3.configurationVisible & Configurability.Recipe) != 0)
								}
							}));
							conversion.config.customPiece.SettingChanged += [<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (object _, EventArgs _) =>
							{
								UpdatePiece();
							};
							void UpdatePiece()
							{
								if (index < item3.conversions.Count && Object.op_Implicit((Object)(object)ZNetScene.instance))
								{
									string text3 = ((conversion.config.piece.Value == ConversionPiece.Disabled) ? null : ((conversion.config.piece.Value == ConversionPiece.Custom) ? conversion.config.customPiece.Value : getInternalName(conversion.config.piece.Value)));
									string activePiece = conversion.config.activePiece;
									if (conversion.config.activePiece != null)
									{
										int num = ZNetScene.instance.GetPrefab(conversion.config.activePiece).GetComponent<Smelter>().m_conversion.IndexOf(item3.conversions[index]);
										if (num >= 0)
										{
											Smelter[] array3 = Resources.FindObjectsOfTypeAll<Smelter>();
											foreach (Smelter val4 in array3)
											{
												if (Utils.GetPrefabName(((Component)val4).gameObject) == activePiece)
												{
													val4.m_conversion.RemoveAt(num);
												}
											}
										}
										conversion.config.activePiece = null;
									}
									if (item3.conversions[index].m_from != null && conversion.config.piece.Value != 0)
									{
										GameObject prefab = ZNetScene.instance.GetPrefab(text3);
										if (((prefab != null) ? prefab.GetComponent<Smelter>() : null) != null)
										{
											conversion.config.activePiece = text3;
											Smelter[] array3 = Resources.FindObjectsOfTypeAll<Smelter>();
											foreach (Smelter val5 in array3)
											{
												if (Utils.GetPrefabName(((Component)val5).gameObject) == text3)
												{
													val5.m_conversion.Add(item3.conversions[index]);
												}
											}
										}
									}
								}
							}
						}
					}
					if ((item3.configurability & Configurability.Stats) != 0)
					{
						item3.statsConfigs.Clear();
						SharedData shared2 = item3.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared;
						ItemType itemType = shared2.m_itemType;
						statcfg<float>("Weight", "Weight of " + englishName + ".", (SharedData shared) => shared.m_weight, delegate(SharedData shared, float value)
						{
							shared.m_weight = value;
						});
						statcfg<int>("Trader Value", "Trader value of " + englishName + ".", (SharedData shared) => shared.m_value, delegate(SharedData shared, int value)
						{
							shared.m_value = value;
						});
						bool flag;
						switch (itemType - 3)
						{
						case 0:
						case 1:
						case 2:
						case 3:
						case 4:
						case 8:
						case 9:
						case 11:
						case 14:
						case 16:
						case 19:
							flag = true;
							break;
						default:
							flag = false;
							break;
						}
						if (flag)
						{
							statcfg<float>("Durability", "Durability of " + englishName + ".", (SharedData shared) => shared.m_maxDurability, delegate(SharedData shared, float value)
							{
								shared.m_maxDurability = value;
							});
							statcfg<float>("Durability per Level", "Durability gain per level of " + englishName + ".", (SharedData shared) => shared.m_durabilityPerLevel, delegate(SharedData shared, float value)
							{
								shared.m_durabilityPerLevel = value;
							});
							statcfg<float>("Movement Speed Modifier", "Movement speed modifier of " + englishName + ".", (SharedData shared) => shared.m_movementModifier, delegate(SharedData shared, float value)
							{
								shared.m_movementModifier = value;
							});
						}
						if ((itemType - 3 <= 2 || (int)itemType == 14 || (int)itemType == 22) ? true : false)
						{
							statcfg<float>("Block Armor", "Block armor of " + englishName + ".", (SharedData shared) => shared.m_blockPower, delegate(SharedData shared, float value)
							{
								shared.m_blockPower = value;
							});
							statcfg<float>("Block Armor per Level", "Block armor per level for " + englishName + ".", (SharedData shared) => shared.m_blockPowerPerLevel, delegate(SharedData shared, float value)
							{
								shared.m_blockPowerPerLevel = value;
							});
							statcfg<float>("Block Force", "Block force of " + englishName + ".", (SharedData shared) => shared.m_deflectionForce, delegate(SharedData shared, float value)
							{
								shared.m_deflectionForce = value;
							});
							statcfg<float>("Block Force per Level", "Block force per level for " + englishName + ".", (SharedData shared) => shared.m_deflectionForcePerLevel, delegate(SharedData shared, float value)
							{
								shared.m_deflectionForcePerLevel = value;
							});
							statcfg<float>("Parry Bonus", "Parry bonus of " + englishName + ".", (SharedData shared) => shared.m_timedBlockBonus, delegate(SharedData shared, float value)
							{
								shared.m_timedBlockBonus = value;
							});
						}
						else if ((itemType - 6 <= 1 || itemType - 11 <= 1 || (int)itemType == 17) ? true : false)
						{
							statcfg<float>("Armor", "Armor of " + englishName + ".", (SharedData shared) => shared.m_armor, delegate(SharedData shared, float value)
							{
								shared.m_armor = value;
							});
							statcfg<float>("Armor per Level", "Armor per level for " + englishName + ".", (SharedData shared) => shared.m_armorPerLevel, delegate(SharedData shared, float value)
							{
								shared.m_armorPerLevel = value;
							});
						}
						SkillType skillType = shared2.m_skillType;
						if (((int)skillType == 7 || (int)skillType == 12) ? true : false)
						{
							statcfg<int>("Tool tier", "Tool tier of " + englishName + ".", (SharedData shared) => shared.m_toolTier, delegate(SharedData shared, int value)
							{
								shared.m_toolTier = value;
							});
						}
						if ((itemType - 5 <= 2 || itemType - 11 <= 1 || (int)itemType == 17) ? true : false)
						{
							Dictionary<DamageType, DamageModifier> modifiers = shared2.m_damageModifiers.ToDictionary((DamageModPair d) => d.m_type, (DamageModPair d) => (DamageModifier)d.m_modifier);
							DamageType[] first = (DamageType[])Enum.GetValues(typeof(DamageType));
							DamageType[] array = new DamageType[5];
							RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
							foreach (DamageType item9 in first.Except((IEnumerable<DamageType>)(object)array))
							{
								DamageType damageType = item9;
								statcfg<DamageModifier>(((object)(DamageType)(ref damageType)).ToString() + " Resistance", ((object)(DamageType)(ref damageType)).ToString() + " resistance of " + englishName + ".", (SharedData _) => (!modifiers.TryGetValue(damageType, out var value3)) ? DamageModifier.None : value3, delegate(SharedData shared, DamageModifier value)
								{
									//IL_0002: Unknown result type (might be due to invalid IL or missing references)
									//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_0018: 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_001e: Unknown result type (might be due to invalid IL or missing references)
									//IL_002a: 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_0035: 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_0054: Unknown result type (might be due to invalid IL or missing references)
									DamageModPair val6 = default(DamageModPair);
									val6.m_type = damageType;
									val6.m_modifier = (DamageModifier)value;
									DamageModPair val7 = val6;
									for (int n = 0; n < shared.m_damageModifiers.Count; n++)
									{
										if (shared.m_damageModifiers[n].m_type == damageType)
										{
											if (value == DamageModifier.None)
											{
												shared.m_damageModifiers.RemoveAt(n);
											}
											else
											{
												shared.m_damageModifiers[n] = val7;
											}
											return;
										}
									}
									if (value != DamageModifier.None)
									{
										shared.m_damageModifiers.Add(val7);
									}
								});
							}
						}
						if ((int)itemType == 2 && shared2.m_food > 0f)
						{
							statcfg<float>("Health", "Health value of " + englishName + ".", (SharedData shared) => shared.m_food, delegate(SharedData shared, float value)
							{
								shared.m_food = value;
							});
							statcfg<float>("Stamina", "Stamina value of " + englishName + ".", (SharedData shared) => shared.m_foodStamina, delegate(SharedData shared, float value)
							{
								shared.m_foodStamina = value;
							});
							statcfg<float>("Eitr", "Eitr value of " + englishName + ".", (SharedData shared) => shared.m_foodEitr, delegate(SharedData shared, float value)
							{
								shared.m_foodEitr = value;
							});
							statcfg<float>("Duration", "Duration of " + englishName + ".", (SharedData shared) => shared.m_foodBurnTime, delegate(SharedData shared, float value)
							{
								shared.m_foodBurnTime = value;
							});
							statcfg<float>("Health Regen", "Health regen value of " + englishName + ".", (SharedData shared) => shared.m_foodRegen, delegate(SharedData shared, float value)
							{
								shared.m_foodRegen = value;
							});
						}
						if ((int)shared2.m_skillType == 10)
						{
							statcfg<float>("Health Cost", "Health cost of " + englishName + ".", (SharedData shared) => shared.m_attack.m_attackHealth, delegate(SharedData shared, float value)
							{
								shared.m_attack.m_attackHealth = value;
							});
							statcfg<float>("Health Cost Percentage", "Health cost percentage of " + englishName + ".", (SharedData shared) => shared.m_attack.m_attackHealthPercentage, delegate(SharedData shared, float value)
							{
								shared.m_attack.m_attackHealthPercentage = value;
							});
						}
						skillType = shared2.m_skillType;
						if (skillType - 9 <= 1)
						{
							statcfg<float>("Eitr Cost", "Eitr cost of " + englishName + ".", (SharedData shared) => shared.m_attack.m_attackEitr, delegate(SharedData shared, float value)
							{
								shared.m_attack.m_attackEitr = value;
							});
						}
						if ((itemType - 3 <= 1 || (int)itemType == 14 || (int)itemType == 22) ? true : false)
						{
							statcfg<float>("Knockback", "Knockback of " + englishName + ".", (SharedData shared) => shared.m_attackForce, delegate(SharedData shared, float value)
							{
								shared.m_attackForce = value;
							});
							statcfg<float>("Backstab Bonus", "Backstab bonus of " + englishName + ".", (SharedData shared) => shared.m_backstabBonus, delegate(SharedData shared, float value)
							{
								shared.m_backstabBonus = value;
							});
							statcfg<float>("Attack Stamina", "Attack stamina of " + englishName + ".", (SharedData shared) => shared.m_attack.m_attackStamina, delegate(SharedData shared, float value)
							{
								shared.m_attack.m_attackStamina = value;
							});
							SetDmg("True", (DamageTypes dmg) => dmg.m_damage, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_damage = val;
							});
							SetDmg("Slash", (DamageTypes dmg) => dmg.m_slash, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_slash = val;
							});
							SetDmg("Pierce", (DamageTypes dmg) => dmg.m_pierce, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_pierce = val;
							});
							SetDmg("Blunt", (DamageTypes dmg) => dmg.m_blunt, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_blunt = val;
							});
							SetDmg("Chop", (DamageTypes dmg) => dmg.m_chop, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_chop = val;
							});
							SetDmg("Pickaxe", (DamageTypes dmg) => dmg.m_pickaxe, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_pickaxe = val;
							});
							SetDmg("Fire", (DamageTypes dmg) => dmg.m_fire, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_fire = val;
							});
							SetDmg("Poison", (DamageTypes dmg) => dmg.m_poison, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_poison = val;
							});
							SetDmg("Frost", (DamageTypes dmg) => dmg.m_frost, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_frost = val;
							});
							SetDmg("Lightning", (DamageTypes dmg) => dmg.m_lightning, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_lightning = val;
							});
							SetDmg("Spirit", (DamageTypes dmg) => dmg.m_spirit, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_spirit = val;
							});
							if ((int)itemType == 4)
							{
								statcfg<int>("Projectiles", "Number of projectiles that " + englishName + " shoots at once.", (SharedData shared) => shared.m_attack.m_projectileBursts, delegate(SharedData shared, int value)
								{
									shared.m_attack.m_projectileBursts = value;
								});
								statcfg<float>("Burst Interval", "Time between the projectiles " + englishName + " shoots at once.", (SharedData shared) => shared.m_attack.m_burstInterval, delegate(SharedData shared, float value)
								{
									shared.m_attack.m_burstInterval = value;
								});
								statcfg<float>("Minimum Accuracy", "Minimum accuracy for " + englishName + ".", (SharedData shared) => shared.m_attack.m_projectileAccuracyMin, delegate(SharedData shared, float value)
								{
									shared.m_attack.m_projectileAccuracyMin = value;
								});
								statcfg<float>("Accuracy", "Accuracy for " + englishName + ".", (SharedData shared) => shared.m_attack.m_projectileAccuracy, delegate(SharedData shared, float value)
								{
									shared.m_attack.m_projectileAccuracy = value;
								});
								statcfg<float>("Minimum Velocity", "Minimum velocity for " + englishName + ".", (SharedData shared) => shared.m_attack.m_projectileVelMin, delegate(SharedData shared, float value)
								{
									shared.m_attack.m_projectileVelMin = value;
								});
								statcfg<float>("Velocity", "Velocity for " + englishName + ".", (SharedData shared) => shared.m_attack.m_projectileVel, delegate(SharedData shared, float value)
								{
									shared.m_attack.m_projectileVel = value;
								});
								statcfg<float>("Maximum Draw Time", "Time until " + englishName + " is fully drawn at skill level 0.", (SharedData shared) => shared.m_attack.m_drawDurationMin, delegate(SharedData shared, float value)
								{
									shared.m_attack.m_drawDurationMin = value;
								});
								statcfg<float>("Stamina Drain", "Stamina drain per second while drawing " + englishName + ".", (SharedData shared) => shared.m_attack.m_drawStaminaDrain, delegate(SharedData shared, float value)
								{
									shared.m_attack.m_drawStaminaDrain = value;
								});
							}
						}
					}
					List<ConfigurationManagerAttributes> traderAttributes;
					if ((item3.configurability & Configurability.Trader) != 0)
					{
						traderAttributes = new List<ConfigurationManagerAttributes>();
						item3.traderConfig = new TraderConfig
						{
							trader = config(englishName, "Trader Selling", item3.Trade.Trader, new ConfigDescription("Which traders sell " + englishName + ".", (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									Order = (order -= 1),
									Browsable = ((item3.configurationVisible & Configurability.Trader) != 0),
									Category = localizedName
								}
							}))
						};
						item3.traderConfig.trader.SettingChanged += [<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (object _, EventArgs _) =>
						{
							item3.ReloadTraderConfiguration();
							foreach (ConfigurationManagerAttributes item10 in traderAttributes)
							{
								item10.Browsable = TraderBrowsability();
							}
							reloadConfigDisplay();
						};
						item3.traderConfig.price = traderConfig<uint>("Trader Price", item3.Trade.Price, "Price of " + englishName + " at the trader.");
						item3.traderConfig.stack = traderConfig<uint>("Trader Stack", item3.Trade.Stack, "Stack size of " + englishName + " in the trader. Also known as the number of items sold by a trader in one transaction.");
						item3.traderConfig.requiredGlobalKey = traderConfig<string>("Trader Required Global Key", item3.Trade.RequiredGlobalKey ?? "", "Required global key to unlock " + englishName + " at the trader.");
						if (item3.traderConfig.trader.Value != 0)
						{
							PrefabManager.AddItemToTrader(item3.Prefab, item3.traderConfig.trader.Value, item3.traderConfig.price.Value, item3.traderConfig.stack.Value, item3.traderConfig.requiredGlobalKey.Value);
						}
					}
					else if (item3.Trade.Trader != 0)
					{
						PrefabManager.AddItemToTrader(item3.Prefab, item3.Trade.Trader, item3.Trade.Price, item3.Trade.Stack, item3.Trade.RequiredGlobalKey);
					}
					void SetDmg(string dmgType, Func<DamageTypes, float> readDmg, setDmgFunc setDmg)
					{
						statcfg<float>(dmgType + " Damage", dmgType + " damage dealt by " + englishName + ".", (SharedData shared) => readDmg(shared.m_damages), delegate(SharedData shared, float val)
						{
							setDmg(ref shared.m_damages, val);
						});
						statcfg<float>(dmgType + " Damage Per Level", dmgType + " damage dealt increase per level for " + englishName + ".", (SharedData shared) => readDmg(shared.m_damagesPerLevel), delegate(SharedData shared, float val)
						{
							setDmg(ref shared.m_damagesPerLevel, val);
						});
					}
					bool TraderBrowsability()
					{
						return item3.traderConfig.trader.Value != Trader.None;
					}
					void statcfg<T>(string configName, string description, [<82a1631b-0574-48ea-9154-6530a461483e>Nullable(new byte[] { 1, 1, 0 })] Func<SharedData, T> readDefault, [<82a1631b-0574-48ea-9154-6530a461483e>Nullable(new byte[] { 1, 1, 0 })] Action<SharedData, T> setValue)
					{
						//IL_0078: Unknown result type (might be due to invalid IL or missing references)
						//IL_0082: Expected O, but got Unknown
						SharedData shared3 = item3.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared;
						ConfigEntry<T> cfg2 = config(englishName, configName, readDefault(shared3), new ConfigDescription(description, (AcceptableValueBase)null, new object[1]
						{
							new ConfigurationManagerAttributes
							{
								Category = localizedName,
								Browsable = ((item3.configurationVisible & Configurability.Stats) != 0)
							}
						}));
						if ((item3.configurationVisible & Configurability.Stats) != 0)
						{
							setValue(shared3, cfg2.Value);
						}
						item3.statsConfigs.Add((ConfigEntryBase)(object)cfg2, ApplyConfig);
						cfg2.SettingChanged += [<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (object _, EventArgs _) =>
						{
							if ((item3.configurationVisible & Configurability.Stats) != 0)
							{
								ApplyConfig();
							}
						};
						void ApplyConfig()
						{
							item3.ApplyToAllInstances(delegate(ItemData item)
							{
								setValue(item.m_shared, cfg2.Value);
							});
						}
					}
					[return: <82a1631b-0574-48ea-9154-6530a461483e>Nullable(new byte[] { 1, 0 })]
					ConfigEntry<T> traderConfig<T>(string name, [<82a1631b-0574-48ea-9154-6530a461483e>Nullable(0)] T value, string desc)
					{
						//IL_0099: Unknown result type (might be due to invalid IL or missing references)
						//IL_00a3: Expected O, but got Unknown
						ConfigurationManagerAttributes configurationManagerAttributes2 = new ConfigurationManagerAttributes
						{
							Order = (order -= 1),
							browsability = TraderBrowsability,
							Browsable = (TraderBrowsability() && (item3.configurationVisible & Configurability.Trader) != 0),
							Category = localizedName
						};
						traderAttributes.Add(configurationManagerAttributes2);
						ConfigEntry<T> obj = config(englishName, name, value, new ConfigDescription(desc, (AcceptableValueBase)null, new object[1] { configurationManagerAttributes2 }));
						obj.SettingChanged += [<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (object _, EventArgs _) =>
						{
							item3.ReloadTraderConfiguration();
						};
						return obj;
					}
				}
				if (saveOnConfigSet)
				{
					plugin.Config.SaveOnConfigSet = true;
					plugin.Config.Save();
				}
			}
			configManager = ((type == null) ? null : Chainloader.ManagerObject.GetComponent(type));
			foreach (Item registeredItem in registeredItems)
			{
				Item item2 = registeredItem;
				foreach (KeyValuePair<string, ItemRecipe> recipe in item2.Recipes)
				{
					KeyValuePair<string, ItemRecipe> kv = recipe;
					RequiredResourceList[] array2 = new RequiredResourceList[2]
					{
						kv.Value.RequiredItems,
						kv.Value.RequiredUpgradeItems
					};
					foreach (RequiredResourceList requiredResourceList in array2)
					{
						for (int l = 0; l < requiredResourceList.Requirements.Count; l++)
						{
							ConfigEntry<int> amountCfg;
							int resourceIndex;
							if ((item2.configurability & Configurability.Recipe) != 0)
							{
								amountCfg = requiredResourceList.Requirements[l].amountConfig;
								if (amountCfg != null)
								{
									resourceIndex = l;
									amountCfg.SettingChanged += ConfigChanged;
								}
							}
							void ConfigChanged(object o, EventArgs e)
							{
								if (Object.op_Implicit((Object)(object)ObjectDB.instance) && activeRecipes.ContainsKey(item2) && activeRecipes[item2].TryGetValue(kv.Key, out var value2))
								{
									foreach (Recipe item11 in value2)
									{
										item11.m_resources[resourceIndex].m_amount = amountCfg.Value;
									}
								}
							}
						}
					}
				}
				item2.InitializeNewRegisteredItem();
			}
		}

		private void InitializeNewRegisteredItem()
		{
			foreach (KeyValuePair<string, ItemRecipe> recipe in Recipes)
			{
				KeyValuePair<string, ItemRecipe> kv = recipe;
				ConfigEntryBase enabledCfg = kv.Value.RecipeIsActive;
				if (enabledCfg != null)
				{
					((object)enabledCfg).GetType().GetEvent("SettingChanged").AddEventHandler(enabledCfg, new EventHandler(ConfigChanged));
				}
				void ConfigChanged(object o, EventArgs e)
				{
					if (Object.op_Implicit((Object)(object)ObjectDB.instance) && activeRecipes.ContainsKey(this) && activeRecipes[this].TryGetValue(kv.Key, out var value))
					{
						foreach (Recipe item in value)
						{
							item.m_enabled = (int)enabledCfg.BoxedValue != 0;
						}
					}
				}
			}
		}

		public void ReloadCraftingConfiguration()
		{
			if (Object.op_Implicit((Object)(object)ObjectDB.instance) && ObjectDB.instance.GetItemPrefab(StringExtensionMethods.GetStableHashCode(((Object)Prefab).name)) == null)
			{
				registerRecipesInObjectDB(ObjectDB.instance);
				ObjectDB.instance.m_items.Add(Prefab);
				ObjectDB.instance.m_itemByHash.Add(StringExtensionMethods.GetStableHashCode(((Object)Prefab).name), Prefab);
				ZNetScene.instance.m_prefabs.Add(Prefab);
				ZNetScene.instance.m_namedPrefabs.Add(StringExtensionMethods.GetStableHashCode(((Object)Prefab).name), Prefab);
			}
			foreach (string item in Recipes.Keys.DefaultIfEmpty(""))
			{
				if (Recipes.TryGetValue(item, out var value) && value.Crafting.Stations.Count > 0)
				{
					UpdateItemTableConfig(item, value.Crafting.Stations.First().Table, value.Crafting.Stations.First().custom ?? "");
					UpdateCraftConfig(item, new SerializedRequirements(value.RequiredItems.Requirements), new SerializedRequirements(value.RequiredUpgradeItems.Requirements));
				}
			}
		}

		private void ReloadTraderConfiguration()
		{
			if (traderConfig.trader.Value == Trader.None)
			{
				PrefabManager.RemoveItemFromTrader(Prefab);
			}
			else
			{
				PrefabManager.AddItemToTrader(Prefab, traderConfig.trader.Value, traderConfig.price.Value, traderConfig.stack.Value, traderConfig.requiredGlobalKey.Value);
			}
		}

		public static void ApplyToAllInstances(GameObject prefab, Action<ItemData> callback)
		{
			callback(prefab.GetComponent<ItemDrop>().m_itemData);
			string name = prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_name;
			Inventory[] source = (from c in Player.s_players.Select([<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (Player p) => ((Humanoid)p).GetInventory()).Concat(from c in Object.FindObjectsOfType<Container>()
					select c.GetInventory())
				where c != null
				select c).ToArray();
			foreach (ItemData item in (from i in (from p in ObjectDB.instance.m_items
					select p.GetComponent<ItemDrop>() into c
					where Object.op_Implicit((Object)(object)c) && Object.op_Implicit((Object)(object)((Component)c).GetComponent<ZNetView>())
					select c).Concat(ItemDrop.s_instances)
				select i.m_itemData).Concat(source.SelectMany([<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (Inventory i) => i.GetAllItems())))
			{
				if (item.m_shared.m_name == name)
				{
					callback(item);
				}
			}
		}

		public void ApplyToAllInstances(Action<ItemData> callback)
		{
			ApplyToAllInstances(Prefab, callback);
		}

		[<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)]
		[return: <82a1631b-0574-48ea-9154-6530a461483e>Nullable(1)]
		private static string getInternalName<T>(T value) where T : struct
		{
			return ((InternalName)typeof(T).GetMember(value.ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName;
		}

		private void registerRecipesInObjectDB(ObjectDB objectDB)
		{
			//IL_044e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0453: Unknown result type (might be due to invalid IL or missing references)
			//IL_0486: Unknown result type (might be due to invalid IL or missing references)
			//IL_049c: Expected O, but got Unknown
			activeRecipes[this] = new Dictionary<string, List<Recipe>>();
			itemCraftConfigs.TryGetValue(this, out var value);
			foreach (KeyValuePair<string, ItemRecipe> recipe in Recipes)
			{
				List<Recipe> list = new List<Recipe>();
				foreach (CraftingStationConfig station in recipe.Value.Crafting.Stations)
				{
					ItemConfig itemConfig = value?[recipe.Key];
					Recipe val = ScriptableObject.CreateInstance<Recipe>();
					string name = ((Object)Prefab).name;
					CraftingTable table = station.Table;
					((Object)val).name = name + "_Recipe_" + table;
					val.m_amount = recipe.Value.CraftAmount;
					bool enabled;
					if (itemConfig != null)
					{
						enabled = itemConfig.table.Value != CraftingTable.Disabled;
					}
					else
					{
						ConfigEntryBase recipeIsActive = recipe.Value.RecipeIsActive;
						enabled = (int)(((recipeIsActive != null) ? recipeIsActive.BoxedValue : null) ?? ((object)1)) != 0;
					}
					val.m_enabled = enabled;
					val.m_item = Prefab.GetComponent<ItemDrop>();
					val.m_resources = SerializedRequirements.toPieceReqs(objectDB, (itemConfig?.craft == null) ? new SerializedRequirements(recipe.Value.RequiredItems.Requirements) : new SerializedRequirements(itemConfig.craft.Value), (itemConfig?.upgrade == null) ? new SerializedRequirements(recipe.Value.RequiredUpgradeItems.Requirements) : new SerializedRequirements(itemConfig.upgrade.Value));
					table = ((itemConfig == null || list.Count > 0) ? station.Table : itemConfig.table.Value);
					if ((uint)table <= 1u)
					{
						val.m_craftingStation = null;
					}
					else if (((itemConfig == null || list.Count > 0) ? station.Table : itemConfig.table.Value) == CraftingTable.Custom)
					{
						GameObject prefab = ZNetScene.instance.GetPrefab((itemConfig == null || list.Count > 0) ? station.custom : itemConfig.customTable.Value);
						if (prefab != null)
						{
							val.m_craftingStation = prefab.GetComponent<CraftingStation>();
						}
						else
						{
							Debug.LogWarning((object)("Custom crafting station '" + ((itemConfig == null || list.Count > 0) ? station.custom : itemConfig.customTable.Value) + "' does not exist"));
						}
					}
					else
					{
						val.m_craftingStation = ZNetScene.instance.GetPrefab(getInternalName((itemConfig == null || list.Count > 0) ? station.Table : itemConfig.table.Value)).GetComponent<CraftingStation>();
					}
					val.m_minStationLevel = ((itemConfig == null || list.Count > 0) ? station.level : itemConfig.tableLevel.Value);
					val.m_requireOnlyOneIngredient = ((itemConfig == null) ? recipe.Value.RequireOnlyOneIngredient : (itemConfig.requireOneIngredient.Value == Toggle.On));
					val.m_qualityResultAmountMultiplier = itemConfig?.qualityResultAmountMultiplier.Value ?? recipe.Value.QualityResultAmountMultiplier;
					list.Add(val);
					RequiredResourceList requiredItems = recipe.Value.RequiredItems;
					if (requiredItems != null && !requiredItems.Free)
					{
						List<Requirement> requirements = requiredItems.Requirements;
						if (requirements != null && requirements.Count == 0)
						{
							hiddenCraftRecipes.Add(val, recipe.Value.RecipeIsActive);
						}
					}
					requiredItems = recipe.Value.RequiredUpgradeItems;
					if (requiredItems != null && !requiredItems.Free)
					{
						List<Requirement> requirements = requiredItems.Requirements;
						if (requirements != null && requirements.Count == 0)
						{
							hiddenUpgradeRecipes.Add(val, recipe.Value.RecipeIsActive);
						}
					}
				}
				activeRecipes[this].Add(recipe.Key, list);
				objectDB.m_recipes.AddRange(list);
			}
			conversions = new List<ItemConversion>();
			for (int i = 0; i < Conversions.Count; i++)
			{
				Conversion conversion = Conversions[i];
				conversions.Add(new ItemConversion
				{
					m_from = SerializedRequirements.fetchByName(ObjectDB.instance, conversion.config?.input.Value ?? conversion.Input),
					m_to = Prefab.GetComponent<ItemDrop>()
				});
				ConversionPiece conversionPiece = conversion.config?.piece.Value ?? conversion.Piece;
				string text = null;
				if (conversionPiece != 0 && conversions[i].m_from != null)
				{
					text = ((conversionPiece != ConversionPiece.Custom) ? getInternalName(conversionPiece) : (conversion.config?.customPiece.Value ?? conversion.customPiece));
					GameObject prefab2 = ZNetScene.instance.GetPrefab(text);
					Smelter val2 = ((prefab2 != null) ? prefab2.GetComponent<Smelter>() : null);
					if (val2 != null)
					{
						val2.m_conversion.Add(conversions[i]);
					}
					else
					{
						text = null;
					}
				}
				if (conversion.config != null)
				{
					conversion.config.activePiece = text;
				}
			}
		}

		[HarmonyPriority(0)]
		internal static void Patch_ObjectDBInit(ObjectDB __instance)
		{
			if ((Object)(object)__instance.GetItemPrefab("YagluthDrop") == (Object)null)
			{
				return;
			}
			hiddenCraftRecipes.Clear();
			hiddenUpgradeRecipes.Clear();
			foreach (Item registeredItem in registeredItems)
			{
				registeredItem.registerRecipesInObjectDB(__instance);
			}
		}

		internal static void Patch_TraderGetAvailableItems(Trader __instance, ref List<TradeItem> __result)
		{
			string prefabName = Utils.GetPrefabName(((Component)__instance).gameObject);
			Trader trader2 = ((prefabName == "Haldor") ? Trader.Haldor : ((prefabName == "Hildir") ? Trader.Hildir : Trader.None));
			Trader trader = trader2;
			__result.AddRange(from tuple in PrefabManager.CustomTradeItems.Values
				where (tuple.Item1 & trader) != 0
				select tuple.Item2 into tradeItem
				where string.IsNullOrEmpty(tradeItem.m_requiredGlobalKey) || ZoneSystem.instance.GetGlobalKey(tradeItem.m_requiredGlobalKey)
				select tradeItem);
		}

		internal static void Patch_OnAddSmelterInput(ItemData item, bool __result)
		{
			if (__result)
			{
				((Humanoid)Player.m_localPlayer).UnequipItem(item, true);
			}
		}

		internal static void Patch_MaximumRequiredStationLevel(Recipe __instance, ref int __result, int quality)
		{
			if (!itemDropMap.TryGetValue(__instance.m_item, out var value))
			{
				return;
			}
			IEnumerable<ItemConfig> source;
			if (!itemCraftConfigs.TryGetValue(value, out var value2))
			{
				source = Enumerable.Empty<ItemConfig>();
			}
			else
			{
				CraftingStation currentCraftingStation = Player.m_localPlayer.GetCurrentCraftingStation();
				if (currentCraftingStation != null)
				{
					string stationName = Utils.GetPrefabName(((Component)currentCraftingStation).gameObject);
					source = from c in value2.Where([<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (KeyValuePair<string, ItemConfig> c) =>
						{
							switch (c.Value.table.Value)
							{
							case CraftingTable.Disabled:
							case CraftingTable.Inventory:
								return false;
							case CraftingTable.Custom:
								return c.Value.customTable.Value == stationName;
							default:
								return getInternalName(c.Value.table.Value) == stationName;
							}
						})
						select c.Value;
				}
				else
				{
					source = value2.Values;
				}
			}
			__result = Mathf.Min(Mathf.Max(1, __instance.m_minStationLevel) + (quality - 1), (from cfg in source
				where cfg.maximumTableLevel != null
				select cfg.maximumTableLevel.Value).DefaultIfEmpty(value.MaximumRequiredStationLevel).Max());
		}

		internal static void Patch_GetAvailableRecipesPrefix([<82a1631b-0574-48ea-9154-6530a461483e>Nullable(new byte[] { 2, 1, 1, 1, 2 })] ref Dictionary<Assembly, Dictionary<Recipe, ConfigEntryBase>> __state)
		{
			if (__state == null)
			{
				__state = new Dictionary<Assembly, Dictionary<Recipe, ConfigEntryBase>>();
			}
			Dictionary<Recipe, ConfigEntryBase> dictionary;
			if (InventoryGui.instance.InCraftTab())
			{
				dictionary = hiddenCraftRecipes;
			}
			else
			{
				if (!InventoryGui.instance.InUpradeTab())
				{
					return;
				}
				dictionary = hiddenUpgradeRecipes;
			}
			foreach (Recipe key in dictionary.Keys)
			{
				key.m_enabled = false;
			}
			__state[Assembly.GetExecutingAssembly()] = dictionary;
		}

		internal static void Patch_GetAvailableRecipesFinalizer([<82a1631b-0574-48ea-9154-6530a461483e>Nullable(new byte[] { 1, 1, 1, 1, 2 })] Dictionary<Assembly, Dictionary<Recipe, ConfigEntryBase>> __state)
		{
			if (!__state.TryGetValue(Assembly.GetExecutingAssembly(), out var value))
			{
				return;
			}
			foreach (KeyValuePair<Recipe, ConfigEntryBase> item in value)
			{
				Recipe key = item.Key;
				ConfigEntryBase value2 = item.Value;
				key.m_enabled = (int)(((value2 != null) ? value2.BoxedValue : null) ?? ((object)1)) != 0;
			}
		}

		internal static IEnumerable<CodeInstruction> Transpile_SetupRequirementList(IEnumerable<CodeInstruction> instructionsEnumerable, ILGenerator ilg)
		{
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Expected O, but got Unknown
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Expected O, but got Unknown
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Expected O, but got Unknown
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Expected O, but got Unknown
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Expected O, but got Unknown
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Expected O, but got Unknown
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Expected O, but got Unknown
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Expected O, but got Unknown
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Expected O, but got Unknown
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Expected O, but got Unknown
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Expected O, but got Unknown
			List<CodeInstruction> list = instructionsEnumerable.ToList();
			MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(InventoryGui), "SetupRequirement", (Type[])null, (Type[])null);
			CodeInstruction val = null;
			CodeInstruction val2 = null;
			LocalBuilder localBuilder = ilg.DeclareLocal(typeof(int));
			Dictionary<Label, int> dictionary = new Dictionary<Label, int>();
			bool flag = false;
			int num = 0;
			int value = 0;
			Label? label = default(Label?);
			for (int i = 0; i < list.Count; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo))
				{
					val = list[i + 2];
					val2 = list[i + 5];
					flag = true;
				}
				if (flag)
				{
					if (CodeInstructionExtensions.Branches(list[i], ref label) && dictionary.TryGetValue(label.Value, out value))
					{
						num = i;
						break;
					}
					continue;
				}
				foreach (Label label4 in list[i].labels)
				{
					dictionary[label4] = i;
				}
			}
			if (list[value - 3].opcode == OpCodes.Dup)
			{
				return list;
			}
			Label label2 = ilg.DefineLabel();
			Label label3 = ilg.DefineLabel();
			list[num + 1].labels.Add(label2);
			list.InsertRange(num + 1, (IEnumerable<CodeInstruction>)(object)new CodeInstruction[11]
			{
				new CodeInstruction(OpCodes.Ldloc, (object)localBuilder),
				new CodeInstruction(OpCodes.Brfalse, (object)label2),
				val.Clone(),
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.DeclaredField(typeof(InventoryGui), "m_recipeRequirementList")),
				new CodeInstruction(OpCodes.Ldlen, (object)null),
				new CodeInstruction(OpCodes.Bgt, (object)label2),
				new CodeInstruction(OpCodes.Ldc_I4_0, (object)null),
				val2.Clone(),
				new CodeInstruction(OpCodes.Ldc_I4_0, (object)null),
				new CodeInstruction(OpCodes.Br, (object)label3)
			});
			list.InsertRange(value - 2, (IEnumerable<CodeInstruction>)(object)new CodeInstruction[2]
			{
				new CodeInstruction(OpCodes.Dup, (object)null)
				{
					labels = new List<Label> { label3 }
				},
				new CodeInstruction(OpCodes.Stloc, (object)localBuilder)
			});
			return list;
		}

		internal static bool Patch_RequirementGetAmount(Requirement __instance, int qualityLevel, ref int __result)
		{
			if (requirementQuality.TryGetValue(__instance, out var value))
			{
				__result = ((value.quality == qualityLevel) ? __instance.m_amountPerLevel : 0);
				return false;
			}
			return true;
		}

		internal static void Patch_ZNetSceneAwake(ZNetScene __instance)
		{
			foreach (Item registeredItem in registeredItems)
			{
				registeredItem.AssignDropToCreature();
			}
		}

		public void AssignDropToCreature()
		{
			foreach (KeyValuePair<CharacterDrop, Drop> characterDrop in characterDrops)
			{
				if (Object.op_Implicit((Object)(object)characterDrop.Key))
				{
					characterDrop.Key.m_drops.Remove(characterDrop.Value);
				}
			}
			characterDrops.Clear();
			SerializedDrop serializedDrop = new SerializedDrop(DropsFrom.Drops);
			if (itemDropConfigs.TryGetValue(this, out var value))
			{
				serializedDrop = new SerializedDrop(value.Value);
			}
			foreach (KeyValuePair<Character, Drop> item in serializedDrop.toCharacterDrops(ZNetScene.s_instance, Prefab))
			{
				CharacterDrop val = ((Component)item.Key).GetComponent<CharacterDrop>();
				if (val == null)
				{
					val = ((Component)item.Key).gameObject.AddComponent<CharacterDrop>();
				}
				val.m_drops.Add(item.Value);
				characterDrops.Add(val, item.Value);
			}
		}

		public void UpdateCharacterDrop()
		{
			if (Object.op_Implicit((Object)(object)ZNetScene.instance))
			{
				AssignDropToCreature();
			}
		}

		public void Snapshot(float lightIntensity = 1.3f, Quaternion? cameraRotation = null, Quaternion? itemRotation = null)
		{
			SnapshotItem(Prefab.GetComponent<ItemDrop>(), lightIntensity, cameraRotation, itemRotation);
		}

		public static void SnapshotItem(ItemDrop item, float lightIntensity = 1.3f, Quaternion? cameraRotation = null, Quaternion? itemRotation = null)
		{
			<>c__DisplayClass83_0 CS$<>8__locals0 = new <>c__DisplayClass83_0();
			CS$<>8__locals0.cameraRotation = cameraRotation;
			CS$<>8__locals0.lightIntensity = lightIntensity;
			CS$<>8__locals0.item = item;
			CS$<>8__locals0.itemRotation = itemRotation;
			if (Object.op_Implicit((Object)(object)ObjectDB.instance))
			{
				Do();
			}
			else
			{
				((MonoBehaviour)plugin).StartCoroutine(Delay());
			}
			[IteratorStateMachine(typeof(<>c__DisplayClass83_0.<<SnapshotItem>g__Delay|1>d))]
			IEnumerator Delay()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass83_0.<<SnapshotItem>g__Delay|1>d(0)
				{
					<>4__this = CS$<>8__locals0
				};
			}
			void Do()
			{
				//IL_0018: 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_0085: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_016a: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f6: 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_01fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0201: Unknown result type (might be due to invalid IL or missing references)
				//IL_0206: Unknown result type (might be due to invalid IL or missing references)
				//IL_0223: Unknown result type (might be due to invalid IL or missing references)
				//IL_022a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0236: Unknown result type (might be due to invalid IL or missing references)
				//IL_023d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0277: Unknown result type (might be due to invalid IL or missing references)
				//IL_0279: Unknown result type (might be due to invalid IL or missing references)
				//IL_027b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0285: Unknown result type (might be due to invalid IL or missing references)
				//IL_028a: Unknown result type (might be due to invalid IL or missing references)
				//IL_028e: 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_02a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_02bf: 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_02dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_031c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0323: Expected O, but got Unknown
				//IL_0325: Unknown result type (might be due to invalid IL or missing references)
				//IL_0353: Unknown result type (might be due to invalid IL or missing references)
				//IL_035e: Unknown result type (might be due to invalid IL or missing references)
				Camera component = new GameObject("Camera", new Type[1] { typeof(Camera) }).GetComponent<Camera>();
				component.backgroundColor = Color.clear;
				component.clearFlags = (CameraClearFlags)2;
				component.fieldOfView = 0.5f;
				component.farClipPlane = 10000000f;
				component.cullingMask = 1073741824;
				((Component)component).transform.rotation = (Quaternion)(((??)CS$<>8__locals0.cameraRotation) ?? Quaternion.Euler(90f, 0f, 45f));
				Light component2 = new GameObject("Light", new Type[1] { typeof(Light) }).GetComponent<Light>();
				((Component)component2).transform.rotation = Quaternion.Euler(150f, 0f, -5f);
				component2.type = (LightType)1;
				component2.cullingMask = 1073741824;
				component2.intensity = CS$<>8__locals0.lightIntensity;
				Rect val = default(Rect);
				((Rect)(ref val))..ctor(0f, 0f, 64f, 64f);
				Transform val2 = ((Component)CS$<>8__locals0.item).transform.Find("attach");
				GameObject val3;
				if (val2 != null)
				{
					val3 = Object.Instantiate<GameObject>(((Component)val2).gameObject);
				}
				else
				{
					ZNetView.m_forceDisableInit = true;
					val3 = Object.Instantiate<GameObject>(((Component)CS$<>8__locals0.item).gameObject);
					ZNetView.m_forceDisableInit = false;
				}
				if (CS$<>8__locals0.itemRotation.HasValue)
				{
					val3.transform.rotation = CS$<>8__locals0.itemRotation.Value;
				}
				Transform[] componentsInChildren = val3.GetComponentsInChildren<Transform>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					((Component)componentsInChildren[i]).gameObject.layer = 30;
				}
				Renderer[] componentsInChildren2 = val3.GetComponentsInChildren<Renderer>();
				Vector3 val4 = componentsInChildren2.Aggregate<Renderer, Vector3>(Vector3.positiveInfinity, [<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (Vector3 cur, Renderer renderer) =>
				{
					//IL_001d: 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_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)
					//IL_0012: Unknown result type (might be due to invalid IL or missing references)
					//IL_0017: Unknown result type (might be due to invalid IL or missing references)
					if (!(renderer is ParticleSystemRenderer))
					{
						Bounds bounds2 = renderer.bounds;
						return Vector3.Min(cur, ((Bounds)(ref bounds2)).min);
					}
					return cur;
				});
				Vector3 val5 = componentsInChildren2.Aggregate<Renderer, Vector3>(Vector3.negativeInfinity, [<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (Vector3 cur, Renderer renderer) =>
				{
					//IL_001d: 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_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)
					//IL_0012: Unknown result type (might be due to invalid IL or missing references)
					//IL_0017: Unknown result type (might be due to invalid IL or missing references)
					if (!(renderer is ParticleSystemRenderer))
					{
						Bounds bounds = renderer.bounds;
						return Vector3.Max(cur, ((Bounds)(ref bounds)).max);
					}
					return cur;
				});
				Vector3 val6 = val5 - val4;
				component.targetTexture = RenderTexture.GetTemporary((int)((Rect)(ref val)).width, (int)((Rect)(ref val)).height);
				float num = Mathf.Max(val6.x, val6.z);
				float num2 = Mathf.Min(val6.x, val6.z);
				float num3 = (num + num2) / Mathf.Sqrt(2f) / Mathf.Tan(component.fieldOfView * ((float)Math.PI / 180f));
				Transform transform = ((Component)component).transform;
				Vector3 val7 = (val4 + val5) / 2f;
				val7.y = val5.y;
				transform.position = val7 + new Vector3(0f, num3, 0f);
				((Component)component2).transform.position = transform.position + new Vector3(-2f, 0f, 0.2f) / 3f * (0f - num3);
				component.Render();
				RenderTexture active = RenderTexture.active;
				RenderTexture.active = component.targetTexture;
				Texture2D val8 = new Texture2D((int)((Rect)(ref val)).width, (int)((Rect)(ref val)).height, (TextureFormat)4, false);
				val8.ReadPixels(val, 0, 0);
				val8.Apply();
				RenderTexture.active = active;
				CS$<>8__locals0.item.m_itemData.m_shared.m_icons = (Sprite[])(object)new Sprite[1] { Sprite.Create(val8, val, new Vector2(0.5f, 0.5f)) };
				Object.DestroyImmediate((Object)(object)val3);
				component.targetTexture.Release();
				Object.Destroy((Object)(object)component);
				Object.Destroy((Object)(object)component2);
			}
		}

		private static bool CheckItemIsUpgrade(InventoryGui gui)
		{
			ItemData itemData = ((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData;
			if (itemData == null)
			{
				return false;
			}
			return itemData.m_quality > 0;
		}

		[IteratorStateMachine(typeof(<Transpile_InventoryGui>d__85))]
		internal static IEnumerable<CodeInstruction> Transpile_InventoryGui(IEnumerable<CodeInstruction> instructions)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Transpile_InventoryGui>d__85(-2)
			{
				<>3__instructions = instructions
			};
		}

		private static Action<ConfigEntryBase> drawRequirementsConfigTable(Item item, bool isUpgrade)
		{
			return delegate(ConfigEntryBase cfg)
			{
				bool locked = cfg.Description.Tags.Select([<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (object a) => (!(a.GetType().Name == "ConfigurationManagerAttributes")) ? null : ((bool?)a.GetType().GetField("ReadOnly")?.GetValue(a))).FirstOrDefault((bool? v) => v.HasValue).GetValueOrDefault();
				List<Requirement> newReqs = new List<Requirement>();
				bool wasUpdated = false;
				int RightColumnWidth = (int)(configManager?.GetType().GetProperty("RightColumnWidth", BindingFlags.Instance | BindingFlags.NonPublic).GetGetMethod(nonPublic: true)
					.Invoke(configManager, Array.Empty<object>()) ?? ((object)130));
				GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
				List<Requirement> reqs = new SerializedRequirements((string)cfg.BoxedValue).Reqs;
				bool flag = false;
				int maxQuality = item.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_maxQuality;
				if (isUpgrade && maxQuality > 2)
				{
					flag = reqs.Any((Requirement r) => r.quality > 0);
					if (flag)
					{
						int count = reqs.Count;
						for (int i = 0; i < count; i++)
						{
							if (reqs[i].quality == 0)
							{
								List<Requirement> list = reqs;
								int index = i;
								Requirement value = reqs[i];
								value.quality = 2;
								list[index] = value;
								for (int j = 3; j <= maxQuality; j++)
								{
									List<Requirement> list2 = reqs;
									value = reqs[i];
									value.quality = j;
									list2.Add(value);
								}
							}
						}
					}
					if (flag != GUILayout.Toggle(flag, "Individual costs per upgrade level", Array.Empty<GUILayoutOption>()))
					{
						flag = !flag;
						wasUpdated = true;
						if (flag)
						{
							int count2 = reqs.Count;
							for (int k = 0; k < count2; k++)
							{
								List<Requirement> list3 = reqs;
								int index2 = k;
								Requirement value = reqs[k];
								value.quality = 2;
								list3[index2] = value;
								for (int l = 3; l <= maxQuality; l++)
								{
									List<Requirement> list4 = reqs;
									value = reqs[k];
									value.quality = l;
									list4.Add(value);
								}
							}
						}
						else
						{
							reqs.RemoveAll((Requirement req) => req.quality > 1);
							for (int m = 0; m < reqs.Count; m++)
							{
								List<Requirement> list5 = reqs;
								int index3 = m;
								Requirement value = reqs[m];
								value.quality = 0;
								list5[index3] = value;
							}
						}
					}
				}
				if (flag)
				{
					for (int n = 2; n <= maxQuality; n++)
					{
						GUILayout.Label($"Upgrade level {n - 1}:", Array.Empty<GUILayoutOption>());
						DisplayQuality(n);
					}
				}
				else
				{
					DisplayQuality(0);
				}
				GUILayout.EndVertical();
				if (wasUpdated)
				{
					cfg.BoxedValue = new SerializedRequirements(newReqs).ToString();
				}
				void DisplayQuality(int quality)
				{
					//IL_006c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0071: Unknown result type (might be due to invalid IL or missing references)
					//IL_0086: Expected O, but got Unknown
					//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
					//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
					//IL_00e0: Expected O, but got Unknown
					//IL_0123: Unknown result type (might be due to invalid IL or missing references)
					//IL_0128: Unknown result type (might be due to invalid IL or missing references)
					//IL_013d: Expected O, but got Unknown
					//IL_0193: 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_01ad: Expected O, but got Unknown
					foreach (Requirement item2 in reqs.Where((Requirement r) => r.quality == quality))
					{
						GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
						int num = item2.amount;
						if (int.TryParse(GUILayout.TextField(num.ToString(), new GUIStyle(GUI.skin.textField)
						{
							fixedWidth = 40f
						}, Array.Empty<GUILayoutOption>()), out var result) && result != num && !locked)
						{
							num = result;
							wasUpdated = true;
						}
						string text = GUILayout.TextField(item2.itemName, new GUIStyle(GUI.skin.textField)
						{
							fixedWidth = RightColumnWidth - 40 - 21 - 21 - 9
						}, Array.Empty<GUILayoutOption>());
						string text2 = (locked ? item2.itemName : text);
						wasUpdated = wasUpdated || text2 != item2.itemName;
						if (GUILayout.Button("x", new GUIStyle(GUI.skin.button)
						{
							fixedWidth = 21f
						}, Array.Empty<GUILayoutOption>()) && !locked)
						{
							wasUpdated = true;
						}
						else
						{
							newReqs.Add(new Requirement
							{
								amount = num,
								itemName = text2,
								quality = quality
							});
						}
						if (GUILayout.Button("+", new GUIStyle(GUI.skin.button)
						{
							fixedWidth = 21f
						}, Array.Empty<GUILayoutOption>()) && !locked)
						{
							wasUpdated = true;
							newReqs.Add(new Requirement
							{
								amount = 1,
								itemName = "",
								quality = quality
							});
						}
						GUILayout.EndHorizontal();
					}
				}
			};
		}

		private static void drawDropsConfigTable(ConfigEntryBase cfg)
		{
			//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_0150: Expected O, but got Unknown
			//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_01a0: Expected O, but got Unknown
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Expected O, but got Unknown
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Expected O, but got Unknown
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Expected O, but got Unknown
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Expected O, but got Unknown
			bool valueOrDefault = cfg.Description.Tags.Select([<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (object a) => (!(a.GetType().Name == "ConfigurationManagerAttributes")) ? null : ((bool?)a.GetType().GetField("ReadOnly")?.GetValue(a))).FirstOrDefault((bool? v) => v.HasValue).GetValueOrDefault();
			List<DropTarget> list = new List<DropTarget>();
			bool flag = false;
			int num = (int)(configManager?.GetType().GetProperty("RightColumnWidth", BindingFlags.Instance | BindingFlags.NonPublic).GetGetMethod(nonPublic: true)
				.Invoke(configManager, Array.Empty<object>()) ?? ((object)130));
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			foreach (DropTarget item in new SerializedDrop((string)cfg.BoxedValue).Drops.DefaultIfEmpty(new DropTarget
			{
				min = 1,
				max = 1,
				creature = "",
				chance = 1f
			}))
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				string text = GUILayout.TextField(item.creature, new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = num - 21 - 21 - 6
				}, Array.Empty<GUILayoutOption>());
				string text2 = (valueOrDefault ? item.creature : text);
				flag = flag || text2 != item.creature;
				bool num2 = GUILayout.Button("x", new GUIStyle(GUI.skin.button)
				{
					fixedWidth = 21f
				}, Array.Empty<GUILayoutOption>());
				bool flag2 = GUILayout.Button("+", new GUIStyle(GUI.skin.button)
				{
					fixedWidth = 21f
				}, Array.Empty<GUILayoutOption>());
				GUILayout.EndHorizontal();
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.Label("Chance: ", Array.Empty<GUILayoutOption>());
				float num3 = item.chance;
				if (float.TryParse(GUILayout.TextField((num3 * 100f).ToString(CultureInfo.InvariantCulture), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 45f
				}, Array.Empty<GUILayoutOption>()), NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && !Mathf.Approximately(result / 100f, num3) && !valueOrDefault)
				{
					num3 = result / 100f;
					flag = true;
				}
				GUILayout.Label("% Amount: ", Array.Empty<GUILayoutOption>());
				int num4 = item.min;
				if (int.TryParse(GUILayout.TextField(num4.ToString(), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 35f
				}, Array.Empty<GUILayoutOption>()), out var result2) && result2 != num4 && !valueOrDefault)
				{
					num4 = result2;
					flag = true;
				}
				GUILayout.Label(" - ", Array.Empty<GUILayoutOption>());
				int num5 = item.max;
				if (int.TryParse(GUILayout.TextField(num5.ToString(), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 35f
				}, Array.Empty<GUILayoutOption>()), out var result3) && result3 != num5 && !valueOrDefault)
				{
					num5 = result3;
					flag = true;
				}
				GUILayout.EndHorizontal();
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				bool flag3 = item.levelMultiplier;
				if (GUILayout.Toggle(flag3, "Level scaling drop amount", Array.Empty<GUILayoutOption>()) != flag3)
				{
					flag3 = !flag3;
					flag = true;
				}
				GUILayout.EndHorizontal();
				if (num2 && !valueOrDefault)
				{
					flag = true;
				}
				else
				{
					list.Add(new DropTarget
					{
						creature = text2,
						min = num4,
						max = num5,
						chance = num3,
						levelMultiplier = flag3
					});
				}
				if (flag2 && !valueOrDefault)
				{
					flag = true;
					list.Add(new DropTarget
					{
						min = 1,
						max = 1,
						creature = "",
						chance = 1f,
						levelMultiplier = true
					});
				}
			}
			GUILayout.EndVertical();
			if (flag)
			{
				cfg.BoxedValue = new SerializedDrop(list).ToString();
			}
		}

		private static ConfigEntry<T> config<[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(2)] T>(string group, string name, T value, ConfigDescription description)
		{
			ConfigEntry<T> val = plugin.Config.Bind<T>(group, name, value, description);
			configSync?.GetType().GetMethod("AddConfigEntry").MakeGenericMethod(typeof(T))
				.Invoke(configSync, new object[1] { val });
			return val;
		}

		private static ConfigEntry<T> config<[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(2)] 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>()));
		}
	}
	[PublicAPI]
	[<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(1)]
	[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(0)]
	internal 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 var 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));
				}
			}
		}
	}
	[<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(1)]
	[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(0)]
	internal static class LocalizationCache
	{
		private static readonly Dictionary<string, Localization> localizations = new Dictionary<string, Localization>();

		internal static void LocalizationPostfix(Localization __instance, string language)
		{
			string key = localizations.FirstOrDefault([<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (KeyValuePair<string, Localization> l) => l.Value == __instance).Key;
			if (key != null)
			{
				localizations.Remove(key);
			}
			if (!localizations.ContainsKey(language))
			{
				localizations.Add(language, __instance);
			}
		}

		public static Localization ForLanguage([<82a1631b-0574-48ea-9154-6530a461483e>Nullable(2)] string language = null)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			if (localizations.TryGetValue(language ?? PlayerPrefs.GetString("language", "English"), out var value))
			{
				return value;
			}
			value = new Localization();
			if (language != null)
			{
				value.SetupLanguage(language);
			}
			return value;
		}
	}
	[<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(1)]
	[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(0)]
	[PublicAPI]
	internal static class PrefabManager
	{
		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(0)]
		private struct BundleId
		{
			[UsedImplicitly]
			public string assetBundleFileName;

			[UsedImplicitly]
			public string folderName;
		}

		private static readonly Dictionary<BundleId, AssetBundle> bundleCache;

		private static readonly List<GameObject> prefabs;

		private static readonly List<GameObject> ZnetOnlyPrefabs;

		internal static readonly Dictionary<GameObject, Tuple<Trader, TradeItem>> CustomTradeItems;

		static PrefabManager()
		{
			//IL_002d: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			//IL_00aa: 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_00e5: Expected O, but got Unknown
			//IL_00e6: 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_0121: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Expected O, but got Unknown
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Expected O, but got Unknown
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Expected O, but got Unknown
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Expected O, but got Unknown
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Expected O, but got Unknown
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Expected O, but got Unknown
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Expected O, but got Unknown
			//IL_02df: Expected O, but got Unknown
			//IL_02e0: 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_031b: Expected O, but got Unknown
			//IL_031c: 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_0357: Expected O, but got Unknown
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Expected O, but got Unknown
			//IL_0394: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cf: Expected O, but got Unknown
			//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_040b: Expected O, but got Unknown
			//IL_0439: Unknown result type (might be due to invalid IL or missing references)
			//IL_0446: Expected O, but got Unknown
			bundleCache = new Dictionary<BundleId, AssetBundle>();
			prefabs = new List<GameObject>();
			ZnetOnlyPrefabs = new List<GameObject>();
			CustomTradeItems = new Dictionary<GameObject, Tuple<Trader, TradeItem>>();
			Harmony val = new Harmony("org.bepinex.helpers.ItemManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "CopyOtherDB", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PrefabManager), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PrefabManager), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "CopyOtherDB", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_FejdStartup", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_ZNetSceneAwake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PrefabManager), "Patch_ZNetSceneAwake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(InventoryGui), "UpdateRecipe", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Transpile_InventoryGui", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(InventoryGui), "SetupRequirementList", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Transpile_SetupRequirementList", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Requirement), "GetAmount", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_RequirementGetAmount", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Player), "GetAvailableRecipes", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_GetAvailableRecipesPrefix", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_GetAvailableRecipesFinalizer", (Type[])null, (Type[])null)), (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Recipe), "GetRequiredStationLevel", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_MaximumRequiredStationLevel", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Smelter), "OnAddFuel", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_OnAddSmelterInput", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Smelter), "OnAddOre", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_OnAddSmelterInput", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Trader), "GetAvailableItems", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_TraderGetAvailableItems", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Localization), "SetupLanguage", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(LocalizationCache), "LocalizationPostfix", (Type[])null, (Type[])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);
		}

		public static AssetBundle RegisterAssetBundle(string assetBundleFileName, string folderName = "assets")
		{
			BundleId bundleId = default(BundleId);
			bundleId.assetBundleFileName = assetBundleFileName;
			bundleId.folderName = folderName;
			BundleId key = bundleId;
			if (!bundleCache.TryGetValue(key, out var value))
			{
				Dictionary<BundleId, AssetBundle> dictionary = bundleCache;
				AssetBundle? obj = ((IEnumerable<AssetBundle>)Resources.FindObjectsOfTypeAll<AssetBundle>()).FirstOrDefault((Func<AssetBundle, bool>)([<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(0)] (AssetBundle a) => ((Object)a).name == assetBundleFileName)) ?? AssetBundle.LoadFromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream(Assembly.GetExecutingAssembly().GetName().Name + "." + folderName + "." + assetBundleFileName));
				AssetBundle result = obj;
				dictionary[key] = obj;
				return result;
			}
			return value;
		}

		public static GameObject RegisterPrefab(string assetBundleFileName, string prefabName, string folderName = "assets")
		{
			return RegisterPrefab(RegisterAssetBundle(assetBundleFileName, folderName), prefabName);
		}

		public static GameObject RegisterPrefab(AssetBundle assets, string prefabName, bool addToObjectDb = false)
		{
			return RegisterPrefab(assets.LoadAsset<GameObject>(prefabName), addToObjectDb);
		}

		public static GameObject RegisterPrefab(GameObject prefab, bool addToObjectDb = false)
		{
			if (addToObjectDb)
			{
				prefabs.Add(prefab);
			}
			else
			{
				ZnetOnlyPrefabs.Add(prefab);
			}
			return prefab;
		}

		public static void AddItemToTrader(GameObject prefab, Trader trader, uint price, uint stack = 1u, [<82a1631b-0574-48ea-9154-6530a461483e>Nullable(2)] string requiredGlobalKey = null)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			CustomTradeItems[prefab] = new Tuple<Trader, TradeItem>(trader, new TradeItem
			{
				m_prefab = prefab.GetComponent<ItemDrop>(),
				m_price = (int)price,
				m_stack = (int)stack,
				m_requiredGlobalKey = (requiredGlobalKey ?? "")
			});
		}

		public static void RemoveItemFromTrader(GameObject prefab)
		{
			CustomTradeItems.Remove(prefab);
		}

		[HarmonyPriority(700)]
		private static void Patch_ObjectDBInit(ObjectDB __instance)
		{
			foreach (GameObject prefab in prefabs)
			{
				if (!__instance.m_items.Contains(prefab))
				{
					__instance.m_items.Add(prefab);
				}
				SharedData shared = prefab.GetComponent<ItemDrop>().m_itemData.m_shared;
				RegisterStatusEffect(shared.m_attackStatusEffect);
				RegisterStatusEffect(shared.m_consumeStatusEffect);
				RegisterStatusEffect(shared.m_equipStatusEffect);
				RegisterStatusEffect(shared.m_setStatusEffect);
			}
			__instance.UpdateRegisters();
			[<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(2)]
			void RegisterStatusEffect(StatusEffect statusEffect)
			{
				if (statusEffect != null && !Object.op_Implicit((Object)(object)__instance.GetStatusEffect(StringExtensionMethods.GetStableHashCode(((Object)statusEffect).name))))
				{
					__instance.m_StatusEffects.Add(statusEffect);
				}
			}
		}

		[HarmonyPriority(700)]
		private static void Patch_ZNetSceneAwake(ZNetScene __instance)
		{
			foreach (GameObject item in prefabs.Concat(ZnetOnlyPrefabs))
			{
				if (!__instance.m_prefabs.Contains(item))
				{
					__instance.m_prefabs.Add(item);
				}
				else
				{
					Debug.LogWarning((object)("ZNetScene already contains " + ((Object)item).name + " it cannot be added twice."));
				}
			}
		}
	}
	[PublicAPI]
	[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(0)]
	[<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(2)]
	internal class Conversion
	{
		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(0)]
		[<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(1)]
		internal class ConversionConfig
		{
			public ConfigEntry<string> input;

			[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(2)]
			public string activePiece;

			public ConfigEntry<ConversionPiece> piece;

			public ConfigEntry<string> customPiece;
		}

		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(1)]
		public string Input;

		public ConversionPiece Piece;

		internal string customPiece;

		internal ConversionConfig config;

		public string Custom
		{
			get
			{
				return customPiece;
			}
			set
			{
				customPiece = value;
				Piece = ConversionPiece.Custom;
			}
		}

		[<38959417-0b4b-413a-a929-3b218fab2835>NullableContext(1)]
		public Conversion(Item outputItem)
		{
			outputItem.Conversions.Add(this);
		}
	}
	internal static class ItemManagerVersion
	{
		[<82a1631b-0574-48ea-9154-6530a461483e>Nullable(1)]
		public const string Version = "1.2.9";
	}
}
namespace Microsoft.CodeAnalysis
{
	[<2aa579f7-064e-4779-8631-b791e5abe11f>Embedded]
	[CompilerGenerated]
	internal sealed class <2aa579f7-064e-4779-8631-b791e5abe11f>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[<2aa579f7-064e-4779-8631-b791e5abe11f>Embedded]
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class <22957838-652f-402d-8d20-b0d370add669>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <22957838-652f-402d-8d20-b0d370add669>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <22957838-652f-402d-8d20-b0d370add669>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[<2aa579f7-064e-4779-8631-b791e5abe11f>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class <50128e01-106a-4503-be43-774e41560cd9>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <50128e01-106a-4503-be43-774e41560cd9>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace PieceManager
{
	[<50128e01-106a-4503-be43-774e41560cd9>NullableContext(1)]
	[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
	[PublicAPI]
	internal static class MaterialReplacer
	{
		[<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)]
		public enum ShaderType
		{
			PieceShader,
			VegetationShader,
			RockShader,
			RugShader,
			GrassShader,
			CustomCreature,
			UseUnityShader
		}

		private static readonly Dictionary<GameObject, bool> ObjectToSwap;

		private static readonly Dictionary<string, Material> OriginalMaterials;

		private static readonly Dictionary<GameObject, ShaderType> ObjectsForShaderReplace;

		private static readonly HashSet<Shader> CachedShaders;

		private static bool hasRun;

		static MaterialReplacer()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			CachedShaders = new HashSet<Shader>();
			hasRun = false;
			OriginalMaterials = new Dictionary<string, Material>();
			ObjectToSwap = new Dictionary<GameObject, bool>();
			ObjectsForShaderReplace = new Dictionary<GameObject, ShaderType>();
			new Harmony("org.bepinex.helpers.PieceManager").Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZoneSystem), "Start", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(MaterialReplacer), "ReplaceAllMaterialsWithOriginal", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public static void RegisterGameObjectForShaderSwap(GameObject go, ShaderType type)
		{
			if (!ObjectsForShaderReplace.ContainsKey(go))
			{
				ObjectsForShaderReplace.Add(go, type);
			}
		}

		public static void RegisterGameObjectForMatSwap(GameObject go, bool isJotunnMock = false)
		{
			if (!ObjectToSwap.ContainsKey(go))
			{
				ObjectToSwap.Add(go, isJotunnMock);
			}
		}

		private static void GetAllMaterials()
		{
			Material[] array = Resources.FindObjectsOfTypeAll<Material>();
			foreach (Material val in array)
			{
				OriginalMaterials[((Object)val).name] = val;
			}
		}

		[HarmonyPriority(700)]
		private static void ReplaceAllMaterialsWithOriginal()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			if ((int)SystemInfo.graphicsDeviceType == 4 || hasRun)
			{
				return;
			}
			if (OriginalMaterials.Count == 0)
			{
				GetAllMaterials();
			}
			foreach (KeyValuePair<GameObject, bool> item in ObjectToSwap)
			{
				GameObject key = item.Key;
				bool value = item.Value;
				ProcessGameObjectMaterials(key, value);
			}
			AssetBundle[] array = Resources.FindObjectsOfTypeAll<AssetBundle>();
			foreach (AssetBundle val in array)
			{
				IEnumerable<Shader> enumerable3;
				try
				{
					IEnumerable<Shader> enumerable2;
					if (!val.isStreamedSceneAssetBundle || !Object.op_Implicit((Object)(object)val))
					{
						IEnumerable<Shader> enumerable = val.LoadAllAssets<Shader>();
						enumerable2 = enumerable;
					}
					else
					{
						enumerable2 = from shader in ((IEnumerable<string>)val.GetAllAssetNames()).Select((Func<string, Shader>)val.LoadAsset<Shader>)
							where (Object)(object)shader != (Object)null
							select shader;
					}
					enumerable3 = enumerable2;
				}
				catch (Exception)
				{
					continue;
				}
				if (enumerable3 == null)
				{
					continue;
				}
				foreach (Shader item2 in enumerable3)
				{
					CachedShaders.Add(item2);
				}
			}
			foreach (KeyValuePair<GameObject, ShaderType> item3 in ObjectsForShaderReplace)
			{
				GameObject key2 = item3.Key;
				ShaderType value2 = item3.Value;
				ProcessGameObjectShaders(key2, value2);
			}
			hasRun = true;
		}

		private static void ProcessGameObjectMaterials(GameObject go, bool isJotunnMock)
		{
			Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer obj in componentsInChildren)
			{
				Material[] sharedMaterials = obj.sharedMaterials.Select([<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)] (Material material) => (!((Object)(object)material == (Object)null)) ? ReplaceMaterial(material, isJotunnMock) : null).ToArray();
				obj.sharedMaterials = sharedMaterials;
			}
		}

		private static Material ReplaceMaterial(Material originalMaterial, bool isJotunnMock)
		{
			if ((Object)(object)originalMaterial == (Object)null)
			{
				return null;
			}
			string text = (isJotunnMock ? "JVLmock_" : "_REPLACE_");
			if (!((Object)originalMaterial).name.StartsWith(text, StringComparison.Ordinal))
			{
				return originalMaterial;
			}
			string text2 = ((Object)originalMaterial).name.Replace(" (Instance)", "").Replace(text, "");
			if (OriginalMaterials.TryGetValue(text2, out var value))
			{
				return value;
			}
			Debug.LogWarning((object)("No suitable material found to replace: " + text2));
			return originalMaterial;
		}

		private static void ProcessGameObjectShaders(GameObject go, ShaderType shaderType)
		{
			Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Material[] sharedMaterials = componentsInChildren[i].sharedMaterials;
				foreach (Material val in sharedMaterials)
				{
					if ((Object)(object)val != (Object)null)
					{
						val.shader = GetShaderForType(val.shader, shaderType, ((Object)val.shader).name);
					}
				}
			}
		}

		private static Shader GetShaderForType(Shader orig, ShaderType shaderType, string originalShaderName)
		{
			return (Shader)(shaderType switch
			{
				ShaderType.PieceShader => FindShaderWithName(orig, "Custom/Piece"), 
				ShaderType.VegetationShader => FindShaderWithName(orig, "Custom/Vegetation"), 
				ShaderType.RockShader => FindShaderWithName(orig, "Custom/StaticRock"), 
				ShaderType.RugShader => FindShaderWithName(orig, "Custom/Rug"), 
				ShaderType.GrassShader => FindShaderWithName(orig, "Custom/Grass"), 
				ShaderType.CustomCreature => FindShaderWithName(orig, "Custom/Creature"), 
				ShaderType.UseUnityShader => FindShaderWithName(orig, ((Object)(object)FindShaderWithName(orig, originalShaderName) != (Object)null) ? originalShaderName : "ToonDeferredShading2017"), 
				_ => FindShaderWithName(orig, "Standard"), 
			});
		}

		public static Shader FindShaderWithName(Shader origShader, string name)
		{
			foreach (Shader cachedShader in CachedShaders)
			{
				if (((Object)cachedShader).name == name)
				{
					return cachedShader;
				}
			}
			return origShader;
		}
	}
	[PublicAPI]
	internal 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
	}
	[<50128e01-106a-4503-be43-774e41560cd9>NullableContext(1)]
	[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
	internal class InternalName : Attribute
	{
		public readonly string internalName;

		public InternalName(string internalName)
		{
			this.internalName = internalName;
		}
	}
	[PublicAPI]
	[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
	[<50128e01-106a-4503-be43-774e41560cd9>NullableContext(1)]
	internal class ExtensionList
	{
		public readonly List<ExtensionConfig> ExtensionStations = new List<ExtensionConfig>();

		public void Set(CraftingTable table, int maxStationDistance = 5)
		{
			ExtensionStations.Add(new ExtensionConfig
			{
				Table = table,
				maxStationDistance = maxStationDistance
			});
		}

		public void Set(string customTable, int maxStationDistance = 5)
		{
			ExtensionStations.Add(new ExtensionConfig
			{
				Table = CraftingTable.Custom,
				custom = customTable,
				maxStationDistance = maxStationDistance
			});
		}
	}
	internal struct ExtensionConfig
	{
		public CraftingTable Table;

		public float maxStationDistance;

		[<22957838-652f-402d-8d20-b0d370add669>Nullable(2)]
		public string custom;
	}
	[PublicAPI]
	[<50128e01-106a-4503-be43-774e41560cd9>NullableContext(1)]
	[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
	internal 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
			});
		}
	}
	internal struct CraftingStationConfig
	{
		public CraftingTable Table;

		public int level;

		[<22957838-652f-402d-8d20-b0d370add669>Nullable(2)]
		public string custom;
	}
	[PublicAPI]
	internal enum BuildPieceCategory
	{
		Misc = 0,
		Crafting = 1,
		BuildingWorkbench = 2,
		BuildingStonecutter = 3,
		Furniture = 4,
		All = 100,
		Custom = 99
	}
	[<50128e01-106a-4503-be43-774e41560cd9>NullableContext(1)]
	[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
	[PublicAPI]
	internal 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
			});
		}
	}
	internal struct Requirement
	{
		[<22957838-652f-402d-8d20-b0d370add669>Nullable(1)]
		public string itemName;

		public int amount;

		public bool recover;
	}
	internal struct SpecialProperties
	{
		[Description("Admins should be the only ones that can build this piece.")]
		public bool AdminOnly;

		[Description("Turns off generating a config for this build piece.")]
		public bool NoConfig;
	}
	[PublicAPI]
	[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
	[<50128e01-106a-4503-be43-774e41560cd9>NullableContext(1)]
	internal 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;
		}
	}
	[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
	[PublicAPI]
	[<50128e01-106a-4503-be43-774e41560cd9>NullableContext(1)]
	internal class PieceTool
	{
		public readonly HashSet<string> Tools = new HashSet<string>();

		public void Add(string tool)
		{
			Tools.Add(tool);
		}
	}
	[PublicAPI]
	[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
	[<50128e01-106a-4503-be43-774e41560cd9>NullableContext(1)]
	internal class BuildPiece
	{
		[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
		internal class PieceConfig
		{
			public ConfigEntry<string> craft;

			public ConfigEntry<BuildPieceCategory> category;

			public ConfigEntry<string> customCategory;

			public ConfigEntry<string> tools;

			public ConfigEntry<CraftingTable> extensionTable;

			public ConfigEntry<string> customExtentionTable;

			public ConfigEntry<float> maxStationDistance;

			public ConfigEntry<CraftingTable> table;

			public ConfigEntry<string> customTable;
		}

		[<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)]
		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public int? Order;

			[UsedImplicitly]
			public bool? Browsable;

			[<22957838-652f-402d-8d20-b0d370add669>Nullable(2)]
			[UsedImplicitly]
			public string Category;

			[<22957838-652f-402d-8d20-b0d370add669>Nullable(new byte[] { 2, 1 })]
			[UsedImplicitly]
			public Action<ConfigEntryBase> CustomDrawer;
		}

		[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
		private class SerializedRequirements
		{
			public readonly List<Requirement> Reqs;

			public SerializedRequirements(List<Requirement> reqs)
			{
				Reqs = reqs;
			}

			public SerializedRequirements(string reqs)
			{
				Reqs = reqs.Split(new char[1] { ',' }).Select([<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)] (string r) =>
				{
					string[] array = r.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;
				}).ToList();
			}

			public override string ToString()
			{
				return string.Join(",", Reqs.Select([<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)] (Requirement r) => $"{r.itemName}:{r.amount}:{r.recover}"));
			}

			[return: <22957838-652f-402d-8d20-b0d370add669>Nullable(2)]
			public static ItemDrop fetchByName(ObjectDB objectDB, string name)
			{
				GameObject itemPrefab = objectDB.GetItemPrefab(name);
				ItemDrop obj = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
				if ((Object)(object)obj == (Object)null)
				{
					Debug.LogWarning((object)(((!string.IsNullOrWhiteSpace(((Object)plugin).name)) ? ("[" + ((Object)plugin).name + "]") : "") + " The required item '" + name + "' does not exist."));
				}
				return obj;
			}

			public static Requirement[] toPieceReqs(SerializedRequirements craft)
			{
				return craft.Reqs.Where((Requirement r) => r.itemName != "").ToDictionary((Func<Requirement, string>)([<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)] (Requirement r) => r.itemName), (Func<Requirement, Requirement>)([<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)] (Requirement r) =>
				{
					//IL_000c: 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_001d: 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_0031: Expected O, but got Unknown
					ItemDrop val = ResItem(r);
					return (val != null) ? new Requirement
					{
						m_amount = r.amount,
						m_resItem = val,
						m_recover = r.recover
					} : ((Requirement)null);
				})).Values.Where([<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)] (Requirement v) => v != null).ToArray();
				[<50128e01-106a-4503-be43-774e41560cd9>NullableContext(2)]
				static ItemDrop ResItem(Requirement r)
				{
					return fetchByName(ObjectDB.instance, r.itemName);
				}
			}
		}

		internal static readonly List<BuildPiece> registeredPieces = new List<BuildPiece>();

		private static readonly Dictionary<Piece, BuildPiece> pieceMap = new Dictionary<Piece, BuildPiece>();

		internal static Dictionary<BuildPiece, PieceConfig> pieceConfigs = new Dictionary<BuildPiece, PieceConfig>();

		internal List<Conversion> Conversions = new List<Conversion>();

		internal List<ItemConversion> conversions = new List<ItemConversion>();

		[Description("Disables generation of the configs for your pieces. This is global, this turns it off for all pieces in your mod.")]
		public static bool ConfigurationEnabled = true;

		public readonly GameObject Prefab;

		[Description("Specifies the resources needed to craft the piece.\nUse .Add to add resources with their internal ID and an amount.\nUse one .Add for each resource type the building piece should need.")]
		public readonly RequiredResourcesList RequiredItems = new RequiredResourcesList();

		[Description("Sets the category for the building piece.")]
		public readonly BuildingPieceCategory Category = new BuildingPieceCategory();

		[Description("Specifies the tool needed to build your piece.\nUse .Add to add a tool.")]
		public readonly PieceTool Tool = new PieceTool();

		[Description("Specifies the crafting station needed to build your piece.\nUse .Add to add a crafting station, using the CraftingTable enum and a minimum level for the crafting station.")]
		public CraftingStationList Crafting = new CraftingStationList();

		[Description("Makes this piece a station extension")]
		public ExtensionList Extension = new ExtensionList();

		[Description("Change the extended/special properties of your build piece.")]
		public SpecialProperties SpecialProperties;

		[Description("Specifies a config entry which toggles whether a recipe is active.")]
		[<22957838-652f-402d-8d20-b0d370add669>Nullable(2)]
		public ConfigEntryBase RecipeIsActive;

		[<22957838-652f-402d-8d20-b0d370add669>Nullable(2)]
		private LocalizeKey _name;

		[<22957838-652f-402d-8d20-b0d370add669>Nullable(2)]
		private LocalizeKey _description;

		internal string[] activeTools;

		[<22957838-652f-402d-8d20-b0d370add669>Nullable(2)]
		private static object configManager;

		[<22957838-652f-402d-8d20-b0d370add669>Nullable(2)]
		private static Localization _english;

		[<22957838-652f-402d-8d20-b0d370add669>Nullable(2)]
		internal static BaseUnityPlugin _plugin = null;

		private static bool hasConfigSync = true;

		[<22957838-652f-402d-8d20-b0d370add669>Nullable(2)]
		private static object _configSync;

		public LocalizeKey Name
		{
			get
			{
				LocalizeKey name = _name;
				if (name != null)
				{
					return name;
				}
				Piece component = Prefab.GetComponent<Piece>();
				if (component.m_name.StartsWith("$"))
				{
					_name = new LocalizeKey(component.m_name);
				}
				else
				{
					string text = "$piece_" + ((Object)Prefab).name.Replace(" ", "_");
					_name = new LocalizeKey(text).English(component.m_name);
					component.m_name = text;
				}
				return _name;
			}
		}

		public LocalizeKey Description
		{
			get
			{
				LocalizeKey description = _description;
				if (description != null)
				{
					return description;
				}
				Piece component = Prefab.GetComponent<Piece>();
				if (component.m_description.StartsWith("$"))
				{
					_description = new LocalizeKey(component.m_description);
				}
				else
				{
					string text = "$piece_" + ((Object)Prefab).name.Replace(" ", "_") + "_description";
					_description = new LocalizeKey(text).English(component.m_description);
					component.m_description = text;
				}
				return _description;
			}
		}

		private static Localization english => _english ?? (_english = LocalizationCache.ForLanguage("English"));

		internal static BaseUnityPlugin plugin
		{
			get
			{
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Expected O, but got Unknown
				if (_plugin != null)
				{
					return _plugin;
				}
				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([<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)] (TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
				return _plugin;
			}
		}

		[<22957838-652f-402d-8d20-b0d370add669>Nullable(2)]
		private static object configSync
		{
			[<50128e01-106a-4503-be43-774e41560cd9>NullableContext(2)]
			get
			{
				if (_configSync != null || !hasConfigSync)
				{
					return _configSync;
				}
				Type type = Assembly.GetExecutingAssembly().GetType("ServerSync.ConfigSync");
				if ((object)type != null)
				{
					_configSync = Activator.CreateInstance(type, plugin.Info.Metadata.GUID + " PieceManager");
					type.GetField("CurrentVersion").SetValue(_configSync, plugin.Info.Metadata.Version.ToString());
					type.GetProperty("IsLocked").SetValue(_configSync, true);
				}
				else
				{
					hasConfigSync = false;
				}
				return _configSync;
			}
		}

		public BuildPiece(string assetBundleFileName, string prefabName, string folderName = "assets")
			: this(PiecePrefabManager.RegisterAssetBundle(assetBundleFileName, folderName), prefabName)
		{
		}

		public BuildPiece(AssetBundle bundle, string prefabName)
		{
			Prefab = PiecePrefabManager.RegisterPrefab(bundle, prefabName);
			registeredPieces.Add(this);
		}

		internal static void Patch_FejdStartup(FejdStartup __instance)
		{
			//IL_00e9: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Expected O, but got Unknown
			//IL_0337: Unknown result type (might be due to invalid IL or missing references)
			//IL_0341: Expected O, but got Unknown
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0428: Unknown result type (might be due to invalid IL or missing references)
			//IL_0432: Expected O, but got Unknown
			//IL_0586: Unknown result type (might be due to invalid IL or missing references)
			//IL_0590: Expected O, but got Unknown
			//IL_0849: Unknown result type (might be due to invalid IL or missing references)
			//IL_0853: Expected O, but got Unknown
			//IL_05f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0600: Expected O, but got Unknown
			//IL_0697: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a1: Expected O, but got Unknown
			//IL_08b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c3: Expected O, but got Unknown
			//IL_0ac1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0acb: Expected O, but got Unknown
			//IL_0b5a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b64: Expected O, but got Unknown
			Type configManagerType = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault([<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)] (Assembly a) => a.GetName().Name == "ConfigurationManager")?.GetType("ConfigurationManager.ConfigurationManager");
			configManager = ((configManagerType == null) ? null : Chainloader.ManagerObject.GetComponent(configManagerType));
			foreach (BuildPiece registeredPiece in registeredPieces)
			{
				registeredPiece.activeTools = registeredPiece.Tool.Tools.DefaultIfEmpty("Hammer").ToArray();
				if (registeredPiece.Category.Category != BuildPieceCategory.Custom)
				{
					registeredPiece.Prefab.GetComponent<Piece>().m_category = (PieceCategory)registeredPiece.Category.Category;
				}
				else
				{
					registeredPiece.Prefab.GetComponent<Piece>().m_category = PiecePrefabManager.GetCategory(registeredPiece.Category.custom);
				}
			}
			if (!ConfigurationEnabled)
			{
				return;
			}
			bool saveOnConfigSet = plugin.Config.SaveOnConfigSet;
			plugin.Config.SaveOnConfigSet = false;
			foreach (BuildPiece registeredPiece2 in registeredPieces)
			{
				BuildPiece piece = registeredPiece2;
				if (piece.SpecialProperties.NoConfig)
				{
					continue;
				}
				PieceConfig pieceConfig2 = (pieceConfigs[piece] = new PieceConfig());
				PieceConfig cfg = pieceConfig2;
				Piece piecePrefab2 = piece.Prefab.GetComponent<Piece>();
				string pieceName = piecePrefab2.m_name;
				string englishName = new Regex("[=\\n\\t\\\\\"\\'\\[\\]]*").Replace(english.Localize(pieceName), "").Trim();
				string localizedName = Localization.instance.Localize(pieceName).Trim();
				int order = 0;
				cfg.category = config(englishName, "Build Table Category", piece.Category.Category, new ConfigDescription("Build Category where " + localizedName + " is available.", (AcceptableValueBase)null, new object[1]
				{
					new ConfigurationManagerAttributes
					{
						Order = (order -= 1),
						Category = localizedName
					}
				}));
				ConfigurationManagerAttributes customTableAttributes = new ConfigurationManagerAttributes
				{
					Order = (order -= 1),
					Browsable = (cfg.category.Value == BuildPieceCategory.Custom),
					Category = localizedName
				};
				cfg.customCategory = config(englishName, "Custom Build Category", piece.Category.custom, new ConfigDescription("", (AcceptableValueBase)null, new object[1] { customTableAttributes }));
				cfg.category.SettingChanged += BuildTableConfigChanged;
				cfg.customCategory.SettingChanged += BuildTableConfigChanged;
				if (cfg.category.Value == BuildPieceCategory.Custom)
				{
					piecePrefab2.m_category = PiecePrefabManager.GetCategory(cfg.customCategory.Value);
				}
				else
				{
					piecePrefab2.m_category = (PieceCategory)cfg.category.Value;
				}
				cfg.tools = config(englishName, "Tools", string.Join(", ", piece.activeTools), new ConfigDescription("Comma separated list of tools where " + localizedName + " is available.", (AcceptableValueBase)null, new object[1] { customTableAttributes }));
				piece.activeTools = (from s in cfg.tools.Value.Split(new char[1] { ',' })
					select s.Trim()).ToArray();
				cfg.tools.SettingChanged += [<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)] (object _, EventArgs _) =>
				{
					Inventory[] source = (from c in Player.s_players.Select([<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)] (Player p) => ((Humanoid)p).GetInventory()).Concat(from c in Object.FindObjectsOfType<Container>()
							select c.GetInventory())
						where c != null
						select c).ToArray();
					Dictionary<string, List<PieceTable>> dictionary = (from kv in (from i in (from p in ObjectDB.instance.m_items
								select p.GetComponent<ItemDrop>() into c
								where Object.op_Implicit((Object)(object)c) && Object.op_Implicit((Object)(object)((Component)c).GetComponent<ZNetView>())
								select c).Concat(ItemDrop.s_instances)
							select new KeyValuePair<string, ItemData>(Utils.GetPrefabName(((Component)i).gameObject), i.m_itemData)).Concat(from i in source.SelectMany([<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)] (Inventory i) => i.GetAllItems())
							select new KeyValuePair<string, ItemData>(((Object)i.m_dropPrefab).name, i))
						where Object.op_Implicit((Object)(object)kv.Value.m_shared.m_buildPieces)
						group kv by kv.Key).ToDictionary([<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)] (IGrouping<string, KeyValuePair<string, ItemData>> g) => g.Key, [<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)] (IGrouping<string, KeyValuePair<string, ItemData>> g) => g.Select([<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)] (KeyValuePair<string, ItemData> kv) => kv.Value.m_shared.m_buildPieces).Distinct().ToList());
					string[] array5 = piece.activeTools;
					foreach (string key in array5)
					{
						if (dictionary.TryGetValue(key, out var value2))
						{
							foreach (PieceTable item3 in value2)
							{
								item3.m_pieces.Remove(piece.Prefab);
							}
						}
					}
					piece.activeTools = (from s in cfg.tools.Value.Split(new char[1] { ',' })
						select s.Trim()).ToArray();
					if (Object.op_Implicit((Object)(object)ObjectDB.instance))
					{
						array5 = piece.activeTools;
						foreach (string key2 in array5)
						{
							if (dictionary.TryGetValue(key2, out var value3))
							{
								foreach (PieceTable item4 in value3)
								{
									if (!item4.m_pieces.Contains(piece.Prefab))
									{
										item4.m_pieces.Add(piece.Prefab);
									}
								}
							}
						}
						if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && Object.op_Implicit((Object)(object)Player.m_localPlayer.m_buildPieces))
						{
							PiecePrefabManager.CategoryRefreshNeeded = true;
							((Humanoid)Player.m_localPlayer).SetPlaceMode(Player.m_localPlayer.m_buildPieces);
						}
					}
				};
				StationExtension pieceExtensionComp;
				List<ConfigurationManagerAttributes> hideWhenNoneAttributes2;
				if (piece.Extension.ExtensionStations.Count > 0)
				{
					pieceExtensionComp = piece.Prefab.GetOrAddComponent<StationExtension>();
					PieceConfig pieceConfig3 = cfg;
					string group = englishName;
					CraftingTable table = piece.Extension.ExtensionStations.First().Table;
					string text = "Crafting station that " + localizedName + " extends.";
					object[] array = new object[1];
					ConfigurationManagerAttributes configurationManagerAttributes = new ConfigurationManagerAttributes();
					int num = order - 1;
					order = num;
					configurationManagerAttributes.Order = num;
					array[0] = configurationManagerAttributes;
					pieceConfig3.extensionTable = config(group, "Extends Station", table, new ConfigDescription(text, (AcceptableValueBase)null, array));
					cfg.customExtentionTable = config(englishName, "Custom Extend Station", piece.Extension.ExtensionStations.First().custom ?? "", new ConfigDescription("", (AcceptableValueBase)null, new object[1] { customTableAttributes }));
					PieceConfig pieceConfig4 = cfg;
					string group2 = englishName;
					float maxStationDistance = piece.Extension.ExtensionStations.First().maxStationDistance;
					string text2 = "Distance from the station that " + localizedName + " can be placed.";
					object[] array2 = new object[1];
					ConfigurationManagerAttributes configurationManagerAttributes2 = new ConfigurationManagerAttributes();
					num = order - 1;
					order = num;
					configurationManagerAttributes2.Order = num;
					array2[0] = configurationManagerAttributes2;
					pieceConfig4.maxStationDistance = config(group2, "Max Station Distance", maxStationDistance, new ConfigDescription(text2, (AcceptableValueBase)null, array2));
					hideWhenNoneAttributes2 = new List<ConfigurationManagerAttributes>();
					cfg.extensionTable.SettingChanged += ExtensionTableConfigChanged;
					cfg.customExtentionTable.SettingChanged += ExtensionTableConfigChanged;
					cfg.maxStationDistance.SettingChanged += ExtensionTableConfigChanged;
					ConfigurationManagerAttributes configurationManagerAttributes3 = new ConfigurationManagerAttributes();
					num = order - 1;
					order = num;
					configurationManagerAttributes3.Order = num;
					configurationManagerAttributes3.Browsable = cfg.extensionTable.Value != CraftingTable.None;
					ConfigurationManagerAttributes item = configurationManagerAttributes3;
					hideWhenNoneAttributes2.Add(item);
				}
				List<ConfigurationManagerAttributes> hideWhenNoneAttributes;
				if (piece.Crafting.Stations.Count > 0)
				{
					hideWhenNoneAttributes = new List<ConfigurationManagerAttributes>();
					PieceConfig pieceConfig5 = cfg;
					string group3 = englishName;
					CraftingTable table2 = piece.Crafting.Stations.First().Table;
					string text3 = "Crafting station where " + localizedName + " is available.";
					object[] array3 = new object[1];
					ConfigurationManagerAttributes configurationManagerAttributes4 = new ConfigurationManagerAttributes();
					int num = order - 1;
					order = num;
					configurationManagerAttributes4.Order = num;
					array3[0] = configurationManagerAttributes4;
					pieceConfig5.table = config(group3, "Crafting Station", table2, new ConfigDescription(text3, (AcceptableValueBase)null, array3));
					cfg.customTable = config(englishName, "Custom Crafting Station", piece.Crafting.Stations.First().custom ?? "", new ConfigDescription("", (AcceptableValueBase)null, new object[1] { customTableAttributes }));
					cfg.table.SettingChanged += TableConfigChanged;
					cfg.customTable.SettingChanged += TableConfigChanged;
					ConfigurationManagerAttributes configurationManagerAttributes5 = new ConfigurationManagerAttributes();
					num = order - 1;
					order = num;
					configurationManagerAttributes5.Order = num;
					configurationManagerAttributes5.Browsable = cfg.table.Value != CraftingTable.None;
					ConfigurationManagerAttributes item2 = configurationManagerAttributes5;
					hideWhenNoneAttributes.Add(item2);
				}
				cfg.craft = itemConfig("Crafting Costs", new SerializedRequirements(piece.RequiredItems.Requirements).ToString(), "Item costs to craft " + localizedName);
				cfg.craft.SettingChanged += [<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)] (object _, EventArgs _) =>
				{
					if (Object.op_Implicit((Object)(object)ObjectDB.instance) && (Object)(object)ObjectDB.instance.GetItemPrefab("YmirRemains") != (Object)null)
					{
						Requirement[] resources = SerializedRequirements.toPieceReqs(new SerializedRequirements(cfg.craft.Value));
						piecePrefab2.m_resources = resources;
						Piece[] array4 = Object.FindObjectsOfType<Piece>();
						foreach (Piece val in array4)
						{
							if (val.m_name == pieceName)
							{
								val.m_resources = resources;
							}
						}
					}
				};
				for (int j = 0; j < piece.Conversions.Count; j++)
				{
					string text4 = ((piece.Conversions.Count > 1) ? $"{j + 1}. " : "");
					Conversion conversion = piece.Conversions[j];
					conversion.config = new Conversion.ConversionConfig();
					int index = j;
					conversion.config.input = config(englishName, text4 + "Conversion Input Item", conversion.Input, new ConfigDescription("Conversion input item within " + englishName, (AcceptableValueBase)null, new object[1]
					{
						new ConfigurationManagerAttributes
						{
							Category = localizedName
						}
					}));
					conversion.config.input.SettingChanged += [<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)] (object _, EventArgs _) =>
					{
						if (index < piece.conversions.Count)
						{
							ObjectDB instance2 = ObjectDB.instance;
							if (instance2 != null)
							{
								ItemDrop from = SerializedRequirements.fetchByName(instance2, conversion.config.input.Value);
								piece.conversions[index].m_from = from;
							}
						}
					};
					conversion.config.output = config(englishName, text4 + "Conversion Output Item", conversion.Output, new ConfigDescription("Conversion output item within " + englishName, (AcceptableValueBase)null, new object[1]
					{
						new ConfigurationManagerAttributes
						{
							Category = localizedName
						}
					}));
					conversion.config.output.SettingChanged += [<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)] (object _, EventArgs _) =>
					{
						if (index < piece.conversions.Count)
						{
							ObjectDB instance = ObjectDB.instance;
							if (instance != null)
							{
								ItemDrop to = SerializedRequirements.fetchByName(instance, conversion.config.output.Value);
								piece.conversions[index].m_to = to;
							}
						}
					};
				}
				void BuildTableConfigChanged(object o, EventArgs e)
				{
					//IL_0059: Unknown result type (might be due to invalid IL or missing references)
					//IL_0037: 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)
					if (registeredPieces.Count > 0)
					{
						if (cfg.category.Value == BuildPieceCategory.Custom)
						{
							piecePrefab2.m_category = PiecePrefabManager.GetCategory(cfg.customCategory.Value);
						}
						else
						{
							piecePrefab2.m_category = (PieceCategory)cfg.category.Value;
						}
						if (Object.op_Implicit((Object)(object)Hud.instance))
						{
							PiecePrefabManager.CategoryRefreshNeeded = true;
							PiecePrefabManager.CreateCategoryTabs();
						}
					}
					customTableAttributes.Browsable = cfg.category.Value == BuildPieceCategory.Custom;
					ReloadConfigDisplay();
				}
				void ExtensionTableConfigChanged(object o, EventArgs e)
				{
					if (piece.RequiredItems.Requirements.Count > 0)
					{
						if (cfg.extensionTable.Value == CraftingTable.Custom)
						{
							StationExtension obj2 = pieceExtensionComp;
							GameObject prefab2 = ZNetScene.instance.GetPrefab(cfg.customExtentionTable.Value);
							obj2.m_craftingStation = ((prefab2 != null) ? prefab2.GetComponent<CraftingStation>() : null);
						}
						else
						{
							pieceExtensionComp.m_craftingStation = ZNetScene.instance.GetPrefab(((InternalName)typeof(CraftingTable).GetMember(cfg.extensionTable.Value.ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName).GetComponent<CraftingStation>();
						}
						pieceExtensionComp.m_maxStationDistance = cfg.maxStationDistance.Value;
					}
					customTableAttributes.Browsable = cfg.extensionTable.Value == CraftingTable.Custom;
					foreach (ConfigurationManagerAttributes item5 in hideWhenNoneAttributes2)
					{
						item5.Browsable = cfg.extensionTable.Value != CraftingTable.None;
					}
					ReloadConfigDisplay();
					plugin.Config.Save();
				}
				void TableConfigChanged(object o, EventArgs e)
				{
					if (piece.RequiredItems.Requirements.Count > 0)
					{
						switch (cfg.table.Value)
						{
						case CraftingTable.None:
							piecePrefab2.m_craftingStation = null;
							break;
						case CraftingTable.Custom:
						{
							Piece obj = piecePrefab2;
							GameObject prefab = ZNetScene.instance.GetPrefab(cfg.customTable.Value);
							obj.m_craftingStation = ((prefab != null) ? prefab.GetComponent<CraftingStation>() : null);
							break;
						}
						default:
							piecePrefab2.m_craftingStation = ZNetScene.instance.GetPrefab(((InternalName)typeof(CraftingTable).GetMember(cfg.table.Value.ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName).GetComponent<CraftingStation>();
							break;
						}
					}
					customTableAttributes.Browsable = cfg.table.Value == CraftingTable.Custom;
					foreach (ConfigurationManagerAttributes item6 in hideWhenNoneAttributes)
					{
						item6.Browsable = cfg.table.Value != CraftingTable.None;
					}
					ReloadConfigDisplay();
					plugin.Config.Save();
				}
				ConfigEntry<string> itemConfig(string name, string value, string desc)
				{
					//IL_0054: Unknown result type (might be due to invalid IL or missing references)
					//IL_005e: Expected O, but got Unknown
					ConfigurationManagerAttributes configurationManagerAttributes6 = new ConfigurationManagerAttributes
					{
						CustomDrawer = DrawConfigTable,
						Order = (order -= 1),
						Category = localizedName
					};
					return config(englishName, name, value, new ConfigDescription(desc, (AcceptableValueBase)null, new object[1] { configurationManagerAttributes6 }));
				}
			}
			foreach (BuildPiece registeredPiece3 in registeredPieces)
			{
				ConfigEntryBase enabledCfg = registeredPiece3.RecipeIsActive;
				Piece piecePrefab;
				if (enabledCfg != null)
				{
					piecePrefab = registeredPiece3.Prefab.GetComponent<Piece>();
					ConfigChanged(null, null);
					((object)enabledCfg).GetType().GetEvent("SettingChanged").AddEventHandler(enabledCfg, new EventHandler(ConfigChanged));
				}
				registeredPiece3.InitializeNewRegisteredPiece(registeredPiece3);
				[<50128e01-106a-4503-be43-774e41560cd9>NullableContext(2)]
				void ConfigChanged(object o, EventArgs e)
				{
					piecePrefab.m_enabled = (int)enabledCfg.BoxedValue != 0;
				}
			}
			if (saveOnConfigSet)
			{
				plugin.Config.SaveOnConfigSet = true;
				plugin.Config.Save();
			}
			void ReloadConfigDisplay()
			{
				object obj3 = configManagerType?.GetProperty("DisplayingWindow").GetValue(configManager);
				if (obj3 is bool && (bool)obj3)
				{
					configManagerType.GetMethod("BuildSettingList").Invoke(configManager, Array.Empty<object>());
				}
			}
		}

		private void InitializeNewRegisteredPiece(BuildPiece piece)
		{
			ConfigEntryBase recipeIsActive = piece.RecipeIsActive;
			PieceConfig cfg;
			Piece piecePrefab;
			string pieceName;
			if (recipeIsActive != null)
			{
				pieceConfigs.TryGetValue(piece, out cfg);
				piecePrefab = piece.Prefab.GetComponent<Piece>();
				pieceName = piecePrefab.m_name;
				((object)recipeIsActive).GetType().GetEvent("SettingChanged").AddEventHandler(recipeIsActive, new EventHandler(ConfigChanged));
			}
			void ConfigChanged(object o, EventArgs e)
			{
				if (Object.op_Implicit((Object)(object)ObjectDB.instance) && (Object)(object)ObjectDB.instance.GetItemPrefab("YmirRemains") != (Object)null && cfg != null)
				{
					Requirement[] resources = SerializedRequirements.toPieceReqs(new SerializedRequirements(cfg.craft.Value));
					piecePrefab.m_resources = resources;
					Piece[] array = Object.FindObjectsOfType<Piece>();
					foreach (Piece val in array)
					{
						if (val.m_name == pieceName)
						{
							val.m_resources = resources;
						}
					}
				}
			}
		}

		[HarmonyPriority(700)]
		internal static void Patch_ObjectDBInit(ObjectDB __instance)
		{
			//IL_0441: Unknown result type (might be due to invalid IL or missing references)
			//IL_0446: Unknown result type (might be due to invalid IL or missing references)
			//IL_0479: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b1: Expected O, but got Unknown
			if ((Object)(object)__instance.GetItemPrefab("YmirRemains") == (Object)null)
			{
				return;
			}
			foreach (BuildPiece registeredPiece in registeredPieces)
			{
				pieceConfigs.TryGetValue(registeredPiece, out var value);
				registeredPiece.Prefab.GetComponent<Piece>().m_resources = SerializedRequirements.toPieceReqs((value == null) ? new SerializedRequirements(registeredPiece.RequiredItems.Requirements) : new SerializedRequirements(value.craft.Value));
				foreach (ExtensionConfig extensionStation in registeredPiece.Extension.ExtensionStations)
				{
					switch ((value == null || registeredPiece.Extension.ExtensionStations.Count > 1) ? extensionStation.Table : value.extensionTable.Value)
					{
					case CraftingTable.None:
						registeredPiece.Prefab.GetComponent<StationExtension>().m_craftingStation = null;
						break;
					case CraftingTable.Custom:
					{
						GameObject prefab = ZNetScene.instance.GetPrefab((value == null || registeredPiece.Extension.ExtensionStations.Count > 0) ? extensionStation.custom : value.customExtentionTable.Value);
						if (prefab != null)
						{
							registeredPiece.Prefab.GetComponent<StationExtension>().m_craftingStation = prefab.GetComponent<CraftingStation>();
						}
						else
						{
							Debug.LogWarning((object)("Custom crafting station '" + ((value == null || registeredPiece.Extension.ExtensionStations.Count > 0) ? extensionStation.custom : value.customExtentionTable.Value) + "' does not exist"));
						}
						break;
					}
					default:
						if (value != null && value.table.Value == CraftingTable.None)
						{
							registeredPiece.Prefab.GetComponent<StationExtension>().m_craftingStation = null;
						}
						else
						{
							registeredPiece.Prefab.GetComponent<StationExtension>().m_craftingStation = ZNetScene.instance.GetPrefab(((InternalName)typeof(CraftingTable).GetMember(((value == null || registeredPiece.Extension.ExtensionStations.Count > 1) ? extensionStation.Table : value.extensionTable.Value).ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName).GetComponent<CraftingStation>();
						}
						break;
					}
				}
				foreach (CraftingStationConfig station in registeredPiece.Crafting.Stations)
				{
					switch ((value == null || registeredPiece.Crafting.Stations.Count > 1) ? station.Table : value.table.Value)
					{
					case CraftingTable.None:
						registeredPiece.Prefab.GetComponent<Piece>().m_craftingStation = null;
						break;
					case CraftingTable.Custom:
					{
						GameObject prefab2 = ZNetScene.instance.GetPrefab((value == null || registeredPiece.Crafting.Stations.Count > 0) ? station.custom : value.customTable.Value);
						if (prefab2 != null)
						{
							registeredPiece.Prefab.GetComponent<Piece>().m_craftingStation = prefab2.GetComponent<CraftingStation>();
						}
						else
						{
							Debug.LogWarning((object)("Custom crafting station '" + ((value == null || registeredPiece.Crafting.Stations.Count > 0) ? station.custom : value.customTable.Value) + "' does not exist"));
						}
						break;
					}
					default:
						if (value != null && value.table.Value == CraftingTable.None)
						{
							registeredPiece.Prefab.GetComponent<Piece>().m_craftingStation = null;
						}
						else
						{
							registeredPiece.Prefab.GetComponent<Piece>().m_craftingStation = ZNetScene.instance.GetPrefab(((InternalName)typeof(CraftingTable).GetMember(((value == null || registeredPiece.Crafting.Stations.Count > 1) ? station.Table : value.table.Value).ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName).GetComponent<CraftingStation>();
						}
						break;
					}
				}
				registeredPiece.conversions = new List<ItemConversion>();
				for (int i = 0; i < registeredPiece.Conversions.Count; i++)
				{
					Conversion conversion = registeredPiece.Conversions[i];
					registeredPiece.conversions.Add(new ItemConversion
					{
						m_from = SerializedRequirements.fetchByName(ObjectDB.instance, conversion.config?.input.Value ?? conversion.Input),
						m_to = SerializedRequirements.fetchByName(ObjectDB.instance, conversion.config?.output.Value ?? conversion.Output)
					});
					if (registeredPiece.conversions[i].m_from != null && registeredPiece.conversions[i].m_to != null)
					{
						registeredPiece.Prefab.GetComponent<Smelter>().m_conversion.Add(registeredPiece.conversions[i]);
					}
				}
			}
		}

		public void Snapshot(float lightIntensity = 1.3f, Quaternion? cameraRotation = null)
		{
			SnapshotPiece(Prefab, lightIntensity, cameraRotation);
		}

		internal void SnapshotPiece(GameObject prefab, float lightIntensity = 1.3f, Quaternion? cameraRotation = null)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_00a3: 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_00e2: 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_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: 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_01b4: 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_01dd: 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_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: 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_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: 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_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: 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_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Expected O, but got Unknown
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_039a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)prefab == (Object)null) && (prefab.GetComponentsInChildren<Renderer>().Any() || prefab.GetComponentsInChildren<MeshFilter>().Any()))
			{
				Camera component = new GameObject("CameraIcon", new Type[1] { typeof(Camera) }).GetComponent<Camera>();
				component.backgroundColor = Color.clear;
				component.clearFlags = (CameraClearFlags)2;
				((Component)component).transform.position = new Vector3(10000f, 10000f, 10000f);
				((Component)component).transform.rotation = (Quaternion)(((??)cameraRotation) ?? Quaternion.Euler(0f, 180f, 0f));
				component.fieldOfView = 0.5f;
				component.farClipPlane = 100000f;
				component.cullingMask = 8;
				Light component2 = new GameObject("LightIcon", new Type[1] { typeof(Light) }).GetComponent<Light>();
				((Component)component2).transform.position = new Vector3(10000f, 10000f, 10000f);
				((Component)component2).transform.rotation = Quaternion.Euler(5f, 180f, 5f);
				component2.type = (LightType)1;
				component2.cullingMask = 8;
				component2.intensity = lightIntensity;
				GameObject val = Object.Instantiate<GameObject>(prefab);
				Transform[] componentsInChildren = val.GetComponentsInChildren<Transform>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					((Component)componentsInChildren[i]).gameObject.layer = 3;
				}
				val.transform.position = Vector3.zero;
				val.transform.rotation = Quaternion.Euler(23f, 51f, 25.8f);
				((Object)val).name = ((Object)prefab).name;
				MeshRenderer[] componentsInChildren2 = val.GetComponentsInChildren<MeshRenderer>();
				Vector3 val2 = componentsInChildren2.Aggregate(Vector3.positiveInfinity, [<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)] (Vector3 cur, MeshRenderer renderer) =>
				{
					//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_0007: 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_000f: Unknown result type (might be due to invalid IL or missing references)
					Bounds bounds2 = ((Renderer)renderer).bounds;
					return Vector3.Min(cur, ((Bounds)(ref bounds2)).min);
				});
				Vector3 val3 = componentsInChildren2.Aggregate(Vector3.negativeInfinity, [<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)] (Vector3 cur, MeshRenderer renderer) =>
				{
					//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_0007: 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_000f: Unknown result type (might be due to invalid IL or missing references)
					Bounds bounds = ((Renderer)renderer).bounds;
					return Vector3.Max(cur, ((Bounds)(ref bounds)).max);
				});
				val.transform.position = new Vector3(10000f, 10000f, 10000f) - (val2 + val3) / 2f;
				Vector3 val4 = val3 - val2;
				val.AddComponent<TimedDestruction>().Trigger(1f);
				Rect val5 = default(Rect);
				((Rect)(ref val5))..ctor(0f, 0f, 128f, 128f);
				component.targetTexture = RenderTexture.GetTemporary((int)((Rect)(ref val5)).width, (int)((Rect)(ref val5)).height);
				component.fieldOfView = 20f;
				float num = (Mathf.Max(val4.x, val4.y) + 0.1f) / Mathf.Tan(component.fieldOfView * ((float)Math.PI / 180f)) * 1.1f;
				((Component)component).transform.position = new Vector3(10000f, 10000f, 10000f) + new Vector3(0f, 0f, num);
				component.Render();
				RenderTexture active = RenderTexture.active;
				RenderTexture.active = component.targetTexture;
				Texture2D val6 = new Texture2D((int)((Rect)(ref val5)).width, (int)((Rect)(ref val5)).height, (TextureFormat)4, false);
				val6.ReadPixels(new Rect(0f, 0f, (float)(int)((Rect)(ref val5)).width, (float)(int)((Rect)(ref val5)).height), 0, 0);
				val6.Apply();
				RenderTexture.active = active;
				prefab.GetComponent<Piece>().m_icon = Sprite.Create(val6, new Rect(0f, 0f, (float)(int)((Rect)(ref val5)).width, (float)(int)((Rect)(ref val5)).height), Vector2.one / 2f);
				((Component)component2).gameObject.SetActive(false);
				component.targetTexture.Release();
				((Component)component).gameObject.SetActive(false);
				val.SetActive(false);
				Object.DestroyImmediate((Object)(object)val);
				Object.Destroy((Object)(object)component);
				Object.Destroy((Object)(object)component2);
				Object.Destroy((Object)(object)((Component)component).gameObject);
				Object.Destroy((Object)(object)((Component)component2).gameObject);
			}
		}

		private static void DrawConfigTable(ConfigEntryBase cfg)
		{
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected O, but got Unknown
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Expected O, but got Unknown
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Expected O, but got Unknown
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Expected O, but got Unknown
			bool valueOrDefault = cfg.Description.Tags.Select([<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)] (object a) => (!(a.GetType().Name == "ConfigurationManagerAttributes")) ? null : ((bool?)a.GetType().GetField("ReadOnly")?.GetValue(a))).FirstOrDefault((bool? v) => v.HasValue).GetValueOrDefault();
			List<Requirement> list = new List<Requirement>();
			bool flag = false;
			int num = (int)(configManager?.GetType().GetProperty("RightColumnWidth", BindingFlags.Instance | BindingFlags.NonPublic).GetGetMethod(nonPublic: true)
				.Invoke(configManager, Array.Empty<object>()) ?? ((object)130));
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			foreach (Requirement req in new SerializedRequirements((string)cfg.BoxedValue).Reqs)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				int num2 = req.amount;
				if (int.TryParse(GUILayout.TextField(num2.ToString(), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 40f
				}, Array.Empty<GUILayoutOption>()), out var result) && result != num2 && !valueOrDefault)
				{
					num2 = result;
					flag = true;
				}
				string text = GUILayout.TextField(req.itemName, new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = num - 40 - 67 - 21 - 21 - 12
				}, Array.Empty<GUILayoutOption>());
				string text2 = (valueOrDefault ? req.itemName : text);
				flag = flag || text2 != req.itemName;
				bool flag2 = req.recover;
				if (GUILayout.Toggle(req.recover, "Recover", new GUIStyle(GUI.skin.toggle)
				{
					fixedWidth = 67f
				}, Array.Empty<GUILayoutOption>()) != req.recover)
				{
					flag2 = !flag2;
					flag = true;
				}
				if (GUILayout.Button("x", new GUIStyle(GUI.skin.button)
				{
					fixedWidth = 21f
				}, Array.Empty<GUILayoutOption>()) && !valueOrDefault)
				{
					flag = true;
				}
				else
				{
					list.Add(new Requirement
					{
						amount = num2,
						itemName = text2,
						recover = flag2
					});
				}
				if (GUILayout.Button("+", new GUIStyle(GUI.skin.button)
				{
					fixedWidth = 21f
				}, Array.Empty<GUILayoutOption>()) && !valueOrDefault)
				{
					flag = true;
					list.Add(new Requirement
					{
						amount = 1,
						itemName = "",
						recover = false
					});
				}
				GUILayout.EndHorizontal();
			}
			GUILayout.EndVertical();
			if (flag)
			{
				cfg.BoxedValue = new SerializedRequirements(list).ToString();
			}
		}

		private static ConfigEntry<T> config<[<22957838-652f-402d-8d20-b0d370add669>Nullable(2)] T>(string group, string name, T value, ConfigDescription description)
		{
			ConfigEntry<T> val = plugin.Config.Bind<T>(group, name, value, description);
			configSync?.GetType().GetMethod("AddConfigEntry").MakeGenericMethod(typeof(T))
				.Invoke(configSync, new object[1] { val });
			return val;
		}

		private static ConfigEntry<T> config<[<22957838-652f-402d-8d20-b0d370add669>Nullable(2)] 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>()));
		}
	}
	internal static class GoExtensions
	{
		[<50128e01-106a-4503-be43-774e41560cd9>NullableContext(1)]
		public static T GetOrAddComponent<[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)] T>(this GameObject gameObject) where T : Component
		{
			return gameObject.GetComponent<T>() ?? gameObject.AddComponent<T>();
		}
	}
	[PublicAPI]
	[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
	[<50128e01-106a-4503-be43-774e41560cd9>NullableContext(1)]
	internal 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 var 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));
				}
			}
		}
	}
	[<50128e01-106a-4503-be43-774e41560cd9>NullableContext(1)]
	[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
	internal static class LocalizationCache
	{
		private static readonly Dictionary<string, Localization> localizations = new Dictionary<string, Localization>();

		internal static void LocalizationPostfix(Localization __instance, string language)
		{
			string key = localizations.FirstOrDefault([<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)] (KeyValuePair<string, Localization> l) => l.Value == __instance).Key;
			if (key != null)
			{
				localizations.Remove(key);
			}
			if (!localizations.ContainsKey(language))
			{
				localizations.Add(language, __instance);
			}
		}

		public static Localization ForLanguage([<22957838-652f-402d-8d20-b0d370add669>Nullable(2)] string language = null)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			if (localizations.TryGetValue(language ?? PlayerPrefs.GetString("language", "English"), out var value))
			{
				return value;
			}
			value = new Localization();
			if (language != null)
			{
				value.SetupLanguage(language);
			}
			return value;
		}
	}
	[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
	[<50128e01-106a-4503-be43-774e41560cd9>NullableContext(1)]
	internal class AdminSyncing
	{
		[CompilerGenerated]
		private sealed class <<AdminStatusSync>g__WatchAdminListChanges|2_0>d : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
			private object <>2__current;

			[<22957838-652f-402d-8d20-b0d370add669>Nullable(new byte[] { 0, 1 })]
			private List<string> <currentList>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				[return: <22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				[return: <22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <<AdminStatusSync>g__WatchAdminListChanges|2_0>d(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Expected O, but got Unknown
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					if (!ZNet.instance.m_adminList.GetList().SequenceEqual(<currentList>5__2))
					{
						<currentList>5__2 = new List<string>(ZNet.instance.m_adminList.GetList());
						List<ZNetPeer> list = (from p in ZNet.instance.GetPeers()
							where ZNet.instance.ListContainsId(ZNet.instance.m_adminList, p.m_rpc.GetSocket().GetHostName())
							select p).ToList();
						<AdminStatusSync>g__SendAdmin|2_2(ZNet.instance.GetPeers().Except(list).ToList(), isAdmin: false);
						<AdminStatusSync>g__SendAdmin|2_2(list, isAdmin: true);
					}
				}
				else
				{
					<>1__state = -1;
					<currentList>5__2 = new List<string>(ZNet.instance.m_adminList.GetList());
				}
				<>2__current = (object)new WaitForSeconds(30f);
				<>1__state = 1;
				return true;
			}

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

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

		[CompilerGenerated]
		private sealed class <>c__DisplayClass3_0
		{
			[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
			public ZPackage package;

			[<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)]
			internal IEnumerator<bool> <sendZPackage>b__1(ZNetPeer p)
			{
				return TellPeerAdminStatus(p, package);
			}
		}

		[StructLayout(LayoutKind.Auto)]
		[CompilerGenerated]
		private struct <>c__DisplayClass4_0
		{
			[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
			public ZNetPeer peer;

			[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
			public ZRoutedRpc rpc;
		}

		[CompilerGenerated]
		private sealed class <TellPeerAdminStatus>d__4 : IEnumerator<bool>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private bool <>2__current;

			[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
			public ZNetPeer peer;

			[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
			public ZPackage package;

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

			object IEnumerator.Current
			{
				[DebuggerHidden]
				[return: <22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
				get
				{
					return <>2__current;
				}
			}

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				<>c__DisplayClass4_0 <>c__DisplayClass4_ = default(<>c__DisplayClass4_0);
				<>c__DisplayClass4_.peer = peer;
				<>c__DisplayClass4_.rpc = ZRoutedRpc.instance;
				if (<>c__DisplayClass4_.rpc == null)
				{
					return false;
				}
				<TellPeerAdminStatus>g__SendPackage|4_0(package, ref <>c__DisplayClass4_);
				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();
			}
		}

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

			[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
			private object <>2__current;

			[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
			public ZPackage package;

			[<22957838-652f-402d-8d20-b0d370add669>Nullable(new byte[] { 0, 1 })]
			public List<ZNetPeer> peers;

			[<22957838-652f-402d-8d20-b0d370add669>Nullable(new byte[] { 0, 1 })]
			private List<IEnumerator<bool>> <writers>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				[return: <22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				[return: <22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
				get
				{
					return <>2__current;
				}
			}

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

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

			private bool MoveNext()
			{
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>c__DisplayClass3_0 CS$<>8__locals0 = new <>c__DisplayClass3_0
					{
						package = package
					};
					if (!Object.op_Implicit((Object)(object)ZNet.instance))
					{
						return false;
					}
					byte[] array = CS$<>8__locals0.package.GetArray();
					if (array != null && array.LongLength > 10000)
					{
						ZPackage val = new ZPackage();
						val.Write(4);
						MemoryStream memoryStream = new MemoryStream();
						using (DeflateStream deflateStream = new DeflateStream(memoryStream, CompressionLevel.Optimal))
						{
							deflateStream.Write(array, 0, array.Length);
						}
						val.Write(memoryStream.ToArray());
						CS$<>8__locals0.package = val;
					}
					<writers>5__2 = (from peer in peers
						where peer.IsReady()
						select peer into p
						select TellPeerAdminStatus(p, CS$<>8__locals0.package)).ToList();
					<writers>5__2.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
					break;
				}
				case 1:
					<>1__state = -1;
					<writers>5__2.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
					break;
				}
				if (<writers>5__2.Count > 0)
				{
					<>2__current = null;
					<>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();
			}
		}

		private static bool isServer;

		internal static bool registeredOnClient;

		[HarmonyPriority(700)]
		internal static void AdminStatusSync(ZNet __instance)
		{
			isServer = __instance.IsServer();
			if (BuildPiece._plugin != null)
			{
				if (isServer)
				{
					ZRoutedRpc.instance.Register<ZPackage>(BuildPiece._plugin.Info.Metadata.Name + " PMAdminStatusSync", (Action<long, ZPackage>)RPC_AdminPieceAddRemove);
				}
				else if (!registeredOnClient)
				{
					ZRoutedRpc.instance.Register<ZPackage>(BuildPiece._plugin.Info.Metadata.Name + " PMAdminStatusSync", (Action<long, ZPackage>)RPC_AdminPieceAddRemove);
					registeredOnClient = true;
				}
			}
			if (isServer)
			{
				((MonoBehaviour)ZNet.instance).StartCoroutine(WatchAdminListChanges());
			}
			[IteratorStateMachine(typeof(<<AdminStatusSync>g__WatchAdminListChanges|2_0>d))]
			static IEnumerator WatchAdminListChanges()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <<AdminStatusSync>g__WatchAdminListChanges|2_0>d(0);
			}
		}

		[IteratorStateMachine(typeof(<sendZPackage>d__3))]
		private static IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <sendZPackage>d__3(0)
			{
				peers = peers,
				package = package
			};
		}

		[IteratorStateMachine(typeof(<TellPeerAdminStatus>d__4))]
		private static IEnumerator<bool> TellPeerAdminStatus(ZNetPeer peer, ZPackage package)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TellPeerAdminStatus>d__4(0)
			{
				peer = peer,
				package = package
			};
		}

		internal static void RPC_AdminPieceAddRemove(long sender, ZPackage package)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			bool flag = false;
			try
			{
				flag = package.ReadBool();
			}
			catch
			{
			}
			if (isServer)
			{
				ZRoutedRpc instance = ZRoutedRpc.instance;
				long everybody = ZRoutedRpc.Everybody;
				BaseUnityPlugin plugin = BuildPiece._plugin;
				instance.InvokeRoutedRPC(everybody, ((plugin != null) ? plugin.Info.Metadata.Name : null) + " PMAdminStatusSync", new object[1] { (object)new ZPackage() });
				if (ZNet.instance.ListContainsId(ZNet.instance.m_adminList, peer.m_rpc.GetSocket().GetHostName()))
				{
					ZPackage val = new ZPackage();
					val.Write(true);
					ZRpc rpc = peer.m_rpc;
					BaseUnityPlugin plugin2 = BuildPiece._plugin;
					rpc.Invoke(((plugin2 != null) ? plugin2.Info.Metadata.Name : null) + " PMAdminStatusSync", new object[1] { val });
				}
				return;
			}
			foreach (BuildPiece registeredPiece in BuildPiece.registeredPieces)
			{
				if (!registeredPiece.SpecialProperties.AdminOnly)
				{
					continue;
				}
				Piece component = registeredPiece.Prefab.GetComponent<Piece>();
				string name = component.m_name;
				Localization.instance.Localize(name).Trim();
				if (!Object.op_Implicit((Object)(object)ObjectDB.instance) || (Object)(object)ObjectDB.instance.GetItemPrefab("YmirRemains") == (Object)null)
				{
					continue;
				}
				Piece[] array = Object.FindObjectsOfType<Piece>();
				foreach (Piece val2 in array)
				{
					if (flag)
					{
						if (val2.m_name == name)
						{
							val2.m_enabled = true;
						}
					}
					else if (val2.m_name == name)
					{
						val2.m_enabled = false;
					}
				}
				List<GameObject> pieces = ObjectDB.instance.GetItemPrefab("Hammer").GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces.m_pieces;
				if (flag)
				{
					if (!pieces.Contains(ZNetScene.instance.GetPrefab(((Object)component).name)))
					{
						pieces.Add(ZNetScene.instance.GetPrefab(((Object)component).name));
					}
				}
				else if (pieces.Contains(ZNetScene.instance.GetPrefab(((Object)component).name)))
				{
					pieces.Remove(ZNetScene.instance.GetPrefab(((Object)component).name));
				}
			}
		}

		[CompilerGenerated]
		internal static void <AdminStatusSync>g__SendAdmin|2_2(List<ZNetPeer> peers, bool isAdmin)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(isAdmin);
			((MonoBehaviour)ZNet.instance).StartCoroutine(sendZPackage(peers, val));
		}

		[CompilerGenerated]
		internal static void <TellPeerAdminStatus>g__SendPackage|4_0(ZPackage pkg, ref <>c__DisplayClass4_0 P_1)
		{
			BaseUnityPlugin plugin = BuildPiece._plugin;
			string text = ((plugin != null) ? plugin.Info.Metadata.Name : null) + " PMAdminStatusSync";
			if (isServer)
			{
				P_1.peer.m_rpc.Invoke(text, new object[1] { pkg });
			}
			else
			{
				P_1.rpc.InvokeRoutedRPC(P_1.peer.m_server ? 0 : P_1.peer.m_uid, text, new object[1] { pkg });
			}
		}
	}
	[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
	[<50128e01-106a-4503-be43-774e41560cd9>NullableContext(1)]
	[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
	internal class RegisterClientRPCPatch
	{
		private static void Postfix(ZNet __instance, ZNetPeer peer)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			if (!__instance.IsServer())
			{
				ZRpc rpc = peer.m_rpc;
				BaseUnityPlugin plugin = BuildPiece._plugin;
				rpc.Register<ZPackage>(((plugin != null) ? plugin.Info.Metadata.Name : null) + " PMAdminStatusSync", (Action<ZRpc, ZPackage>)RPC_InitialAdminSync);
				return;
			}
			ZPackage val = new ZPackage();
			val.Write(__instance.ListContainsId(__instance.m_adminList, peer.m_rpc.GetSocket().GetHostName()));
			ZRpc rpc2 = peer.m_rpc;
			BaseUnityPlugin plugin2 = BuildPiece._plugin;
			rpc2.Invoke(((plugin2 != null) ? plugin2.Info.Metadata.Name : null) + " PMAdminStatusSync", new object[1] { val });
		}

		private static void RPC_InitialAdminSync(ZRpc rpc, ZPackage package)
		{
			AdminSyncing.RPC_AdminPieceAddRemove(0L, package);
		}
	}
	[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
	[<50128e01-106a-4503-be43-774e41560cd9>NullableContext(1)]
	internal static class PiecePrefabManager
	{
		[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
		private struct BundleId
		{
			[UsedImplicitly]
			public string assetBundleFileName;

			[UsedImplicitly]
			public string folderName;
		}

		private static readonly Dictionary<BundleId, AssetBundle> bundleCache;

		private static readonly List<GameObject> piecePrefabs;

		private static readonly Dictionary<string, PieceCategory> PieceCategories;

		private static readonly Dictionary<string, PieceCategory> OtherPieceCategories;

		private static readonly Dictionary<PieceCategory, string> VanillaLabels;

		internal static bool CategoryRefreshNeeded;

		static PiecePrefabManager()
		{
			//IL_0037: 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)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			//IL_00f0: 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)
			//IL_012b: Expected O, but got Unknown
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Expected O, but got Unknown
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Expected O, but got Unknown
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Expected O, but got Unknown
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Expected O, but got Unknown
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Expected O, but got Unknown
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Expected O, but got Unknown
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Expected O, but got Unknown
			//IL_02e9: Expected O, but got Unknown
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Expected O, but got Unknown
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_0361: Expected O, but got Unknown
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_039d: Expected O, but got Unknown
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d9: Expected O, but got Unknown
			//IL_03da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0408: Unknown result type (might be due to invalid IL or missing references)
			//IL_0415: Expected O, but got Unknown
			//IL_0443: Unknown result type (might be due to invalid IL or missing references)
			//IL_0450: Expected O, but got Unknown
			bundleCache = new Dictionary<BundleId, AssetBundle>();
			piecePrefabs = new List<GameObject>();
			PieceCategories = new Dictionary<string, PieceCategory>();
			OtherPieceCategories = new Dictionary<string, PieceCategory>();
			VanillaLabels = new Dictionary<PieceCategory, string>();
			Harmony val = new Harmony("org.bepinex.helpers.PieceManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(BuildPiece), "Patch_FejdStartup", (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(Localization), "SetupLanguage", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(LocalizationCache), "LocalizationPostfix", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.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);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "CopyOtherDB", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Patch_ObjectDBInit", (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(AdminSyncing), "AdminStatusSync", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Patch_ZNetSceneAwake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "RefFixPatch_ZNetSceneAwake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(PieceTable), "UpdateAvailable", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "UpdateAvailable_Transpiler", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(PieceTable), "UpdateAvailable", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "UpdateAvailable_Prefix", (Type[])null, (Type[])null)), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "UpdateAvailable_Postfix", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Player), "SetPlaceMode", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Patch_SetPlaceMode", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Hud), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Hud_AwakeCreateTabs", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Hud), "UpdateBuild", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "RepositionCatsIfNeeded", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Hud), "LateUpdate", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "RepositionCatsIfNeeded", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Enum), "GetValues", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "EnumGetValuesPatch", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Enum), "GetNames", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "EnumGetNamesPatch", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public static AssetBundle RegisterAssetBundle(string assetBundleFileName, string folderName = "assets")
		{
			BundleId bundleId = default(BundleId);
			bundleId.assetBundleFileName = assetBundleFileName;
			bundleId.folderName = folderName;
			BundleId key = bundleId;
			if (!bundleCache.TryGetValue(key, out var value))
			{
				Dictionary<BundleId, AssetBundle> dictionary = bundleCache;
				AssetBundle? obj = ((IEnumerable<AssetBundle>)Resources.FindObjectsOfTypeAll<AssetBundle>()).FirstOrDefault((Func<AssetBundle, bool>)([<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)] (AssetBundle a) => ((Object)a).name == assetBundleFileName)) ?? AssetBundle.LoadFromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream(Assembly.GetExecutingAssembly().GetName().Name + "." + folderName + "." + assetBundleFileName));
				AssetBundle result = obj;
				dictionary[key] = obj;
				return result;
			}
			return value;
		}

		public static IEnumerable<GameObject> FixRefs(AssetBundle assetBundle)
		{
			return assetBundle.LoadAllAssets<GameObject>();
		}

		public static GameObject RegisterPrefab(string assetBundleFileName, string prefabName, string folderName = "assets")
		{
			return RegisterPrefab(RegisterAssetBundle(assetBundleFileName, folderName), prefabName);
		}

		public static GameObject RegisterPrefab(AssetBundle assets, string prefabName)
		{
			if ((Object)(object)assets == (Object)null)
			{
				Debug.LogError((object)"Failed to load asset bundle. Please make sure to mark all asset bundles as embedded resources.");
				return null;
			}
			GameObject val = assets.LoadAsset<GameObject>(prefabName);
			if ((Object)(object)val == (Object)null)
			{
				Debug.LogError((object)("Failed to load prefab " + prefabName + " from asset bundle " + ((Object)assets).name));
				return null;
			}
			piecePrefabs.Add(val);
			return val;
		}

		public static Sprite RegisterSprite(string assetBundleFileName, string prefabName, string folderName = "assets")
		{
			return RegisterSprite(RegisterAssetBundle(assetBundleFileName, folderName), prefabName);
		}

		public static Sprite RegisterSprite(AssetBundle assets, string prefabName)
		{
			return assets.LoadAsset<Sprite>(prefabName);
		}

		private static void EnumGetValuesPatch(Type enumType, ref Array __result)
		{
			if (!(enumType != typeof(PieceCategory)) && PieceCategories.Count != 0)
			{
				PieceCategory[] array = (PieceCategory[])(object)new PieceCategory[__result.Length + PieceCategories.Count];
				__result.CopyTo(array, 0);
				PieceCategories.Values.CopyTo(array, __result.Length);
				__result = array;
			}
		}

		private static void EnumGetNamesPatch(Type enumType, ref string[] __result)
		{
			if (!(enumType != typeof(PieceCategory)) && PieceCategories.Count != 0)
			{
				__result = CollectionExtensions.AddRangeToArray<string>(__result, PieceCategories.Keys.ToArray());
			}
		}

		public static Dictionary<PieceCategory, string> GetPieceCategoriesMap()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			Array values = Enum.GetValues(typeof(PieceCategory));
			string[] names = Enum.GetNames(typeof(PieceCategory));
			Dictionary<PieceCategory, string> dictionary = new Dictionary<PieceCategory, string>();
			for (int i = 0; i < values.Length; i++)
			{
				dictionary[(PieceCategory)values.GetValue(i)] = names[i];
			}
			return dictionary;
		}

		public static PieceCategory GetCategory(string name)
		{
			//IL_000b: 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_002d: 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_005d: 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_006a: 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_0090: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			if (Enum.TryParse<PieceCategory>(name, ignoreCase: true, out PieceCategory result))
			{
				return result;
			}
			if (PieceCategories.TryGetValue(name, out result))
			{
				return result;
			}
			if (OtherPieceCategories.TryGetValue(name, out result))
			{
				return result;
			}
			Dictionary<PieceCategory, string> pieceCategoriesMap = GetPieceCategoriesMap();
			foreach (KeyValuePair<PieceCategory, string> item in pieceCategoriesMap)
			{
				if (item.Value == name)
				{
					result = item.Key;
					OtherPieceCategories[name] = result;
					return result;
				}
			}
			result = (PieceCategory)(pieceCategoriesMap.Count - 1);
			PieceCategories[name] = result;
			string categoryToken = GetCategoryToken(name);
			Localization.instance.AddWord(categoryToken, name);
			return result;
		}

		internal static void CreateCategoryTabs()
		{
			if (Object.op_Implicit((Object)(object)Hud.instance))
			{
				int num = ModifiedMaxCategory();
				for (int i = Hud.instance.m_pieceCategoryTabs.Length; i < num; i++)
				{
					GameObject val = CreateCategoryTab();
					Hud.instance.m_pieceCategoryTabs = CollectionExtensions.AddItem<GameObject>((IEnumerable<GameObject>)Hud.instance.m_pieceCategoryTabs, val).ToArray();
				}
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && Object.op_Implicit((Object)(object)Player.m_localPlayer.m_buildPieces))
				{
					RepositionCategories(Player.m_localPlayer.m_buildPieces);
					Player.m_localPlayer.UpdateAvailablePiecesList();
				}
			}
		}

		private static GameObject CreateCategoryTab()
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Hud.instance.m_pieceCategoryTabs[0];
			GameObject val2 = Object.Instantiate<GameObject>(Hud.instance.m_pieceCategoryTabs[0], val.transform.parent);
			val2.SetActive(false);
			UIInputHandler orAddComponent = val2.GetOrAddComponent<UIInputHandler>();
			orAddComponent.m_onLeftDown = (Action<UIInputHandler>)Delegate.Combine(orAddComponent.m_onLeftDown, new Action<UIInputHandler>(Hud.instance.OnLeftClickCategory));
			TMP_Text[] componentsInChildren = val2.GetComponentsInChildren<TMP_Text>();
			foreach (TMP_Text obj in componentsInChildren)
			{
				obj.rectTransform.offsetMin = new Vector2(3f, 1f);
				obj.rectTransform.offsetMax = new Vector2(-3f, -1f);
				obj.enableAutoSizing = true;
				obj.fontSizeMin = 12f;
				obj.fontSizeMax = 20f;
				obj.lineSpacing = 0.8f;
				obj.textWrappingMode = (TextWrappingModes)1;
				obj.overflowMode = (TextOverflowModes)3;
			}
			return val2;
		}

		private static int ModifiedMaxCategory()
		{
			return Enum.GetValues(typeof(PieceCategory)).Length - 1;
		}

		private static int GetMaxCategoryOrDefault()
		{
			try
			{
				return (int)Enum.Parse(typeof(PieceCategory), "Max");
			}
			catch (ArgumentException)
			{
				Debug.LogWarning((object)"Could not find Piece.PieceCategory.Max, using fallback value 4");
				return 4;
			}
		}

		private static List<CodeInstruction> TranspileMaxCategory(IEnumerable<CodeInstruction> instructions, int maxOffset)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			int num = GetMaxCategoryOrDefault() + maxOffset;
			List<CodeInstruction> list = new List<CodeInstruction>();
			foreach (CodeInstruction instruction in instructions)
			{
				if (CodeInstructionExtensions.LoadsConstant(instruction, (long)num))
				{
					list.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "ModifiedMaxCategory", (Type[])null, (Type[])null)));
					if (maxOffset != 0)
					{
						list.Add(new CodeInstruction(OpCodes.Ldc_I4, (object)maxOffset));
						list.Add(new CodeInstruction(OpCodes.Add, (object)null));
					}
				}
				else
				{
					list.Add(instruction);
				}
			}
			return list;
		}

		private static IEnumerable<CodeInstruction> UpdateAvailable_Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			return TranspileMaxCategory(instructions, 0);
		}

		private static HashSet<PieceCategory> CategoriesInPieceTable(PieceTable pieceTable)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			HashSet<PieceCategory> hashSet = new HashSet<PieceCategory>();
			Piece val = default(Piece);
			foreach (GameObject item in pieceTable.m_pieces.Where([<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)] (GameObject pieceFab) => (Object)(object)pieceFab != (Object)null))
			{
				if (item.TryGetComponent<Piece>(ref val))
				{
					hashSet.Add(val.m_category);
				}
			}
			return hashSet;
		}

		private static void RepositionCatsIfNeeded()
		{
			if (CategoryRefreshNeeded)
			{
				CategoryRefreshNeeded = false;
				CreateCategoryTabs();
				RepositionCats();
			}
		}

		private static void RepositionCats()
		{
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && Object.op_Implicit((Object)(object)Player.m_localPlayer.m_buildPieces))
			{
				RepositionCategories(Player.m_localPlayer.m_buildPieces);
			}
		}

		private static void RepositionCategories(PieceTable pieceTable)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_0026: 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_0040: Expected O, but got Unknown
			//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_005f: 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_0089: 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_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: 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_013a: 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_016c: 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_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Expected O, but got Unknown
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = (RectTransform)Hud.instance.m_pieceCategoryTabs[0].transform;
			RectTransform val2 = (RectTransform)Hud.instance.m_pieceCategoryRoot.transform;
			RectTransform val3 = (RectTransform)Hud.instance.m_pieceSelectionWindow.transform;
			HorizontalLayoutGroup val4 = default(HorizontalLayoutGroup);
			if (((Component)((Transform)val).parent).TryGetComponent<HorizontalLayoutGroup>(ref val4))
			{
				Object.DestroyImmediate((Object)(object)val4);
			}
			Rect rect = val.rect;
			Vector2 size = ((Rect)(ref rect)).size;
			GridLayoutGroup val5 = default(GridLayoutGroup);
			GridLayoutGroup obj = (((Component)((Transform)val).parent).TryGetComponent<GridLayoutGroup>(ref val5) ? val5 : ((Component)((Transform)val).parent).gameObject.AddComponent<GridLayoutGroup>());
			obj.cellSize = size;
			obj.spacing = new Vector2(0f, 1f);
			obj.constraint = (Constraint)1;
			obj.constraintCount = 5;
			((LayoutGroup)obj).childAlignment = (TextAnchor)4;
			HashSet<PieceCategory> hashSet = CategoriesInPieceTable(pieceTable);
			UpdatePieceTableCategories(pieceTable, hashSet);
			rect = val2.rect;
			int num = Mathf.Max((int)(((Rect)(ref rect)).width / size.x), 1);
			int count = pieceTable.m_categories.Count;
			float num2 = (0f - size.x) * (float)num / 2f + size.x / 2f;
			float num3 = (size.y + 1f) * Mathf.Floor((float)(count - 1) / (float)num) + 5f;
			new Vector2(num2, num3);
			int num4 = Mathf.CeilToInt((float)count / (float)num);
			float num5 = (size.y + 1f) * (float)num4;
			RectTransform component = ((Component)((Transform)val).parent).GetComponent<RectTransform>();
			component.anchoredPosition = new Vector2(component.anchoredPosition.x, num5 / 2f);
			int num6 = 0;
			for (int i = 0; i < Hud.instance.m_pieceCategoryTabs.Length; i++)
			{
				GameObject val6 = Hud.instance.m_pieceCategoryTabs[i];
				if ((Object)(object)val6 == (Object)null)
				{
					continue;
				}
				if (i >= pieceTable.m_categories.Count)
				{
					val6.SetActive(false);
					continue;
				}
				PieceCategory item = pieceTable.m_categories[i];
				string text = pieceTable.m_categoryLabels[i];
				if (hashSet.Contains(item))
				{
					num6++;
				}
				val6.GetComponentInChildren<TMP_Text>().text = Localization.instance.Localize(text);
			}
			Transform obj2 = ((Transform)val3).Find("Bkg2");
			RectTransform val7 = (RectTransform)((obj2 != null) ? ((Component)obj2).transform : null);
			if (Object.op_Implicit((Object)(object)val7))
			{
				float num7 = (size.y + 1f) * (float)Mathf.Max(0, Mathf.FloorToInt((float)(num6 - 1) / (float)num));
				val7.offsetMax = new Vector2(val7.offsetMax.x, num7);
			}
			else
			{
				Debug.LogWarning((object)"RefreshCategories: Could not find background image");
			}
			((Component)Hud.instance).GetComponentInParent<Localize>().RefreshLocalization();
		}

		private static void UpdatePieceTableCategories(PieceTable pieceTable, HashSet<PieceCategory> visibleCategories)
		{
			//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_003b: 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_0049: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: 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_00bd: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < GetMaxCategoryOrDefault(); i++)
			{
				PieceCategory val = (PieceCategory)i;
				if (visibleCategories.Contains(val) && !pieceTable.m_categories.Contains(val))
				{
					pieceTable.m_categories.Add(val);
					pieceTable.m_categoryLabels.Add(GetVanillaLabel(val));
				}
				if (!visibleCategories.Contains(val) && pieceTable.m_categories.Contains(val))
				{
					int index = pieceTable.m_categories.IndexOf(val);
					pieceTable.m_categories.RemoveAt(index);
					pieceTable.m_categoryLabels.RemoveAt(index);
				}
			}
			foreach (KeyValuePair<string, PieceCategory> pieceCategory in PieceCategories)
			{
				string key = pieceCategory.Key;
				PieceCategory value = pieceCategory.Value;
				if (visibleCategories.Contains(value) && !pieceTable.m_categories.Contains(value))
				{
					pieceTable.m_categories.Add(value);
					pieceTable.m_categoryLabels.Add("$" + GetCategoryToken(key));
				}
				if (visibleCategories.Contains(value) && !pieceTable.m_categoryLabels.Contains("$" + GetCategoryToken(key)))
				{
					pieceTable.m_categoryLabels.Add("$" + GetCategoryToken(key));
				}
				if (!visibleCategories.Contains(value) && pieceTable.m_categories.Contains(value))
				{
					int index2 = pieceTable.m_categories.IndexOf(value);
					pieceTable.m_categories.RemoveAt(index2);
					pieceTable.m_categoryLabels.RemoveAt(index2);
				}
			}
		}

		private static string GetVanillaLabel(PieceCategory category)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (!VanillaLabels.ContainsKey(category))
			{
				SearchVanillaLabels();
			}
			if (!VanillaLabels.TryGetValue(category, out var value))
			{
				return string.Empty;
			}
			return value;
		}

		private static void SearchVanillaLabels()
		{
			//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_0033: 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)
			PieceTable[] array = Resources.FindObjectsOfTypeAll<PieceTable>();
			foreach (PieceTable val in array)
			{
				for (int j = 0; j < val.m_categories.Count; j++)
				{
					PieceCategory key = val.m_categories[j];
					if (j < val.m_categoryLabels.Count && !VanillaLabels.ContainsKey(key) && !string.IsNullOrEmpty(val.m_categoryLabels[j]))
					{
						VanillaLabels[key] = val.m_categoryLabels[j];
					}
				}
			}
		}

		private static string GetCategoryToken(string name)
		{
			char[] endChars = Localization.instance.m_endChars;
			string text = string.Concat(name.ToLower().Split(endChars));
			return "piecemanager_cat_" + text;
		}

		private static void Patch_SetPlaceMode(Player __instance)
		{
			if (Object.op_Implicit((Object)(object)__instance.m_buildPieces))
			{
				RepositionCategories(__instance.m_buildPieces);
			}
		}

		private static void UpdateAvailable_Prefix(PieceTable __instance)
		{
			if (__instance.m_availablePieces.Count > 0)
			{
				int num = ModifiedMaxCategory() - __instance.m_availablePieces.Count;
				for (int i = 0; i < num; i++)
				{
					__instance.m_availablePieces.Add(new List<Piece>());
				}
			}
		}

		private static void UpdateAvailable_Postfix(PieceTable __instance)
		{
			Array.Resize(ref __instance.m_selectedPiece, __instance.m_availablePieces.Count);
			Array.Resize(ref __instance.m_lastSelectedPiece, __instance.m_availablePieces.Count);
		}

		[HarmonyPriority(200)]
		private static void Hud_AwakeCreateTabs()
		{
			CreateCategoryTabs();
		}

		[HarmonyPriority(700)]
		private static void Patch_ZNetSceneAwake(ZNetScene __instance)
		{
			foreach (GameObject piecePrefab in piecePrefabs)
			{
				if (!__instance.m_prefabs.Contains(piecePrefab))
				{
					__instance.m_prefabs.Add(piecePrefab);
				}
			}
		}

		[HarmonyPriority(700)]
		private static void RefFixPatch_ZNetSceneAwake(ZNetScene __instance)
		{
			//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)
			foreach (GameObject piecePrefab in piecePrefabs)
			{
				if (__instance.m_prefabs.Contains(piecePrefab) && Object.op_Implicit((Object)(object)piecePrefab.GetComponent<StationExtension>()))
				{
					piecePrefab.GetComponent<Piece>().m_isUpgrade = true;
					piecePrefab.GetComponent<StationExtension>().m_connectionPrefab = __instance.GetPrefab("piece_workbench_ext3").GetComponent<StationExtension>().m_connectionPrefab;
					piecePrefab.GetComponent<StationExtension>().m_connectionOffset = __instance.GetPrefab("piece_workbench_ext3").GetComponent<StationExtension>().m_connectionOffset;
				}
			}
		}

		[HarmonyPriority(300)]
		private static void Patch_ObjectDBInit(ObjectDB __instance)
		{
			foreach (BuildPiece registeredPiece in BuildPiece.registeredPieces)
			{
				string[] activeTools = registeredPiece.activeTools;
				foreach (string text in activeTools)
				{
					GameObject itemPrefab = __instance.GetItemPrefab(text);
					PieceTable val = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces : null);
					if (val != null && !val.m_pieces.Contains(registeredPiece.Prefab))
					{
						val.m_pieces.Add(registeredPiece.Prefab);
					}
				}
			}
		}
	}
	internal static class PieceManagerVersion
	{
		[<22957838-652f-402d-8d20-b0d370add669>Nullable(1)]
		public const string Version = "1.2.9";
	}
	[PublicAPI]
	[<50128e01-106a-4503-be43-774e41560cd9>NullableContext(1)]
	[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
	internal class Conversion
	{
		[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
		internal class ConversionConfig
		{
			public ConfigEntry<string> input;

			public ConfigEntry<string> output;
		}

		public string Input;

		public string Output;

		[<22957838-652f-402d-8d20-b0d370add669>Nullable(2)]
		internal ConversionConfig config;

		public Conversion(BuildPiece conversionPiece)
		{
			conversionPiece.Conversions.Add(this);
		}
	}
	[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
	[<50128e01-106a-4503-be43-774e41560cd9>NullableContext(1)]
	internal class SnapPoint
	{
		public GameObject GameObject { get; private set; }

		public bool IsInUse { get; set; }

		public SnapPoint(GameObject gameObject)
		{
			GameObject = gameObject;
		}
	}
	[<22957838-652f-402d-8d20-b0d370add669>Nullable(0)]
	[PublicAPI]
	[<50128e01-106a-4503-be43-774e41560cd9>NullableContext(1)]
	internal class SnapPointMaker
	{
		[<50128e01-106a-4503-be43-774e41560cd9>NullableContext(0)]
		public enum SnapPointType
		{
			Vertices,
			Center,
			Poles,
			Equator
		}

		private static readonly List<GameObject> ObjectsToApplySnaps = new List<GameObject>();

		private static readonly List<SnapPoint> SnapPoints = new List<SnapPoint>();

		public static void AddObjectForSnapPoints(GameObject obj)
		{
			ObjectsToApplySnaps.Add(obj);
		}

		public static void ApplySnapPoints(SnapPointType snapPointType)
		{
			foreach (GameObject objectsToApplySnap in ObjectsToApplySnaps)
			{
				GrabVerticesAssignSnaps(objectsToApplySnap, snapPointType);
			}
		}

		private static void GrabVerticesAssignSnaps(GameObject obj, SnapPointType snapPointType)
		{
			Collider component = obj.GetComponent<Collider>();
			BoxCollider val = (BoxCollider)(object)((component is BoxCollider) ? component : null);
			if (val != null)
			{
				Vector3[] boxColliderSnapPoints = GetBoxColliderSnapPoints(obj, val, snapPointType);
				AttachSnapPoints(obj, boxColliderSnapPoints);
				return;
			}
			SphereCollider val2 = (SphereCollider)(object)((component is SphereCollider) ? component : null);
			if (val2 != null)
			{
				Vector3[] sphereColliderSnapPoints = GetSphereColliderSnapPoints(obj, val2, snapPointType);
				AttachSnapPoints(obj, sphereColliderSnapPoints);
			}
			else
			{
				Debug.LogWarning((object)("Unsupported collider type for " + ((Object)obj).name + ": " + ((object)component).GetType()));
			}
		}

		private static Vector3[] GetBoxColliderSnapPoints(GameObject obj, BoxCollider col, SnapPointType snapPointType)
		{
			//IL_000e: 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_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_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_003a: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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_0074: 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_0080: 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_008b: 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_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: 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)
			//IL_00c0: 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_00cc: 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_00dd: 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_00e9: 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_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: 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_010c: 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_0123: 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_012f: 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_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: 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_0158: 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_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = new List<Vector3>();
			Transform transform = obj.transform;
			Vector3 val = col.center - col.size * 0.5f;
			Vector3 val2 = col.center + col.size * 0.5f;
			if (snapPointType == SnapPointType.Vertices || snapPointType == SnapPointType.Center)
			{
				list.Add(transform.TransformPoint(new Vector3(val.x, val.y, val.z)));
				list.Add(transform.TransformPoint(new Vector3(val.x, val.y, val2.z)));
				list.Add(transform.TransformPoint(new Vector3(val.x, val2.y, val.z)));
				list.Add(transform.TransformPoint(new Vector3(val.x, val2.y, val2.z)));
				list.Add(transform.TransformPoint(new Vector3(val2.x, val.y, val.z)));
				list.Add(transform.TransformPoint(new Vector3(val2.x, val.y, val2.z)));
				list.Add(transform.TransformPoint(new Vector3(val2.x, val2.y, val.z)));
				list.Add(transform.TransformPoint(new Vector3(val2.x, val2.y, val2.z)));
			}
			if (snapPointType == SnapPointType.Center)
			{
				list.Add(transform.TransformPoint(col.center));
			}
			return list.ToArray();
		}

		private static Vector3[] GetSphereColliderSnapPoints(GameObject obj, SphereCollider col, SnapPointType snapPointType)
		{
			//IL_0027: 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_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_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)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: 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_00f1: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = new List<Vector3>();
			Transform transform = obj.transform;
			if (snapPointType == SnapPointType.Poles || snapPointType == SnapPointType.Center)
			{
				list.Add(transform.TransformPoint(new Vector3(0f, col.radius, 0f)));
				list.Add(transform.TransformPoint(new Vector3(0f, 0f - col.radius, 0f)));
			}
			if (snapPointType == SnapPointType.Equator)
			{
				list.Add(transform.TransformPoint(new Vector3(0f - col.radius, 0f, 0f)));
				list.Add(transform.TransformPoint(new Vector3(col.radius, 0f, 0f)));
				list.Add(transform.TransformPoint(new Vector3(0f, 0f, 0f - col.radius)));
				list.Add(transform.TransformPoint(new Vector3(0f, 0f, col.radius)));
			}
			if (snapPointType == SnapPointType.Center)
			{
				list.Add(transform.TransformPoint(col.center));
			}
			return list.ToArray();
		}

		private static Vector3[] GetColliderVertexPosRotated(GameObject obj)
		{
			//IL_0021: 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_0031: 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)
			//IL_003b: 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_0043: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//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_0062: 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_006e: 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_0080: 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_008c: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: 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_00d0: 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_00e8: 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_00f7: 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_0103: Unknown result type (might be due to invalid IL or missing references)
			//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_0115: 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_0122: 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_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_013b: 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_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: 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_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] array = (Vector3[])(object)new Vector3[8];
			BoxCollider componentInChildren = obj.GetComponentInChildren<BoxCollider>();
			if ((Object)(object)componentInChildren == (Object)null)
			{
				return array;
			}
			Transform transform = obj.transform;
			Vector3 val = componentInChildren.center - componentInChildren.size * 0.5f;
			Vector3 val2 = componentInChildren.center + componentInChildren.size * 0.5f;
			array[0] = transform.TransformPoint(new Vector3(val.x, val.y, val.z));
			array[1] = transform.TransformPoint(new Vector3(val.x, val.y, val2.z));
			array[2] = transform.TransformPoint(new Vector3(val.x, val2.y, val.z));
			array[3] = transform.TransformPoint(new Vector3(val.x, val2.y, val2.z));
			array[4] = transform.TransformPoint(new Vector3(val2.x, val.y, val.z));
			array[5] = transform.TransformPoint(new Vector3(val2.x, val.y, val2.z));
			array[6] = transform.TransformPoint(new Vector3(val2.x, val2.y, val.z));
			array[7] = transform.TransformPoint(new Vector3(val2.x, val2.y, val2.z));
			return array;
		}

		private static void AttachSnapPoints(GameObject objecttosnap, Vector3[] vector3S)
		{
			//IL_0008: 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_000f: Unknown result type (might be due to invalid IL or missing references)
			foreach (Vector3 position in vector3S)
			{
				AddSnapPoint(objecttosnap, position).GameObject.SetActive(false);
			}
		}

		public static SnapPoint AddSnapPoint(GameObject parent, Vector3 position)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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_007e: 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_0098: 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_00a9: Expected O, but got Unknown
			foreach (SnapPoint snapPoint2 in SnapPoints)
			{
				if (!snapPoint2.IsInUse)
				{
					snapPoint2.GameObject.transform.SetParent(parent.transform, false);
					snapPoint2.GameObject.transform.position = position;
					snapPoint2.IsInUse = true;
					return snapPoint2;
				}
			}
			GameObject val = new GameObject("_snappoint")
			{
				tag = "snappoint",
				layer = 10
			};
			val.transform.SetParent(parent.transform, false);
			val.transform.position = position;
			SnapPoint snapPoint = new SnapPoint(val);
			snapPoint.IsInUse = true;
			SnapPoints.Add(snapPoint);
			return snapPoint;
		}

		public static void ReleaseSnapPoint(SnapPoint snapPoint)
		{
			snapPoint.GameObject.transform.parent = null;
			snapPoint.IsInUse = false;
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[<a9371ec1-d5e7-475f-b185-d17f2a599462>Embedded]
	[CompilerGenerated]
	internal sealed class <a9371ec1-d5e7-475f-b185-d17f2a599462>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[<a9371ec1-d5e7-475f-b185-d17f2a599462>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class <7e4c5f11-01fb-49da-aef6-ad246f24495b>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <7e4c5f11-01fb-49da-aef6-ad246f24495b>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <7e4c5f11-01fb-49da-aef6-ad246f24495b>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[<a9371ec1-d5e7-475f-b185-d17f2a599462>Embedded]
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class <2beb9a87-5522-48bc-94ee-01e6f5ca1641>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <2beb9a87-5522-48bc-94ee-01e6f5ca1641>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace StatusEffectManager
{
	[Description("The ItemDrop effect to apply the status effect")]
	[PublicAPI]
	internal enum EffectType
	{
		Equip,
		Attack,
		Consume,
		Set
	}
	internal struct SE_Item
	{
		[<7e4c5f11-01fb-49da-aef6-ad246f24495b>Nullable(1)]
		public StatusEffect Effect;

		public EffectType Type;
	}
	[<7e4c5f11-01fb-49da-aef6-ad246f24495b>Nullable(0)]
	[PublicAPI]
	[<2beb9a87-5522-48bc-94ee-01e6f5ca1641>NullableContext(1)]
	internal class CustomSE
	{
		private static readonly List<CustomSE> RegisteredEffects = new List<CustomSE>();

		private static readonly Dictionary<StatusEffect, CustomSE> CustomEffectMap = new Dictionary<StatusEffect, CustomSE>();

		internal static readonly List<StatusEffect> CustomSEs = new List<StatusEffect>();

		internal static readonly Dictionary<SE_Item, string> AddToPrefabs = new Dictionary<SE_Item, string>();

		[Description("Instance of the StatusEffect.")]
		public readonly StatusEffect Effect;

		public EffectType Type;

		private string _folderName = "icons";

		private AssetBundle _assetBundle = null;

		[Description("Sets the icon for the StatusEffect. Must be 64x64")]
		[<7e4c5f11-01fb-49da-aef6-ad246f24495b>Nullable(2)]
		public Sprite IconSprite = null;

		[<7e4c5f11-01fb-49da-aef6-ad246f24495b>Nullable(2)]
		private string IconName = null;

		[<7e4c5f11-01fb-49da-aef6-ad246f24495b>Nullable(2)]
		private LocalizeKey _name;

		[<7e4c5f11-01fb-49da-aef6-ad246f24495b>Nullable(2)]
		private static Localization _english;

		[<7e4c5f11-01fb-49da-aef6-ad246f24495b>Nullable(2)]
		private static BaseUnityPlugin _plugin;

		private static bool hasConfigSync = true;

		[<7e4c5f11-01fb-49da-aef6-ad246f24495b>Nullable(2)]
		private static object _configSync;

		[Description("Sets the icon for the StatusEffect. Must be 64x64")]
		[<7e4c5f11-01fb-49da-aef6-ad246f24495b>Nullable(2)]
		public string Icon
		{
			[<2beb9a87-5522-48bc-94ee-01e6f5ca1641>NullableContext(2)]
			get
			{
				return IconName;
			}
			[<2beb9a87-5522-48bc-94ee-01e6f5ca1641>NullableContext(2)]
			set
			{
				IconName = value;
				IconSprite = ((IconName == null) ? null : loadSprite(IconName));
				Effect.m_icon = IconSprite;
			}
		}

		[Description("Sets the in-game name for the StatusEffect")]
		public LocalizeKey Name
		{
			get
			{
				LocalizeKey name = _name;
				if (name != null)
				{
					return name;
				}
				StatusEffect effect = Effect;
				if (effect.m_name.StartsWith("$"))
				{
					_name = new LocalizeKey(effect.m_name);
				}
				else
				{
					string text = "$statuseffect_" + ((Object)Effect).name.Replace(" ", "_");
					_name = new LocalizeKey(text).English(effect.m_name);
					effect.m_name = text;
				}
				return _name;
			}
		}

		private static Localization english
		{
			get
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Expected O, but got Unknown
				if (_english == null)
				{
					_english = new Localization();
					_english.SetupLanguage("English");
				}
				return _english;
			}
		}

		private static BaseUnityPlugin plugin
		{
			get
			{
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: 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([<2beb9a87-5522-48bc-94ee-01e6f5ca1641>NullableContext(0)] (TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
				}
				return _plugin;
			}
		}

		[<7e4c5f11-01fb-49da-aef6-ad246f24495b>Nullable(2)]
		private static object configSync
		{
			[<2beb9a87-5522-48bc-94ee-01e6f5ca1641>NullableContext(2)]
			get
			{
				if (_configSync == null && hasConfigSync)
				{
					Type type = Assembly.GetExecutingAssembly().GetType("ServerSync.ConfigSync");
					if ((object)type != null)
					{
						_configSync = Activator.CreateInstance(type, plugin.Info.Metadata.GUID + " ItemManager");
						type.GetField("CurrentVersion").SetValue(_configSync, plugin.Info.Metadata.Version.ToString());
						type.GetProperty("IsLocked").SetValue(_configSync, true);
					}
					else
					{
						hasConfigSync = false;
					}
				}
				return _configSync;
			}
		}

		public CustomSE(string assetBundleFileName, string customEffectName, string folderName = "assets")
			: this(EffectManager.RegisterAssetBundle(assetBundleFileName, folderName), customEffectName)
		{
		}

		public CustomSE(AssetBundle bundle, string customEffectName)
		{
			Effect = EffectManager.RegisterCustomSE(bundle, customEffectName);
			RegisteredEffects.Add(this);
			CustomEffectMap[Effect] = this;
		}

		public CustomSE(string customEffectName)
		{
			Effect = ScriptableObject.CreateInstance<StatusEffect>();
			EffectManager.RegisterCustomSE(Effect, customEffectName);
			RegisteredEffects.Add(this);
			CustomEffectMap[Effect] = this;
		}

		[return: <7e4c5f11-01fb-49da-aef6-ad246f24495b>Nullable(2)]
		private byte[] ReadEmbeddedFileBytes(string name)
		{
			using MemoryStream memoryStream = new MemoryStream();
			Stream manifestResourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(Assembly.GetExecutingAssembly().GetName().Name + ((_folderName == "") ? "" : ".") + _folderName + "." + name);
			if (manifestResourceStream == null)
			{
				return null;
			}
			manifestResourceStream.CopyTo(memoryStream);
			return memoryStream.ToArray();
		}

		[return: <7e4c5f11-01fb-49da-aef6-ad246f24495b>Nullable(2)]
		private Texture2D loadTexture(string name)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			byte[] array = ReadEmbeddedFileBytes(name);
			if (array != null)
			{
				Texture2D val = new Texture2D(0, 0);
				ImageConversion.LoadImage(val, array);
				return val;
			}
			return null;
		}

		private Sprite loadSprite(string name)
		{
			//IL_0027: 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)
			Texture2D val = loadTexture(name);
			if (val != null)
			{
				return Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), Vector2.zero);
			}
			AssetBundle assetBundle = _assetBundle;
			Sprite val2 = ((assetBundle != null) ? assetBundle.LoadAsset<Sprite>(name) : null);
			if (val2 != null)
			{
				return val2;
			}
			throw new FileNotFoundException("Could not find a file named " + name + " for the effect icon");
		}

		public void AddSEToPrefab(CustomSE customSE, string prefabName)
		{
			SE_Item sE_Item = default(SE_Item);
			sE_Item.Effect = customSE.Effect;
			sE_Item.Type = customSE.Type;
			SE_Item key = sE_Item;
			AddToPrefabs.Add(key, prefabName);
		}

		private static ConfigEntry<T> config<[<7e4c5f11-01fb-49da-aef6-ad246f24495b>Nullable(2)] T>(string group, string name, T value, ConfigDescription description)
		{
			ConfigEntry<T> val = plugin.Config.Bind<T>(group, name, value, description);
			configSync?.GetType().GetMethod("AddConfigEntry").MakeGenericMethod(typeof(T))
				.Invoke(configSync, new object[1] { val });
			return val;
		}

		private static ConfigEntry<T> config<[<7e4c5f11-01fb-49da-aef6-ad246f24495b>Nullable(2)] 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>()));
		}
	}
	[<2beb9a87-5522-48bc-94ee-01e6f5ca1641>NullableContext(1)]
	[<7e4c5f11-01fb-49da-aef6-ad246f24495b>Nullable(0)]
	[PublicAPI]
	internal class LocalizeKey
	{
		public readonly string Key;

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

		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)
		{
			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;
		}
	}
	[<7e4c5f11-01fb-49da-aef6-ad246f24495b>Nullable(0)]
	[<2beb9a87-5522-48bc-94ee-01e6f5ca1641>NullableContext(1)]
	internal static class EffectManager
	{
		[<7e4c5f11-01fb-49da-aef6-ad246f24495b>Nullable(0)]
		private struct BundleId
		{
			[UsedImplicitly]
			public string assetBundleFileName;

			[UsedImplicitly]
			public string folderName;
		}

		private static readonly Dictionary<BundleId, AssetBundle> bundleCache;

		static EffectManager()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			bundleCache = new Dictionary<BundleId, AssetBundle>();
			Harmony val = new Harmony("org.bepinex.helpers.StatusEffectManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(EffectManager), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(EffectManager), "Patch_ZNetSceneAwake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public static AssetBundle RegisterAssetBundle(string assetBundleFileName, string folderName = "assets")
		{
			BundleId bundleId = default(BundleId);
			bundleId.assetBundleFileName = assetBundleFileName;
			bundleId.folderName = folderName;
			BundleId key = bundleId;
			if (!bundleCache.TryGetValue(key, out var value))
			{
				Dictionary<BundleId, AssetBundle> dictionary = bundleCache;
				AssetBundle? obj = ((IEnumerable<AssetBundle>)Resources.FindObjectsOfTypeAll<AssetBundle>()).FirstOrDefault((Func<AssetBundle, bool>)([<2beb9a87-5522-48bc-94ee-01e6f5ca1641>NullableContext(0)] (AssetBundle a) => ((Object)a).name == assetBundleFileName)) ?? AssetBundle.LoadFromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream(Assembly.GetExecutingAssembly().GetName().Name + ((folderName == "") ? "" : ".") + folderName + "." + assetBundleFileName));
				AssetBundle result = obj;
				dictionary[key] = obj;
				return result;
			}
			return value;
		}

		public static StatusEffect RegisterCustomSE(string assetBundleFileName, string customEffectName, string folderName = "assets")
		{
			return RegisterCustomSE(RegisterAssetBundle(assetBundleFileName, folderName), customEffectName);
		}

		public static StatusEffect RegisterCustomSE(AssetBundle assets, string customEffectName)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			StatusEffect val = (StatusEffect)assets.LoadAsset<ScriptableObject>(customEffectName);
			CustomSE.CustomSEs.Add(val);
			return val;
		}

		public static StatusEffect RegisterCustomSE(StatusEffect customSE, string customEffectName)
		{
			((Object)customSE).name = customEffectName;
			CustomSE.CustomSEs.Add(customSE);
			return customSE;
		}

		[HarmonyPriority(700)]
		private static void Patch_ObjectDBInit(ObjectDB __instance)
		{
			foreach (StatusEffect customSE in CustomSE.CustomSEs)
			{
				if (!__instance.m_StatusEffects.Contains(customSE))
				{
					__instance.m_StatusEffects.Add(customSE);
				}
			}
			__instance.UpdateRegisters();
		}

		[HarmonyPriority(700)]
		private static void Patch_ZNetSceneAwake(ZNetScene __instance)
		{
			foreach (KeyValuePair<SE_Item, string> addToPrefab in CustomSE.AddToPrefabs)
			{
				try
				{
					GameObject prefab = __instance.GetPrefab(addToPrefab.Value);
					ItemDrop val = (Object.op_Implicit((Object)(object)prefab) ? prefab.GetComponent<ItemDrop>() : prefab.GetComponentInChildren<ItemDrop>());
					Aoe val2 = (Object.op_Implicit((Object)(object)prefab) ? prefab.GetComponent<Aoe>() : prefab.GetComponentInChildren<Aoe>());
					EffectArea val3 = (Object.op_Implicit((Object)(object)prefab) ? prefab.GetComponent<EffectArea>() : prefab.GetComponentInChildren<EffectArea>());
					if (Object.op_Implicit((Object)(object)val))
					{
						switch (addToPrefab.Key.Type)
						{
						case EffectType.Equip:
							val.m_itemData.m_shared.m_equipStatusEffect = addToPrefab.Key.Effect;
							break;
						case EffectType.Attack:
							val.m_itemData.m_shared.m_attackStatusEffect = addToPrefab.Key.Effect;
							break;
						case EffectType.Consume:
							val.m_itemData.m_shared.m_consumeStatusEffect = addToPrefab.Key.Effect;
							break;
						case EffectType.Set:
							val.m_itemData.m_shared.m_setSize = 1;
							val.m_itemData.m_shared.m_setName = ((Object)addToPrefab.Key.Effect).name;
							val.m_itemData.m_shared.m_setStatusEffect = addToPrefab.Key.Effect;
							break;
						default:
							throw new ArgumentOutOfRangeException();
						}
					}
					else if (Object.op_Implicit((Object)(object)val2))
					{
						val2.m_statusEffect = ((Object)addToPrefab.Key.Effect).name;
					}
					else if (Object.op_Implicit((Object)(object)val3))
					{
						val3.m_statusEffect = ((Object)addToPrefab.Key.Effect).name;
					}
					else
					{
						Debug.LogWarning((object)("The prefab '" + ((Object)prefab).name + "' does not have an ItemDrop, AOE, or EffectArea component. Cannot add the StatusEffect to the prefab."));
					}
				}
				catch (Exception arg)
				{
					Debug.LogWarning((object)$"BROKE : {arg}");
				}
			}
		}
	}
}
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;
		}
	}
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	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;
		}
	}
}
internal static class AnimationSpeedManager
{
	public delegate double Handler(Character character, double speed);

	private static readonly Harmony harmony = new Harmony("AnimationSpeedManager");

	private static bool hasMarkerPatch = false;

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

	private static int index = 0;

	private static bool changed = false;

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

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

	[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_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Expected O, but got Unknown
		if (!hasMarkerPatch)
		{
			harmony.Patch((MethodBase)method, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(AnimationSpeedManager), "markerPatch", (Type[])null, (Type[])null)), (HarmonyMethod)null);
			hasMarkerPatch = true;
		}
		if (!handlersPriorities.TryGetValue(priority, out List<Handler> value))
		{
			handlersPriorities.Add(priority, value = new List<Handler>());
			harmony.Patch((MethodBase)method, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(AnimationSpeedManager), "wrapper", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
		value.Add(handler);
		handlers = (from kv in handlersPriorities
			orderby kv.Key
			select kv.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[index++].Aggregate(num2, (double current, Handler handler) => handler(___m_character2, current));
			if (num3 != num2)
			{
				___m_animator.speed = (float)(num3 - num3 % 1E-05);
				changed = true;
			}
		}
	}

	private static void markerPatch(Animator ___m_animator)
	{
		if (changed)
		{
			double num = (double)___m_animator.speed * 10000000.0 % 100.0;
			if ((num < 10.0 || num > 30.0) ? true : false)
			{
				___m_animator.speed += 1.9E-06f;
			}
			changed = false;
		}
		index = 0;
	}
}