using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using JetBrains.Annotations;
using LocalizationManager;
using Microsoft.CodeAnalysis;
using ServerSync;
using TMPro;
using UnityEngine;
using UnityEngine.SceneManagement;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Core.Tokens;
using YamlDotNet.Helpers;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.BufferedDeserialization;
using YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators;
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;

[assembly: AssemblyFileVersion("1.0.3")]
[assembly: Guid("9a76071c-0d37-415e-a1c3-d855a3598f13")]
[assembly: ComVisible(false)]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCopyright("Copyright ©  2022")]
[assembly: AssemblyProduct("Ice&RuneStone Skills")]
[assembly: AssemblyCompany("WackyMole")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyTitle("Ice&RuneStone Skills")]
[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.0.3.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<e390d8b9-6d0d-4049-83a4-b5236b7e2b80>Embedded]
	internal sealed class <e390d8b9-6d0d-4049-83a4-b5236b7e2b80>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)]
	[<e390d8b9-6d0d-4049-83a4-b5236b7e2b80>Embedded]
	[CompilerGenerated]
	internal sealed class <112d6ed7-dc6b-4fda-bdf2-ab7972ac2d69>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <112d6ed7-dc6b-4fda-bdf2-ab7972ac2d69>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <112d6ed7-dc6b-4fda-bdf2-ab7972ac2d69>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[<e390d8b9-6d0d-4049-83a4-b5236b7e2b80>Embedded]
	[CompilerGenerated]
	internal sealed class <ea9bb20d-487b-4a97-8899-23175f62942b>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <ea9bb20d-487b-4a97-8899-23175f62942b>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace IceCaveSkills
{
	[<ea9bb20d-487b-4a97-8899-23175f62942b>NullableContext(1)]
	[<112d6ed7-dc6b-4fda-bdf2-ab7972ac2d69>Nullable(0)]
	[BepInPlugin("WackyMole.IceAndRuneStoneSkills", "IceAndRuneStoneSkills", "1.0.3")]
	public class IceCaveSkillsPlugin : BaseUnityPlugin
	{
		[<ea9bb20d-487b-4a97-8899-23175f62942b>NullableContext(0)]
		public enum Toggle
		{
			On = 1,
			Off = 0
		}

		[<ea9bb20d-487b-4a97-8899-23175f62942b>NullableContext(0)]
		public enum RewardAmountMode
		{
			Flat,
			PercentageOfMax
		}

		[<ea9bb20d-487b-4a97-8899-23175f62942b>NullableContext(0)]
		public enum DiscoveryScope
		{
			World,
			PerPlayer
		}

		[<ea9bb20d-487b-4a97-8899-23175f62942b>NullableContext(0)]
		private enum RewardSource
		{
			CavePainting,
			Runestone
		}

		[<ea9bb20d-487b-4a97-8899-23175f62942b>NullableContext(0)]
		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public int? Order;

			[UsedImplicitly]
			public bool? Browsable;

			[UsedImplicitly]
			[<112d6ed7-dc6b-4fda-bdf2-ab7972ac2d69>Nullable(2)]
			public string Category;

			[<112d6ed7-dc6b-4fda-bdf2-ab7972ac2d69>Nullable(new byte[] { 2, 1 })]
			[UsedImplicitly]
			public Action<ConfigEntryBase> CustomDrawer;
		}

		[<112d6ed7-dc6b-4fda-bdf2-ab7972ac2d69>Nullable(0)]
		private class AcceptableShortcuts : AcceptableValueBase
		{
			public AcceptableShortcuts()
				: base(typeof(KeyboardShortcut))
			{
			}

			public override object Clamp(object value)
			{
				return value;
			}

			public override bool IsValid(object value)
			{
				return true;
			}

			public override string ToDescriptionString()
			{
				return "# Acceptable values: " + string.Join(", ", UnityInput.Current.SupportedKeyCodes);
			}
		}

		[<112d6ed7-dc6b-4fda-bdf2-ab7972ac2d69>Nullable(0)]
		[<ea9bb20d-487b-4a97-8899-23175f62942b>NullableContext(2)]
		private readonly struct MuralDetectionCache
		{
			public bool IsEligible { get; }

			public string DiscoveryKey { get; }

			public MuralDetectionCache(bool isEligible, string discoveryKey)
			{
				IsEligible = isEligible;
				DiscoveryKey = discoveryKey;
			}
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			[<112d6ed7-dc6b-4fda-bdf2-ab7972ac2d69>Nullable(0)]
			public static readonly <>c <>9 = new <>c();

			[<112d6ed7-dc6b-4fda-bdf2-ab7972ac2d69>Nullable(0)]
			public static ConsoleEvent <>9__76_0;

			[<ea9bb20d-487b-4a97-8899-23175f62942b>NullableContext(0)]
			internal void <RegisterConsoleCommand>b__76_0(ConsoleEventArgs args)
			{
				if (args == null)
				{
					return;
				}
				long newVersion;
				if (!IsResetCommandAuthorized())
				{
					Terminal context = args.Context;
					if (context != null)
					{
						context.AddString("You must be a server admin to reset discoveries.");
					}
				}
				else if (TryResetDiscoveries(out newVersion))
				{
					Terminal context2 = args.Context;
					if (context2 != null)
					{
						context2.AddString($"Ice&RuneStone Skills discoveries reset. New reset version: {newVersion}.");
					}
				}
				else
				{
					Terminal context3 = args.Context;
					if (context3 != null)
					{
						context3.AddString("Unable to reset discoveries right now.");
					}
				}
			}

			internal bool <.cctor>b__83_0(SkillType skillType)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Invalid comparison between Unknown and I4
				if ((int)skillType != 0)
				{
					return (int)skillType != 999;
				}
				return false;
			}
		}

		internal const string ModName = "IceAndRuneStoneSkills";

		internal const string DisplayName = "Ice&RuneStone Skills";

		internal const string ModVersion = "1.0.3";

		internal const string Author = "WackyMole";

		private const string ModGUID = "WackyMole.IceAndRuneStoneSkills";

		private const string DiscoveryKeyPrefix = "IceCaveSkills_Mural_";

		private const string DiscoveryZdoKeyPrefix = "icecaveskills_mural_claimed_";

		internal const string ClaimMuralRpcName = "IceCaveSkills_ClaimMural";

		private const string ResetDiscoveriesCommand = "irs_resetdiscoveries";

		private const string DiscoveryResetVersionGlobalKeyPrefix = "icecaveskills_reset_version_";

		private const string RewardSfxPrefabName = "sfx_Potion_health_medium";

		private const float MaxSkillLevel = 100f;

		private const long RewardScanCooldownSeconds = 10L;

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

		private static string ConfigFileFullPath;

		internal static string ConnectionError;

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

		private static readonly int ClaimedMessageCooldownHash;

		private static readonly int RewardScanCooldownHash;

		private static int _lastHoverObjectInstanceId;

		[<112d6ed7-dc6b-4fda-bdf2-ab7972ac2d69>Nullable(2)]
		private static string _lastHoveredDiscoveryKey;

		private static readonly string[] SearchableFieldNames;

		private static readonly Dictionary<Type, FieldInfo[]> SearchableFieldsByType;

		private static readonly Dictionary<int, MuralDetectionCache> MuralDetectionCacheByComponent;

		private static readonly string[] FrostCaveTerms;

		private static readonly string[] MuralTerms;

		private static readonly string[] BossRuneStoneTerms;

		private static readonly SkillType[] RewardableSkillTypes;

		public static readonly ManualLogSource PieceManagerModTemplateLogger;

		private static readonly ConfigSync ConfigSync;

		private static ConfigEntry<Toggle> _serverConfigLocked;

		private static ConfigEntry<DiscoveryScope> _discoveryScope;

		private static ConfigEntry<Toggle> _enableCavePaintingRewards;

		private static ConfigEntry<RewardAmountMode> _cavePaintingRewardAmountMode;

		private static ConfigEntry<float> _cavePaintingRewardAmount;

		private static ConfigEntry<Toggle> _enableRunestoneRewards;

		private static ConfigEntry<RewardAmountMode> _runestoneRewardAmountMode;

		private static ConfigEntry<float> _runestoneRewardAmount;

		public void Awake()
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Expected O, but got Unknown
			Localizer.Load();
			_serverConfigLocked = config("1 - General", "Lock Configuration", Toggle.On, "If on, the configuration is locked and can be changed by server admins only.");
			ConfigSync.AddLockingConfigEntry<Toggle>(_serverConfigLocked);
			_discoveryScope = config("1 - General", "Discovery Scope", DiscoveryScope.World, "Choose whether discoveries are shared for the whole world or can be earned once per player.");
			_enableCavePaintingRewards = config("2 - Rewards", "Enable Cave Painting Rewards", Toggle.On, "If on, Frost Cave cave paintings can award skills.");
			_cavePaintingRewardAmountMode = config("2 - Cave Painting Rewards", "Skill Reward Mode", RewardAmountMode.Flat, "Choose whether Frost Cave cave painting rewards are granted as flat skill levels or as a percentage of the max skill level.");
			_cavePaintingRewardAmount = config("2 - Cave Painting Rewards", "Skill Reward Amount", 10f, new ConfigDescription("Amount awarded by each Frost Cave cave painting. In PercentageOfMax mode, this is treated as a percent of the max skill level.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 100f), Array.Empty<object>()));
			_enableRunestoneRewards = config("3 - Runestone Rewards", "Enable Runestone Rewards", Toggle.On, "If on, regular runestones can award skills. Boss runestones and Vegvisirs are excluded.");
			_runestoneRewardAmountMode = config("3 - Runestone Rewards", "Skill Reward Mode", RewardAmountMode.Flat, "Choose whether regular runestone rewards are granted as flat skill levels or as a percentage of the max skill level.");
			_runestoneRewardAmount = config("3 - Runestone Rewards", "Skill Reward Amount", 4f, new ConfigDescription("Amount awarded by each eligible regular runestone. In PercentageOfMax mode, this is treated as a percent of the max skill level.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 100f), Array.Empty<object>()));
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			_harmony.PatchAll(executingAssembly);
			RegisterConsoleCommand();
			SetupWatcher();
		}

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

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

		private void ReadConfigValues(object sender, FileSystemEventArgs e)
		{
			if (!File.Exists(ConfigFileFullPath))
			{
				return;
			}
			try
			{
				PieceManagerModTemplateLogger.LogDebug((object)"ReadConfigValues called");
				((BaseUnityPlugin)this).Config.Reload();
			}
			catch
			{
				PieceManagerModTemplateLogger.LogError((object)("There was an issue loading your " + ConfigFileName));
				PieceManagerModTemplateLogger.LogError((object)"Please check your config entries for spelling and format!");
			}
		}

		private ConfigEntry<T> config<[<112d6ed7-dc6b-4fda-bdf2-ab7972ac2d69>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<[<112d6ed7-dc6b-4fda-bdf2-ab7972ac2d69>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);
		}

		internal static bool TryDiscoverMural(Component component, Humanoid character)
		{
			if (_enableCavePaintingRewards.Value != 0 && !((Object)(object)component == (Object)null))
			{
				Player val = (Player)(object)((character is Player) ? character : null);
				if (val != null && ((Character)val).IsOwner())
				{
					if (!TryGetMuralDetection(component, out var discoveryKey))
					{
						return false;
					}
					ZNetView discoveryZNetView = GetDiscoveryZNetView(component);
					if ((Object)(object)discoveryZNetView == (Object)null || !discoveryZNetView.IsValid())
					{
						return false;
					}
					return EnsureDiscoveryRpcProxy(discoveryZNetView).TryClaimMural(val.GetPlayerID(), discoveryKey);
				}
			}
			return false;
		}

		internal static bool TryDiscoverRunestone(RuneStone runeStone, Humanoid character)
		{
			if (_enableRunestoneRewards.Value != 0 && !((Object)(object)runeStone == (Object)null))
			{
				Player val = (Player)(object)((character is Player) ? character : null);
				if (val != null && ((Character)val).IsOwner())
				{
					if (!TryGetRegularRunestoneDetection(runeStone, out var discoveryKey))
					{
						return false;
					}
					ZNetView discoveryZNetView = GetDiscoveryZNetView((Component)(object)runeStone);
					if ((Object)(object)discoveryZNetView == (Object)null || !discoveryZNetView.IsValid())
					{
						return false;
					}
					return EnsureDiscoveryRpcProxy(discoveryZNetView).TryClaimMural(val.GetPlayerID(), discoveryKey);
				}
			}
			return false;
		}

		internal static bool TryProcessMuralClaim(ZNetView zNetView, long playerId, string discoveryKey)
		{
			//IL_00fa: 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_014e: 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_0187: Unknown result type (might be due to invalid IL or missing references)
			Player player = Player.GetPlayer(playerId);
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			Component muralComponentFromRoot = GetMuralComponentFromRoot(((Component)zNetView).gameObject);
			RuneStone val = (RuneStone)(object)((muralComponentFromRoot is RuneStone) ? muralComponentFromRoot : null);
			RewardSource rewardSource;
			if (val != null && TryGetRegularRunestoneDetection(val, out var discoveryKey2))
			{
				rewardSource = RewardSource.Runestone;
			}
			else
			{
				if (!((Object)(object)muralComponentFromRoot != (Object)null) || !TryGetMuralDetection(muralComponentFromRoot, out discoveryKey2))
				{
					return false;
				}
				rewardSource = RewardSource.CavePainting;
			}
			if (!string.Equals(discoveryKey2, discoveryKey, StringComparison.Ordinal))
			{
				discoveryKey = discoveryKey2;
			}
			ZDO zDO = zNetView.GetZDO();
			if (zDO == null)
			{
				return false;
			}
			int discoveryZdoKey = GetDiscoveryZdoKey(discoveryKey, playerId);
			long discoveryResetVersion = GetDiscoveryResetVersion();
			if (zDO.GetLong(discoveryZdoKey, -1L) == discoveryResetVersion)
			{
				ShowClaimedMessage(player, rewardSource);
				return false;
			}
			Skills playerSkills = GetPlayerSkills(player);
			if ((Object)(object)playerSkills == (Object)null)
			{
				PieceManagerModTemplateLogger.LogWarning((object)$"Failed to access player skills while processing a {rewardSource} reward.");
				return false;
			}
			if (RewardableSkillTypes.Length == 0)
			{
				PieceManagerModTemplateLogger.LogWarning((object)$"No valid skills were available for a {rewardSource} reward.");
				return false;
			}
			SkillType val2 = RewardableSkillTypes[Random.Range(0, RewardableSkillTypes.Length)];
			if (!TryApplySkillReward(playerSkills, rewardSource, val2, out var previousLevel, out var newLevel))
			{
				return false;
			}
			zDO.Set(discoveryZdoKey, discoveryResetVersion);
			ZNetView nview = ((Character)player).m_nview;
			if (nview != null)
			{
				ZDO zDO2 = nview.GetZDO();
				if (zDO2 != null)
				{
					zDO2.Set(RewardScanCooldownHash, DateTimeOffset.UtcNow.ToUnixTimeSeconds() + 10);
				}
			}
			ShowRewardMessage(player, rewardSource, val2, newLevel - previousLevel, newLevel);
			PlayRewardEffect(((Component)player).transform.position);
			PieceManagerModTemplateLogger.LogInfo((object)$"Awarded {rewardSource} reward {val2} (+{newLevel - previousLevel:0.#}) for {discoveryKey}.");
			return true;
		}

		[<ea9bb20d-487b-4a97-8899-23175f62942b>NullableContext(2)]
		internal static void EnsureDiscoveryRpcProxyIfEligible(ZNetView zNetView)
		{
			if ((Object)(object)zNetView == (Object)null || !zNetView.IsValid())
			{
				return;
			}
			Component muralComponentFromRoot = GetMuralComponentFromRoot(((Component)zNetView).gameObject);
			if ((Object)(object)muralComponentFromRoot == (Object)null)
			{
				return;
			}
			RuneStone val = (RuneStone)(object)((muralComponentFromRoot is RuneStone) ? muralComponentFromRoot : null);
			string discoveryKey;
			if (val != null)
			{
				if (!TryGetRegularRunestoneDetection(val, out discoveryKey) && !TryGetMuralDetection(muralComponentFromRoot, out discoveryKey))
				{
					return;
				}
			}
			else if (!TryGetMuralDetection(muralComponentFromRoot, out discoveryKey))
			{
				return;
			}
			EnsureDiscoveryRpcProxy(zNetView);
		}

		internal static void TryDiscoverHoveredMural([<112d6ed7-dc6b-4fda-bdf2-ab7972ac2d69>Nullable(2)] GameObject hoverObject, Player player)
		{
			if (_enableCavePaintingRewards.Value == Toggle.Off || (Object)(object)hoverObject == (Object)null)
			{
				ResetHoveredMuralTracking();
				return;
			}
			long num = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
			ZNetView nview = ((Character)player).m_nview;
			long? obj;
			if (nview == null)
			{
				obj = null;
			}
			else
			{
				ZDO zDO = nview.GetZDO();
				obj = ((zDO != null) ? new long?(zDO.GetLong(RewardScanCooldownHash, 0L)) : null);
			}
			long? num2 = obj;
			if (num2.GetValueOrDefault() > num)
			{
				ResetHoveredMuralTracking();
				return;
			}
			int instanceID = ((Object)hoverObject).GetInstanceID();
			if (instanceID != _lastHoverObjectInstanceId)
			{
				_lastHoverObjectInstanceId = instanceID;
				Component muralComponent = GetMuralComponent(hoverObject);
				if ((Object)(object)muralComponent == (Object)null || !TryGetMuralDetection(muralComponent, out var discoveryKey))
				{
					_lastHoveredDiscoveryKey = null;
				}
				else if (!string.Equals(_lastHoveredDiscoveryKey, discoveryKey, StringComparison.Ordinal))
				{
					_lastHoveredDiscoveryKey = discoveryKey;
					TryDiscoverMural(muralComponent, (Humanoid)(object)player);
				}
			}
		}

		[return: <112d6ed7-dc6b-4fda-bdf2-ab7972ac2d69>Nullable(2)]
		private static Skills GetPlayerSkills(Player player)
		{
			return ((Character)player).GetSkills();
		}

		private static bool TryApplySkillReward(Skills skills, RewardSource rewardSource, SkillType rewardedSkill, out float previousLevel, out float newLevel)
		{
			//IL_0001: 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_0053: Unknown result type (might be due to invalid IL or missing references)
			Skill skill = skills.GetSkill(rewardedSkill);
			if (skill == null)
			{
				previousLevel = skills.GetSkillLevel(rewardedSkill);
				newLevel = previousLevel;
				return false;
			}
			previousLevel = skill.m_level;
			float rewardAmount = GetRewardAmount(rewardSource, previousLevel);
			if (rewardAmount <= 0f)
			{
				newLevel = previousLevel;
				return false;
			}
			skills.CheatRaiseSkill(((object)(SkillType)(ref rewardedSkill)).ToString(), rewardAmount, false);
			newLevel = skills.GetSkill(rewardedSkill).m_level;
			return newLevel > previousLevel;
		}

		private static float GetRewardAmount(RewardSource rewardSource, float currentLevel)
		{
			float num = Mathf.Max(0f, (rewardSource == RewardSource.Runestone) ? _runestoneRewardAmount.Value : _cavePaintingRewardAmount.Value);
			if (num <= 0f || currentLevel >= 100f)
			{
				return 0f;
			}
			return Mathf.Clamp((((rewardSource == RewardSource.Runestone) ? _runestoneRewardAmountMode.Value : _cavePaintingRewardAmountMode.Value) == RewardAmountMode.PercentageOfMax) ? (100f * (num / 100f)) : num, 0f, 100f - currentLevel);
		}

		[return: <112d6ed7-dc6b-4fda-bdf2-ab7972ac2d69>Nullable(2)]
		private static Component GetMuralComponent(GameObject hoverObject)
		{
			Component componentInParent = (Component)(object)hoverObject.GetComponentInParent<HoverText>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				return componentInParent;
			}
			componentInParent = (Component)(object)hoverObject.GetComponentInParent<RuneStone>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				return componentInParent;
			}
			return (Component)(object)hoverObject.GetComponentInParent<Vegvisir>();
		}

		[return: <112d6ed7-dc6b-4fda-bdf2-ab7972ac2d69>Nullable(2)]
		private static Component GetMuralComponentFromRoot(GameObject rootObject)
		{
			Component componentInChildren = (Component)(object)rootObject.GetComponentInChildren<HoverText>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				return componentInChildren;
			}
			componentInChildren = (Component)(object)rootObject.GetComponentInChildren<RuneStone>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				return componentInChildren;
			}
			return (Component)(object)rootObject.GetComponentInChildren<Vegvisir>(true);
		}

		private static MuralDiscoveryRpcProxy EnsureDiscoveryRpcProxy(ZNetView zNetView)
		{
			return ((Component)zNetView).GetComponent<MuralDiscoveryRpcProxy>() ?? ((Component)zNetView).gameObject.AddComponent<MuralDiscoveryRpcProxy>();
		}

		private static bool TryGetMuralDetection(Component component, out string discoveryKey)
		{
			int instanceID = ((Object)component).GetInstanceID();
			if (MuralDetectionCacheByComponent.TryGetValue(instanceID, out var value))
			{
				discoveryKey = value.DiscoveryKey ?? string.Empty;
				return value.IsEligible;
			}
			bool flag = IsFrostCaveMural(component);
			discoveryKey = (flag ? BuildDiscoveryKey(component) : string.Empty);
			MuralDetectionCacheByComponent[instanceID] = new MuralDetectionCache(flag, discoveryKey);
			return flag;
		}

		private static bool TryGetRegularRunestoneDetection(RuneStone runeStone, out string discoveryKey)
		{
			if (!IsRegularRunestone(runeStone))
			{
				discoveryKey = string.Empty;
				return false;
			}
			discoveryKey = BuildDiscoveryKey((Component)(object)runeStone);
			return true;
		}

		private static bool IsFrostCaveMural(Component component)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			bool hasCaveMarker = false;
			bool hasMuralMarker = false;
			if (!UpdateMuralMarkers(((Object)component).name, ref hasCaveMarker, ref hasMuralMarker) && !UpdateMuralMarkers(((Object)component.gameObject).name, ref hasCaveMarker, ref hasMuralMarker) && !UpdateMuralMarkers(((object)component).GetType().Name, ref hasCaveMarker, ref hasMuralMarker))
			{
				Scene scene = component.gameObject.scene;
				if (!UpdateMuralMarkers(((Scene)(ref scene)).name, ref hasCaveMarker, ref hasMuralMarker))
				{
					Transform[] componentsInParent = ((Component)component.transform).GetComponentsInParent<Transform>(true);
					for (int i = 0; i < componentsInParent.Length; i++)
					{
						if (UpdateMuralMarkers(((Object)componentsInParent[i]).name, ref hasCaveMarker, ref hasMuralMarker))
						{
							return true;
						}
					}
					FieldInfo[] searchableFields = GetSearchableFields(((object)component).GetType());
					for (int i = 0; i < searchableFields.Length; i++)
					{
						if (searchableFields[i].GetValue(component) is string value && UpdateMuralMarkers(value, ref hasCaveMarker, ref hasMuralMarker))
						{
							return true;
						}
					}
					return false;
				}
			}
			return true;
		}

		private static FieldInfo[] GetSearchableFields(Type componentType)
		{
			if (SearchableFieldsByType.TryGetValue(componentType, out var value))
			{
				return value;
			}
			List<FieldInfo> list = new List<FieldInfo>();
			string[] searchableFieldNames = SearchableFieldNames;
			foreach (string name in searchableFieldNames)
			{
				FieldInfo field = componentType.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field != null)
				{
					list.Add(field);
				}
			}
			value = list.ToArray();
			SearchableFieldsByType[componentType] = value;
			return value;
		}

		private static bool IsRegularRunestone(RuneStone runeStone)
		{
			if (_enableRunestoneRewards.Value == Toggle.Off)
			{
				return false;
			}
			if (IsFrostCaveMural((Component)(object)runeStone))
			{
				return false;
			}
			if (!string.IsNullOrWhiteSpace(runeStone.m_locationName) || runeStone.m_showMap || ContainsAny(runeStone.m_name, BossRuneStoneTerms) || ContainsAny(runeStone.m_topic, BossRuneStoneTerms) || ContainsAny(runeStone.m_pinName, BossRuneStoneTerms))
			{
				return false;
			}
			return true;
		}

		[<ea9bb20d-487b-4a97-8899-23175f62942b>NullableContext(2)]
		private static bool UpdateMuralMarkers(string value, ref bool hasCaveMarker, ref bool hasMuralMarker)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return false;
			}
			if (!hasCaveMarker && ContainsAny(value, FrostCaveTerms))
			{
				hasCaveMarker = true;
			}
			if (!hasMuralMarker && ContainsAny(value, MuralTerms))
			{
				hasMuralMarker = true;
			}
			return hasCaveMarker & hasMuralMarker;
		}

		private static bool ContainsAny(string value, IEnumerable<string> candidates)
		{
			foreach (string candidate in candidates)
			{
				if (value.IndexOf(candidate, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			return false;
		}

		private static string BuildDiscoveryKey(Component component)
		{
			//IL_0006: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = component.transform.position;
			object[] obj = new object[7]
			{
				"IceCaveSkills_Mural_",
				((object)component).GetType().Name,
				null,
				null,
				null,
				null,
				null
			};
			Scene scene = component.gameObject.scene;
			obj[2] = ((Scene)(ref scene)).name;
			obj[3] = ((Object)component).name;
			obj[4] = Mathf.RoundToInt(position.x * 10f);
			obj[5] = Mathf.RoundToInt(position.y * 10f);
			obj[6] = Mathf.RoundToInt(position.z * 10f);
			string text = string.Format("{0}{1}_{2}_{3}_{4}_{5}_{6}", obj);
			StringBuilder stringBuilder = new StringBuilder(text.Length);
			string text2 = text;
			foreach (char c in text2)
			{
				stringBuilder.Append(char.IsLetterOrDigit(c) ? c : '_');
			}
			return stringBuilder.ToString();
		}

		[return: <112d6ed7-dc6b-4fda-bdf2-ab7972ac2d69>Nullable(2)]
		private static ZNetView GetDiscoveryZNetView(Component component)
		{
			return component.GetComponentInParent<ZNetView>();
		}

		private static int GetDiscoveryZdoKey(string discoveryKey, long playerId)
		{
			return StringExtensionMethods.GetStableHashCode("icecaveskills_mural_claimed_" + GetScopedDiscoveryKey(discoveryKey, playerId));
		}

		private static string GetScopedDiscoveryKey(string discoveryKey, long playerId)
		{
			if (_discoveryScope.Value != DiscoveryScope.PerPlayer)
			{
				return discoveryKey;
			}
			return discoveryKey + "_" + playerId;
		}

		private static long GetDiscoveryResetVersion()
		{
			if ((Object)(object)ZoneSystem.instance == (Object)null)
			{
				return 0L;
			}
			for (long num = 1L; num < 1024; num++)
			{
				if (!ZoneSystem.instance.GetGlobalKey("icecaveskills_reset_version_" + num))
				{
					return num - 1;
				}
			}
			return 1023L;
		}

		private static bool TryResetDiscoveries(out long newVersion)
		{
			newVersion = 0L;
			if (!IsResetCommandAuthorized())
			{
				return false;
			}
			if ((Object)(object)ZoneSystem.instance == (Object)null)
			{
				return false;
			}
			newVersion = GetDiscoveryResetVersion() + 1;
			ZoneSystem.instance.SetGlobalKey("icecaveskills_reset_version_" + newVersion);
			ResetHoveredMuralTracking();
			PieceManagerModTemplateLogger.LogInfo((object)$"Discovery reset command executed. New reset version: {newVersion}.");
			return true;
		}

		private static bool IsResetCommandAuthorized()
		{
			return ConfigSync.IsAdmin;
		}

		private static void RegisterConsoleCommand()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			object obj = <>c.<>9__76_0;
			if (obj == null)
			{
				ConsoleEvent val = [<ea9bb20d-487b-4a97-8899-23175f62942b>NullableContext(0)] (ConsoleEventArgs args) =>
				{
					if (args != null)
					{
						long newVersion;
						if (!IsResetCommandAuthorized())
						{
							Terminal context = args.Context;
							if (context != null)
							{
								context.AddString("You must be a server admin to reset discoveries.");
							}
						}
						else if (TryResetDiscoveries(out newVersion))
						{
							Terminal context2 = args.Context;
							if (context2 != null)
							{
								context2.AddString($"Ice&RuneStone Skills discoveries reset. New reset version: {newVersion}.");
							}
						}
						else
						{
							Terminal context3 = args.Context;
							if (context3 != null)
							{
								context3.AddString("Unable to reset discoveries right now.");
							}
						}
					}
				};
				<>c.<>9__76_0 = val;
				obj = (object)val;
			}
			new ConsoleCommand("irs_resetdiscoveries", "Reset all Ice&RuneStone Skills mural and runestone discoveries so they can be found again.", (ConsoleEvent)obj, false, false, false, false, true, (ConsoleOptionsFetcher)null, false, false, false);
		}

		private static void ShowRewardMessage(Player player, RewardSource rewardSource, SkillType rewardedSkill, float grantedLevels, float newLevel)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			string skillDisplayName = GetSkillDisplayName(rewardedSkill);
			string text = string.Format(Localization.instance.Localize((rewardSource == RewardSource.Runestone) ? "$icecaveskills_runestone_reward_message" : "$icecaveskills_reward_message"), skillDisplayName, grantedLevels.ToString("0.#"), newLevel.ToString("0.#"));
			((Character)player).Message((MessageType)2, text, 0, (Sprite)null);
		}

		private static void PlayRewardEffect(Vector3 position)
		{
			//IL_0031: 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)
			ZNetScene instance = ZNetScene.instance;
			GameObject val = ((instance != null) ? instance.GetPrefab("sfx_Potion_health_medium") : null);
			if ((Object)(object)val == (Object)null)
			{
				PieceManagerModTemplateLogger.LogWarning((object)"Failed to find reward effect prefab 'sfx_Potion_health_medium'.");
			}
			else
			{
				Object.Instantiate<GameObject>(val, position, Quaternion.identity);
			}
		}

		private static void ShowClaimedMessage(Player player, RewardSource rewardSource)
		{
			long num = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
			ZNetView nview = ((Character)player).m_nview;
			long? obj;
			if (nview == null)
			{
				obj = null;
			}
			else
			{
				ZDO zDO = nview.GetZDO();
				obj = ((zDO != null) ? new long?(zDO.GetLong(ClaimedMessageCooldownHash, 0L)) : null);
			}
			long? num2 = obj;
			long valueOrDefault = num2.GetValueOrDefault();
			if (num - valueOrDefault < 3)
			{
				return;
			}
			ZNetView nview2 = ((Character)player).m_nview;
			if (nview2 != null)
			{
				ZDO zDO2 = nview2.GetZDO();
				if (zDO2 != null)
				{
					zDO2.Set(ClaimedMessageCooldownHash, num);
				}
			}
			((Character)player).Message((MessageType)2, Localization.instance.Localize((rewardSource == RewardSource.Runestone) ? "$icecaveskills_runestone_claimed_message" : "$icecaveskills_claimed_message"), 0, (Sprite)null);
		}

		private static void ResetHoveredMuralTracking()
		{
			_lastHoverObjectInstanceId = 0;
			_lastHoveredDiscoveryKey = null;
		}

		private static string GetSkillDisplayName(SkillType skillType)
		{
			string text = "$skill_" + ((object)(SkillType)(ref skillType)).ToString().ToLowerInvariant();
			string text2 = Localization.instance.Localize(text);
			if (!string.Equals(text2, text, StringComparison.Ordinal))
			{
				return text2;
			}
			StringBuilder stringBuilder = new StringBuilder();
			string text3 = ((object)(SkillType)(ref skillType)).ToString();
			for (int i = 0; i < text3.Length; i++)
			{
				char c = text3[i];
				if (i > 0 && char.IsUpper(c) && !char.IsUpper(text3[i - 1]))
				{
					stringBuilder.Append(' ');
				}
				stringBuilder.Append(c);
			}
			return stringBuilder.ToString();
		}

		static IceCaveSkillsPlugin()
		{
			string configPath = Paths.ConfigPath;
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			ConfigFileFullPath = configPath + directorySeparatorChar + ConfigFileName;
			ConnectionError = "";
			ClaimedMessageCooldownHash = StringExtensionMethods.GetStableHashCode("IceCaveSkillsLastClaimedMessage");
			RewardScanCooldownHash = StringExtensionMethods.GetStableHashCode("IceCaveSkillsRewardScanCooldownUntil");
			SearchableFieldNames = new string[6] { "m_name", "m_locationName", "m_topic", "m_hoverName", "m_pinName", "m_text" };
			SearchableFieldsByType = new Dictionary<Type, FieldInfo[]>();
			MuralDetectionCacheByComponent = new Dictionary<int, MuralDetectionCache>();
			FrostCaveTerms = new string[10] { "frostcave", "frost_cave", "mountaincave", "mountain_cave", "hildir_cave", "hildircave", "dg_cave", "iceendcap", "ice_endcap", "cave_new_ice" };
			MuralTerms = new string[5] { "mural", "rune", "runestone", "cavepainting", "cave_painting" };
			BossRuneStoneTerms = new string[3] { "boss", "forsaken", "vegvisir" };
			RewardableSkillTypes = (from SkillType skillType in Enum.GetValues(typeof(SkillType))
				where (int)skillType != 0 && (int)skillType != 999
				select skillType).ToArray();
			PieceManagerModTemplateLogger = Logger.CreateLogSource("Ice&RuneStone Skills");
			ConfigSync = new ConfigSync("WackyMole.IceAndRuneStoneSkills")
			{
				DisplayName = "Ice&RuneStone Skills",
				CurrentVersion = "1.0.3",
				MinimumRequiredVersion = "1.0.3"
			};
			_serverConfigLocked = null;
			_discoveryScope = null;
			_enableCavePaintingRewards = null;
			_cavePaintingRewardAmountMode = null;
			_cavePaintingRewardAmount = null;
			_enableRunestoneRewards = null;
			_runestoneRewardAmountMode = null;
			_runestoneRewardAmount = null;
		}
	}
	[HarmonyPatch(typeof(RuneStone), "Interact")]
	public static class RuneStoneInteractPatch
	{
		[UsedImplicitly]
		[<ea9bb20d-487b-4a97-8899-23175f62942b>NullableContext(1)]
		private static void Postfix(RuneStone __instance, Humanoid character, bool hold)
		{
			if (!hold && !IceCaveSkillsPlugin.TryDiscoverRunestone(__instance, character))
			{
				IceCaveSkillsPlugin.TryDiscoverMural((Component)(object)__instance, character);
			}
		}
	}
	[HarmonyPatch(typeof(Vegvisir), "Interact")]
	public static class VegvisirInteractPatch
	{
		[<ea9bb20d-487b-4a97-8899-23175f62942b>NullableContext(1)]
		[UsedImplicitly]
		private static void Postfix(Vegvisir __instance, Humanoid character, bool hold, bool __result)
		{
		}
	}
	[HarmonyPatch(typeof(Player), "UpdateHover")]
	public static class PlayerUpdateHoverPatch
	{
		[UsedImplicitly]
		[<ea9bb20d-487b-4a97-8899-23175f62942b>NullableContext(1)]
		private static void Postfix(Player __instance)
		{
			if (((Character)__instance).IsOwner())
			{
				IceCaveSkillsPlugin.TryDiscoverHoveredMural(((Humanoid)__instance).GetHoverObject(), __instance);
			}
		}
	}
	[HarmonyPatch(typeof(ZNetView), "Awake")]
	public static class ZNetViewAwakePatch
	{
		[<ea9bb20d-487b-4a97-8899-23175f62942b>NullableContext(1)]
		[UsedImplicitly]
		private static void Postfix(ZNetView __instance)
		{
			IceCaveSkillsPlugin.EnsureDiscoveryRpcProxyIfEligible(__instance);
		}
	}
	[<ea9bb20d-487b-4a97-8899-23175f62942b>NullableContext(1)]
	[<112d6ed7-dc6b-4fda-bdf2-ab7972ac2d69>Nullable(0)]
	public class MuralDiscoveryRpcProxy : MonoBehaviour
	{
		private const string RpcName = "IceCaveSkills_ClaimMural";

		private ZNetView _zNetView;

		private void Awake()
		{
			_zNetView = ((Component)this).GetComponent<ZNetView>();
			_zNetView.Register<long, string>("IceCaveSkills_ClaimMural", (Action<long, long, string>)RPC_ClaimMural);
		}

		public bool TryClaimMural(long playerId, string discoveryKey)
		{
			if (!_zNetView.IsValid())
			{
				return false;
			}
			if (_zNetView.IsOwner())
			{
				return IceCaveSkillsPlugin.TryProcessMuralClaim(_zNetView, playerId, discoveryKey);
			}
			_zNetView.InvokeRPC("IceCaveSkills_ClaimMural", new object[2] { playerId, discoveryKey });
			return true;
		}

		private void RPC_ClaimMural(long sender, long playerId, string discoveryKey)
		{
			if (_zNetView.IsOwner())
			{
				IceCaveSkillsPlugin.TryProcessMuralClaim(_zNetView, playerId, discoveryKey);
			}
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<7a802543-733b-4e25-a52a-8c43c1d53d15>Embedded]
	internal sealed class <7a802543-733b-4e25-a52a-8c43c1d53d15>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]
	[<7a802543-733b-4e25-a52a-8c43c1d53d15>Embedded]
	internal sealed class <915bb526-e3a5-436c-a7cb-cda39a346a91>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <915bb526-e3a5-436c-a7cb-cda39a346a91>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <915bb526-e3a5-436c-a7cb-cda39a346a91>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[<7a802543-733b-4e25-a52a-8c43c1d53d15>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class <b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	[<7a802543-733b-4e25-a52a-8c43c1d53d15>Embedded]
	internal sealed class <658982e4-9aa1-440e-b300-8fb918649c1a>RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public <658982e4-9aa1-440e-b300-8fb918649c1a>RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ServerSync
{
	[<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(1)]
	[<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(0)]
	[PublicAPI]
	internal abstract class OwnConfigEntryBase
	{
		[<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(2)]
		public object LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[PublicAPI]
	[<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(1)]
	[<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(0)]
	internal class SyncedConfigEntry<[<915bb526-e3a5-436c-a7cb-cda39a346a91>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;
			}
		}
	}
	[<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(2)]
	[<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(0)]
	internal abstract class CustomSyncedValueBase
	{
		public object LocalBaseValue;

		[<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(1)]
		public readonly string Identifier;

		[<915bb526-e3a5-436c-a7cb-cda39a346a91>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;

		[<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>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;
			};
		}
	}
	[<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(1)]
	[<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(0)]
	[PublicAPI]
	internal sealed class CustomSyncedValue<[<915bb526-e3a5-436c-a7cb-cda39a346a91>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;
	}
	[<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(1)]
	[PublicAPI]
	[<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(0)]
	internal class ConfigSync
	{
		[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
		[<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(0)]
		private static class SnatchCurrentlyHandlingRPC
		{
			[<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(2)]
			public static ZRpc currentRpc;

			[<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(1)]
			[HarmonyPrefix]
			private static void Prefix(ZRpc __instance)
			{
				currentRpc = __instance;
			}
		}

		[<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(0)]
		[HarmonyPatch(typeof(ZNet), "Awake")]
		internal static class RegisterRPCPatch
		{
			[HarmonyPostfix]
			[<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>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());
				}
				[<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>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));
					}
				}
				[<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>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);
						}
					}
				}
			}
		}

		[<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(0)]
		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class RegisterClientRPCPatch
		{
			[<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(1)]
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				if (__instance.IsServer())
				{
					return;
				}
				foreach (ConfigSync configSync in configSyncs)
				{
					peer.m_rpc.Register<ZPackage>(configSync.Name + " ConfigSync", (Action<ZRpc, ZPackage>)configSync.RPC_FromServerConfigSync);
				}
			}
		}

		[<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(0)]
		private class ParsedConfigs
		{
			[<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(new byte[] { 1, 1, 2 })]
			public readonly Dictionary<OwnConfigEntryBase, object> configValues = new Dictionary<OwnConfigEntryBase, object>();

			[<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(new byte[] { 1, 1, 2 })]
			public readonly Dictionary<CustomSyncedValueBase, object> customValues = new Dictionary<CustomSyncedValueBase, object>();
		}

		[<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(0)]
		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		private class ResetConfigsOnShutdown
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				ProcessingServerUpdate = true;
				foreach (ConfigSync configSync in configSyncs)
				{
					configSync.resetConfigsFromServer();
					configSync.IsSourceOfTruth = true;
					configSync.InitialSyncDone = false;
				}
				ProcessingServerUpdate = false;
			}
		}

		[<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(0)]
		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private class SendConfigsAfterLogin
		{
			[<915bb526-e3a5-436c-a7cb-cda39a346a91>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);
					}
				}
			}

			[HarmonyPrefix]
			[HarmonyPriority(800)]
			private static void Prefix([<915bb526-e3a5-436c-a7cb-cda39a346a91>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([<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(0)] (OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, entries, partial: false);
						yield return ((MonoBehaviour)__instance).StartCoroutine(configSync.sendZPackage(new List<ZNetPeer> { peer }, package));
					}
					SendBufferedData();
				}
			}
		}

		[<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(0)]
		private class PackageEntry
		{
			public string section = null;

			public string key = null;

			public Type type = null;

			[<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(2)]
			public object value;
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
		[<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(0)]
		private static class PreventSavingServerInfo
		{
			[HarmonyPrefix]
			[<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(1)]
			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")]
		[<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(0)]
		private static class PreventConfigRereadChangingValues
		{
			[<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>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;
			}
		}

		[<915bb526-e3a5-436c-a7cb-cda39a346a91>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;

		[<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(2)]
		public string DisplayName;

		[<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(2)]
		public string CurrentVersion;

		[<915bb526-e3a5-436c-a7cb-cda39a346a91>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;

		[<915bb526-e3a5-436c-a7cb-cda39a346a91>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[]>>();

		[<915bb526-e3a5-436c-a7cb-cda39a346a91>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;


		[<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(2)]
		[method: <b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(2)]
		[field: <915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(2)]
		public event Action<bool> SourceOfTruthChanged;

		[<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(2)]
		[method: <b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(2)]
		[field: <915bb526-e3a5-436c-a7cb-cda39a346a91>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<[<915bb526-e3a5-436c-a7cb-cda39a346a91>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 += [<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(0)] (object _, EventArgs _) =>
				{
					if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
					{
						Broadcast(ZRoutedRpc.Everybody, (ConfigEntryBase)configEntry);
					}
				};
				allConfigs.Add(syncedEntry);
			}
			return syncedEntry;
		}

		public SyncedConfigEntry<T> AddLockingConfigEntry<[<915bb526-e3a5-436c-a7cb-cda39a346a91>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 += [<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(0)] (object _, EventArgs _) =>
			{
				this.lockedConfigChanged?.Invoke();
			};
			return (SyncedConfigEntry<T>)lockedConfig;
		}

		internal void AddCustomValue(CustomSyncedValueBase customValue)
		{
			if (allCustomValues.Select([<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>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([<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>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(([<915bb526-e3a5-436c-a7cb-cda39a346a91>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([<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>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([<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(0)] (OwnConfigEntryBase c) => c.SynchronizedConfig).ToDictionary([<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(0)] (OwnConfigEntryBase c) => c.BaseConfig.Definition.Section + "_" + c.BaseConfig.Definition.Key, [<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(0)] (OwnConfigEntryBase c) => c);
			Dictionary<string, CustomSyncedValueBase> dictionary2 = allCustomValues.ToDictionary([<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(0)] (CustomSyncedValueBase c) => c.Identifier, [<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>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([<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>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([<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>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([<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>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([<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>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: <915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(2)]
		private static OwnConfigEntryBase configData(ConfigEntryBase config)
		{
			return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
		}

		[return: <915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(new byte[] { 2, 1 })]
		public static SyncedConfigEntry<T> ConfigData<[<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(2)] T>(ConfigEntry<T> config)
		{
			return ((ConfigEntryBase)config).Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
		}

		private static T configAttribute<[<915bb526-e3a5-436c-a7cb-cda39a346a91>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([<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(new byte[] { 2, 1 })] IEnumerable<ConfigEntryBase> configs = null, [<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(new byte[] { 2, 1 })] IEnumerable<CustomSyncedValueBase> customValues = null, [<915bb526-e3a5-436c-a7cb-cda39a346a91>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([<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>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, [<915bb526-e3a5-436c-a7cb-cda39a346a91>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();
		}
	}
	[PublicAPI]
	[HarmonyPatch]
	[<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(0)]
	[<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(1)]
	internal class VersionCheck
	{
		private static readonly HashSet<VersionCheck> versionChecks;

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		[<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(2)]
		private string displayName;

		[<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(2)]
		private string currentVersion;

		[<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(2)]
		private string minimumRequiredVersion;

		public bool ModRequired = true;

		[<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(2)]
		private string ReceivedCurrentVersion;

		[<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(2)]
		private string ReceivedMinimumRequiredVersion;

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

		[<915bb526-e3a5-436c-a7cb-cda39a346a91>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([<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>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([<915bb526-e3a5-436c-a7cb-cda39a346a91>Nullable(2)] ZRpc rpc = null)
		{
			return (rpc == null) ? ErrorClient() : ErrorServer(rpc);
		}

		private static VersionCheck[] GetFailedClient()
		{
			return versionChecks.Where([<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(0)] (VersionCheck check) => !check.IsVersionOk()).ToArray();
		}

		private static VersionCheck[] GetFailedServer(ZRpc rpc)
		{
			return versionChecks.Where([<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>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, [<915bb526-e3a5-436c-a7cb-cda39a346a91>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>)([<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>NullableContext(0)] (ZRpc rpc, [<915bb526-e3a5-436c-a7cb-cda39a346a91>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 });
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ZNet), "Disconnect")]
		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([<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>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([<b2d09775-5040-4116-8fbd-a2cfbb2bbd77>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 Microsoft.CodeAnalysis
{
	[<5381afca-79a3-49d8-a868-89aa9d07be1a>Embedded]
	[CompilerGenerated]
	internal sealed class <5381afca-79a3-49d8-a868-89aa9d07be1a>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[<5381afca-79a3-49d8-a868-89aa9d07be1a>Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[<5381afca-79a3-49d8-a868-89aa9d07be1a>Embedded]
	[CompilerGenerated]
	internal sealed class <0d606795-0ee1-47ee-aaaa-2df0804da96c>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <0d606795-0ee1-47ee-aaaa-2df0804da96c>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <0d606795-0ee1-47ee-aaaa-2df0804da96c>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[<5381afca-79a3-49d8-a868-89aa9d07be1a>Embedded]
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class <b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace YamlDotNet
{
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <b192bfb0-ebb2-4763-89b5-24154963710d>CultureInfoAdapter : CultureInfo
	{
		private readonly IFormatProvider provider;

		public <b192bfb0-ebb2-4763-89b5-24154963710d>CultureInfoAdapter(CultureInfo baseCulture, IFormatProvider provider)
			: base(baseCulture.LCID)
		{
			this.provider = provider;
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		public override object GetFormat(Type formatType)
		{
			return provider.GetFormat(formatType);
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal static class <397f8e31-bc53-4ed5-b3c2-66ee3558e043>ReflectionExtensions
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		private static readonly FieldInfo RemoteStackTraceField = typeof(Exception).GetField("_remoteStackTraceString", BindingFlags.Instance | BindingFlags.NonPublic);

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>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, bool allowPrivateConstructors)
		{
			BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public;
			if (allowPrivateConstructors)
			{
				bindingFlags |= BindingFlags.NonPublic;
			}
			if (!type.IsValueType)
			{
				return type.GetConstructor(bindingFlags, null, Type.EmptyTypes, null) != null;
			}
			return true;
		}

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

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public static PropertyInfo GetPublicProperty(this Type type, string name)
		{
			return type.GetProperty(name);
		}

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>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([<b36caba6-ec7b-49e8-8641-5a4015501a0a>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: <0d606795-0ee1-47ee-aaaa-2df0804da96c>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: <0d606795-0ee1-47ee-aaaa-2df0804da96c>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<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TAttribute>(this PropertyInfo property)
		{
			return Attribute.GetCustomAttributes(property, typeof(TAttribute), inherit: true);
		}
	}
	internal static class <1beb23a3-6fe4-4b3c-89b3-727b095fd6be>PropertyInfoExtensions
	{
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public static object ReadValue(this PropertyInfo property, object target)
		{
			return property.GetValue(target, null);
		}
	}
	internal static class <371477a0-99c6-4a22-a917-657c2da12160>StandardRegexOptions
	{
		public const RegexOptions Compiled = RegexOptions.Compiled;
	}
}
namespace YamlDotNet.Serialization
{
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal abstract class <69289e38-c77d-4a5b-92b4-f9b084cfe166>BuilderSkeleton<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TBuilder> where TBuilder : <69289e38-c77d-4a5b-92b4-f9b084cfe166>BuilderSkeleton<TBuilder>
	{
		internal <4ecad175-097b-490b-92b5-e349039d0335>INamingConvention namingConvention = <74573528-4a43-4f7f-868c-a260d880c43a>NullNamingConvention.Instance;

		internal <14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver;

		internal readonly <95222622-92e5-4d75-ae5b-5dd10bb21ec7>YamlAttributeOverrides overrides;

		internal readonly <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing, <ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> typeConverterFactories;

		internal readonly <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector, <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector> typeInspectorFactories;

		internal bool ignoreFields;

		internal bool includeNonPublicProperties;

		internal Settings settings;

		protected abstract TBuilder Self { get; }

		internal <69289e38-c77d-4a5b-92b4-f9b084cfe166>BuilderSkeleton(<14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver)
		{
			overrides = new <95222622-92e5-4d75-ae5b-5dd10bb21ec7>YamlAttributeOverrides();
			typeConverterFactories = new <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing, <ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter>
			{
				{
					typeof(<2d47cdac-8cd8-47ea-80bc-fc9e84fda98a>GuidConverter),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <2d47cdac-8cd8-47ea-80bc-fc9e84fda98a>GuidConverter(jsonCompatible: false)
				},
				{
					typeof(<a965b595-6158-457a-83bb-f3cb9cd014d7>SystemTypeConverter),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <a965b595-6158-457a-83bb-f3cb9cd014d7>SystemTypeConverter()
				}
			};
			typeInspectorFactories = new <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector, <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector>();
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			settings = new Settings();
		}

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

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

		public TBuilder EnablePrivateConstructors()
		{
			settings.AllowPrivateConstructors = true;
			return Self;
		}

		public TBuilder WithNamingConvention(<4ecad175-097b-490b-92b5-e349039d0335>INamingConvention namingConvention)
		{
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
			return Self;
		}

		public TBuilder WithTypeResolver(<14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			return Self;
		}

		public abstract TBuilder WithTagMapping(<baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName tag, Type type);

		public TBuilder WithAttributeOverride<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>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(<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter typeConverter)
		{
			return WithTypeConverter(typeConverter, delegate(<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeConverter(<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter typeConverter, Action<<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter>> where)
		{
			if (typeConverter == null)
			{
				throw new ArgumentNullException("typeConverter");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter.GetType(), (<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => typeConverter));
			return Self;
		}

		public TBuilder WithTypeConverter<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TYamlTypeConverter>(<3b4b8ccf-3e0d-4ddf-8f1c-125fe84d2bc4>WrapperFactory<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter, <ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> typeConverterFactory, Action<<18c7fbcc-5471-41e0-b0d5-c272fe9a2c7a>ITrackingRegistrationLocationSelectionSyntax<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter>> where) where TYamlTypeConverter : <ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter
		{
			if (typeConverterFactory == null)
			{
				throw new ArgumentNullException("typeConverterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter wrapped, <74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => typeConverterFactory(wrapped)));
			return Self;
		}

		public TBuilder WithoutTypeConverter<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TYamlTypeConverter>() where TYamlTypeConverter : <ddaaa542-dd60-4d14-a733-9acfc1784a67>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<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TTypeInspector>(Func<<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector
		{
			return WithTypeInspector(typeInspectorFactory, delegate(<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeInspector<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TTypeInspector>(Func<<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector, TTypeInspector> typeInspectorFactory, Action<<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector>> where) where TTypeInspector : <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector
		{
			if (typeInspectorFactory == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector inner) => typeInspectorFactory(inner)));
			return Self;
		}

		public TBuilder WithTypeInspector<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TTypeInspector>(<5b34dae8-7cb0-482e-9895-29da17adc606>WrapperFactory<<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector, <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector, TTypeInspector> typeInspectorFactory, Action<<18c7fbcc-5471-41e0-b0d5-c272fe9a2c7a>ITrackingRegistrationLocationSelectionSyntax<<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector>> where) where TTypeInspector : <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector
		{
			if (typeInspectorFactory == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector wrapped, <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector inner) => typeInspectorFactory(wrapped, inner)));
			return Self;
		}

		public TBuilder WithoutTypeInspector<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TTypeInspector>() where TTypeInspector : <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector
		{
			return WithoutTypeInspector(typeof(TTypeInspector));
		}

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

		protected IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> BuildTypeConverters()
		{
			return typeConverterFactories.BuildComponentList();
		}
	}
	internal delegate TComponent <3b4b8ccf-3e0d-4ddf-8f1c-125fe84d2bc4>WrapperFactory<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TComponentBase, TComponent>(TComponentBase wrapped) where TComponent : TComponentBase;
	internal delegate TComponent <5b34dae8-7cb0-482e-9895-29da17adc606>WrapperFactory<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TArgument, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TComponentBase, TComponent>(TComponentBase wrapped, TArgument argument) where TComponent : TComponentBase;
	[Flags]
	internal enum <d96bfc2d-895f-47ec-bf95-11ebc61b365e>DefaultValuesHandling
	{
		Preserve = 0,
		OmitNull = 1,
		OmitDefaults = 2,
		OmitEmptyCollections = 4
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <4df984f5-d079-4ea0-938b-5abff63cf97f>Deserializer : <54776c2e-9032-4200-be77-61dd0de51426>IDeserializer
	{
		private readonly <5859ace3-9e9b-4c5b-b336-e1564105a8fe>IValueDeserializer valueDeserializer;

		public <4df984f5-d079-4ea0-938b-5abff63cf97f>Deserializer()
			: this(new <4f91ff6a-994f-4610-be63-3f4293173662>DeserializerBuilder().BuildValueDeserializer())
		{
		}

		private <4df984f5-d079-4ea0-938b-5abff63cf97f>Deserializer(<5859ace3-9e9b-4c5b-b336-e1564105a8fe>IValueDeserializer valueDeserializer)
		{
			this.valueDeserializer = valueDeserializer ?? throw new ArgumentNullException("valueDeserializer");
		}

		public static <4df984f5-d079-4ea0-938b-5abff63cf97f>Deserializer FromValueDeserializer(<5859ace3-9e9b-4c5b-b336-e1564105a8fe>IValueDeserializer valueDeserializer)
		{
			return new <4df984f5-d079-4ea0-938b-5abff63cf97f>Deserializer(valueDeserializer);
		}

		public T Deserialize<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] T>(string input)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize<T>(input2);
		}

		public T Deserialize<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] T>(TextReader input)
		{
			return Deserialize<T>(new <05269e02-726c-41a0-a367-bc46c1e60b64>Parser(input));
		}

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public object Deserialize(TextReader input)
		{
			return Deserialize(input, typeof(object));
		}

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public object Deserialize(string input, Type type)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize(input2, type);
		}

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public object Deserialize(TextReader input, Type type)
		{
			return Deserialize(new <05269e02-726c-41a0-a367-bc46c1e60b64>Parser(input), type);
		}

		public T Deserialize<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] T>(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser)
		{
			return (T)Deserialize(parser, typeof(T));
		}

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public object Deserialize(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser)
		{
			return Deserialize(parser, typeof(object));
		}

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public object Deserialize(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type type)
		{
			if (parser == null)
			{
				throw new ArgumentNullException("parser");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			<b0b23517-beda-496a-8223-4c3554a848bc>StreamStart @event;
			bool flag = parser.TryConsume<<b0b23517-beda-496a-8223-4c3554a848bc>StreamStart>(out @event);
			<b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart event2;
			bool flag2 = parser.TryConsume<<b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart>(out event2);
			object result = null;
			if (!parser.Accept<<c51742f9-fbb1-469d-bb0b-e52d59018ce6>DocumentEnd>(out var _) && !parser.Accept<<639c5f87-0aee-41c1-9e7d-0f8ace8688c9>StreamEnd>(out var _))
			{
				using <03887f38-5396-46ae-aa15-aa9d9e2cc48b>SerializerState <03887f38-5396-46ae-aa15-aa9d9e2cc48b>SerializerState = new <03887f38-5396-46ae-aa15-aa9d9e2cc48b>SerializerState();
				result = valueDeserializer.DeserializeValue(parser, type, <03887f38-5396-46ae-aa15-aa9d9e2cc48b>SerializerState, valueDeserializer);
				<03887f38-5396-46ae-aa15-aa9d9e2cc48b>SerializerState.OnDeserialization();
			}
			if (flag2)
			{
				parser.Consume<<c51742f9-fbb1-469d-bb0b-e52d59018ce6>DocumentEnd>();
			}
			if (flag)
			{
				parser.Consume<<639c5f87-0aee-41c1-9e7d-0f8ace8688c9>StreamEnd>();
			}
			return result;
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 0, 1 })]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <4f91ff6a-994f-4610-be63-3f4293173662>DeserializerBuilder : <69289e38-c77d-4a5b-92b4-f9b084cfe166>BuilderSkeleton<<4f91ff6a-994f-4610-be63-3f4293173662>DeserializerBuilder>
	{
		private Lazy<<2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory> objectFactory;

		private readonly <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing, <1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer> nodeDeserializerFactories;

		private readonly <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing, <65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver> nodeTypeResolverFactories;

		private readonly Dictionary<<baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName, Type> tagMappings;

		private readonly Dictionary<Type, Type> typeMappings;

		private readonly ITypeConverter typeConverter;

		private bool ignoreUnmatched;

		private bool duplicateKeyChecking;

		private bool attemptUnknownTypeDeserialization;

		protected override <4f91ff6a-994f-4610-be63-3f4293173662>DeserializerBuilder Self => this;

		public <4f91ff6a-994f-4610-be63-3f4293173662>DeserializerBuilder()
			: base((<14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver)new <98465f71-96c8-45ed-8b91-ff3d452bf125>StaticTypeResolver())
		{
			typeMappings = new Dictionary<Type, Type>();
			objectFactory = new Lazy<<2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory>(() => new <02300856-d081-446f-a999-63a6afc06472>DefaultObjectFactory(typeMappings, settings), isThreadSafe: true);
			tagMappings = new Dictionary<<baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName, Type>
			{
				{
					<4cc800bb-1836-48cd-a3e0-17306397eb4e>FailsafeSchema.Tags.Map,
					typeof(Dictionary<object, object>)
				},
				{
					<4cc800bb-1836-48cd-a3e0-17306397eb4e>FailsafeSchema.Tags.Str,
					typeof(string)
				},
				{
					<fe4ef112-43d5-48b5-a3a3-86cc5a0fcc5b>JsonSchema.Tags.Bool,
					typeof(bool)
				},
				{
					<fe4ef112-43d5-48b5-a3a3-86cc5a0fcc5b>JsonSchema.Tags.Float,
					typeof(double)
				},
				{
					<fe4ef112-43d5-48b5-a3a3-86cc5a0fcc5b>JsonSchema.Tags.Int,
					typeof(int)
				},
				{
					<81f08b43-1c97-4f9b-b979-a743caedabb3>DefaultSchema.Tags.Timestamp,
					typeof(DateTime)
				}
			};
			typeInspectorFactories.Add(typeof(<beb62730-abb8-4cf4-a3cd-ff1d2c9c0107>CachedTypeInspector), (<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector inner) => new <beb62730-abb8-4cf4-a3cd-ff1d2c9c0107>CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(<9758241b-18f7-4060-9d08-5ab47a363edd>NamingConventionTypeInspector), (<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector inner) => (!(namingConvention is <74573528-4a43-4f7f-868c-a260d880c43a>NullNamingConvention)) ? new <9758241b-18f7-4060-9d08-5ab47a363edd>NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(<f79f0abc-db6f-40db-84ad-92e6ecbd9879>YamlAttributesTypeInspector), (<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector inner) => new <f79f0abc-db6f-40db-84ad-92e6ecbd9879>YamlAttributesTypeInspector(inner));
			typeInspectorFactories.Add(typeof(<6cf47502-3232-429d-9da0-30ce8271ebb5>YamlAttributeOverridesInspector), (<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector inner) => (overrides == null) ? inner : new <6cf47502-3232-429d-9da0-30ce8271ebb5>YamlAttributeOverridesInspector(inner, overrides.Clone()));
			typeInspectorFactories.Add(typeof(<5f4a0820-fb63-4029-9060-830ea493b4c6>ReadableAndWritablePropertiesTypeInspector), (<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector inner) => new <5f4a0820-fb63-4029-9060-830ea493b4c6>ReadableAndWritablePropertiesTypeInspector(inner));
			nodeDeserializerFactories = new <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing, <1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer>
			{
				{
					typeof(<52e06420-a414-44c5-b050-32f8c50d3c73>YamlConvertibleNodeDeserializer),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <52e06420-a414-44c5-b050-32f8c50d3c73>YamlConvertibleNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(<91d47f48-768b-4156-878e-5db746f252b1>YamlSerializableNodeDeserializer),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <91d47f48-768b-4156-878e-5db746f252b1>YamlSerializableNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(<6b23cfcb-093c-4338-af8b-9b06e9fa8693>TypeConverterNodeDeserializer),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <6b23cfcb-093c-4338-af8b-9b06e9fa8693>TypeConverterNodeDeserializer(BuildTypeConverters())
				},
				{
					typeof(<c92497bb-e732-4e03-8b07-63d99fe073c2>NullNodeDeserializer),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <c92497bb-e732-4e03-8b07-63d99fe073c2>NullNodeDeserializer()
				},
				{
					typeof(<469f90d5-64f3-4820-ab4b-6bba9aa75ec3>ScalarNodeDeserializer),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <469f90d5-64f3-4820-ab4b-6bba9aa75ec3>ScalarNodeDeserializer(attemptUnknownTypeDeserialization, typeConverter)
				},
				{
					typeof(<5b8d84af-318a-4060-a3ca-0c8cddc1905d>ArrayNodeDeserializer),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <5b8d84af-318a-4060-a3ca-0c8cddc1905d>ArrayNodeDeserializer()
				},
				{
					typeof(<a02a687b-156e-4d44-851f-111959502d7b>DictionaryNodeDeserializer),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <a02a687b-156e-4d44-851f-111959502d7b>DictionaryNodeDeserializer(objectFactory.Value, duplicateKeyChecking)
				},
				{
					typeof(<14e2f167-2529-400d-8b24-fb07cea47505>CollectionNodeDeserializer),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <14e2f167-2529-400d-8b24-fb07cea47505>CollectionNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(<69993307-8a26-4698-b642-9d482b90e9e0>EnumerableNodeDeserializer),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <69993307-8a26-4698-b642-9d482b90e9e0>EnumerableNodeDeserializer()
				},
				{
					typeof(<5d250f4d-109d-48f8-88c8-442c55c65c3f>ObjectNodeDeserializer),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <5d250f4d-109d-48f8-88c8-442c55c65c3f>ObjectNodeDeserializer(objectFactory.Value, BuildTypeInspector(), ignoreUnmatched, duplicateKeyChecking, typeConverter)
				}
			};
			nodeTypeResolverFactories = new <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing, <65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver>
			{
				{
					typeof(<d8f9faff-1f0f-40ca-a49a-88710edd1f40>MappingNodeTypeResolver),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <d8f9faff-1f0f-40ca-a49a-88710edd1f40>MappingNodeTypeResolver(typeMappings)
				},
				{
					typeof(<46985615-ba7b-447d-85d0-c2020ee1c192>YamlConvertibleTypeResolver),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <46985615-ba7b-447d-85d0-c2020ee1c192>YamlConvertibleTypeResolver()
				},
				{
					typeof(<86cc761d-0f06-48c3-a216-6acd2b63d61a>YamlSerializableTypeResolver),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <86cc761d-0f06-48c3-a216-6acd2b63d61a>YamlSerializableTypeResolver()
				},
				{
					typeof(<463c4e57-a312-4cc9-bd72-a377b5edfc9f>TagNodeTypeResolver),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <463c4e57-a312-4cc9-bd72-a377b5edfc9f>TagNodeTypeResolver(tagMappings)
				},
				{
					typeof(<02975dea-881b-4f37-b863-997aad25fb13>PreventUnknownTagsNodeTypeResolver),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <02975dea-881b-4f37-b863-997aad25fb13>PreventUnknownTagsNodeTypeResolver()
				},
				{
					typeof(<072feac1-f97b-4588-adb6-916ecf8798c1>DefaultContainersNodeTypeResolver),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <072feac1-f97b-4588-adb6-916ecf8798c1>DefaultContainersNodeTypeResolver()
				}
			};
			typeConverter = new ReflectionTypeConverter();
		}

		internal <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector BuildTypeInspector()
		{
			<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector2 = new WritablePropertiesTypeInspector(typeResolver, includeNonPublicProperties);
			if (!ignoreFields)
			{
				<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector2 = new <e78c014d-f9c5-476e-b4d3-4ceeb2c3903a>CompositeTypeInspector(new <c9af07c0-1e0a-4091-9acc-16646a8d71a0>ReadableFieldsTypeInspector(typeResolver), <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector2);
			}
			return typeInspectorFactories.BuildComponentChain(<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector2);
		}

		public <4f91ff6a-994f-4610-be63-3f4293173662>DeserializerBuilder WithAttemptingUnquotedStringTypeDeserialization()
		{
			attemptUnknownTypeDeserialization = true;
			return this;
		}

		public <4f91ff6a-994f-4610-be63-3f4293173662>DeserializerBuilder WithObjectFactory(<2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory objectFactory)
		{
			if (objectFactory == null)
			{
				throw new ArgumentNullException("objectFactory");
			}
			this.objectFactory = new Lazy<<2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory>(() => objectFactory, isThreadSafe: true);
			return this;
		}

		public <4f91ff6a-994f-4610-be63-3f4293173662>DeserializerBuilder WithObjectFactory(Func<Type, object> objectFactory)
		{
			if (objectFactory == null)
			{
				throw new ArgumentNullException("objectFactory");
			}
			return WithObjectFactory(new <dfdf1478-c2a1-4536-9c52-fd3e86acf4f6>LambdaObjectFactory(objectFactory));
		}

		public <4f91ff6a-994f-4610-be63-3f4293173662>DeserializerBuilder WithNodeDeserializer(<1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer nodeDeserializer)
		{
			return WithNodeDeserializer(nodeDeserializer, delegate(<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer> w)
			{
				w.OnTop();
			});
		}

		public <4f91ff6a-994f-4610-be63-3f4293173662>DeserializerBuilder WithNodeDeserializer(<1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer nodeDeserializer, Action<<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer>> where)
		{
			if (nodeDeserializer == null)
			{
				throw new ArgumentNullException("nodeDeserializer");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer.GetType(), (<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => nodeDeserializer));
			return this;
		}

		public <4f91ff6a-994f-4610-be63-3f4293173662>DeserializerBuilder WithNodeDeserializer<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TNodeDeserializer>(<3b4b8ccf-3e0d-4ddf-8f1c-125fe84d2bc4>WrapperFactory<<1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<<18c7fbcc-5471-41e0-b0d5-c272fe9a2c7a>ITrackingRegistrationLocationSelectionSyntax<<1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer>> where) where TNodeDeserializer : <1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer
		{
			if (nodeDeserializerFactory == null)
			{
				throw new ArgumentNullException("nodeDeserializerFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (<1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer wrapped, <74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => nodeDeserializerFactory(wrapped)));
			return this;
		}

		public <4f91ff6a-994f-4610-be63-3f4293173662>DeserializerBuilder WithoutNodeDeserializer<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TNodeDeserializer>() where TNodeDeserializer : <1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer
		{
			return WithoutNodeDeserializer(typeof(TNodeDeserializer));
		}

		public <4f91ff6a-994f-4610-be63-3f4293173662>DeserializerBuilder WithoutNodeDeserializer(Type nodeDeserializerType)
		{
			if (nodeDeserializerType == null)
			{
				throw new ArgumentNullException("nodeDeserializerType");
			}
			nodeDeserializerFactories.Remove(nodeDeserializerType);
			return this;
		}

		public <4f91ff6a-994f-4610-be63-3f4293173662>DeserializerBuilder WithTypeDiscriminatingNodeDeserializer(Action<ITypeDiscriminatingNodeDeserializerOptions> configureTypeDiscriminatingNodeDeserializerOptions, int maxDepth = -1, int maxLength = -1)
		{
			TypeDiscriminatingNodeDeserializerOptions typeDiscriminatingNodeDeserializerOptions = new TypeDiscriminatingNodeDeserializerOptions();
			configureTypeDiscriminatingNodeDeserializerOptions(typeDiscriminatingNodeDeserializerOptions);
			TypeDiscriminatingNodeDeserializer nodeDeserializer = new TypeDiscriminatingNodeDeserializer(nodeDeserializerFactories.BuildComponentList(), typeDiscriminatingNodeDeserializerOptions.discriminators, maxDepth, maxLength);
			return WithNodeDeserializer(nodeDeserializer, delegate(<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer> s)
			{
				s.Before<<a02a687b-156e-4d44-851f-111959502d7b>DictionaryNodeDeserializer>();
			});
		}

		public <4f91ff6a-994f-4610-be63-3f4293173662>DeserializerBuilder WithNodeTypeResolver(<65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver nodeTypeResolver)
		{
			return WithNodeTypeResolver(nodeTypeResolver, delegate(<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver> w)
			{
				w.OnTop();
			});
		}

		public <4f91ff6a-994f-4610-be63-3f4293173662>DeserializerBuilder WithNodeTypeResolver(<65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver nodeTypeResolver, Action<<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver>> where)
		{
			if (nodeTypeResolver == null)
			{
				throw new ArgumentNullException("nodeTypeResolver");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver.GetType(), (<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => nodeTypeResolver));
			return this;
		}

		public <4f91ff6a-994f-4610-be63-3f4293173662>DeserializerBuilder WithNodeTypeResolver<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TNodeTypeResolver>(<3b4b8ccf-3e0d-4ddf-8f1c-125fe84d2bc4>WrapperFactory<<65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<<18c7fbcc-5471-41e0-b0d5-c272fe9a2c7a>ITrackingRegistrationLocationSelectionSyntax<<65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver>> where) where TNodeTypeResolver : <65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver
		{
			if (nodeTypeResolverFactory == null)
			{
				throw new ArgumentNullException("nodeTypeResolverFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (<65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver wrapped, <74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => nodeTypeResolverFactory(wrapped)));
			return this;
		}

		public <4f91ff6a-994f-4610-be63-3f4293173662>DeserializerBuilder WithoutNodeTypeResolver<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TNodeTypeResolver>() where TNodeTypeResolver : <65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver
		{
			return WithoutNodeTypeResolver(typeof(TNodeTypeResolver));
		}

		public <4f91ff6a-994f-4610-be63-3f4293173662>DeserializerBuilder WithoutNodeTypeResolver(Type nodeTypeResolverType)
		{
			if (nodeTypeResolverType == null)
			{
				throw new ArgumentNullException("nodeTypeResolverType");
			}
			nodeTypeResolverFactories.Remove(nodeTypeResolverType);
			return this;
		}

		public override <4f91ff6a-994f-4610-be63-3f4293173662>DeserializerBuilder WithTagMapping(<baffffec-0e3a-40cd-94b0-5056fc2cc14e>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 <4f91ff6a-994f-4610-be63-3f4293173662>DeserializerBuilder WithTypeMapping<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TInterface, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>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 <4f91ff6a-994f-4610-be63-3f4293173662>DeserializerBuilder WithoutTagMapping(<baffffec-0e3a-40cd-94b0-5056fc2cc14e>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 <4f91ff6a-994f-4610-be63-3f4293173662>DeserializerBuilder IgnoreUnmatchedProperties()
		{
			ignoreUnmatched = true;
			return this;
		}

		public <4f91ff6a-994f-4610-be63-3f4293173662>DeserializerBuilder WithDuplicateKeyChecking()
		{
			duplicateKeyChecking = true;
			return this;
		}

		public <54776c2e-9032-4200-be77-61dd0de51426>IDeserializer Build()
		{
			return <4df984f5-d079-4ea0-938b-5abff63cf97f>Deserializer.FromValueDeserializer(BuildValueDeserializer());
		}

		public <5859ace3-9e9b-4c5b-b336-e1564105a8fe>IValueDeserializer BuildValueDeserializer()
		{
			return new <830bb613-9eea-4f2e-87ee-70baa6fa5839>AliasValueDeserializer(new <303d59cf-a252-4573-a9ae-9a1656455601>NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList(), typeConverter));
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs
	{
		private readonly IEnumerable<<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>> preProcessingPhaseVisitors;

		public <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter> InnerVisitor { get; private set; }

		public <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter EventEmitter { get; private set; }

		public <50dc5b9c-d2ff-457e-b37e-4022fe8e6bb7>ObjectSerializer NestedObjectSerializer { get; private set; }

		public IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> TypeConverters { get; private set; }

		public <a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs(<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter> innerVisitor, <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter eventEmitter, IEnumerable<<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>> preProcessingPhaseVisitors, IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> typeConverters, <50dc5b9c-d2ff-457e-b37e-4022fe8e6bb7>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<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] T>() where T : <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>
		{
			return preProcessingPhaseVisitors.OfType<T>().Single();
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal abstract class <9cc85b74-675f-4652-9a4a-cf7a729904a7>EventInfo
	{
		public <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor Source { get; }

		protected <9cc85b74-675f-4652-9a4a-cf7a729904a7>EventInfo(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor source)
		{
			Source = source ?? throw new ArgumentNullException("source");
		}
	}
	internal class <f4cbcba3-c718-4c5d-8fe8-dc444ac4fa0d>AliasEventInfo : <9cc85b74-675f-4652-9a4a-cf7a729904a7>EventInfo
	{
		public <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName Alias { get; }

		public bool NeedsExpansion { get; set; }

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public <f4cbcba3-c718-4c5d-8fe8-dc444ac4fa0d>AliasEventInfo(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor source, <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName alias)
			: base(source)
		{
			if (alias.IsEmpty)
			{
				throw new ArgumentNullException("alias");
			}
			Alias = alias;
		}
	}
	internal class <4f252c9c-9664-4495-9ef7-6fe67855a8cf>ObjectEventInfo : <9cc85b74-675f-4652-9a4a-cf7a729904a7>EventInfo
	{
		public <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName Anchor { get; set; }

		public <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName Tag { get; set; }

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		protected <4f252c9c-9664-4495-9ef7-6fe67855a8cf>ObjectEventInfo(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <4f19da32-6bd3-477f-8fb8-71554a9f7201>ScalarEventInfo : <4f252c9c-9664-4495-9ef7-6fe67855a8cf>ObjectEventInfo
	{
		public string RenderedValue { get; set; }

		public <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle Style { get; set; }

		public bool IsPlainImplicit { get; set; }

		public bool IsQuotedImplicit { get; set; }

		public <4f19da32-6bd3-477f-8fb8-71554a9f7201>ScalarEventInfo(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor source)
			: base(source)
		{
			Style = source.ScalarStyle;
			RenderedValue = string.Empty;
		}
	}
	internal sealed class <808a48ba-4a82-4d7c-9d8a-7016aba735c4>MappingStartEventInfo : <4f252c9c-9664-4495-9ef7-6fe67855a8cf>ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public <5bdd0818-2e61-4148-a2dc-8d667b816026>MappingStyle Style { get; set; }

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public <808a48ba-4a82-4d7c-9d8a-7016aba735c4>MappingStartEventInfo(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class <c472ed17-bdcd-472b-9699-e0216ea33fe7>MappingEndEventInfo : <9cc85b74-675f-4652-9a4a-cf7a729904a7>EventInfo
	{
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public <c472ed17-bdcd-472b-9699-e0216ea33fe7>MappingEndEventInfo(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class <b57e9ab0-e846-43da-873c-969a61caa7de>SequenceStartEventInfo : <4f252c9c-9664-4495-9ef7-6fe67855a8cf>ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public <633aecbb-227c-4a56-bde3-6176f414312f>SequenceStyle Style { get; set; }

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public <b57e9ab0-e846-43da-873c-969a61caa7de>SequenceStartEventInfo(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class <0b6d516e-249c-42e6-bb74-a0db4a9b3ce8>SequenceEndEventInfo : <9cc85b74-675f-4652-9a4a-cf7a729904a7>EventInfo
	{
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public <0b6d516e-249c-42e6-bb74-a0db4a9b3ce8>SequenceEndEventInfo(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface <5fd14629-aafa-4def-a300-e8bf70cd80f4>IAliasProvider
	{
		<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName GetAlias(object target);
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface <54776c2e-9032-4200-be77-61dd0de51426>IDeserializer
	{
		T Deserialize<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] T>(string input);

		T Deserialize<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] T>(TextReader input);

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		object Deserialize(TextReader input);

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		object Deserialize(string input, Type type);

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		object Deserialize(TextReader input, Type type);

		T Deserialize<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] T>(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser);

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		object Deserialize(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser);

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		object Deserialize(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type type);
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter
	{
		void Emit(<f4cbcba3-c718-4c5d-8fe8-dc444ac4fa0d>AliasEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter);

		void Emit(<4f19da32-6bd3-477f-8fb8-71554a9f7201>ScalarEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter);

		void Emit(<808a48ba-4a82-4d7c-9d8a-7016aba735c4>MappingStartEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter);

		void Emit(<c472ed17-bdcd-472b-9699-e0216ea33fe7>MappingEndEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter);

		void Emit(<b57e9ab0-e846-43da-873c-969a61caa7de>SequenceStartEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter);

		void Emit(<0b6d516e-249c-42e6-bb74-a0db4a9b3ce8>SequenceEndEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter);
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface <4ecad175-097b-490b-92b5-e349039d0335>INamingConvention
	{
		string Apply(string value);
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface <1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer
	{
		bool Deserialize(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser reader, Type expectedType, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser, Type, object> nestedObjectDeserializer, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] out object value);
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface <65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver
	{
		bool Resolve([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] <17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent nodeEvent, ref Type currentType);
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface IObjectAccessor
	{
		void Set(string name, object target, object value);

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		object Read(string name, object target);
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		object Value
		{
			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
			get;
		}

		Type Type { get; }

		Type StaticType { get; }

		<04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle ScalarStyle { get; }
	}
	internal static class <fdb35438-7447-46db-a505-7070fc67626c>ObjectDescriptorExtensions
	{
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public static object NonNullValue(this <11db0d0d-df5b-4ee5-a780-8f997e315481>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.");
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface <2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory
	{
		object Create(Type type);

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		object CreatePrimitive(Type type);

		bool GetDictionary(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor descriptor, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] out IDictionary dictionary, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 2, 1 })] out Type[] genericArguments);

		Type GetValueType(Type type);
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface <451614b3-1a11-4438-915e-8375d51a70af>IObjectGraphTraversalStrategy
	{
		void Traverse<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TContext>(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor graph, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<TContext> visitor, TContext context);
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TContext>
	{
		bool Enter(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value, TContext context);

		bool EnterMapping(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor key, <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value, TContext context);

		bool EnterMapping(<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor key, <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value, TContext context);

		void VisitScalar(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor scalar, TContext context);

		void VisitMappingStart(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor mapping, Type keyType, Type valueType, TContext context);

		void VisitMappingEnd(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor mapping, TContext context);

		void VisitSequenceStart(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor sequence, Type elementType, TContext context);

		void VisitSequenceEnd(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor sequence, TContext context);
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface <1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor
	{
		string Name { get; }

		bool CanWrite { get; }

		Type Type { get; }

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		Type TypeOverride
		{
			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
			get;
			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
			set;
		}

		int Order { get; set; }

		<04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle ScalarStyle { get; set; }

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)]
		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		T GetCustomAttribute<T>() where T : Attribute;

		<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor Read(object target);

		void Write(object target, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object value);
	}
	internal interface <47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>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 <18c7fbcc-5471-41e0-b0d5-c272fe9a2c7a>ITrackingRegistrationLocationSelectionSyntax<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface <fa87965e-2f74-48c8-a278-adcafb2bdf38>ISerializer
	{
		void Serialize(TextWriter writer, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object graph);

		string Serialize([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object graph);

		void Serialize(TextWriter writer, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object graph, Type type);

		void Serialize(<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object graph);

		void Serialize(<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object graph, Type type);
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector
	{
		IEnumerable<<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor> GetProperties(Type type, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object container);

		<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor GetProperty(Type type, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object container, string name, [<6977aacd-47a7-4a01-9bad-79c003aa1e36>MaybeNullWhen(true)] bool ignoreUnmatched);
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface <14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver
	{
		Type Resolve(Type staticType, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object actualValue);
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface <5859ace3-9e9b-4c5b-b336-e1564105a8fe>IValueDeserializer
	{
		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		object DeserializeValue(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type expectedType, <03887f38-5396-46ae-aa15-aa9d9e2cc48b>SerializerState state, <5859ace3-9e9b-4c5b-b336-e1564105a8fe>IValueDeserializer nestedObjectDeserializer);
	}
	internal interface <0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 2 })]
		event Action<object> ValueAvailable;
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
	internal interface <dcd8bcd4-89a2-444e-9230-d5bc88209068>IValueSerializer
	{
		void SerializeValue([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)] <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, object value, Type type);
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface <f8718f3a-c5b2-48c8-81a0-662be8a96cd4>IYamlConvertible
	{
		void Read(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type expectedType, <97d1143a-e250-473f-8f49-4efad2c2274e>ObjectDeserializer nestedObjectDeserializer);

		void Write(<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, <50dc5b9c-d2ff-457e-b37e-4022fe8e6bb7>ObjectSerializer nestedObjectSerializer);
	}
	[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
	internal delegate object <97d1143a-e250-473f-8f49-4efad2c2274e>ObjectDeserializer(Type type);
	internal delegate void <50dc5b9c-d2ff-457e-b37e-4022fe8e6bb7>ObjectSerializer(object value, Type type = null);
	[Obsolete("Please use IYamlConvertible instead")]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface <4b6fe5f2-3b66-4371-b16f-70d5594285af>IYamlSerializable
	{
		void ReadYaml(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser);

		void WriteYaml(<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter);
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface <ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter
	{
		bool Accepts(Type type);

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		object ReadYaml(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type type);

		void WriteYaml(<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object value, Type type);
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TArgument, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TComponent> : IEnumerable<Func<TArgument, TComponent>>, IEnumerable
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>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;
			}
		}

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>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;
			}
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)]
		private class RegistrationLocationSelector : <47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<TComponent>
		{
			[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)]
			private readonly <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<TArgument, TComponent> registrations;

			[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 0, 0 })]
			private readonly LazyComponentRegistration newRegistration;

			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
			public RegistrationLocationSelector(<4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<TArgument, TComponent> registrations, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 0, 0 })] LazyComponentRegistration newRegistration)
			{
				this.registrations = registrations;
				this.newRegistration = newRegistration;
			}

			void <47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<TComponent>.InsteadOf<TRegistrationType>()
			{
				if (newRegistration.ComponentType != typeof(TRegistrationType))
				{
					registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				}
				int index = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries[index] = newRegistration;
			}

			void <47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<TComponent>.After<TRegistrationType>()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				int num = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries.Insert(num + 1, newRegistration);
			}

			void <47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<TComponent>.Before<TRegistrationType>()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				int index = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries.Insert(index, newRegistration);
			}

			void <47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<TComponent>.OnBottom()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				registrations.entries.Add(newRegistration);
			}

			void <47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<TComponent>.OnTop()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				registrations.entries.Insert(0, newRegistration);
			}
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)]
		private class TrackingRegistrationLocationSelector : <18c7fbcc-5471-41e0-b0d5-c272fe9a2c7a>ITrackingRegistrationLocationSelectionSyntax<TComponent>
		{
			[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)]
			private readonly <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<TArgument, TComponent> registrations;

			[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 0, 0 })]
			private readonly TrackingLazyComponentRegistration newRegistration;

			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
			public TrackingRegistrationLocationSelector(<4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<TArgument, TComponent> registrations, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 0, 0 })] TrackingLazyComponentRegistration newRegistration)
			{
				this.registrations = registrations;
				this.newRegistration = newRegistration;
			}

			void <18c7fbcc-5471-41e0-b0d5-c272fe9a2c7a>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, [<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)] (TArgument arg) => newRegistration.Factory(innerComponentFactory(arg), arg));
			}
		}

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>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 <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<TArgument, TComponent> Clone()
		{
			<4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<TArgument, TComponent> <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList2 = new <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<TArgument, TComponent>();
			foreach (LazyComponentRegistration entry in entries)
			{
				<4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList2.entries.Add(entry);
			}
			return <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList2;
		}

		public void Clear()
		{
			entries.Clear();
		}

		public void Add(Type componentType, Func<TArgument, TComponent> factory)
		{
			entries.Add(new LazyComponentRegistration(componentType, factory));
		}

		public void Remove(Type componentType)
		{
			for (int i = 0; i < entries.Count; i++)
			{
				if (entries[i].ComponentType == componentType)
				{
					entries.RemoveAt(i);
					return;
				}
			}
			throw new KeyNotFoundException("A component registration of type '" + componentType.FullName + "' was not found.");
		}

		public <47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<TComponent> CreateRegistrationLocationSelector(Type componentType, Func<TArgument, TComponent> factory)
		{
			return new RegistrationLocationSelector(this, new LazyComponentRegistration(componentType, factory));
		}

		public <18c7fbcc-5471-41e0-b0d5-c272fe9a2c7a>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([<b36caba6-ec7b-49e8-8641-5a4015501a0a>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.");
			}
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>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;
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal static class <c411b9cf-53f6-4591-8b1f-034637f5a635>LazyComponentRegistrationListExtensions
	{
		public static TComponent BuildComponentChain<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TComponent>(this <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<TComponent, TComponent> registrations, TComponent innerComponent)
		{
			return registrations.InReverseOrder.Aggregate(innerComponent, [<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] (TComponent inner, Func<TComponent, TComponent> factory) => factory(inner));
		}

		public static TComponent BuildComponentChain<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TArgument, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TComponent>(this <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<TArgument, TComponent> registrations, TComponent innerComponent, Func<TComponent, TArgument> argumentBuilder)
		{
			return registrations.InReverseOrder.Aggregate(innerComponent, [<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] (TComponent inner, Func<TArgument, TComponent> factory) => factory(argumentBuilder(inner)));
		}

		public static List<TComponent> BuildComponentList<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TComponent>(this <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing, TComponent> registrations)
		{
			return registrations.Select([<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] (Func<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing, TComponent> factory) => factory(default(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing))).ToList();
		}

		public static List<TComponent> BuildComponentList<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TArgument, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TComponent>(this <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<TArgument, TComponent> registrations, TArgument argument)
		{
			return registrations.Select([<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] (Func<TArgument, TComponent> factory) => factory(argument)).ToList();
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	internal struct <74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing
	{
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <256cfd2a-7986-41ec-9ef1-d630af4cf0a3>ObjectDescriptor : <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		[field: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public object Value
		{
			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
			get;
			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
			private set;
		}

		public Type Type { get; private set; }

		public Type StaticType { get; private set; }

		public <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle ScalarStyle { get; private set; }

		public <256cfd2a-7986-41ec-9ef1-d630af4cf0a3>ObjectDescriptor([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object value, Type type, Type staticType)
			: this(value, type, staticType, <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Any)
		{
		}

		public <256cfd2a-7986-41ec-9ef1-d630af4cf0a3>ObjectDescriptor([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object value, Type type, Type staticType, <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle scalarStyle)
		{
			Value = value;
			Type = type ?? throw new ArgumentNullException("type");
			StaticType = staticType ?? throw new ArgumentNullException("staticType");
			ScalarStyle = scalarStyle;
		}
	}
	internal delegate <451614b3-1a11-4438-915e-8375d51a70af>IObjectGraphTraversalStrategy <51a5294e-6c04-4723-b54f-249688f55c36>ObjectGraphTraversalStrategyFactory(<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector typeInspector, <14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver, IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> typeConverters, int maximumRecursion);
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <7b7ba259-eb90-4bac-b4bd-d47c702c44fe>PropertyDescriptor : <1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor
	{
		private readonly <1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor baseDescriptor;

		public string Name { get; set; }

		public Type Type => baseDescriptor.Type;

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public Type TypeOverride
		{
			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
			get
			{
				return baseDescriptor.TypeOverride;
			}
			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
			set
			{
				baseDescriptor.TypeOverride = value;
			}
		}

		public int Order { get; set; }

		public <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle ScalarStyle
		{
			get
			{
				return baseDescriptor.ScalarStyle;
			}
			set
			{
				baseDescriptor.ScalarStyle = value;
			}
		}

		public bool CanWrite => baseDescriptor.CanWrite;

		public <7b7ba259-eb90-4bac-b4bd-d47c702c44fe>PropertyDescriptor(<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor baseDescriptor)
		{
			this.baseDescriptor = baseDescriptor;
			Name = baseDescriptor.Name;
		}

		public void Write(object target, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object value)
		{
			baseDescriptor.Write(target, value);
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)]
		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public T GetCustomAttribute<T>() where T : Attribute
		{
			return baseDescriptor.GetCustomAttribute<T>();
		}

		public <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor Read(object target)
		{
			return baseDescriptor.Read(target);
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <00138ba2-bdcc-48d5-834b-0b360fe71e37>Serializer : <fa87965e-2f74-48c8-a278-adcafb2bdf38>ISerializer
	{
		private readonly <dcd8bcd4-89a2-444e-9230-d5bc88209068>IValueSerializer valueSerializer;

		private readonly <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings emitterSettings;

		public <00138ba2-bdcc-48d5-834b-0b360fe71e37>Serializer()
			: this(new <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder().BuildValueSerializer(), <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings.Default)
		{
		}

		private <00138ba2-bdcc-48d5-834b-0b360fe71e37>Serializer(<dcd8bcd4-89a2-444e-9230-d5bc88209068>IValueSerializer valueSerializer, <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings emitterSettings)
		{
			this.valueSerializer = valueSerializer ?? throw new ArgumentNullException("valueSerializer");
			this.emitterSettings = emitterSettings ?? throw new ArgumentNullException("emitterSettings");
		}

		public static <00138ba2-bdcc-48d5-834b-0b360fe71e37>Serializer FromValueSerializer(<dcd8bcd4-89a2-444e-9230-d5bc88209068>IValueSerializer valueSerializer, <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings emitterSettings)
		{
			return new <00138ba2-bdcc-48d5-834b-0b360fe71e37>Serializer(valueSerializer, emitterSettings);
		}

		public void Serialize(TextWriter writer, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object graph)
		{
			Serialize(new <ef4ea80d-be69-456f-ae89-a173cffd181f>Emitter(writer, emitterSettings), graph);
		}

		public string Serialize([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object graph)
		{
			using StringWriter stringWriter = new StringWriter();
			Serialize(stringWriter, graph);
			return stringWriter.ToString();
		}

		public void Serialize(TextWriter writer, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object graph, Type type)
		{
			Serialize(new <ef4ea80d-be69-456f-ae89-a173cffd181f>Emitter(writer, emitterSettings), graph, type);
		}

		public void Serialize(<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object graph)
		{
			if (emitter == null)
			{
				throw new ArgumentNullException("emitter");
			}
			EmitDocument(emitter, graph, null);
		}

		public void Serialize(<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object graph, Type type)
		{
			if (emitter == null)
			{
				throw new ArgumentNullException("emitter");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			EmitDocument(emitter, graph, type);
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		private void EmitDocument([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)] <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, object graph, Type type)
		{
			emitter.Emit(new <b0b23517-beda-496a-8223-4c3554a848bc>StreamStart());
			emitter.Emit(new <b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart());
			valueSerializer.SerializeValue(emitter, graph, type);
			emitter.Emit(new <c51742f9-fbb1-469d-bb0b-e52d59018ce6>DocumentEnd(isImplicit: true));
			emitter.Emit(new <639c5f87-0aee-41c1-9e7d-0f8ace8688c9>StreamEnd());
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 0, 1 })]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder : <69289e38-c77d-4a5b-92b4-f9b084cfe166>BuilderSkeleton<<c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder>
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
		private class ValueSerializer : <dcd8bcd4-89a2-444e-9230-d5bc88209068>IValueSerializer
		{
			private readonly <451614b3-1a11-4438-915e-8375d51a70af>IObjectGraphTraversalStrategy traversalStrategy;

			private readonly <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter eventEmitter;

			private readonly IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> typeConverters;

			private readonly <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter>, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

			private readonly <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>> emissionPhaseObjectGraphVisitorFactories;

			public ValueSerializer(<451614b3-1a11-4438-915e-8375d51a70af>IObjectGraphTraversalStrategy traversalStrategy, <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter eventEmitter, IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> typeConverters, <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter>, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>> preProcessingPhaseObjectGraphVisitorFactories, <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>> emissionPhaseObjectGraphVisitorFactories)
			{
				this.traversalStrategy = traversalStrategy;
				this.eventEmitter = eventEmitter;
				this.typeConverters = typeConverters;
				this.preProcessingPhaseObjectGraphVisitorFactories = preProcessingPhaseObjectGraphVisitorFactories;
				this.emissionPhaseObjectGraphVisitorFactories = emissionPhaseObjectGraphVisitorFactories;
			}

			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
			public void SerializeValue([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)] <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, object value, Type type)
			{
				Type type2 = type ?? ((value != null) ? value.GetType() : typeof(object));
				Type staticType = type ?? typeof(object);
				<256cfd2a-7986-41ec-9ef1-d630af4cf0a3>ObjectDescriptor graph = new <256cfd2a-7986-41ec-9ef1-d630af4cf0a3>ObjectDescriptor(value, type2, staticType);
				List<<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>> preProcessingPhaseObjectGraphVisitors = preProcessingPhaseObjectGraphVisitorFactories.BuildComponentList(typeConverters);
				foreach (<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing> item in preProcessingPhaseObjectGraphVisitors)
				{
					traversalStrategy.Traverse(graph, item, default(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing));
				}
				<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter> visitor = emissionPhaseObjectGraphVisitorFactories.BuildComponentChain(new <1f917276-7cb7-47cb-837f-9340dcd2afd2>EmittingObjectGraphVisitor(eventEmitter), [<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] (<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter> inner) => new <a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
				traversalStrategy.Traverse(graph, visitor, emitter);
				[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
				void NestedObjectSerializer(object v, Type t)
				{
					SerializeValue(emitter, v, t);
				}
			}
		}

		private <51a5294e-6c04-4723-b54f-249688f55c36>ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory;

		private readonly <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter>, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

		private readonly <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>> emissionPhaseObjectGraphVisitorFactories;

		private readonly <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter, <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter> eventEmitterFactories;

		private readonly IDictionary<Type, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName> tagMappings = new Dictionary<Type, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName>();

		private readonly <2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory objectFactory;

		private int maximumRecursion = 50;

		private <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings emitterSettings = <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings.Default;

		private <d96bfc2d-895f-47ec-bf95-11ebc61b365e>DefaultValuesHandling defaultValuesHandlingConfiguration;

		private bool quoteNecessaryStrings;

		private bool quoteYaml1_1Strings;

		protected override <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder Self => this;

		public <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder()
			: base((<14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver)new <af98e88d-b15d-458f-a37e-68cd41982196>DynamicTypeResolver())
		{
			typeInspectorFactories.Add(typeof(<beb62730-abb8-4cf4-a3cd-ff1d2c9c0107>CachedTypeInspector), (<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector inner) => new <beb62730-abb8-4cf4-a3cd-ff1d2c9c0107>CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(<9758241b-18f7-4060-9d08-5ab47a363edd>NamingConventionTypeInspector), (<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector inner) => (!(namingConvention is <74573528-4a43-4f7f-868c-a260d880c43a>NullNamingConvention)) ? new <9758241b-18f7-4060-9d08-5ab47a363edd>NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(<f79f0abc-db6f-40db-84ad-92e6ecbd9879>YamlAttributesTypeInspector), (<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector inner) => new <f79f0abc-db6f-40db-84ad-92e6ecbd9879>YamlAttributesTypeInspector(inner));
			typeInspectorFactories.Add(typeof(<6cf47502-3232-429d-9da0-30ce8271ebb5>YamlAttributeOverridesInspector), (<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector inner) => (overrides == null) ? inner : new <6cf47502-3232-429d-9da0-30ce8271ebb5>YamlAttributeOverridesInspector(inner, overrides.Clone()));
			preProcessingPhaseObjectGraphVisitorFactories = new <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter>, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>> { 
			{
				typeof(<98b90ca6-9ce1-414d-957d-7e148c835587>AnchorAssigner),
				(IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> typeConverters) => new <98b90ca6-9ce1-414d-957d-7e148c835587>AnchorAssigner(typeConverters)
			} };
			emissionPhaseObjectGraphVisitorFactories = new <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>>
			{
				{
					typeof(<81f4bc1d-8977-4beb-80bc-3a86026f9535>CustomSerializationObjectGraphVisitor),
					(<a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs args) => new <81f4bc1d-8977-4beb-80bc-3a86026f9535>CustomSerializationObjectGraphVisitor(args.InnerVisitor, args.TypeConverters, args.NestedObjectSerializer)
				},
				{
					typeof(<11170e7d-1410-4033-9bd9-a7b638764d88>AnchorAssigningObjectGraphVisitor),
					(<a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs args) => new <11170e7d-1410-4033-9bd9-a7b638764d88>AnchorAssigningObjectGraphVisitor(args.InnerVisitor, args.EventEmitter, args.GetPreProcessingPhaseObjectGraphVisitor<<98b90ca6-9ce1-414d-957d-7e148c835587>AnchorAssigner>())
				},
				{
					typeof(<d0f2e925-f060-42f3-b5af-477eef6eb3d5>DefaultValuesObjectGraphVisitor),
					(<a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs args) => new <d0f2e925-f060-42f3-b5af-477eef6eb3d5>DefaultValuesObjectGraphVisitor(defaultValuesHandlingConfiguration, args.InnerVisitor, new <02300856-d081-446f-a999-63a6afc06472>DefaultObjectFactory())
				},
				{
					typeof(<0b8c21d0-f0b8-4cdf-8b95-d9d5c35dbfb4>CommentsObjectGraphVisitor),
					(<a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs args) => new <0b8c21d0-f0b8-4cdf-8b95-d9d5c35dbfb4>CommentsObjectGraphVisitor(args.InnerVisitor)
				}
			};
			eventEmitterFactories = new <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter, <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter> { 
			{
				typeof(<0162706c-c168-4372-b87d-6cd624ba9304>TypeAssigningEventEmitter),
				(<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter inner) => new <0162706c-c168-4372-b87d-6cd624ba9304>TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: false, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings)
			} };
			objectFactory = new <02300856-d081-446f-a999-63a6afc06472>DefaultObjectFactory();
			objectGraphTraversalStrategyFactory = (<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector typeInspector, <14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver, IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> typeConverters, int maximumRecursion) => new <52d47d71-4507-4f72-bcd7-c48178ada8a7>FullObjectGraphTraversalStrategy(typeInspector, typeResolver, maximumRecursion, namingConvention, objectFactory);
		}

		public <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder WithQuotingNecessaryStrings(bool quoteYaml1_1Strings = false)
		{
			quoteNecessaryStrings = true;
			this.quoteYaml1_1Strings = quoteYaml1_1Strings;
			return this;
		}

		public <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>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 <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder WithEventEmitter<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TEventEmitter>(Func<<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder WithEventEmitter<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TEventEmitter>(Func<<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter, TEventEmitter> eventEmitterFactory, Action<<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter>> where) where TEventEmitter : <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter
		{
			if (eventEmitterFactory == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateRegistrationLocationSelector(typeof(TEventEmitter), (<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter inner) => eventEmitterFactory(inner)));
			return Self;
		}

		public <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder WithEventEmitter<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TEventEmitter>(<5b34dae8-7cb0-482e-9895-29da17adc606>WrapperFactory<<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter, <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter, TEventEmitter> eventEmitterFactory, Action<<18c7fbcc-5471-41e0-b0d5-c272fe9a2c7a>ITrackingRegistrationLocationSelectionSyntax<<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter>> where) where TEventEmitter : <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter
		{
			if (eventEmitterFactory == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateTrackingRegistrationLocationSelector(typeof(TEventEmitter), (<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter wrapped, <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter inner) => eventEmitterFactory(wrapped, inner)));
			return Self;
		}

		public <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder WithoutEventEmitter<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TEventEmitter>() where TEventEmitter : <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter
		{
			return WithoutEventEmitter(typeof(TEventEmitter));
		}

		public <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder WithoutEventEmitter(Type eventEmitterType)
		{
			if (eventEmitterType == null)
			{
				throw new ArgumentNullException("eventEmitterType");
			}
			eventEmitterFactories.Remove(eventEmitterType);
			return this;
		}

		public override <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder WithTagMapping(<baffffec-0e3a-40cd-94b0-5056fc2cc14e>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 <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>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 <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder EnsureRoundtrip()
		{
			objectGraphTraversalStrategyFactory = (<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector typeInspector, <14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver, IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> typeConverters, int maximumRecursion) => new <7085160d-c56a-4dea-8936-bf24bc9acd82>RoundtripObjectGraphTraversalStrategy(typeConverters, typeInspector, typeResolver, maximumRecursion, namingConvention, settings, objectFactory);
			WithEventEmitter([<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] ([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)] <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter inner) => new <0162706c-c168-4372-b87d-6cd624ba9304>TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: true, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings), delegate(<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter> loc)
			{
				loc.InsteadOf<<0162706c-c168-4372-b87d-6cd624ba9304>TypeAssigningEventEmitter>();
			});
			return WithTypeInspector([<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] ([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)] <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector inner) => new <5f4a0820-fb63-4029-9060-830ea493b4c6>ReadableAndWritablePropertiesTypeInspector(inner), delegate(<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector> loc)
			{
				loc.OnBottom();
			});
		}

		public <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder DisableAliases()
		{
			preProcessingPhaseObjectGraphVisitorFactories.Remove(typeof(<98b90ca6-9ce1-414d-957d-7e148c835587>AnchorAssigner));
			emissionPhaseObjectGraphVisitorFactories.Remove(typeof(<11170e7d-1410-4033-9bd9-a7b638764d88>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 <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder EmitDefaults()
		{
			return ConfigureDefaultValuesHandling(<d96bfc2d-895f-47ec-bf95-11ebc61b365e>DefaultValuesHandling.Preserve);
		}

		public <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder ConfigureDefaultValuesHandling(<d96bfc2d-895f-47ec-bf95-11ebc61b365e>DefaultValuesHandling configuration)
		{
			defaultValuesHandlingConfiguration = configuration;
			return this;
		}

		public <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder JsonCompatible()
		{
			emitterSettings = emitterSettings.WithMaxSimpleKeyLength(int.MaxValue).WithoutAnchorName();
			return WithTypeConverter(new <2d47cdac-8cd8-47ea-80bc-fc9e84fda98a>GuidConverter(jsonCompatible: true), delegate(<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> w)
			{
				w.InsteadOf<<2d47cdac-8cd8-47ea-80bc-fc9e84fda98a>GuidConverter>();
			}).WithTypeConverter(new <f913999a-7bed-4589-ae4f-dd322e04e734>DateTimeConverter(DateTimeKind.Utc, null, true)).WithEventEmitter([<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] ([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)] <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter inner) => new <a013011b-1d74-4c39-8dc3-1737c7dda292>JsonEventEmitter(inner), delegate(<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter> loc)
			{
				loc.InsteadOf<<0162706c-c168-4372-b87d-6cd624ba9304>TypeAssigningEventEmitter>();
			});
		}

		public <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder WithNewLine(string newLine)
		{
			emitterSettings = emitterSettings.WithNewLine(newLine);
			return this;
		}

		public <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>> w)
			{
				w.OnTop();
			});
		}

		public <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor, Action<<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>>> where) where TObjectGraphVisitor : <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>
		{
			if (objectGraphVisitor == null)
			{
				throw new ArgumentNullException("objectGraphVisitor");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> _) => objectGraphVisitor));
			return this;
		}

		public <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TObjectGraphVisitor>(<3b4b8ccf-3e0d-4ddf-8f1c-125fe84d2bc4>WrapperFactory<<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<<18c7fbcc-5471-41e0-b0d5-c272fe9a2c7a>ITrackingRegistrationLocationSelectionSyntax<<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>>> where) where TObjectGraphVisitor : <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing> wrapped, IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> _) => objectGraphVisitorFactory(wrapped)));
			return this;
		}

		public <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TObjectGraphVisitor>() where TObjectGraphVisitor : <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>
		{
			return WithoutPreProcessingPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

		public <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor(Type objectGraphVisitorType)
		{
			if (objectGraphVisitorType == null)
			{
				throw new ArgumentNullException("objectGraphVisitorType");
			}
			preProcessingPhaseObjectGraphVisitorFactories.Remove(objectGraphVisitorType);
			return this;
		}

		public <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder WithObjectGraphTraversalStrategyFactory(<51a5294e-6c04-4723-b54f-249688f55c36>ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory)
		{
			this.objectGraphTraversalStrategyFactory = objectGraphTraversalStrategyFactory;
			return this;
		}

		public <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder WithEmissionPhaseObjectGraphVisitor<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TObjectGraphVisitor>(Func<<a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>
		{
			return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>> w)
			{
				w.OnTop();
			});
		}

		public <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder WithEmissionPhaseObjectGraphVisitor<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TObjectGraphVisitor>(Func<<a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory, Action<<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>>> where) where TObjectGraphVisitor : <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (<a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(args)));
			return this;
		}

		public <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder WithEmissionPhaseObjectGraphVisitor<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TObjectGraphVisitor>(<5b34dae8-7cb0-482e-9895-29da17adc606>WrapperFactory<<a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<<18c7fbcc-5471-41e0-b0d5-c272fe9a2c7a>ITrackingRegistrationLocationSelectionSyntax<<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>>> where) where TObjectGraphVisitor : <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter> wrapped, <a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(wrapped, args)));
			return this;
		}

		public <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder WithoutEmissionPhaseObjectGraphVisitor<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TObjectGraphVisitor>() where TObjectGraphVisitor : <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>
		{
			return WithoutEmissionPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

		public <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder WithoutEmissionPhaseObjectGraphVisitor(Type objectGraphVisitorType)
		{
			if (objectGraphVisitorType == null)
			{
				throw new ArgumentNullException("objectGraphVisitorType");
			}
			emissionPhaseObjectGraphVisitorFactories.Remove(objectGraphVisitorType);
			return this;
		}

		public <c67b131f-5ca1-4f1e-9e7a-7c8cb0b6de8b>SerializerBuilder WithIndentedSequences()
		{
			emitterSettings = emitterSettings.WithIndentedSequences();
			return this;
		}

		public <fa87965e-2f74-48c8-a278-adcafb2bdf38>ISerializer Build()
		{
			return <00138ba2-bdcc-48d5-834b-0b360fe71e37>Serializer.FromValueSerializer(BuildValueSerializer(), emitterSettings);
		}

		public <dcd8bcd4-89a2-444e-9230-d5bc88209068>IValueSerializer BuildValueSerializer()
		{
			IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> typeConverters = BuildTypeConverters();
			<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector typeInspector = BuildTypeInspector();
			<451614b3-1a11-4438-915e-8375d51a70af>IObjectGraphTraversalStrategy traversalStrategy = objectGraphTraversalStrategyFactory(typeInspector, typeResolver, typeConverters, maximumRecursion);
			<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter eventEmitter = eventEmitterFactories.BuildComponentChain(new <7f037384-521e-4d90-8f63-105fac34d3ce>WriterEventEmitter());
			return new ValueSerializer(traversalStrategy, eventEmitter, typeConverters, preProcessingPhaseObjectGraphVisitorFactories.Clone(), emissionPhaseObjectGraphVisitorFactories.Clone());
		}

		internal <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector BuildTypeInspector()
		{
			<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector2 = new <ac823e26-ce2a-4b5b-a91b-fd564c61fdc6>ReadablePropertiesTypeInspector(typeResolver, includeNonPublicProperties);
			if (!ignoreFields)
			{
				<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector2 = new <e78c014d-f9c5-476e-b4d3-4ceeb2c3903a>CompositeTypeInspector(new <c9af07c0-1e0a-4091-9acc-16646a8d71a0>ReadableFieldsTypeInspector(typeResolver), <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector2);
			}
			return typeInspectorFactories.BuildComponentChain(<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector2);
		}
	}
	internal class Settings
	{
		public bool AllowPrivateConstructors { get; set; }
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal abstract class StaticBuilderSkeleton<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TBuilder> where TBuilder : StaticBuilderSkeleton<TBuilder>
	{
		internal <4ecad175-097b-490b-92b5-e349039d0335>INamingConvention namingConvention = <74573528-4a43-4f7f-868c-a260d880c43a>NullNamingConvention.Instance;

		internal <14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver;

		internal readonly <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing, <ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> typeConverterFactories;

		internal readonly <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector, <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector> typeInspectorFactories;

		internal bool includeNonPublicProperties;

		internal Settings settings;

		protected abstract TBuilder Self { get; }

		internal StaticBuilderSkeleton(<14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver)
		{
			typeConverterFactories = new <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing, <ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> { 
			{
				typeof(<2d47cdac-8cd8-47ea-80bc-fc9e84fda98a>GuidConverter),
				(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <2d47cdac-8cd8-47ea-80bc-fc9e84fda98a>GuidConverter(jsonCompatible: false)
			} };
			typeInspectorFactories = new <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector, <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector>();
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			settings = new Settings();
		}

		public TBuilder WithNamingConvention(<4ecad175-097b-490b-92b5-e349039d0335>INamingConvention namingConvention)
		{
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
			return Self;
		}

		public TBuilder WithTypeResolver(<14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			return Self;
		}

		public abstract TBuilder WithTagMapping(<baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName tag, Type type);

		public TBuilder WithTypeConverter(<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter typeConverter)
		{
			return WithTypeConverter(typeConverter, delegate(<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeConverter(<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter typeConverter, Action<<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter>> where)
		{
			if (typeConverter == null)
			{
				throw new ArgumentNullException("typeConverter");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter.GetType(), (<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => typeConverter));
			return Self;
		}

		public TBuilder WithTypeConverter<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TYamlTypeConverter>(<3b4b8ccf-3e0d-4ddf-8f1c-125fe84d2bc4>WrapperFactory<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter, <ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> typeConverterFactory, Action<<18c7fbcc-5471-41e0-b0d5-c272fe9a2c7a>ITrackingRegistrationLocationSelectionSyntax<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter>> where) where TYamlTypeConverter : <ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter
		{
			if (typeConverterFactory == null)
			{
				throw new ArgumentNullException("typeConverterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter wrapped, <74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => typeConverterFactory(wrapped)));
			return Self;
		}

		public TBuilder WithoutTypeConverter<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TYamlTypeConverter>() where TYamlTypeConverter : <ddaaa542-dd60-4d14-a733-9acfc1784a67>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<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TTypeInspector>(Func<<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector
		{
			return WithTypeInspector(typeInspectorFactory, delegate(<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeInspector<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TTypeInspector>(Func<<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector, TTypeInspector> typeInspectorFactory, Action<<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector>> where) where TTypeInspector : <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector
		{
			if (typeInspectorFactory == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector inner) => typeInspectorFactory(inner)));
			return Self;
		}

		public TBuilder WithTypeInspector<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TTypeInspector>(<5b34dae8-7cb0-482e-9895-29da17adc606>WrapperFactory<<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector, <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector, TTypeInspector> typeInspectorFactory, Action<<18c7fbcc-5471-41e0-b0d5-c272fe9a2c7a>ITrackingRegistrationLocationSelectionSyntax<<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector>> where) where TTypeInspector : <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector
		{
			if (typeInspectorFactory == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector wrapped, <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector inner) => typeInspectorFactory(wrapped, inner)));
			return Self;
		}

		public TBuilder WithoutTypeInspector<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TTypeInspector>() where TTypeInspector : <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector
		{
			return WithoutTypeInspector(typeof(TTypeInspector));
		}

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

		protected IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> BuildTypeConverters()
		{
			return typeConverterFactories.BuildComponentList();
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal abstract class StaticContext
	{
		public virtual StaticObjectFactory GetFactory()
		{
			throw new NotImplementedException();
		}

		public virtual <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector GetTypeInspector()
		{
			throw new NotImplementedException();
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 0, 1 })]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class StaticDeserializerBuilder : StaticBuilderSkeleton<StaticDeserializerBuilder>
	{
		private readonly StaticContext context;

		private readonly StaticObjectFactory factory;

		private readonly <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing, <1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer> nodeDeserializerFactories;

		private readonly <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing, <65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver> nodeTypeResolverFactories;

		private readonly Dictionary<<baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName, Type> tagMappings;

		private readonly ITypeConverter typeConverter;

		private readonly Dictionary<Type, Type> typeMappings;

		private bool ignoreUnmatched;

		private bool duplicateKeyChecking;

		private bool attemptUnknownTypeDeserialization;

		protected override StaticDeserializerBuilder Self => this;

		public StaticDeserializerBuilder(StaticContext context)
			: base((<14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver)new <98465f71-96c8-45ed-8b91-ff3d452bf125>StaticTypeResolver())
		{
			this.context = context;
			factory = context.GetFactory();
			typeMappings = new Dictionary<Type, Type>();
			tagMappings = new Dictionary<<baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName, Type>
			{
				{
					<4cc800bb-1836-48cd-a3e0-17306397eb4e>FailsafeSchema.Tags.Map,
					typeof(Dictionary<object, object>)
				},
				{
					<4cc800bb-1836-48cd-a3e0-17306397eb4e>FailsafeSchema.Tags.Str,
					typeof(string)
				},
				{
					<fe4ef112-43d5-48b5-a3a3-86cc5a0fcc5b>JsonSchema.Tags.Bool,
					typeof(bool)
				},
				{
					<fe4ef112-43d5-48b5-a3a3-86cc5a0fcc5b>JsonSchema.Tags.Float,
					typeof(double)
				},
				{
					<fe4ef112-43d5-48b5-a3a3-86cc5a0fcc5b>JsonSchema.Tags.Int,
					typeof(int)
				},
				{
					<81f08b43-1c97-4f9b-b979-a743caedabb3>DefaultSchema.Tags.Timestamp,
					typeof(DateTime)
				}
			};
			typeInspectorFactories.Add(typeof(<beb62730-abb8-4cf4-a3cd-ff1d2c9c0107>CachedTypeInspector), (<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector inner) => new <beb62730-abb8-4cf4-a3cd-ff1d2c9c0107>CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(<9758241b-18f7-4060-9d08-5ab47a363edd>NamingConventionTypeInspector), (<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector inner) => (!(namingConvention is <74573528-4a43-4f7f-868c-a260d880c43a>NullNamingConvention)) ? new <9758241b-18f7-4060-9d08-5ab47a363edd>NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(<f79f0abc-db6f-40db-84ad-92e6ecbd9879>YamlAttributesTypeInspector), (<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector inner) => new <f79f0abc-db6f-40db-84ad-92e6ecbd9879>YamlAttributesTypeInspector(inner));
			nodeDeserializerFactories = new <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing, <1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer>
			{
				{
					typeof(<52e06420-a414-44c5-b050-32f8c50d3c73>YamlConvertibleNodeDeserializer),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <52e06420-a414-44c5-b050-32f8c50d3c73>YamlConvertibleNodeDeserializer(factory)
				},
				{
					typeof(<91d47f48-768b-4156-878e-5db746f252b1>YamlSerializableNodeDeserializer),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <91d47f48-768b-4156-878e-5db746f252b1>YamlSerializableNodeDeserializer(factory)
				},
				{
					typeof(<6b23cfcb-093c-4338-af8b-9b06e9fa8693>TypeConverterNodeDeserializer),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <6b23cfcb-093c-4338-af8b-9b06e9fa8693>TypeConverterNodeDeserializer(BuildTypeConverters())
				},
				{
					typeof(<c92497bb-e732-4e03-8b07-63d99fe073c2>NullNodeDeserializer),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <c92497bb-e732-4e03-8b07-63d99fe073c2>NullNodeDeserializer()
				},
				{
					typeof(<469f90d5-64f3-4820-ab4b-6bba9aa75ec3>ScalarNodeDeserializer),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <469f90d5-64f3-4820-ab4b-6bba9aa75ec3>ScalarNodeDeserializer(attemptUnknownTypeDeserialization, typeConverter)
				},
				{
					typeof(StaticArrayNodeDeserializer),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new StaticArrayNodeDeserializer(factory)
				},
				{
					typeof(StaticDictionaryNodeDeserializer),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new StaticDictionaryNodeDeserializer(factory, duplicateKeyChecking)
				},
				{
					typeof(StaticCollectionNodeDeserializer),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new StaticCollectionNodeDeserializer(factory)
				},
				{
					typeof(<5d250f4d-109d-48f8-88c8-442c55c65c3f>ObjectNodeDeserializer),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <5d250f4d-109d-48f8-88c8-442c55c65c3f>ObjectNodeDeserializer(factory, BuildTypeInspector(), ignoreUnmatched, duplicateKeyChecking, typeConverter)
				}
			};
			nodeTypeResolverFactories = new <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing, <65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver>
			{
				{
					typeof(<d8f9faff-1f0f-40ca-a49a-88710edd1f40>MappingNodeTypeResolver),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <d8f9faff-1f0f-40ca-a49a-88710edd1f40>MappingNodeTypeResolver(typeMappings)
				},
				{
					typeof(<46985615-ba7b-447d-85d0-c2020ee1c192>YamlConvertibleTypeResolver),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <46985615-ba7b-447d-85d0-c2020ee1c192>YamlConvertibleTypeResolver()
				},
				{
					typeof(<86cc761d-0f06-48c3-a216-6acd2b63d61a>YamlSerializableTypeResolver),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <86cc761d-0f06-48c3-a216-6acd2b63d61a>YamlSerializableTypeResolver()
				},
				{
					typeof(<463c4e57-a312-4cc9-bd72-a377b5edfc9f>TagNodeTypeResolver),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <463c4e57-a312-4cc9-bd72-a377b5edfc9f>TagNodeTypeResolver(tagMappings)
				},
				{
					typeof(<02975dea-881b-4f37-b863-997aad25fb13>PreventUnknownTagsNodeTypeResolver),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <02975dea-881b-4f37-b863-997aad25fb13>PreventUnknownTagsNodeTypeResolver()
				},
				{
					typeof(<072feac1-f97b-4588-adb6-916ecf8798c1>DefaultContainersNodeTypeResolver),
					(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => new <072feac1-f97b-4588-adb6-916ecf8798c1>DefaultContainersNodeTypeResolver()
				}
			};
			typeConverter = new NullTypeConverter();
		}

		internal <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector BuildTypeInspector()
		{
			<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector typeInspector = context.GetTypeInspector();
			return typeInspectorFactories.BuildComponentChain(typeInspector);
		}

		public StaticDeserializerBuilder WithAttemptingUnquotedStringTypeDeserialization()
		{
			attemptUnknownTypeDeserialization = true;
			return this;
		}

		public StaticDeserializerBuilder WithNodeDeserializer(<1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer nodeDeserializer)
		{
			return WithNodeDeserializer(nodeDeserializer, delegate(<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer> w)
			{
				w.OnTop();
			});
		}

		public StaticDeserializerBuilder WithNodeDeserializer(<1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer nodeDeserializer, Action<<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer>> where)
		{
			if (nodeDeserializer == null)
			{
				throw new ArgumentNullException("nodeDeserializer");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer.GetType(), (<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => nodeDeserializer));
			return this;
		}

		public StaticDeserializerBuilder WithNodeDeserializer<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TNodeDeserializer>(<3b4b8ccf-3e0d-4ddf-8f1c-125fe84d2bc4>WrapperFactory<<1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<<18c7fbcc-5471-41e0-b0d5-c272fe9a2c7a>ITrackingRegistrationLocationSelectionSyntax<<1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer>> where) where TNodeDeserializer : <1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer
		{
			if (nodeDeserializerFactory == null)
			{
				throw new ArgumentNullException("nodeDeserializerFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (<1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer wrapped, <74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => nodeDeserializerFactory(wrapped)));
			return this;
		}

		public StaticDeserializerBuilder WithoutNodeDeserializer<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TNodeDeserializer>() where TNodeDeserializer : <1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer
		{
			return WithoutNodeDeserializer(typeof(TNodeDeserializer));
		}

		public StaticDeserializerBuilder WithoutNodeDeserializer(Type nodeDeserializerType)
		{
			if (nodeDeserializerType == null)
			{
				throw new ArgumentNullException("nodeDeserializerType");
			}
			nodeDeserializerFactories.Remove(nodeDeserializerType);
			return this;
		}

		public StaticDeserializerBuilder WithTypeDiscriminatingNodeDeserializer(Action<ITypeDiscriminatingNodeDeserializerOptions> configureTypeDiscriminatingNodeDeserializerOptions, int maxDepth = -1, int maxLength = -1)
		{
			TypeDiscriminatingNodeDeserializerOptions typeDiscriminatingNodeDeserializerOptions = new TypeDiscriminatingNodeDeserializerOptions();
			configureTypeDiscriminatingNodeDeserializerOptions(typeDiscriminatingNodeDeserializerOptions);
			TypeDiscriminatingNodeDeserializer nodeDeserializer = new TypeDiscriminatingNodeDeserializer(nodeDeserializerFactories.BuildComponentList(), typeDiscriminatingNodeDeserializerOptions.discriminators, maxDepth, maxLength);
			return WithNodeDeserializer(nodeDeserializer, delegate(<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer> s)
			{
				s.Before<<a02a687b-156e-4d44-851f-111959502d7b>DictionaryNodeDeserializer>();
			});
		}

		public StaticDeserializerBuilder WithNodeTypeResolver(<65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver nodeTypeResolver)
		{
			return WithNodeTypeResolver(nodeTypeResolver, delegate(<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver> w)
			{
				w.OnTop();
			});
		}

		public StaticDeserializerBuilder WithNodeTypeResolver(<65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver nodeTypeResolver, Action<<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver>> where)
		{
			if (nodeTypeResolver == null)
			{
				throw new ArgumentNullException("nodeTypeResolver");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver.GetType(), (<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => nodeTypeResolver));
			return this;
		}

		public StaticDeserializerBuilder WithNodeTypeResolver<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TNodeTypeResolver>(<3b4b8ccf-3e0d-4ddf-8f1c-125fe84d2bc4>WrapperFactory<<65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<<18c7fbcc-5471-41e0-b0d5-c272fe9a2c7a>ITrackingRegistrationLocationSelectionSyntax<<65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver>> where) where TNodeTypeResolver : <65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver
		{
			if (nodeTypeResolverFactory == null)
			{
				throw new ArgumentNullException("nodeTypeResolverFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (<65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver wrapped, <74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing _) => nodeTypeResolverFactory(wrapped)));
			return this;
		}

		public StaticDeserializerBuilder WithoutNodeTypeResolver<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TNodeTypeResolver>() where TNodeTypeResolver : <65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver
		{
			return WithoutNodeTypeResolver(typeof(TNodeTypeResolver));
		}

		public StaticDeserializerBuilder WithoutNodeTypeResolver(Type nodeTypeResolverType)
		{
			if (nodeTypeResolverType == null)
			{
				throw new ArgumentNullException("nodeTypeResolverType");
			}
			nodeTypeResolverFactories.Remove(nodeTypeResolverType);
			return this;
		}

		public override StaticDeserializerBuilder WithTagMapping(<baffffec-0e3a-40cd-94b0-5056fc2cc14e>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 StaticDeserializerBuilder WithTypeMapping<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TInterface, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>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 StaticDeserializerBuilder WithoutTagMapping(<baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName tag)
		{
			if (tag.IsEmpty)
			{
				throw new ArgumentException("Non-specific tags cannot be maped");
			}
			if (!tagMappings.Remove(tag))
			{
				throw new KeyNotFoundException($"Tag '{tag}' is not registered");
			}
			return this;
		}

		public StaticDeserializerBuilder IgnoreUnmatchedProperties()
		{
			ignoreUnmatched = true;
			return this;
		}

		public StaticDeserializerBuilder WithDuplicateKeyChecking()
		{
			duplicateKeyChecking = true;
			return this;
		}

		public <54776c2e-9032-4200-be77-61dd0de51426>IDeserializer Build()
		{
			return <4df984f5-d079-4ea0-938b-5abff63cf97f>Deserializer.FromValueDeserializer(BuildValueDeserializer());
		}

		public <5859ace3-9e9b-4c5b-b336-e1564105a8fe>IValueDeserializer BuildValueDeserializer()
		{
			return new <830bb613-9eea-4f2e-87ee-70baa6fa5839>AliasValueDeserializer(new <303d59cf-a252-4573-a9ae-9a1656455601>NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList(), typeConverter));
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 0, 1 })]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class StaticSerializerBuilder : StaticBuilderSkeleton<StaticSerializerBuilder>
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
		private class ValueSerializer : <dcd8bcd4-89a2-444e-9230-d5bc88209068>IValueSerializer
		{
			private readonly <451614b3-1a11-4438-915e-8375d51a70af>IObjectGraphTraversalStrategy traversalStrategy;

			private readonly <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter eventEmitter;

			private readonly IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> typeConverters;

			private readonly <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter>, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

			private readonly <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>> emissionPhaseObjectGraphVisitorFactories;

			public ValueSerializer(<451614b3-1a11-4438-915e-8375d51a70af>IObjectGraphTraversalStrategy traversalStrategy, <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter eventEmitter, IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> typeConverters, <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter>, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>> preProcessingPhaseObjectGraphVisitorFactories, <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>> emissionPhaseObjectGraphVisitorFactories)
			{
				this.traversalStrategy = traversalStrategy;
				this.eventEmitter = eventEmitter;
				this.typeConverters = typeConverters;
				this.preProcessingPhaseObjectGraphVisitorFactories = preProcessingPhaseObjectGraphVisitorFactories;
				this.emissionPhaseObjectGraphVisitorFactories = emissionPhaseObjectGraphVisitorFactories;
			}

			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
			public void SerializeValue([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)] <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, object value, Type type)
			{
				Type type2 = type ?? ((value != null) ? value.GetType() : typeof(object));
				Type staticType = type ?? typeof(object);
				<256cfd2a-7986-41ec-9ef1-d630af4cf0a3>ObjectDescriptor graph = new <256cfd2a-7986-41ec-9ef1-d630af4cf0a3>ObjectDescriptor(value, type2, staticType);
				List<<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>> preProcessingPhaseObjectGraphVisitors = preProcessingPhaseObjectGraphVisitorFactories.BuildComponentList(typeConverters);
				foreach (<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing> item in preProcessingPhaseObjectGraphVisitors)
				{
					traversalStrategy.Traverse(graph, item, default(<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing));
				}
				<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter> visitor = emissionPhaseObjectGraphVisitorFactories.BuildComponentChain(new <1f917276-7cb7-47cb-837f-9340dcd2afd2>EmittingObjectGraphVisitor(eventEmitter), [<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] (<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter> inner) => new <a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
				traversalStrategy.Traverse(graph, visitor, emitter);
				[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
				void NestedObjectSerializer(object v, Type t)
				{
					SerializeValue(emitter, v, t);
				}
			}
		}

		private readonly StaticContext context;

		private readonly StaticObjectFactory factory;

		private <51a5294e-6c04-4723-b54f-249688f55c36>ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory;

		private readonly <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter>, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

		private readonly <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>> emissionPhaseObjectGraphVisitorFactories;

		private readonly <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter, <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter> eventEmitterFactories;

		private readonly IDictionary<Type, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName> tagMappings = new Dictionary<Type, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName>();

		private int maximumRecursion = 50;

		private <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings emitterSettings = <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings.Default;

		private <d96bfc2d-895f-47ec-bf95-11ebc61b365e>DefaultValuesHandling defaultValuesHandlingConfiguration;

		private bool quoteNecessaryStrings;

		protected override StaticSerializerBuilder Self => this;

		public StaticSerializerBuilder(StaticContext context)
			: base((<14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver)new <af98e88d-b15d-458f-a37e-68cd41982196>DynamicTypeResolver())
		{
			this.context = context;
			factory = context.GetFactory();
			typeInspectorFactories.Add(typeof(<beb62730-abb8-4cf4-a3cd-ff1d2c9c0107>CachedTypeInspector), (<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector inner) => new <beb62730-abb8-4cf4-a3cd-ff1d2c9c0107>CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(<9758241b-18f7-4060-9d08-5ab47a363edd>NamingConventionTypeInspector), (<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector inner) => (!(namingConvention is <74573528-4a43-4f7f-868c-a260d880c43a>NullNamingConvention)) ? new <9758241b-18f7-4060-9d08-5ab47a363edd>NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(<f79f0abc-db6f-40db-84ad-92e6ecbd9879>YamlAttributesTypeInspector), (<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector inner) => new <f79f0abc-db6f-40db-84ad-92e6ecbd9879>YamlAttributesTypeInspector(inner));
			preProcessingPhaseObjectGraphVisitorFactories = new <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter>, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>> { 
			{
				typeof(<98b90ca6-9ce1-414d-957d-7e148c835587>AnchorAssigner),
				(IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> typeConverters) => new <98b90ca6-9ce1-414d-957d-7e148c835587>AnchorAssigner(typeConverters)
			} };
			emissionPhaseObjectGraphVisitorFactories = new <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>>
			{
				{
					typeof(<81f4bc1d-8977-4beb-80bc-3a86026f9535>CustomSerializationObjectGraphVisitor),
					(<a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs args) => new <81f4bc1d-8977-4beb-80bc-3a86026f9535>CustomSerializationObjectGraphVisitor(args.InnerVisitor, args.TypeConverters, args.NestedObjectSerializer)
				},
				{
					typeof(<11170e7d-1410-4033-9bd9-a7b638764d88>AnchorAssigningObjectGraphVisitor),
					(<a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs args) => new <11170e7d-1410-4033-9bd9-a7b638764d88>AnchorAssigningObjectGraphVisitor(args.InnerVisitor, args.EventEmitter, args.GetPreProcessingPhaseObjectGraphVisitor<<98b90ca6-9ce1-414d-957d-7e148c835587>AnchorAssigner>())
				},
				{
					typeof(<d0f2e925-f060-42f3-b5af-477eef6eb3d5>DefaultValuesObjectGraphVisitor),
					(<a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs args) => new <d0f2e925-f060-42f3-b5af-477eef6eb3d5>DefaultValuesObjectGraphVisitor(defaultValuesHandlingConfiguration, args.InnerVisitor, factory)
				},
				{
					typeof(<0b8c21d0-f0b8-4cdf-8b95-d9d5c35dbfb4>CommentsObjectGraphVisitor),
					(<a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs args) => new <0b8c21d0-f0b8-4cdf-8b95-d9d5c35dbfb4>CommentsObjectGraphVisitor(args.InnerVisitor)
				}
			};
			eventEmitterFactories = new <4700ccda-2c9b-4c6c-ac0f-e5578d60bb8a>LazyComponentRegistrationList<<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter, <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter> { 
			{
				typeof(<0162706c-c168-4372-b87d-6cd624ba9304>TypeAssigningEventEmitter),
				(<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter inner) => new <0162706c-c168-4372-b87d-6cd624ba9304>TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: false, tagMappings, quoteNecessaryStrings)
			} };
			objectGraphTraversalStrategyFactory = (<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector typeInspector, <14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver, IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> typeConverters, int maximumRecursion) => new <52d47d71-4507-4f72-bcd7-c48178ada8a7>FullObjectGraphTraversalStrategy(typeInspector, typeResolver, maximumRecursion, namingConvention, factory);
		}

		public StaticSerializerBuilder WithQuotingNecessaryStrings()
		{
			quoteNecessaryStrings = true;
			return this;
		}

		public StaticSerializerBuilder WithMaximumRecursion(int maximumRecursion)
		{
			if (maximumRecursion <= 0)
			{
				throw new ArgumentOutOfRangeException("maximumRecursion", $"The maximum recursion specified ({maximumRecursion}) is invalid. It should be a positive integer.");
			}
			this.maximumRecursion = maximumRecursion;
			return this;
		}

		public StaticSerializerBuilder WithEventEmitter<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TEventEmitter>(Func<<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithEventEmitter<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TEventEmitter>(Func<<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter, TEventEmitter> eventEmitterFactory, Action<<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter>> where) where TEventEmitter : <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter
		{
			if (eventEmitterFactory == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateRegistrationLocationSelector(typeof(TEventEmitter), (<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter inner) => eventEmitterFactory(inner)));
			return Self;
		}

		public StaticSerializerBuilder WithEventEmitter<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TEventEmitter>(<5b34dae8-7cb0-482e-9895-29da17adc606>WrapperFactory<<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter, <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter, TEventEmitter> eventEmitterFactory, Action<<18c7fbcc-5471-41e0-b0d5-c272fe9a2c7a>ITrackingRegistrationLocationSelectionSyntax<<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter>> where) where TEventEmitter : <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter
		{
			if (eventEmitterFactory == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateTrackingRegistrationLocationSelector(typeof(TEventEmitter), (<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter wrapped, <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter inner) => eventEmitterFactory(wrapped, inner)));
			return Self;
		}

		public StaticSerializerBuilder WithoutEventEmitter<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TEventEmitter>() where TEventEmitter : <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter
		{
			return WithoutEventEmitter(typeof(TEventEmitter));
		}

		public StaticSerializerBuilder WithoutEventEmitter(Type eventEmitterType)
		{
			if (eventEmitterType == null)
			{
				throw new ArgumentNullException("eventEmitterType");
			}
			eventEmitterFactories.Remove(eventEmitterType);
			return this;
		}

		public override StaticSerializerBuilder WithTagMapping(<baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName tag, Type type)
		{
			if (tag.IsEmpty)
			{
				throw new ArgumentException("Non-specific tags cannot be maped");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (tagMappings.TryGetValue(type, out var value))
			{
				throw new ArgumentException($"Type already has a registered tag '{value}' for type '{type.FullName}'", "type");
			}
			tagMappings.Add(type, tag);
			return this;
		}

		public StaticSerializerBuilder WithoutTagMapping(Type type)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (!tagMappings.Remove(type))
			{
				throw new KeyNotFoundException("Tag for type '" + type.FullName + "' is not registered");
			}
			return this;
		}

		public StaticSerializerBuilder EnsureRoundtrip()
		{
			objectGraphTraversalStrategyFactory = (<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector typeInspector, <14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver, IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> typeConverters, int maximumRecursion) => new <7085160d-c56a-4dea-8936-bf24bc9acd82>RoundtripObjectGraphTraversalStrategy(typeConverters, typeInspector, typeResolver, maximumRecursion, namingConvention, settings, factory);
			WithEventEmitter([<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] ([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)] <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter inner) => new <0162706c-c168-4372-b87d-6cd624ba9304>TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: true, tagMappings, quoteNecessaryStrings), delegate(<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter> loc)
			{
				loc.InsteadOf<<0162706c-c168-4372-b87d-6cd624ba9304>TypeAssigningEventEmitter>();
			});
			return WithTypeInspector([<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] ([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)] <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector inner) => new <5f4a0820-fb63-4029-9060-830ea493b4c6>ReadableAndWritablePropertiesTypeInspector(inner), delegate(<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector> loc)
			{
				loc.OnBottom();
			});
		}

		public StaticSerializerBuilder DisableAliases()
		{
			preProcessingPhaseObjectGraphVisitorFactories.Remove(typeof(<98b90ca6-9ce1-414d-957d-7e148c835587>AnchorAssigner));
			emissionPhaseObjectGraphVisitorFactories.Remove(typeof(<11170e7d-1410-4033-9bd9-a7b638764d88>AnchorAssigningObjectGraphVisitor));
			return this;
		}

		[Obsolete("The default behavior is now to always emit default values, thefore calling this method has no effect. This behavior is now controlled by ConfigureDefaultValuesHandling.", true)]
		public StaticSerializerBuilder EmitDefaults()
		{
			return ConfigureDefaultValuesHandling(<d96bfc2d-895f-47ec-bf95-11ebc61b365e>DefaultValuesHandling.Preserve);
		}

		public StaticSerializerBuilder ConfigureDefaultValuesHandling(<d96bfc2d-895f-47ec-bf95-11ebc61b365e>DefaultValuesHandling configuration)
		{
			defaultValuesHandlingConfiguration = configuration;
			return this;
		}

		public StaticSerializerBuilder JsonCompatible()
		{
			emitterSettings = emitterSettings.WithMaxSimpleKeyLength(int.MaxValue).WithoutAnchorName();
			return WithTypeConverter(new <2d47cdac-8cd8-47ea-80bc-fc9e84fda98a>GuidConverter(jsonCompatible: true), delegate(<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> w)
			{
				w.InsteadOf<<2d47cdac-8cd8-47ea-80bc-fc9e84fda98a>GuidConverter>();
			}).WithEventEmitter([<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] ([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)] <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter inner) => new <a013011b-1d74-4c39-8dc3-1737c7dda292>JsonEventEmitter(inner), delegate(<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter> loc)
			{
				loc.InsteadOf<<0162706c-c168-4372-b87d-6cd624ba9304>TypeAssigningEventEmitter>();
			});
		}

		public StaticSerializerBuilder WithNewLine(string newLine)
		{
			emitterSettings = emitterSettings.WithNewLine(newLine);
			return this;
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor, Action<<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>>> where) where TObjectGraphVisitor : <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>
		{
			if (objectGraphVisitor == null)
			{
				throw new ArgumentNullException("objectGraphVisitor");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> _) => objectGraphVisitor));
			return this;
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TObjectGraphVisitor>(<3b4b8ccf-3e0d-4ddf-8f1c-125fe84d2bc4>WrapperFactory<<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<<18c7fbcc-5471-41e0-b0d5-c272fe9a2c7a>ITrackingRegistrationLocationSelectionSyntax<<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>>> where) where TObjectGraphVisitor : <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing> wrapped, IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> _) => objectGraphVisitorFactory(wrapped)));
			return this;
		}

		public StaticSerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TObjectGraphVisitor>() where TObjectGraphVisitor : <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>
		{
			return WithoutPreProcessingPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

		public StaticSerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor(Type objectGraphVisitorType)
		{
			if (objectGraphVisitorType == null)
			{
				throw new ArgumentNullException("objectGraphVisitorType");
			}
			preProcessingPhaseObjectGraphVisitorFactories.Remove(objectGraphVisitorType);
			return this;
		}

		public StaticSerializerBuilder WithObjectGraphTraversalStrategyFactory(<51a5294e-6c04-4723-b54f-249688f55c36>ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory)
		{
			this.objectGraphTraversalStrategyFactory = objectGraphTraversalStrategyFactory;
			return this;
		}

		public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TObjectGraphVisitor>(Func<<a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>
		{
			return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TObjectGraphVisitor>(Func<<a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory, Action<<47e77585-e8c5-4663-a54e-df1a8444a949>IRegistrationLocationSelectionSyntax<<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>>> where) where TObjectGraphVisitor : <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (<a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(args)));
			return this;
		}

		public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TObjectGraphVisitor>(<5b34dae8-7cb0-482e-9895-29da17adc606>WrapperFactory<<a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<<18c7fbcc-5471-41e0-b0d5-c272fe9a2c7a>ITrackingRegistrationLocationSelectionSyntax<<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>>> where) where TObjectGraphVisitor : <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter> wrapped, <a1227bfb-5016-4e8b-b4ff-8c1bc27a7130>EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(wrapped, args)));
			return this;
		}

		public StaticSerializerBuilder WithoutEmissionPhaseObjectGraphVisitor<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] TObjectGraphVisitor>() where TObjectGraphVisitor : <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>
		{
			return WithoutEmissionPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

		public StaticSerializerBuilder WithoutEmissionPhaseObjectGraphVisitor(Type objectGraphVisitorType)
		{
			if (objectGraphVisitorType == null)
			{
				throw new ArgumentNullException("objectGraphVisitorType");
			}
			emissionPhaseObjectGraphVisitorFactories.Remove(objectGraphVisitorType);
			return this;
		}

		public StaticSerializerBuilder WithIndentedSequences()
		{
			emitterSettings = emitterSettings.WithIndentedSequences();
			return this;
		}

		public <fa87965e-2f74-48c8-a278-adcafb2bdf38>ISerializer Build()
		{
			return <00138ba2-bdcc-48d5-834b-0b360fe71e37>Serializer.FromValueSerializer(BuildValueSerializer(), emitterSettings);
		}

		public <dcd8bcd4-89a2-444e-9230-d5bc88209068>IValueSerializer BuildValueSerializer()
		{
			IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> typeConverters = BuildTypeConverters();
			<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector typeInspector = BuildTypeInspector();
			<451614b3-1a11-4438-915e-8375d51a70af>IObjectGraphTraversalStrategy traversalStrategy = objectGraphTraversalStrategyFactory(typeInspector, typeResolver, typeConverters, maximumRecursion);
			<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter eventEmitter = eventEmitterFactories.BuildComponentChain(new <7f037384-521e-4d90-8f63-105fac34d3ce>WriterEventEmitter());
			return new ValueSerializer(traversalStrategy, eventEmitter, typeConverters, preProcessingPhaseObjectGraphVisitorFactories.Clone(), emissionPhaseObjectGraphVisitorFactories.Clone());
		}

		internal <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector BuildTypeInspector()
		{
			<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector typeInspector = context.GetTypeInspector();
			return typeInspectorFactories.BuildComponentChain(typeInspector);
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <80487089-973b-4e02-8633-ddde8572a02b>StreamFragment : <f8718f3a-c5b2-48c8-81a0-662be8a96cd4>IYamlConvertible
	{
		private readonly List<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> events = new List<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent>();

		public IList<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> Events => events;

		void <f8718f3a-c5b2-48c8-81a0-662be8a96cd4>IYamlConvertible.Read(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type expectedType, <97d1143a-e250-473f-8f49-4efad2c2274e>ObjectDeserializer nestedObjectDeserializer)
		{
			events.Clear();
			int num = 0;
			do
			{
				if (!parser.MoveNext())
				{
					throw new InvalidOperationException("The parser has reached the end before deserialization completed.");
				}
				<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent current = parser.Current;
				events.Add(current);
				num += current.NestingIncrease;
			}
			while (num > 0);
		}

		void <f8718f3a-c5b2-48c8-81a0-662be8a96cd4>IYamlConvertible.Write(<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, <50dc5b9c-d2ff-457e-b37e-4022fe8e6bb7>ObjectSerializer nestedObjectSerializer)
		{
			foreach (<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent @event in events)
			{
				emitter.Emit(@event);
			}
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <2b079a69-2f24-4d27-84ba-7dd242a275a6>TagMappings
	{
		private readonly IDictionary<string, Type> mappings;

		public <2b079a69-2f24-4d27-84ba-7dd242a275a6>TagMappings()
		{
			mappings = new Dictionary<string, Type>();
		}

		public <2b079a69-2f24-4d27-84ba-7dd242a275a6>TagMappings(IDictionary<string, Type> mappings)
		{
			this.mappings = new Dictionary<string, Type>(mappings);
		}

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

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		internal Type GetMapping(string tag)
		{
			if (!mappings.TryGetValue(tag, out var value))
			{
				return null;
			}
			return value;
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <95222622-92e5-4d75-ae5b-5dd10bb21ec7>YamlAttributeOverrides
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
		private struct AttributeKey
		{
			public readonly Type AttributeType;

			public readonly string PropertyName;

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

			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>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 <21fc5b2a-a319-41bc-aa9e-d22bcde3f1bb>HashCode.CombineHashCodes(AttributeType.GetHashCode(), PropertyName.GetHashCode());
			}
		}

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
		private sealed class AttributeMapping
		{
			public readonly Type RegisteredType;

			public readonly Attribute Attribute;

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

			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>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 <21fc5b2a-a319-41bc-aa9e-d22bcde3f1bb>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 = <397f8e31-bc53-4ed5-b3c2-66ee3558e043>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: <5efc7cea-0044-4fef-8184-8756b06de675>MaybeNull]
		public T GetAttribute<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>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 <95222622-92e5-4d75-ae5b-5dd10bb21ec7>YamlAttributeOverrides Clone()
		{
			<95222622-92e5-4d75-ae5b-5dd10bb21ec7>YamlAttributeOverrides <95222622-92e5-4d75-ae5b-5dd10bb21ec7>YamlAttributeOverrides2 = new <95222622-92e5-4d75-ae5b-5dd10bb21ec7>YamlAttributeOverrides();
			foreach (KeyValuePair<AttributeKey, List<AttributeMapping>> @override in overrides)
			{
				foreach (AttributeMapping item in @override.Value)
				{
					<95222622-92e5-4d75-ae5b-5dd10bb21ec7>YamlAttributeOverrides2.Add(item.RegisteredType, @override.Key.PropertyName, item.Attribute);
				}
			}
			return <95222622-92e5-4d75-ae5b-5dd10bb21ec7>YamlAttributeOverrides2;
		}

		public void Add<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
		{
			PropertyInfo propertyInfo = <1873258d-de35-4233-8cfd-9997f357849b>ExpressionExtensions.AsProperty(propertyAccessor);
			Add(typeof(TClass), propertyInfo.Name, attribute);
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <6cf47502-3232-429d-9da0-30ce8271ebb5>YamlAttributeOverridesInspector : <ce77702a-669b-49af-a854-357c1c442358>TypeInspectorSkeleton
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
		public sealed class OverridePropertyDescriptor : <1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor
		{
			private readonly <1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor baseDescriptor;

			private readonly <95222622-92e5-4d75-ae5b-5dd10bb21ec7>YamlAttributeOverrides overrides;

			private readonly Type classType;

			public string Name => baseDescriptor.Name;

			public bool CanWrite => baseDescriptor.CanWrite;

			public Type Type => baseDescriptor.Type;

			[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
			public Type TypeOverride
			{
				[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
				get
				{
					return baseDescriptor.TypeOverride;
				}
				[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
				set
				{
					baseDescriptor.TypeOverride = value;
				}
			}

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

			public <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle ScalarStyle
			{
				get
				{
					return baseDescriptor.ScalarStyle;
				}
				set
				{
					baseDescriptor.ScalarStyle = value;
				}
			}

			public OverridePropertyDescriptor(<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor baseDescriptor, <95222622-92e5-4d75-ae5b-5dd10bb21ec7>YamlAttributeOverrides overrides, Type classType)
			{
				this.baseDescriptor = baseDescriptor;
				this.overrides = overrides;
				this.classType = classType;
			}

			public void Write(object target, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object value)
			{
				baseDescriptor.Write(target, value);
			}

			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)]
			[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
			public T GetCustomAttribute<T>() where T : Attribute
			{
				return overrides.GetAttribute<T>(classType, Name) ?? baseDescriptor.GetCustomAttribute<T>();
			}

			public <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor Read(object target)
			{
				return baseDescriptor.Read(target);
			}
		}

		private readonly <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector innerTypeDescriptor;

		private readonly <95222622-92e5-4d75-ae5b-5dd10bb21ec7>YamlAttributeOverrides overrides;

		public <6cf47502-3232-429d-9da0-30ce8271ebb5>YamlAttributeOverridesInspector(<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector innerTypeDescriptor, <95222622-92e5-4d75-ae5b-5dd10bb21ec7>YamlAttributeOverrides overrides)
		{
			this.innerTypeDescriptor = innerTypeDescriptor;
			this.overrides = overrides;
		}

		public override IEnumerable<<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor> GetProperties(Type type, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object container)
		{
			IEnumerable<<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor> enumerable = innerTypeDescriptor.GetProperties(type, container);
			if (overrides != null)
			{
				enumerable = enumerable.Select((Func<<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor, <1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor>)([<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] (<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor p) => new OverridePropertyDescriptor(p, overrides, type)));
			}
			return enumerable;
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <f79f0abc-db6f-40db-84ad-92e6ecbd9879>YamlAttributesTypeInspector : <ce77702a-669b-49af-a854-357c1c442358>TypeInspectorSkeleton
	{
		private readonly <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector innerTypeDescriptor;

		public <f79f0abc-db6f-40db-84ad-92e6ecbd9879>YamlAttributesTypeInspector(<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor;
		}

		public override IEnumerable<<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor> GetProperties(Type type, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object container)
		{
			return from p in (from p in innerTypeDescriptor.GetProperties(type, container)
					where p.GetCustomAttribute<<0365ec82-14b2-4d3b-ad2e-219a12166be7>YamlIgnoreAttribute>() == null
					select p).Select((Func<<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor, <1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor>)([<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] (<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor p) =>
				{
					<7b7ba259-eb90-4bac-b4bd-d47c702c44fe>PropertyDescriptor <7b7ba259-eb90-4bac-b4bd-d47c702c44fe>PropertyDescriptor2 = new <7b7ba259-eb90-4bac-b4bd-d47c702c44fe>PropertyDescriptor(p);
					<3b061578-1c2d-47ce-b7cd-113442ebd8d4>YamlMemberAttribute customAttribute = p.GetCustomAttribute<<3b061578-1c2d-47ce-b7cd-113442ebd8d4>YamlMemberAttribute>();
					if (customAttribute != null)
					{
						if (customAttribute.SerializeAs != null)
						{
							<7b7ba259-eb90-4bac-b4bd-d47c702c44fe>PropertyDescriptor2.TypeOverride = customAttribute.SerializeAs;
						}
						<7b7ba259-eb90-4bac-b4bd-d47c702c44fe>PropertyDescriptor2.Order = customAttribute.Order;
						<7b7ba259-eb90-4bac-b4bd-d47c702c44fe>PropertyDescriptor2.ScalarStyle = customAttribute.ScalarStyle;
						if (customAttribute.Alias != null)
						{
							<7b7ba259-eb90-4bac-b4bd-d47c702c44fe>PropertyDescriptor2.Name = customAttribute.Alias;
						}
					}
					return <7b7ba259-eb90-4bac-b4bd-d47c702c44fe>PropertyDescriptor2;
				}))
				orderby p.Order
				select p;
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal static class <871006a4-e3e9-4119-89bb-05c311a2f23b>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("G", NumberFormat);
		}

		public static string FormatNumber(float number)
		{
			return number.ToString("G", 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 <0365ec82-14b2-4d3b-ad2e-219a12166be7>YamlIgnoreAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
	internal sealed class <3b061578-1c2d-47ce-b7cd-113442ebd8d4>YamlMemberAttribute : Attribute
	{
		private <d96bfc2d-895f-47ec-bf95-11ebc61b365e>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 <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle ScalarStyle { get; set; }

		public <d96bfc2d-895f-47ec-bf95-11ebc61b365e>DefaultValuesHandling DefaultValuesHandling
		{
			get
			{
				return defaultValuesHandling.GetValueOrDefault();
			}
			set
			{
				defaultValuesHandling = value;
			}
		}

		public bool IsDefaultValuesHandlingSpecified => defaultValuesHandling.HasValue;

		public <3b061578-1c2d-47ce-b7cd-113442ebd8d4>YamlMemberAttribute()
		{
			ScalarStyle = <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Any;
			ApplyNamingConventions = true;
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public <3b061578-1c2d-47ce-b7cd-113442ebd8d4>YamlMemberAttribute(Type serializeAs)
			: this()
		{
			SerializeAs = serializeAs ?? throw new ArgumentNullException("serializeAs");
		}
	}
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	internal sealed class YamlSerializableAttribute : Attribute
	{
	}
	internal sealed class YamlStaticContextAttribute : Attribute
	{
	}
}
namespace YamlDotNet.Serialization.ValueDeserializers
{
	internal sealed class <830bb613-9eea-4f2e-87ee-70baa6fa5839>AliasValueDeserializer : <5859ace3-9e9b-4c5b-b336-e1564105a8fe>IValueDeserializer
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 0, 1 })]
		private sealed class AliasState : Dictionary<<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName, ValuePromise>, <2ee3d4a8-e399-4226-ab9a-19e2a0910026>IPostDeserializationCallback
		{
			public void OnDeserialization()
			{
				foreach (ValuePromise value in base.Values)
				{
					if (!value.HasValue)
					{
						<4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias alias = value.Alias;
						<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = alias.Start;
						<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = alias.End;
						throw new <4f2cacbe-02ea-431a-887c-d7f399046b70>AnchorNotFoundException(in start, in end, $"Anchor '{alias.Value}' not found");
					}
				}
			}
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
		private sealed class ValuePromise : <0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise
		{
			private object value;

			public readonly <4a137d3c-94b4-4797-9632-45f2b51012ac>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;

			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
			public ValuePromise(<4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias alias)
			{
				Alias = alias;
			}

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

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)]
		private readonly <5859ace3-9e9b-4c5b-b336-e1564105a8fe>IValueDeserializer innerDeserializer;

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public <830bb613-9eea-4f2e-87ee-70baa6fa5839>AliasValueDeserializer(<5859ace3-9e9b-4c5b-b336-e1564105a8fe>IValueDeserializer innerDeserializer)
		{
			this.innerDeserializer = innerDeserializer ?? throw new ArgumentNullException("innerDeserializer");
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public object DeserializeValue(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type expectedType, <03887f38-5396-46ae-aa15-aa9d9e2cc48b>SerializerState state, <5859ace3-9e9b-4c5b-b336-e1564105a8fe>IValueDeserializer nestedObjectDeserializer)
		{
			if (parser.TryConsume<<4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias>(out var @event))
			{
				if (!state.Get<AliasState>().TryGetValue(@event.Value, out var value))
				{
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = @event.Start;
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = @event.End;
					throw new <4f2cacbe-02ea-431a-887c-d7f399046b70>AnchorNotFoundException(in start, in end, $"Alias ${@event.Value} cannot precede anchor declaration");
				}
				if (!value.HasValue)
				{
					return value;
				}
				return value.Value;
			}
			<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName = <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName.Empty;
			if (parser.Accept<<17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent>(out var event2) && !event2.Anchor.IsEmpty)
			{
				<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName = event2.Anchor;
				AliasState aliasState = state.Get<AliasState>();
				if (!aliasState.ContainsKey(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName))
				{
					aliasState[<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName] = new ValuePromise(new <4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName));
				}
			}
			object obj = innerDeserializer.DeserializeValue(parser, expectedType, state, nestedObjectDeserializer);
			if (!<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName.IsEmpty)
			{
				AliasState aliasState2 = state.Get<AliasState>();
				if (!aliasState2.TryGetValue(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName, out var value2))
				{
					aliasState2.Add(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName, new ValuePromise(obj));
				}
				else if (!value2.HasValue)
				{
					value2.Value = obj;
				}
				else
				{
					aliasState2[<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName] = new ValuePromise(obj);
				}
			}
			return obj;
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <303d59cf-a252-4573-a9ae-9a1656455601>NodeValueDeserializer : <5859ace3-9e9b-4c5b-b336-e1564105a8fe>IValueDeserializer
	{
		private readonly IList<<1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer> deserializers;

		private readonly IList<<65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver> typeResolvers;

		private readonly ITypeConverter typeConverter;

		public <303d59cf-a252-4573-a9ae-9a1656455601>NodeValueDeserializer(IList<<1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer> deserializers, IList<<65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver> typeResolvers, ITypeConverter typeConverter)
		{
			this.deserializers = deserializers ?? throw new ArgumentNullException("deserializers");
			this.typeResolvers = typeResolvers ?? throw new ArgumentNullException("typeResolvers");
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
		}

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public object DeserializeValue(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type expectedType, <03887f38-5396-46ae-aa15-aa9d9e2cc48b>SerializerState state, <5859ace3-9e9b-4c5b-b336-e1564105a8fe>IValueDeserializer nestedObjectDeserializer)
		{
			parser.Accept<<17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent>(out var @event);
			Type typeFromEvent = GetTypeFromEvent(@event, expectedType);
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start;
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end;
			try
			{
				foreach (<1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer deserializer in deserializers)
				{
					if (deserializer.Deserialize(parser, typeFromEvent, [return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] (<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser r, Type t) => nestedObjectDeserializer.DeserializeValue(r, t, state, nestedObjectDeserializer), out var value))
					{
						return typeConverter.ChangeType(value, expectedType);
					}
				}
			}
			catch (<04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException)
			{
				throw;
			}
			catch (Exception innerException)
			{
				start = @event?.Start ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
				end = @event?.End ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
				throw new <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException(in start, in end, "Exception during deserialization", innerException);
			}
			start = @event?.Start ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
			end = @event?.End ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
			throw new <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException(in start, in end, "No node deserializer was able to deserialize the node into type " + expectedType.AssemblyQualifiedName);
		}

		private Type GetTypeFromEvent([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] <17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent nodeEvent, Type currentType)
		{
			using (IEnumerator<<65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver> enumerator = typeResolvers.GetEnumerator())
			{
				while (enumerator.MoveNext() && !enumerator.Current.Resolve(nodeEvent, ref currentType))
				{
				}
			}
			return currentType;
		}
	}
}
namespace YamlDotNet.Serialization.Utilities
{
	internal interface <2ee3d4a8-e399-4226-ab9a-19e2a0910026>IPostDeserializationCallback
	{
		void OnDeserialization();
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
	internal interface ITypeConverter
	{
		object ChangeType(object value, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)] Type expectedType);
	}
	internal class NullTypeConverter : ITypeConverter
	{
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		public object ChangeType(object value, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)] Type expectedType)
		{
			return value;
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <447faaa9-2c61-419d-b207-f18985844243>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 <4f2cacbe-02ea-431a-887c-d7f399046b70>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, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)][<6977aacd-47a7-4a01-9bad-79c003aa1e36>MaybeNullWhen(false)] out string anchor)
		{
			return anchorsByObject.TryGetValue(@object, out anchor);
		}
	}
	internal class ReflectionTypeConverter : ITypeConverter
	{
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		public object ChangeType(object value, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)] Type expectedType)
		{
			return <cf96cff7-b788-4106-93c9-ac54ad4b0b54>TypeConverter.ChangeType(value, expectedType);
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal static class <116a4c16-eb91-45b6-a334-9f92a0f8daa6>ReflectionUtility
	{
		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public static Type GetImplementedGenericInterface(Type type, Type genericInterfaceType)
		{
			foreach (Type implementedInterface in GetImplementedInterfaces(type))
			{
				if (<397f8e31-bc53-4ed5-b3c2-66ee3558e043>ReflectionExtensions.IsGenericType(implementedInterface) && implementedInterface.GetGenericTypeDefinition() == genericInterfaceType)
				{
					return implementedInterface;
				}
			}
			return null;
		}

		public static IEnumerable<Type> GetImplementedInterfaces(Type type)
		{
			if (<397f8e31-bc53-4ed5-b3c2-66ee3558e043>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 <03887f38-5396-46ae-aa15-aa9d9e2cc48b>SerializerState : IDisposable
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)]
		private readonly IDictionary<Type, object> items = new Dictionary<Type, object>();

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>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 (<2ee3d4a8-e399-4226-ab9a-19e2a0910026>IPostDeserializationCallback item in items.Values.OfType<<2ee3d4a8-e399-4226-ab9a-19e2a0910026>IPostDeserializationCallback>())
			{
				item.OnDeserialization();
			}
		}

		public void Dispose()
		{
			foreach (IDisposable item in items.Values.OfType<IDisposable>())
			{
				item.Dispose();
			}
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal static class <f9ad53fc-722b-4cfe-a20e-bc720aec636c>StringExtensions
	{
		private static string ToCamelOrPascalCase(string str, Func<char, char> firstLetterTransform)
		{
			string text = Regex.Replace(str, "([_\\-])(?<char>[a-z])", [<b36caba6-ec7b-49e8-8641-5a4015501a0a>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])", [<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] (Match match) => separator + match.Groups["char"].Value.ToLowerInvariant());
			return str;
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal static class <cf96cff7-b788-4106-93c9-ac54ad4b0b54>TypeConverter
	{
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)]
		public static T ChangeType<T>(object value)
		{
			return (T)ChangeType(value, typeof(T));
		}

		public static T ChangeType<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] T>([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object value, IFormatProvider provider)
		{
			return (T)ChangeType(value, typeof(T), provider);
		}

		public static T ChangeType<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] T>([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object value, CultureInfo culture)
		{
			return (T)ChangeType(value, typeof(T), culture);
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		public static object ChangeType(object value, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)] Type destinationType)
		{
			return ChangeType(value, destinationType, CultureInfo.InvariantCulture);
		}

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public static object ChangeType([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object value, Type destinationType, IFormatProvider provider)
		{
			return ChangeType(value, destinationType, new <b192bfb0-ebb2-4763-89b5-24154963710d>CultureInfoAdapter(CultureInfo.CurrentCulture, provider));
		}

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public static object ChangeType([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object value, Type destinationType, CultureInfo culture)
		{
			if (value == null || <397f8e31-bc53-4ed5-b3c2-66ee3558e043>ReflectionExtensions.IsDbNull(value))
			{
				if (!<397f8e31-bc53-4ed5-b3c2-66ee3558e043>ReflectionExtensions.IsValueType(destinationType))
				{
					return null;
				}
				return Activator.CreateInstance(destinationType);
			}
			Type type = value.GetType();
			if (destinationType == type || destinationType.IsAssignableFrom(type))
			{
				return value;
			}
			if (<397f8e31-bc53-4ed5-b3c2-66ee3558e043>ReflectionExtensions.IsGenericType(destinationType) && destinationType.GetGenericTypeDefinition() == typeof(Nullable<>))
			{
				Type destinationType2 = destinationType.GetGenericArguments()[0];
				object obj = ChangeType(value, destinationType2, culture);
				return Activator.CreateInstance(destinationType, obj);
			}
			if (<397f8e31-bc53-4ed5-b3c2-66ee3558e043>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 <397f8e31-bc53-4ed5-b3c2-66ee3558e043>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 <397f8e31-bc53-4ed5-b3c2-66ee3558e043>ReflectionExtensions.Unwrap(ex);
						}
					}
				}
			}
			if (type == typeof(string))
			{
				try
				{
					MethodInfo publicStaticMethod = <397f8e31-bc53-4ed5-b3c2-66ee3558e043>ReflectionExtensions.GetPublicStaticMethod(destinationType, "Parse", typeof(string), typeof(IFormatProvider));
					if (publicStaticMethod != null)
					{
						return publicStaticMethod.Invoke(null, new object[2] { value, culture });
					}
					publicStaticMethod = <397f8e31-bc53-4ed5-b3c2-66ee3558e043>ReflectionExtensions.GetPublicStaticMethod(destinationType, "Parse", typeof(string));
					if (publicStaticMethod != null)
					{
						return publicStaticMethod.Invoke(null, new object[1] { value });
					}
				}
				catch (TargetInvocationException ex2)
				{
					throw <397f8e31-bc53-4ed5-b3c2-66ee3558e043>ReflectionExtensions.Unwrap(ex2);
				}
			}
			if (destinationType == typeof(TimeSpan))
			{
				return TimeSpan.Parse((string)ChangeType(value, typeof(string), CultureInfo.InvariantCulture));
			}
			return Convert.ChangeType(value, destinationType, CultureInfo.InvariantCulture);
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)]
		public static void RegisterTypeConverter<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TConvertible, TConverter>() where TConverter : System.ComponentModel.TypeConverter
		{
			if (!TypeDescriptor.GetAttributes(typeof(TConvertible)).OfType<TypeConverterAttribute>().Any([<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] (TypeConverterAttribute a) => a.ConverterTypeName == typeof(TConverter).AssemblyQualifiedName))
			{
				TypeDescriptor.AddAttributes(typeof(TConvertible), new TypeConverterAttribute(typeof(TConverter)));
			}
		}
	}
}
namespace YamlDotNet.Serialization.TypeResolvers
{
	internal sealed class <af98e88d-b15d-458f-a37e-68cd41982196>DynamicTypeResolver : <14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver
	{
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public Type Resolve(Type staticType, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object actualValue)
		{
			if (actualValue == null)
			{
				return staticType;
			}
			return actualValue.GetType();
		}
	}
	internal sealed class <98465f71-96c8-45ed-8b91-ff3d452bf125>StaticTypeResolver : <14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver
	{
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public Type Resolve(Type staticType, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object actualValue)
		{
			return staticType;
		}
	}
}
namespace YamlDotNet.Serialization.TypeInspectors
{
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <beb62730-abb8-4cf4-a3cd-ff1d2c9c0107>CachedTypeInspector : <ce77702a-669b-49af-a854-357c1c442358>TypeInspectorSkeleton
	{
		private readonly <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector innerTypeDescriptor;

		private readonly ConcurrentDictionary<Type, List<<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor>> cache = new ConcurrentDictionary<Type, List<<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor>>();

		public <beb62730-abb8-4cf4-a3cd-ff1d2c9c0107>CachedTypeInspector(<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
		}

		public override IEnumerable<<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor> GetProperties(Type type, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object container)
		{
			return cache.GetOrAdd(type, (Type t) => innerTypeDescriptor.GetProperties(t, container).ToList());
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <e78c014d-f9c5-476e-b4d3-4ceeb2c3903a>CompositeTypeInspector : <ce77702a-669b-49af-a854-357c1c442358>TypeInspectorSkeleton
	{
		private readonly IEnumerable<<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector> typeInspectors;

		public <e78c014d-f9c5-476e-b4d3-4ceeb2c3903a>CompositeTypeInspector(params <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector[] typeInspectors)
			: this((IEnumerable<<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector>)typeInspectors)
		{
		}

		public <e78c014d-f9c5-476e-b4d3-4ceeb2c3903a>CompositeTypeInspector(IEnumerable<<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector> typeInspectors)
		{
			this.typeInspectors = typeInspectors?.ToList() ?? throw new ArgumentNullException("typeInspectors");
		}

		public override IEnumerable<<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor> GetProperties(Type type, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object container)
		{
			return typeInspectors.SelectMany([<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] (<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector i) => i.GetProperties(type, container));
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <9758241b-18f7-4060-9d08-5ab47a363edd>NamingConventionTypeInspector : <ce77702a-669b-49af-a854-357c1c442358>TypeInspectorSkeleton
	{
		private readonly <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector innerTypeDescriptor;

		private readonly <4ecad175-097b-490b-92b5-e349039d0335>INamingConvention namingConvention;

		public <9758241b-18f7-4060-9d08-5ab47a363edd>NamingConventionTypeInspector(<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector innerTypeDescriptor, <4ecad175-097b-490b-92b5-e349039d0335>INamingConvention namingConvention)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
		}

		public override IEnumerable<<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor> GetProperties(Type type, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object container)
		{
			return innerTypeDescriptor.GetProperties(type, container).Select([<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] (<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor p) =>
			{
				<3b061578-1c2d-47ce-b7cd-113442ebd8d4>YamlMemberAttribute customAttribute = p.GetCustomAttribute<<3b061578-1c2d-47ce-b7cd-113442ebd8d4>YamlMemberAttribute>();
				return (customAttribute != null && !customAttribute.ApplyNamingConventions) ? p : new <7b7ba259-eb90-4bac-b4bd-d47c702c44fe>PropertyDescriptor(p)
				{
					Name = namingConvention.Apply(p.Name)
				};
			});
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <5f4a0820-fb63-4029-9060-830ea493b4c6>ReadableAndWritablePropertiesTypeInspector : <ce77702a-669b-49af-a854-357c1c442358>TypeInspectorSkeleton
	{
		private readonly <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector innerTypeDescriptor;

		public <5f4a0820-fb63-4029-9060-830ea493b4c6>ReadableAndWritablePropertiesTypeInspector(<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
		}

		public override IEnumerable<<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor> GetProperties(Type type, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object container)
		{
			return from p in innerTypeDescriptor.GetProperties(type, container)
				where p.CanWrite
				select p;
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <c9af07c0-1e0a-4091-9acc-16646a8d71a0>ReadableFieldsTypeInspector : <ce77702a-669b-49af-a854-357c1c442358>TypeInspectorSkeleton
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
		private sealed class ReflectionFieldDescriptor : <1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor
		{
			private readonly FieldInfo fieldInfo;

			private readonly <14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver;

			public string Name => fieldInfo.Name;

			public Type Type => fieldInfo.FieldType;

			[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
			[field: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
			public Type TypeOverride
			{
				[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
				get;
				[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
				set;
			}

			public int Order { get; set; }

			public bool CanWrite => !fieldInfo.IsInitOnly;

			public <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle ScalarStyle { get; set; }

			public ReflectionFieldDescriptor(FieldInfo fieldInfo, <14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver)
			{
				this.fieldInfo = fieldInfo;
				this.typeResolver = typeResolver;
				ScalarStyle = <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Any;
			}

			public void Write(object target, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object value)
			{
				fieldInfo.SetValue(target, value);
			}

			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)]
			[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
			public T GetCustomAttribute<T>() where T : Attribute
			{
				return (T)fieldInfo.GetCustomAttributes(typeof(T), inherit: true).FirstOrDefault();
			}

			public <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor Read(object target)
			{
				object value = fieldInfo.GetValue(target);
				Type type = TypeOverride ?? typeResolver.Resolve(Type, value);
				return new <256cfd2a-7986-41ec-9ef1-d630af4cf0a3>ObjectDescriptor(value, type, Type, ScalarStyle);
			}
		}

		private readonly <14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver;

		public <c9af07c0-1e0a-4091-9acc-16646a8d71a0>ReadableFieldsTypeInspector(<14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
		}

		public override IEnumerable<<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor> GetProperties(Type type, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object container)
		{
			return <397f8e31-bc53-4ed5-b3c2-66ee3558e043>ReflectionExtensions.GetPublicFields(type).Select((Func<FieldInfo, <1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor>)([<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] (FieldInfo p) => new ReflectionFieldDescriptor(p, typeResolver)));
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <ac823e26-ce2a-4b5b-a91b-fd564c61fdc6>ReadablePropertiesTypeInspector : <ce77702a-669b-49af-a854-357c1c442358>TypeInspectorSkeleton
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
		private sealed class ReflectionPropertyDescriptor : <1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor
		{
			private readonly PropertyInfo propertyInfo;

			private readonly <14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver;

			public string Name => propertyInfo.Name;

			public Type Type => propertyInfo.PropertyType;

			[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
			[field: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
			public Type TypeOverride
			{
				[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
				get;
				[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
				set;
			}

			public int Order { get; set; }

			public bool CanWrite => propertyInfo.CanWrite;

			public <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle ScalarStyle { get; set; }

			public ReflectionPropertyDescriptor(PropertyInfo propertyInfo, <14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver)
			{
				this.propertyInfo = propertyInfo ?? throw new ArgumentNullException("propertyInfo");
				this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
				ScalarStyle = <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Any;
			}

			public void Write(object target, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object value)
			{
				propertyInfo.SetValue(target, value, null);
			}

			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)]
			[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
			public T GetCustomAttribute<T>() where T : Attribute
			{
				return (T)<397f8e31-bc53-4ed5-b3c2-66ee3558e043>ReflectionExtensions.GetAllCustomAttributes<T>(propertyInfo).FirstOrDefault();
			}

			public <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor Read(object target)
			{
				object obj = <1beb23a3-6fe4-4b3c-89b3-727b095fd6be>PropertyInfoExtensions.ReadValue(propertyInfo, target);
				Type type = TypeOverride ?? typeResolver.Resolve(Type, obj);
				return new <256cfd2a-7986-41ec-9ef1-d630af4cf0a3>ObjectDescriptor(obj, type, Type, ScalarStyle);
			}
		}

		private readonly <14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver;

		private readonly bool includeNonPublicProperties;

		public <ac823e26-ce2a-4b5b-a91b-fd564c61fdc6>ReadablePropertiesTypeInspector(<14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver)
			: this(typeResolver, includeNonPublicProperties: false)
		{
		}

		public <ac823e26-ce2a-4b5b-a91b-fd564c61fdc6>ReadablePropertiesTypeInspector(<14060048-8e54-421e-b15b-83ddeb716cfe>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<<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor> GetProperties(Type type, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object container)
		{
			return <397f8e31-bc53-4ed5-b3c2-66ee3558e043>ReflectionExtensions.GetProperties(type, includeNonPublicProperties).Where(IsValidProperty).Select((Func<PropertyInfo, <1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor>)([<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] (PropertyInfo p) => new ReflectionPropertyDescriptor(p, typeResolver)));
		}
	}
	internal abstract class <ce77702a-669b-49af-a854-357c1c442358>TypeInspectorSkeleton : <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector
	{
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public abstract IEnumerable<<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor> GetProperties(Type type, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object container);

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public <1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor GetProperty(Type type, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object container, string name, [<6977aacd-47a7-4a01-9bad-79c003aa1e36>MaybeNullWhen(true)] bool ignoreUnmatched)
		{
			IEnumerable<<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor> enumerable = from p in GetProperties(type, container)
				where p.Name == name
				select p;
			using IEnumerator<<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor> enumerator = enumerable.GetEnumerator();
			if (!enumerator.MoveNext())
			{
				if (ignoreUnmatched)
				{
					return null;
				}
				throw new SerializationException("Property '" + name + "' not found on type '" + type.FullName + "'.");
			}
			<1955fdce-5a73-4715-9a1e-627d62658b8d>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((<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor p) => p.Name).ToArray()));
			}
			return current;
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class WritablePropertiesTypeInspector : <ce77702a-669b-49af-a854-357c1c442358>TypeInspectorSkeleton
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
		private sealed class ReflectionPropertyDescriptor : <1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor
		{
			private readonly PropertyInfo propertyInfo;

			private readonly <14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver;

			public string Name => propertyInfo.Name;

			public Type Type => propertyInfo.PropertyType;

			[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
			[field: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
			public Type TypeOverride
			{
				[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
				get;
				[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
				set;
			}

			public int Order { get; set; }

			public bool CanWrite => propertyInfo.CanWrite;

			public <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle ScalarStyle { get; set; }

			public ReflectionPropertyDescriptor(PropertyInfo propertyInfo, <14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver)
			{
				this.propertyInfo = propertyInfo ?? throw new ArgumentNullException("propertyInfo");
				this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
				ScalarStyle = <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Any;
			}

			public void Write(object target, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object value)
			{
				propertyInfo.SetValue(target, value, null);
			}

			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)]
			[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
			public T GetCustomAttribute<T>() where T : Attribute
			{
				return (T)<397f8e31-bc53-4ed5-b3c2-66ee3558e043>ReflectionExtensions.GetAllCustomAttributes<T>(propertyInfo).FirstOrDefault();
			}

			public <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor Read(object target)
			{
				object obj = <1beb23a3-6fe4-4b3c-89b3-727b095fd6be>PropertyInfoExtensions.ReadValue(propertyInfo, target);
				Type type = TypeOverride ?? typeResolver.Resolve(Type, obj);
				return new <256cfd2a-7986-41ec-9ef1-d630af4cf0a3>ObjectDescriptor(obj, type, Type, ScalarStyle);
			}
		}

		private readonly <14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver;

		private readonly bool includeNonPublicProperties;

		public WritablePropertiesTypeInspector(<14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver)
			: this(typeResolver, includeNonPublicProperties: false)
		{
		}

		public WritablePropertiesTypeInspector(<14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver, bool includeNonPublicProperties)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			this.includeNonPublicProperties = includeNonPublicProperties;
		}

		private static bool IsValidProperty(PropertyInfo property)
		{
			if (property.CanWrite)
			{
				return property.GetSetMethod(nonPublic: true).GetParameters().Length == 1;
			}
			return false;
		}

		public override IEnumerable<<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor> GetProperties(Type type, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object container)
		{
			return <397f8e31-bc53-4ed5-b3c2-66ee3558e043>ReflectionExtensions.GetProperties(type, includeNonPublicProperties).Where(IsValidProperty).Select((Func<PropertyInfo, <1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor>)([<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] (PropertyInfo p) => new ReflectionPropertyDescriptor(p, typeResolver)))
				.ToArray();
		}
	}
}
namespace YamlDotNet.Serialization.Schemas
{
	internal sealed class <4cc800bb-1836-48cd-a3e0-17306397eb4e>FailsafeSchema
	{
		public static class Tags
		{
			public static readonly <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName Map = new <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName("tag:yaml.org,2002:map");

			public static readonly <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName Seq = new <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName("tag:yaml.org,2002:seq");

			public static readonly <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName Str = new <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName("tag:yaml.org,2002:str");
		}
	}
	internal sealed class <fe4ef112-43d5-48b5-a3a3-86cc5a0fcc5b>JsonSchema
	{
		public static class Tags
		{
			public static readonly <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName Null = new <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName("tag:yaml.org,2002:null");

			public static readonly <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName Bool = new <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName("tag:yaml.org,2002:bool");

			public static readonly <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName Int = new <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName("tag:yaml.org,2002:int");

			public static readonly <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName Float = new <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName("tag:yaml.org,2002:float");
		}
	}
	internal sealed class <10ad59ef-8701-4b28-9748-67205d03533a>CoreSchema
	{
		public static class Tags
		{
		}
	}
	internal sealed class <81f08b43-1c97-4f9b-b979-a743caedabb3>DefaultSchema
	{
		public static class Tags
		{
			public static readonly <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName Timestamp = new <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName("tag:yaml.org,2002:timestamp");
		}
	}
}
namespace YamlDotNet.Serialization.ObjectGraphVisitors
{
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <98b90ca6-9ce1-414d-957d-7e148c835587>AnchorAssigner : <cf618026-a788-46b6-9ca7-d77117fd9a61>PreProcessingPhaseObjectGraphVisitorSkeleton, <5fd14629-aafa-4def-a300-e8bf70cd80f4>IAliasProvider
	{
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)]
		private class AnchorAssignment
		{
			public <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName Anchor;
		}

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

		private uint nextId;

		public <98b90ca6-9ce1-414d-957d-7e148c835587>AnchorAssigner(IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> typeConverters)
			: base(typeConverters)
		{
		}

		protected override bool Enter(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value)
		{
			if (value.Value != null && assignments.TryGetValue(value.Value, out var value2))
			{
				if (value2.Anchor.IsEmpty)
				{
					value2.Anchor = new <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName("o" + nextId.ToString(CultureInfo.InvariantCulture));
					nextId++;
				}
				return false;
			}
			return true;
		}

		protected override bool EnterMapping(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor key, <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value)
		{
			return true;
		}

		protected override bool EnterMapping(<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor key, <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value)
		{
			return true;
		}

		protected override void VisitScalar(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor scalar)
		{
		}

		protected override void VisitMappingStart(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor mapping, Type keyType, Type valueType)
		{
			VisitObject(mapping);
		}

		protected override void VisitMappingEnd(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor mapping)
		{
		}

		protected override void VisitSequenceStart(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor sequence, Type elementType)
		{
			VisitObject(sequence);
		}

		protected override void VisitSequenceEnd(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor sequence)
		{
		}

		private void VisitObject(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value)
		{
			if (value.Value != null)
			{
				assignments.Add(value.Value, new AnchorAssignment());
			}
		}

		<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName <5fd14629-aafa-4def-a300-e8bf70cd80f4>IAliasProvider.GetAlias(object target)
		{
			if (target != null && assignments.TryGetValue(target, out var value))
			{
				return value.Anchor;
			}
			return <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName.Empty;
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <11170e7d-1410-4033-9bd9-a7b638764d88>AnchorAssigningObjectGraphVisitor : <fcab3e7d-50b2-47b7-a64d-0165cd655833>ChainedObjectGraphVisitor
	{
		private readonly <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter eventEmitter;

		private readonly <5fd14629-aafa-4def-a300-e8bf70cd80f4>IAliasProvider aliasProvider;

		private readonly HashSet<<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName> emittedAliases = new HashSet<<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName>();

		public <11170e7d-1410-4033-9bd9-a7b638764d88>AnchorAssigningObjectGraphVisitor(<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter> nextVisitor, <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter eventEmitter, <5fd14629-aafa-4def-a300-e8bf70cd80f4>IAliasProvider aliasProvider)
			: base(nextVisitor)
		{
			this.eventEmitter = eventEmitter;
			this.aliasProvider = aliasProvider;
		}

		public override bool Enter(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter context)
		{
			if (value.Value != null)
			{
				<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName alias = aliasProvider.GetAlias(value.Value);
				if (!alias.IsEmpty && !emittedAliases.Add(alias))
				{
					<f4cbcba3-c718-4c5d-8fe8-dc444ac4fa0d>AliasEventInfo <f4cbcba3-c718-4c5d-8fe8-dc444ac4fa0d>AliasEventInfo = new <f4cbcba3-c718-4c5d-8fe8-dc444ac4fa0d>AliasEventInfo(value, alias);
					eventEmitter.Emit(<f4cbcba3-c718-4c5d-8fe8-dc444ac4fa0d>AliasEventInfo, context);
					return <f4cbcba3-c718-4c5d-8fe8-dc444ac4fa0d>AliasEventInfo.NeedsExpansion;
				}
			}
			return base.Enter(value, context);
		}

		public override void VisitMappingStart(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor mapping, Type keyType, Type valueType, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter context)
		{
			<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName alias = aliasProvider.GetAlias(mapping.NonNullValue());
			eventEmitter.Emit(new <808a48ba-4a82-4d7c-9d8a-7016aba735c4>MappingStartEventInfo(mapping)
			{
				Anchor = alias
			}, context);
		}

		public override void VisitSequenceStart(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor sequence, Type elementType, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter context)
		{
			<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName alias = aliasProvider.GetAlias(sequence.NonNullValue());
			eventEmitter.Emit(new <b57e9ab0-e846-43da-873c-969a61caa7de>SequenceStartEventInfo(sequence)
			{
				Anchor = alias
			}, context);
		}

		public override void VisitScalar(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor scalar, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter context)
		{
			<4f19da32-6bd3-477f-8fb8-71554a9f7201>ScalarEventInfo <4f19da32-6bd3-477f-8fb8-71554a9f7201>ScalarEventInfo = new <4f19da32-6bd3-477f-8fb8-71554a9f7201>ScalarEventInfo(scalar);
			if (scalar.Value != null)
			{
				<4f19da32-6bd3-477f-8fb8-71554a9f7201>ScalarEventInfo.Anchor = aliasProvider.GetAlias(scalar.Value);
			}
			eventEmitter.Emit(<4f19da32-6bd3-477f-8fb8-71554a9f7201>ScalarEventInfo, context);
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal abstract class <fcab3e7d-50b2-47b7-a64d-0165cd655833>ChainedObjectGraphVisitor : <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>
	{
		private readonly <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter> nextVisitor;

		protected <fcab3e7d-50b2-47b7-a64d-0165cd655833>ChainedObjectGraphVisitor(<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter> nextVisitor)
		{
			this.nextVisitor = nextVisitor;
		}

		public virtual bool Enter(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter context)
		{
			return nextVisitor.Enter(value, context);
		}

		public virtual bool EnterMapping(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor key, <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter context)
		{
			return nextVisitor.EnterMapping(key, value, context);
		}

		public virtual bool EnterMapping(<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor key, <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter context)
		{
			return nextVisitor.EnterMapping(key, value, context);
		}

		public virtual void VisitScalar(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor scalar, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter context)
		{
			nextVisitor.VisitScalar(scalar, context);
		}

		public virtual void VisitMappingStart(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor mapping, Type keyType, Type valueType, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter context)
		{
			nextVisitor.VisitMappingStart(mapping, keyType, valueType, context);
		}

		public virtual void VisitMappingEnd(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor mapping, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter context)
		{
			nextVisitor.VisitMappingEnd(mapping, context);
		}

		public virtual void VisitSequenceStart(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor sequence, Type elementType, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter context)
		{
			nextVisitor.VisitSequenceStart(sequence, elementType, context);
		}

		public virtual void VisitSequenceEnd(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor sequence, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter context)
		{
			nextVisitor.VisitSequenceEnd(sequence, context);
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <0b8c21d0-f0b8-4cdf-8b95-d9d5c35dbfb4>CommentsObjectGraphVisitor : <fcab3e7d-50b2-47b7-a64d-0165cd655833>ChainedObjectGraphVisitor
	{
		public <0b8c21d0-f0b8-4cdf-8b95-d9d5c35dbfb4>CommentsObjectGraphVisitor(<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		public override bool EnterMapping(<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor key, <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter context)
		{
			<3b061578-1c2d-47ce-b7cd-113442ebd8d4>YamlMemberAttribute customAttribute = key.GetCustomAttribute<<3b061578-1c2d-47ce-b7cd-113442ebd8d4>YamlMemberAttribute>();
			if (customAttribute != null && customAttribute.Description != null)
			{
				context.Emit(new <5332d915-103b-4367-bd24-5d21f0bd7d9a>Comment(customAttribute.Description, isInline: false));
			}
			return base.EnterMapping(key, value, context);
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <81f4bc1d-8977-4beb-80bc-3a86026f9535>CustomSerializationObjectGraphVisitor : <fcab3e7d-50b2-47b7-a64d-0165cd655833>ChainedObjectGraphVisitor
	{
		private readonly IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> typeConverters;

		private readonly <50dc5b9c-d2ff-457e-b37e-4022fe8e6bb7>ObjectSerializer nestedObjectSerializer;

		public <81f4bc1d-8977-4beb-80bc-3a86026f9535>CustomSerializationObjectGraphVisitor(<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter> nextVisitor, IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> typeConverters, <50dc5b9c-d2ff-457e-b37e-4022fe8e6bb7>ObjectSerializer nestedObjectSerializer)
			: base(nextVisitor)
		{
			IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> enumerable;
			if (typeConverters == null)
			{
				enumerable = Enumerable.Empty<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter>();
			}
			else
			{
				IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> enumerable2 = typeConverters.ToList();
				enumerable = enumerable2;
			}
			this.typeConverters = enumerable;
			this.nestedObjectSerializer = nestedObjectSerializer;
		}

		public override bool Enter(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter context)
		{
			<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter <ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter = typeConverters.FirstOrDefault([<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] (<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter t) => t.Accepts(value.Type));
			if (<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter != null)
			{
				<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter.WriteYaml(context, value.Value, value.Type);
				return false;
			}
			if (value.Value is <f8718f3a-c5b2-48c8-81a0-662be8a96cd4>IYamlConvertible <f8718f3a-c5b2-48c8-81a0-662be8a96cd4>IYamlConvertible)
			{
				<f8718f3a-c5b2-48c8-81a0-662be8a96cd4>IYamlConvertible.Write(context, nestedObjectSerializer);
				return false;
			}
			if (value.Value is <4b6fe5f2-3b66-4371-b16f-70d5594285af>IYamlSerializable <4b6fe5f2-3b66-4371-b16f-70d5594285af>IYamlSerializable)
			{
				<4b6fe5f2-3b66-4371-b16f-70d5594285af>IYamlSerializable.WriteYaml(context);
				return false;
			}
			return base.Enter(value, context);
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <d9d5f82a-f48e-4fc0-9027-d92a03663f7e>DefaultExclusiveObjectGraphVisitor : <fcab3e7d-50b2-47b7-a64d-0165cd655833>ChainedObjectGraphVisitor
	{
		public <d9d5f82a-f48e-4fc0-9027-d92a03663f7e>DefaultExclusiveObjectGraphVisitor(<d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		private static object GetDefault(Type type)
		{
			if (!<397f8e31-bc53-4ed5-b3c2-66ee3558e043>ReflectionExtensions.IsValueType(type))
			{
				return null;
			}
			return Activator.CreateInstance(type);
		}

		public override bool EnterMapping(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor key, <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter context)
		{
			if (!object.Equals(value.Value, GetDefault(value.Type)))
			{
				return base.EnterMapping(key, value, context);
			}
			return false;
		}

		public override bool EnterMapping(<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor key, <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>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;
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <d0f2e925-f060-42f3-b5af-477eef6eb3d5>DefaultValuesObjectGraphVisitor : <fcab3e7d-50b2-47b7-a64d-0165cd655833>ChainedObjectGraphVisitor
	{
		private readonly <d96bfc2d-895f-47ec-bf95-11ebc61b365e>DefaultValuesHandling handling;

		private readonly <2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory factory;

		public <d0f2e925-f060-42f3-b5af-477eef6eb3d5>DefaultValuesObjectGraphVisitor(<d96bfc2d-895f-47ec-bf95-11ebc61b365e>DefaultValuesHandling handling, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter> nextVisitor, <2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory factory)
			: base(nextVisitor)
		{
			this.handling = handling;
			this.factory = factory;
		}

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		private object GetDefault(Type type)
		{
			return factory.CreatePrimitive(type);
		}

		public override bool EnterMapping(<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor key, <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter context)
		{
			<d96bfc2d-895f-47ec-bf95-11ebc61b365e>DefaultValuesHandling defaultValuesHandling = handling;
			<3b061578-1c2d-47ce-b7cd-113442ebd8d4>YamlMemberAttribute customAttribute = key.GetCustomAttribute<<3b061578-1c2d-47ce-b7cd-113442ebd8d4>YamlMemberAttribute>();
			if (customAttribute != null && customAttribute.IsDefaultValuesHandlingSpecified)
			{
				defaultValuesHandling = customAttribute.DefaultValuesHandling;
			}
			if ((defaultValuesHandling & <d96bfc2d-895f-47ec-bf95-11ebc61b365e>DefaultValuesHandling.OmitNull) != 0 && value.Value == null)
			{
				return false;
			}
			if ((defaultValuesHandling & <d96bfc2d-895f-47ec-bf95-11ebc61b365e>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 & <d96bfc2d-895f-47ec-bf95-11ebc61b365e>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);
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <1f917276-7cb7-47cb-837f-9340dcd2afd2>EmittingObjectGraphVisitor : <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>
	{
		private readonly <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter eventEmitter;

		public <1f917276-7cb7-47cb-837f-9340dcd2afd2>EmittingObjectGraphVisitor(<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter eventEmitter)
		{
			this.eventEmitter = eventEmitter;
		}

		bool <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>.Enter(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter context)
		{
			return true;
		}

		bool <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>.EnterMapping(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor key, <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter context)
		{
			return true;
		}

		bool <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>.EnterMapping(<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor key, <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter context)
		{
			return true;
		}

		void <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>.VisitScalar(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor scalar, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter context)
		{
			eventEmitter.Emit(new <4f19da32-6bd3-477f-8fb8-71554a9f7201>ScalarEventInfo(scalar), context);
		}

		void <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>.VisitMappingStart(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor mapping, Type keyType, Type valueType, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter context)
		{
			eventEmitter.Emit(new <808a48ba-4a82-4d7c-9d8a-7016aba735c4>MappingStartEventInfo(mapping), context);
		}

		void <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>.VisitMappingEnd(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor mapping, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter context)
		{
			eventEmitter.Emit(new <c472ed17-bdcd-472b-9699-e0216ea33fe7>MappingEndEventInfo(mapping), context);
		}

		void <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>.VisitSequenceStart(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor sequence, Type elementType, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter context)
		{
			eventEmitter.Emit(new <b57e9ab0-e846-43da-873c-969a61caa7de>SequenceStartEventInfo(sequence), context);
		}

		void <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter>.VisitSequenceEnd(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor sequence, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter context)
		{
			eventEmitter.Emit(new <0b6d516e-249c-42e6-bb74-a0db4a9b3ce8>SequenceEndEventInfo(sequence), context);
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal abstract class <cf618026-a788-46b6-9ca7-d77117fd9a61>PreProcessingPhaseObjectGraphVisitorSkeleton : <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>
	{
		protected readonly IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> typeConverters;

		public <cf618026-a788-46b6-9ca7-d77117fd9a61>PreProcessingPhaseObjectGraphVisitorSkeleton(IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> typeConverters)
		{
			IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> enumerable;
			if (typeConverters == null)
			{
				enumerable = Enumerable.Empty<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter>();
			}
			else
			{
				IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> enumerable2 = typeConverters.ToList();
				enumerable = enumerable2;
			}
			this.typeConverters = enumerable;
		}

		bool <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>.Enter(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value, <74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing context)
		{
			if (typeConverters.FirstOrDefault([<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] (<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter t) => t.Accepts(value.Type)) != null)
			{
				return false;
			}
			if (value.Value is <f8718f3a-c5b2-48c8-81a0-662be8a96cd4>IYamlConvertible)
			{
				return false;
			}
			if (value.Value is <4b6fe5f2-3b66-4371-b16f-70d5594285af>IYamlSerializable)
			{
				return false;
			}
			return Enter(value);
		}

		bool <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>.EnterMapping(<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor key, <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value, <74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing context)
		{
			return EnterMapping(key, value);
		}

		bool <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>.EnterMapping(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor key, <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value, <74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing context)
		{
			return EnterMapping(key, value);
		}

		void <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>.VisitMappingEnd(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor mapping, <74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing context)
		{
			VisitMappingEnd(mapping);
		}

		void <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>.VisitMappingStart(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor mapping, Type keyType, Type valueType, <74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing context)
		{
			VisitMappingStart(mapping, keyType, valueType);
		}

		void <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>.VisitScalar(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor scalar, <74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing context)
		{
			VisitScalar(scalar);
		}

		void <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>.VisitSequenceEnd(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor sequence, <74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing context)
		{
			VisitSequenceEnd(sequence);
		}

		void <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<<74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing>.VisitSequenceStart(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor sequence, Type elementType, <74ea0c4b-884b-4ae5-abbb-c86565b1db3d>Nothing context)
		{
			VisitSequenceStart(sequence, elementType);
		}

		protected abstract bool Enter(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value);

		protected abstract bool EnterMapping(<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor key, <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value);

		protected abstract bool EnterMapping(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor key, <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value);

		protected abstract void VisitMappingEnd(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor mapping);

		protected abstract void VisitMappingStart(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor mapping, Type keyType, Type valueType);

		protected abstract void VisitScalar(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor scalar);

		protected abstract void VisitSequenceEnd(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor sequence);

		protected abstract void VisitSequenceStart(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor sequence, Type elementType);
	}
}
namespace YamlDotNet.Serialization.ObjectGraphTraversalStrategies
{
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal class <52d47d71-4507-4f72-bcd7-c48178ada8a7>FullObjectGraphTraversalStrategy : <451614b3-1a11-4438-915e-8375d51a70af>IObjectGraphTraversalStrategy
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
		protected struct ObjectPathSegment
		{
			public readonly object Name;

			public readonly <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor Value;

			public ObjectPathSegment(object name, <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value)
			{
				Name = name;
				Value = value;
			}
		}

		private readonly int maxRecursion;

		private readonly <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector typeDescriptor;

		private readonly <14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver;

		private readonly <4ecad175-097b-490b-92b5-e349039d0335>INamingConvention namingConvention;

		private readonly <2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory objectFactory;

		public <52d47d71-4507-4f72-bcd7-c48178ada8a7>FullObjectGraphTraversalStrategy(<286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector typeDescriptor, <14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver, int maxRecursion, <4ecad175-097b-490b-92b5-e349039d0335>INamingConvention namingConvention, <2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory objectFactory)
		{
			if (maxRecursion <= 0)
			{
				throw new ArgumentOutOfRangeException("maxRecursion", maxRecursion, "maxRecursion must be greater than 1");
			}
			this.typeDescriptor = typeDescriptor ?? throw new ArgumentNullException("typeDescriptor");
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			this.maxRecursion = maxRecursion;
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		void <451614b3-1a11-4438-915e-8375d51a70af>IObjectGraphTraversalStrategy.Traverse<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TContext>(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor graph, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<TContext> visitor, TContext context)
		{
			Traverse("<root>", graph, visitor, context, new Stack<ObjectPathSegment>(maxRecursion));
		}

		protected virtual void Traverse<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TContext>(object name, <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value, <d5c78178-20f4-4133-a59e-ccc6e772e107>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 = item.Name?.ToString() ?? string.Empty;
					num = Math.Max(num, text.Length);
					stack.Push(new KeyValuePair<string, string>(text, item.Value.Type.FullName));
				}
				foreach (KeyValuePair<string, string> item2 in stack)
				{
					stringBuilder.Append(" -> ").Append(item2.Key.PadRight(num)).Append("  [")
						.Append(item2.Value)
						.AppendLine("]");
				}
				throw new <e1f13554-13ac-4c5c-b7d5-4ebc5f732030>MaximumRecursionLevelReachedException(stringBuilder.ToString());
			}
			if (!visitor.Enter(value, context))
			{
				return;
			}
			path.Push(new ObjectPathSegment(name, value));
			try
			{
				TypeCode typeCode = <397f8e31-bc53-4ed5-b3c2-66ee3558e043>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 (<397f8e31-bc53-4ed5-b3c2-66ee3558e043>ReflectionExtensions.IsDbNull(value))
				{
					visitor.VisitScalar(new <256cfd2a-7986-41ec-9ef1-d630af4cf0a3>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 <256cfd2a-7986-41ec-9ef1-d630af4cf0a3>ObjectDescriptor(value.Value, underlyingType, value.Type, value.ScalarStyle), visitor, context, path);
				}
				else
				{
					TraverseObject(value, visitor, context, path);
				}
			}
			finally
			{
				path.Pop();
			}
		}

		protected virtual void TraverseObject<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TContext>(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
		{
			IDictionary dictionary;
			Type[] genericArguments;
			if (typeof(IDictionary).IsAssignableFrom(value.Type))
			{
				TraverseDictionary(value, visitor, typeof(object), typeof(object), context, path);
			}
			else if (objectFactory.GetDictionary(value, out dictionary, out genericArguments))
			{
				TraverseDictionary(new <256cfd2a-7986-41ec-9ef1-d630af4cf0a3>ObjectDescriptor(dictionary, 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<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TContext>(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor dictionary, <d5c78178-20f4-4133-a59e-ccc6e772e107>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);
				<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor objectDescriptor = GetObjectDescriptor(obj, keyType);
				<11db0d0d-df5b-4ee5-a780-8f997e315481>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<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TContext>(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
		{
			Type valueType = objectFactory.GetValueType(value.Type);
			visitor.VisitSequenceStart(value, valueType, context);
			int num = 0;
			foreach (object item in (IEnumerable)value.NonNullValue())
			{
				Traverse(num, GetObjectDescriptor(item, valueType), visitor, context, path);
				num++;
			}
			visitor.VisitSequenceEnd(value, context);
		}

		protected virtual void TraverseProperties<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TContext>(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
		{
			visitor.VisitMappingStart(value, typeof(string), typeof(object), context);
			object obj = value.NonNullValue();
			foreach (<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor property in typeDescriptor.GetProperties(value.Type, obj))
			{
				<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value2 = property.Read(obj);
				if (visitor.EnterMapping(property, value2, context))
				{
					Traverse(property.Name, new <256cfd2a-7986-41ec-9ef1-d630af4cf0a3>ObjectDescriptor(property.Name, typeof(string), typeof(string), <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Plain), visitor, context, path);
					Traverse(property.Name, value2, visitor, context, path);
				}
			}
			visitor.VisitMappingEnd(value, context);
		}

		private <11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor GetObjectDescriptor([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object value, Type staticType)
		{
			return new <256cfd2a-7986-41ec-9ef1-d630af4cf0a3>ObjectDescriptor(value, typeResolver.Resolve(staticType, value), staticType);
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal class <7085160d-c56a-4dea-8936-bf24bc9acd82>RoundtripObjectGraphTraversalStrategy : <52d47d71-4507-4f72-bcd7-c48178ada8a7>FullObjectGraphTraversalStrategy
	{
		private readonly IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> converters;

		private readonly Settings settings;

		public <7085160d-c56a-4dea-8936-bf24bc9acd82>RoundtripObjectGraphTraversalStrategy(IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> converters, <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector typeDescriptor, <14060048-8e54-421e-b15b-83ddeb716cfe>ITypeResolver typeResolver, int maxRecursion, <4ecad175-097b-490b-92b5-e349039d0335>INamingConvention namingConvention, Settings settings, <2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory factory)
			: base(typeDescriptor, typeResolver, maxRecursion, namingConvention, factory)
		{
			this.converters = converters;
			this.settings = settings;
		}

		protected override void TraverseProperties<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TContext>(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor value, <d5c78178-20f4-4133-a59e-ccc6e772e107>IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
		{
			if (!value.Type.HasDefaultConstructor(settings.AllowPrivateConstructors) && !converters.Any([<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] (<ddaaa542-dd60-4d14-a733-9acfc1784a67>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
{
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <02300856-d081-446f-a999-63a6afc06472>DefaultObjectFactory : ObjectFactoryBase
	{
		private readonly Dictionary<Type, Type> DefaultGenericInterfaceImplementations = new Dictionary<Type, Type>
		{
			{
				typeof(IEnumerable<>),
				typeof(List<>)
			},
			{
				typeof(ICollection<>),
				typeof(List<>)
			},
			{
				typeof(IList<>),
				typeof(List<>)
			},
			{
				typeof(IDictionary<, >),
				typeof(Dictionary<, >)
			}
		};

		private readonly Dictionary<Type, Type> DefaultNonGenericInterfaceImplementations = new Dictionary<Type, Type>
		{
			{
				typeof(IEnumerable),
				typeof(List<object>)
			},
			{
				typeof(ICollection),
				typeof(List<object>)
			},
			{
				typeof(IList),
				typeof(List<object>)
			},
			{
				typeof(IDictionary),
				typeof(Dictionary<object, object>)
			}
		};

		private readonly Settings settings;

		public <02300856-d081-446f-a999-63a6afc06472>DefaultObjectFactory()
			: this(new Dictionary<Type, Type>(), new Settings())
		{
		}

		public <02300856-d081-446f-a999-63a6afc06472>DefaultObjectFactory(IDictionary<Type, Type> mappings)
			: this(mappings, new Settings())
		{
		}

		public <02300856-d081-446f-a999-63a6afc06472>DefaultObjectFactory(IDictionary<Type, Type> mappings, Settings settings)
		{
			foreach (KeyValuePair<Type, Type> mapping in mappings)
			{
				if (!mapping.Key.IsAssignableFrom(mapping.Value))
				{
					throw new InvalidOperationException($"Type '{mapping.Value}' does not implement type '{mapping.Key}'.");
				}
				DefaultNonGenericInterfaceImplementations.Add(mapping.Key, mapping.Value);
			}
			this.settings = settings;
		}

		public override object Create(Type type)
		{
			if (<397f8e31-bc53-4ed5-b3c2-66ee3558e043>ReflectionExtensions.IsInterface(type))
			{
				Type value2;
				if (<397f8e31-bc53-4ed5-b3c2-66ee3558e043>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, settings.AllowPrivateConstructors);
			}
			catch (Exception innerException)
			{
				throw new InvalidOperationException("Failed to create an instance of type '" + type.FullName + "'.", innerException);
			}
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <dfdf1478-c2a1-4536-9c52-fd3e86acf4f6>LambdaObjectFactory : ObjectFactoryBase
	{
		private readonly Func<Type, object> factory;

		public <dfdf1478-c2a1-4536-9c52-fd3e86acf4f6>LambdaObjectFactory(Func<Type, object> factory)
		{
			this.factory = factory ?? throw new ArgumentNullException("factory");
		}

		public override object Create(Type type)
		{
			return factory(type);
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal abstract class ObjectFactoryBase : <2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory
	{
		public abstract object Create(Type type);

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public virtual object CreatePrimitive(Type type)
		{
			if (!<397f8e31-bc53-4ed5-b3c2-66ee3558e043>ReflectionExtensions.IsValueType(type))
			{
				return null;
			}
			return Activator.CreateInstance(type);
		}

		public virtual bool GetDictionary(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor descriptor, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] out IDictionary dictionary, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 2, 1 })] out Type[] genericArguments)
		{
			Type implementedGenericInterface = <116a4c16-eb91-45b6-a334-9f92a0f8daa6>ReflectionUtility.GetImplementedGenericInterface(descriptor.Type, typeof(IDictionary<, >));
			if (implementedGenericInterface != null)
			{
				genericArguments = implementedGenericInterface.GetGenericArguments();
				object obj = Activator.CreateInstance(typeof(<9e2ccdfe-7c5e-4e1f-9e3c-278d3016bfbd>GenericDictionaryToNonGenericAdapter<, >).MakeGenericType(genericArguments), descriptor.Value);
				dictionary = obj as IDictionary;
				return true;
			}
			genericArguments = null;
			dictionary = null;
			return false;
		}

		public virtual Type GetValueType(Type type)
		{
			Type implementedGenericInterface = <116a4c16-eb91-45b6-a334-9f92a0f8daa6>ReflectionUtility.GetImplementedGenericInterface(type, typeof(IEnumerable<>));
			if (!(implementedGenericInterface != null))
			{
				return typeof(object);
			}
			return implementedGenericInterface.GetGenericArguments()[0];
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal abstract class StaticObjectFactory : <2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory
	{
		public abstract object Create(Type type);

		public abstract Array CreateArray(Type type, int count);

		public abstract bool IsDictionary(Type type);

		public abstract bool IsArray(Type type);

		public abstract bool IsList(Type type);

		public abstract Type GetKeyType(Type type);

		public abstract Type GetValueType(Type type);

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public virtual object CreatePrimitive(Type type)
		{
			return Type.GetTypeCode(type) switch
			{
				TypeCode.Boolean => false, 
				TypeCode.Byte => (byte)0, 
				TypeCode.Int16 => (short)0, 
				TypeCode.Int32 => 0, 
				TypeCode.Int64 => 0L, 
				TypeCode.SByte => (sbyte)0, 
				TypeCode.UInt16 => (ushort)0, 
				TypeCode.UInt32 => 0u, 
				TypeCode.UInt64 => 0uL, 
				TypeCode.Single => 0f, 
				TypeCode.Double => 0.0, 
				TypeCode.Decimal => 0m, 
				TypeCode.Char => '\0', 
				TypeCode.DateTime => default(DateTime), 
				_ => null, 
			};
		}

		public bool GetDictionary(<11db0d0d-df5b-4ee5-a780-8f997e315481>IObjectDescriptor descriptor, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] out IDictionary dictionary, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 2, 1 })] out Type[] genericArguments)
		{
			dictionary = null;
			genericArguments = null;
			return false;
		}
	}
}
namespace YamlDotNet.Serialization.NodeTypeResolvers
{
	internal sealed class <072feac1-f97b-4588-adb6-916ecf8798c1>DefaultContainersNodeTypeResolver : <65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver
	{
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		bool <65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver.Resolve([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] <17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent nodeEvent, ref Type currentType)
		{
			if (currentType == typeof(object))
			{
				if (nodeEvent is <743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart)
				{
					currentType = typeof(List<object>);
					return true;
				}
				if (nodeEvent is <fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart)
				{
					currentType = typeof(Dictionary<object, object>);
					return true;
				}
			}
			return false;
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal class <d8f9faff-1f0f-40ca-a49a-88710edd1f40>MappingNodeTypeResolver : <65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver
	{
		private readonly IDictionary<Type, Type> _mappings;

		public <d8f9faff-1f0f-40ca-a49a-88710edd1f40>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([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] <17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent nodeEvent, ref Type currentType)
		{
			if (_mappings.TryGetValue(currentType, out var value))
			{
				currentType = value;
				return true;
			}
			return false;
		}
	}
	internal class <02975dea-881b-4f37-b863-997aad25fb13>PreventUnknownTagsNodeTypeResolver : <65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver
	{
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		bool <65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver.Resolve([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] <17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty)
			{
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = nodeEvent.Start;
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = nodeEvent.End;
				throw new <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException(in start, in end, $"Encountered an unresolved tag '{nodeEvent.Tag}'");
			}
			return false;
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <463c4e57-a312-4cc9-bd72-a377b5edfc9f>TagNodeTypeResolver : <65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver
	{
		private readonly IDictionary<<baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName, Type> tagMappings;

		public <463c4e57-a312-4cc9-bd72-a377b5edfc9f>TagNodeTypeResolver(IDictionary<<baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName, Type> tagMappings)
		{
			this.tagMappings = tagMappings ?? throw new ArgumentNullException("tagMappings");
		}

		bool <65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver.Resolve([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] <17b80f1e-db12-4b74-94e4-11fb84cb3a26>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 <f3c15542-0d70-42bd-b008-8bef61b47fbb>TypeNameInTagNodeTypeResolver : <65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver
	{
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		bool <65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver.Resolve([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] <17b80f1e-db12-4b74-94e4-11fb84cb3a26>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 <46985615-ba7b-447d-85d0-c2020ee1c192>YamlConvertibleTypeResolver : <65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver
	{
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public bool Resolve([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] <17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent nodeEvent, ref Type currentType)
		{
			return typeof(<f8718f3a-c5b2-48c8-81a0-662be8a96cd4>IYamlConvertible).IsAssignableFrom(currentType);
		}
	}
	internal sealed class <86cc761d-0f06-48c3-a216-6acd2b63d61a>YamlSerializableTypeResolver : <65f9c986-9840-4cc5-8fae-bd3b99cb02cd>INodeTypeResolver
	{
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public bool Resolve([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] <17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent nodeEvent, ref Type currentType)
		{
			return typeof(<4b6fe5f2-3b66-4371-b16f-70d5594285af>IYamlSerializable).IsAssignableFrom(currentType);
		}
	}
}
namespace YamlDotNet.Serialization.NodeDeserializers
{
	internal sealed class <5b8d84af-318a-4060-a3ca-0c8cddc1905d>ArrayNodeDeserializer : <1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer
	{
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
		private sealed class ArrayList : IList, ICollection, IEnumerable
		{
			[<0d606795-0ee1-47ee-aaaa-2df0804da96c>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;

			[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)]
			public object SyncRoot
			{
				[<b36caba6-ec7b-49e8-8641-5a4015501a0a>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();
			}

			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
			public void CopyTo(Array array, int index)
			{
				Array.Copy(data, 0, array, index, Count);
			}

			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
			public IEnumerator GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return data[i];
					int num = i + 1;
					i = num;
				}
			}
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public bool Deserialize(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type expectedType, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser, Type, object> nestedObjectDeserializer, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] out object value)
		{
			if (!expectedType.IsArray)
			{
				value = false;
				return false;
			}
			Type? elementType = expectedType.GetElementType();
			ArrayList arrayList = new ArrayList();
			<14e2f167-2529-400d-8b24-fb07cea47505>CollectionNodeDeserializer.DeserializeHelper(elementType, parser, nestedObjectDeserializer, arrayList, canUpdate: true);
			Array array = Array.CreateInstance(elementType, arrayList.Count);
			arrayList.CopyTo(array, 0);
			value = array;
			return true;
		}
	}
	internal abstract class CollectionDeserializer
	{
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		protected static void DeserializeHelper(Type tItem, <407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser, Type, object> nestedObjectDeserializer, IList result, bool canUpdate, <2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory objectFactory)
		{
			parser.Consume<<743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart>();
			<7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd @event;
			while (!parser.TryConsume<<7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd>(out @event))
			{
				<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem);
				if (obj is <0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise <0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise)
				{
					if (!canUpdate)
					{
						<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = current?.Start ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
						<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = current?.End ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
						throw new <8e1ea460-52d7-43bb-8be5-0bc54fc77271>ForwardAnchorNotSupportedException(in start, in end, "Forward alias references are not allowed because this type does not implement IList<>");
					}
					int index = result.Add(objectFactory.CreatePrimitive(tItem));
					<0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise.ValueAvailable += [<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)] (object v) =>
					{
						result[index] = v;
					};
				}
				else
				{
					result.Add(obj);
				}
			}
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <14e2f167-2529-400d-8b24-fb07cea47505>CollectionNodeDeserializer : <1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer
	{
		private readonly <2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory objectFactory;

		public <14e2f167-2529-400d-8b24-fb07cea47505>CollectionNodeDeserializer(<2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		public bool Deserialize(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type expectedType, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser, Type, object> nestedObjectDeserializer, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] out object value)
		{
			bool canUpdate = true;
			Type implementedGenericInterface = <116a4c16-eb91-45b6-a334-9f92a0f8daa6>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 = <116a4c16-eb91-45b6-a334-9f92a0f8daa6>ReflectionUtility.GetImplementedGenericInterface(expectedType, typeof(IList<>)) != null;
					list = (IList)Activator.CreateInstance(typeof(<47a35ba7-75bb-4ee1-b33f-a14d832c4eb8>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, <407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser, Type, object> nestedObjectDeserializer, IList result, bool canUpdate)
		{
			parser.Consume<<743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart>();
			<7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd @event;
			while (!parser.TryConsume<<7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd>(out @event))
			{
				<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem);
				if (obj is <0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise <0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise)
				{
					if (!canUpdate)
					{
						<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = current?.Start ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
						<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = current?.End ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
						throw new <8e1ea460-52d7-43bb-8be5-0bc54fc77271>ForwardAnchorNotSupportedException(in start, in end, "Forward alias references are not allowed because this type does not implement IList<>");
					}
					int index = result.Add(<397f8e31-bc53-4ed5-b3c2-66ee3558e043>ReflectionExtensions.IsValueType(tItem) ? Activator.CreateInstance(tItem) : null);
					<0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise.ValueAvailable += [<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)] (object v) =>
					{
						result[index] = <cf96cff7-b788-4106-93c9-ac54ad4b0b54>TypeConverter.ChangeType(v, tItem);
					};
				}
				else
				{
					result.Add(<cf96cff7-b788-4106-93c9-ac54ad4b0b54>TypeConverter.ChangeType(obj, tItem));
				}
			}
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal abstract class DictionaryDeserializer
	{
		private readonly bool duplicateKeyChecking;

		public DictionaryDeserializer(bool duplicateKeyChecking)
		{
			this.duplicateKeyChecking = duplicateKeyChecking;
		}

		private void TryAssign(IDictionary result, object key, object value, <fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart propertyName)
		{
			if (duplicateKeyChecking && result.Contains(key))
			{
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = propertyName.Start;
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = propertyName.End;
				throw new <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException(in start, in end, $"Encountered duplicate key {key}");
			}
			result[key] = value;
		}

		protected virtual void Deserialize(Type tKey, Type tValue, <407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser, Type, object> nestedObjectDeserializer, IDictionary result)
		{
			<fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart property = parser.Consume<<fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart>();
			<d66b1b5c-22da-4393-8f8d-68d3635cb59f>MappingEnd @event;
			while (!parser.TryConsume<<d66b1b5c-22da-4393-8f8d-68d3635cb59f>MappingEnd>(out @event))
			{
				object key = nestedObjectDeserializer(parser, tKey);
				object value = nestedObjectDeserializer(parser, tValue);
				<0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise <0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise = value as <0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise;
				if (key is <0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise <0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise2)
				{
					if (<0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise == null)
					{
						<0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise2.ValueAvailable += [<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)] (object v) =>
						{
							result[v] = value;
						};
						continue;
					}
					bool hasFirstPart = false;
					<0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise2.ValueAvailable += [<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)] (object v) =>
					{
						if (hasFirstPart)
						{
							TryAssign(result, v, value, property);
						}
						else
						{
							key = v;
							hasFirstPart = true;
						}
					};
					<0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise.ValueAvailable += [<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)] (object v) =>
					{
						if (hasFirstPart)
						{
							TryAssign(result, key, v, property);
						}
						else
						{
							value = v;
							hasFirstPart = true;
						}
					};
					continue;
				}
				if (key == null)
				{
					throw new ArgumentException("Empty key names are not supported yet.", "key");
				}
				if (<0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise == null)
				{
					TryAssign(result, key, value, property);
					continue;
				}
				<0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise.ValueAvailable += [<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)] (object v) =>
				{
					result[key] = v;
				};
			}
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal class <a02a687b-156e-4d44-851f-111959502d7b>DictionaryNodeDeserializer : DictionaryDeserializer, <1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer
	{
		private readonly <2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory objectFactory;

		public <a02a687b-156e-4d44-851f-111959502d7b>DictionaryNodeDeserializer(<2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory objectFactory, bool duplicateKeyChecking)
			: base(duplicateKeyChecking)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		public bool Deserialize(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type expectedType, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser, Type, object> nestedObjectDeserializer, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] out object value)
		{
			Type implementedGenericInterface = <116a4c16-eb91-45b6-a334-9f92a0f8daa6>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(<9e2ccdfe-7c5e-4e1f-9e3c-278d3016bfbd>GenericDictionaryToNonGenericAdapter<, >).MakeGenericType(type, type2), value);
				}
			}
			else
			{
				if (!typeof(IDictionary).IsAssignableFrom(expectedType))
				{
					value = null;
					return false;
				}
				type = typeof(object);
				type2 = typeof(object);
				value = objectFactory.Create(expectedType);
				dictionary = (IDictionary)value;
			}
			Deserialize(type, type2, parser, nestedObjectDeserializer, dictionary);
			return true;
		}
	}
	internal sealed class <69993307-8a26-4698-b642-9d482b90e9e0>EnumerableNodeDeserializer : <1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer
	{
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public bool Deserialize(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type expectedType, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser, Type, object> nestedObjectDeserializer, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] out object value)
		{
			Type type;
			if (expectedType == typeof(IEnumerable))
			{
				type = typeof(object);
			}
			else
			{
				Type implementedGenericInterface = <116a4c16-eb91-45b6-a334-9f92a0f8daa6>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 <c92497bb-e732-4e03-8b07-63d99fe073c2>NullNodeDeserializer : <1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer
	{
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public bool Deserialize(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type expectedType, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser, Type, object> nestedObjectDeserializer, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] out object value)
		{
			value = null;
			if (parser.Accept<<17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent>(out var @event) && NodeIsNull(@event))
			{
				parser.SkipThisAndNestedEvents();
				return true;
			}
			return false;
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		private bool NodeIsNull(<17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent nodeEvent)
		{
			if (nodeEvent.Tag == "tag:yaml.org,2002:null")
			{
				return true;
			}
			if (nodeEvent is <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar && <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar.Style == <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Plain && !<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar.IsKey)
			{
				string value = <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar.Value;
				switch (value)
				{
				default:
					return value == "NULL";
				case "":
				case "~":
				case "null":
				case "Null":
					return true;
				}
			}
			return false;
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <5d250f4d-109d-48f8-88c8-442c55c65c3f>ObjectNodeDeserializer : <1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer
	{
		private readonly <2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory objectFactory;

		private readonly <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector typeDescriptor;

		private readonly bool ignoreUnmatched;

		private readonly bool duplicateKeyChecking;

		private readonly ITypeConverter typeConverter;

		public <5d250f4d-109d-48f8-88c8-442c55c65c3f>ObjectNodeDeserializer(<2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory objectFactory, <286f29e9-2bcb-4560-b0d8-79dbbea3c41e>ITypeInspector typeDescriptor, bool ignoreUnmatched, bool duplicateKeyChecking, ITypeConverter typeConverter)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
			this.typeDescriptor = typeDescriptor ?? throw new ArgumentNullException("typeDescriptor");
			this.ignoreUnmatched = ignoreUnmatched;
			this.duplicateKeyChecking = duplicateKeyChecking;
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
		}

		public bool Deserialize(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type expectedType, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser, Type, object> nestedObjectDeserializer, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] out object value)
		{
			if (!parser.TryConsume<<fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart>(out var _))
			{
				value = null;
				return false;
			}
			Type type = Nullable.GetUnderlyingType(expectedType) ?? expectedType;
			value = objectFactory.Create(type);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			<d66b1b5c-22da-4393-8f8d-68d3635cb59f>MappingEnd event2;
			while (!parser.TryConsume<<d66b1b5c-22da-4393-8f8d-68d3635cb59f>MappingEnd>(out event2))
			{
				<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar = parser.Consume<<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar>();
				if (duplicateKeyChecking && !hashSet.Add(<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar.Value))
				{
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar.Start;
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar.End;
					throw new <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException(in start, in end, "Encountered duplicate key " + <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar.Value);
				}
				try
				{
					<1955fdce-5a73-4715-9a1e-627d62658b8d>IPropertyDescriptor property = typeDescriptor.GetProperty(type, null, <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar.Value, ignoreUnmatched);
					if (property == null)
					{
						parser.SkipThisAndNestedEvents();
						continue;
					}
					object obj = nestedObjectDeserializer(parser, property.Type);
					if (obj is <0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise <0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise)
					{
						object valueRef = value;
						<0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise.ValueAvailable += [<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)] (object v) =>
						{
							object value3 = typeConverter.ChangeType(v, property.Type);
							property.Write(valueRef, value3);
						};
					}
					else
					{
						object value2 = typeConverter.ChangeType(obj, property.Type);
						property.Write(value, value2);
					}
				}
				catch (SerializationException ex)
				{
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar.Start;
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar.End;
					throw new <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException(in start, in end, ex.Message);
				}
				catch (<04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException)
				{
					throw;
				}
				catch (Exception innerException)
				{
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar.Start;
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar.End;
					throw new <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException(in start, in end, "Exception during deserialization", innerException);
				}
			}
			return true;
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <469f90d5-64f3-4820-ab4b-6bba9aa75ec3>ScalarNodeDeserializer : <1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer
	{
		private const string BooleanTruePattern = "^(true|y|yes|on)$";

		private const string BooleanFalsePattern = "^(false|n|no|off)$";

		private readonly bool attemptUnknownTypeDeserialization;

		private readonly ITypeConverter typeConverter;

		public <469f90d5-64f3-4820-ab4b-6bba9aa75ec3>ScalarNodeDeserializer(bool attemptUnknownTypeDeserialization, ITypeConverter typeConverter)
		{
			this.attemptUnknownTypeDeserialization = attemptUnknownTypeDeserialization;
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
		}

		public bool Deserialize(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type expectedType, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser, Type, object> nestedObjectDeserializer, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] out object value)
		{
			if (!parser.TryConsume<<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar>(out var @event))
			{
				value = null;
				return false;
			}
			Type type = Nullable.GetUnderlyingType(expectedType) ?? expectedType;
			if (<397f8e31-bc53-4ed5-b3c2-66ee3558e043>ReflectionExtensions.IsEnum(type))
			{
				value = Enum.Parse(type, @event.Value, ignoreCase: true);
				return true;
			}
			TypeCode typeCode = <397f8e31-bc53-4ed5-b3c2-66ee3558e043>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, <871006a4-e3e9-4119-89bb-05c311a2f23b>YamlFormatter.NumberFormat);
				break;
			case TypeCode.Double:
				value = double.Parse(@event.Value, <871006a4-e3e9-4119-89bb-05c311a2f23b>YamlFormatter.NumberFormat);
				break;
			case TypeCode.Decimal:
				value = decimal.Parse(@event.Value, <871006a4-e3e9-4119-89bb-05c311a2f23b>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))
				{
					if (!@event.IsKey && attemptUnknownTypeDeserialization)
					{
						value = AttemptUnknownTypeDeserialization(@event);
					}
					else
					{
						value = @event.Value;
					}
				}
				else
				{
					value = 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 static object DeserializeIntegerHelper(TypeCode typeCode, string value)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				int i = 0;
				bool flag = false;
				ulong num = 0uL;
				if (value[0] == '-')
				{
					i++;
					flag = true;
				}
				else if (value[0] == '+')
				{
					i++;
				}
				if (value[i] == '0')
				{
					int num2;
					if (i == value.Length - 1)
					{
						num2 = 10;
						num = 0uL;
					}
					else
					{
						i++;
						if (value[i] == 'b')
						{
							num2 = 2;
							i++;
						}
						else if (value[i] == 'x')
						{
							num2 = 16;
							i++;
						}
						else
						{
							num2 = 8;
						}
					}
					for (; i < value.Length; i++)
					{
						if (value[i] != '_')
						{
							builder.Append(value[i]);
						}
					}
					switch (num2)
					{
					case 2:
					case 8:
						num = Convert.ToUInt64(builder.ToString(), num2);
						break;
					case 16:
						num = ulong.Parse(builder.ToString(), NumberStyles.HexNumber, <871006a4-e3e9-4119-89bb-05c311a2f23b>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(num, typeCode);
				}
				long number = ((num != 9223372036854775808uL) ? checked(-(long)num) : long.MinValue);
				return CastInteger(number, typeCode);
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private static object CastInteger(long number, TypeCode typeCode)
		{
			return checked(typeCode switch
			{
				TypeCode.Byte => (byte)number, 
				TypeCode.Int16 => (short)number, 
				TypeCode.Int32 => (int)number, 
				TypeCode.Int64 => number, 
				TypeCode.SByte => (sbyte)number, 
				TypeCode.UInt16 => (ushort)number, 
				TypeCode.UInt32 => (uint)number, 
				TypeCode.UInt64 => (ulong)number, 
				_ => number, 
			});
		}

		private static object CastInteger(ulong number, TypeCode typeCode)
		{
			return checked(typeCode switch
			{
				TypeCode.Byte => (byte)number, 
				TypeCode.Int16 => (short)number, 
				TypeCode.Int32 => (int)number, 
				TypeCode.Int64 => (long)number, 
				TypeCode.SByte => (sbyte)number, 
				TypeCode.UInt16 => (ushort)number, 
				TypeCode.UInt32 => (uint)number, 
				TypeCode.UInt64 => number, 
				_ => number, 
			});
		}

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		private static object AttemptUnknownTypeDeserialization(<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar value)
		{
			if (value.Style == <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.SingleQuoted || value.Style == <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.DoubleQuoted || value.Style == <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Folded)
			{
				return value.Value;
			}
			string v = value.Value;
			switch (v)
			{
			case "":
			case "~":
			case "null":
			case "Null":
			case "NULL":
				return null;
			case "true":
			case "True":
			case "TRUE":
				return true;
			case "false":
			case "False":
			case "FALSE":
				return false;
			default:
			{
				object value2;
				if (Regex.IsMatch(v, "0x[0-9a-fA-F]+"))
				{
					if (!TryAndSwallow(() => Convert.ToByte(v, 16), out value2) && !TryAndSwallow(() => Convert.ToInt16(v, 16), out value2) && !TryAndSwallow(() => Convert.ToInt32(v, 16), out value2) && !TryAndSwallow(() => Convert.ToInt64(v, 16), out value2) && !TryAndSwallow(() => Convert.ToUInt64(v, 16), out value2))
					{
						return v;
					}
				}
				else if (Regex.IsMatch(v, "0o[0-9a-fA-F]+"))
				{
					if (!TryAndSwallow(() => Convert.ToByte(v, 8), out value2) && !TryAndSwallow(() => Convert.ToInt16(v, 8), out value2) && !TryAndSwallow(() => Convert.ToInt32(v, 8), out value2) && !TryAndSwallow(() => Convert.ToInt64(v, 8), out value2) && !TryAndSwallow(() => Convert.ToUInt64(v, 8), out value2))
					{
						return v;
					}
				}
				else
				{
					if (!Regex.IsMatch(v, "[-+]?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?"))
					{
						if (Regex.IsMatch(v, "^[-+]?(\\.inf|\\.Inf|\\.INF)$"))
						{
							if (v.StartsWith("-"))
							{
								return float.NegativeInfinity;
							}
							return float.PositiveInfinity;
						}
						if (Regex.IsMatch(v, "^(\\.nan|\\.NaN|\\.NAN)$"))
						{
							return float.NaN;
						}
						return v;
					}
					if (!TryAndSwallow(() => byte.Parse(v), out value2) && !TryAndSwallow(() => short.Parse(v), out value2) && !TryAndSwallow(() => int.Parse(v), out value2) && !TryAndSwallow(() => long.Parse(v), out value2) && !TryAndSwallow(() => ulong.Parse(v), out value2) && !TryAndSwallow(() => float.Parse(v), out value2) && !TryAndSwallow(() => double.Parse(v), out value2))
					{
						return v;
					}
				}
				return value2;
			}
			}
		}

		private static bool TryAndSwallow(Func<object> attempt, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] out object value)
		{
			try
			{
				value = attempt();
				return true;
			}
			catch
			{
				value = null;
				return false;
			}
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class StaticArrayNodeDeserializer : <1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer
	{
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
		private sealed class ArrayList : IList, ICollection, IEnumerable
		{
			[<0d606795-0ee1-47ee-aaaa-2df0804da96c>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;

			[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)]
			public object SyncRoot
			{
				[<b36caba6-ec7b-49e8-8641-5a4015501a0a>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();
			}

			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
			public void CopyTo(Array array, int index)
			{
				Array.Copy(data, 0, array, index, Count);
			}

			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
			public IEnumerator GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return data[i];
					int num = i + 1;
					i = num;
				}
			}
		}

		private readonly StaticObjectFactory factory;

		public StaticArrayNodeDeserializer(StaticObjectFactory factory)
		{
			this.factory = factory ?? throw new ArgumentNullException("factory");
		}

		public bool Deserialize(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type expectedType, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser, Type, object> nestedObjectDeserializer, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] out object value)
		{
			if (!factory.IsArray(expectedType))
			{
				value = false;
				return false;
			}
			Type valueType = factory.GetValueType(expectedType);
			ArrayList arrayList = new ArrayList();
			StaticCollectionNodeDeserializer.DeserializeHelper(valueType, parser, nestedObjectDeserializer, arrayList, factory);
			Array array = factory.CreateArray(expectedType, arrayList.Count);
			arrayList.CopyTo(array, 0);
			value = array;
			return true;
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class StaticCollectionNodeDeserializer : <1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer
	{
		private readonly StaticObjectFactory factory;

		public StaticCollectionNodeDeserializer(StaticObjectFactory factory)
		{
			this.factory = factory ?? throw new ArgumentNullException("factory");
		}

		public bool Deserialize(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type expectedType, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser, Type, object> nestedObjectDeserializer, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] out object value)
		{
			if (!factory.IsList(expectedType))
			{
				value = null;
				return false;
			}
			DeserializeHelper(result: (IList)(value = factory.Create(expectedType) as IList), tItem: factory.GetValueType(expectedType), parser: parser, nestedObjectDeserializer: nestedObjectDeserializer, factory: factory);
			return true;
		}

		internal static void DeserializeHelper(Type tItem, <407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser, Type, object> nestedObjectDeserializer, IList result, <2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory factory)
		{
			parser.Consume<<743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart>();
			<7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd @event;
			while (!parser.TryConsume<<7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd>(out @event))
			{
				_ = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem);
				if (obj is <0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise <0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise)
				{
					int index = result.Add(factory.CreatePrimitive(tItem));
					<0c7bbe24-e43f-40a0-a8d9-97acfa59edb3>IValuePromise.ValueAvailable += [<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)] (object v) =>
					{
						result[index] = v;
					};
				}
				else
				{
					result.Add(obj);
				}
			}
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal class StaticDictionaryNodeDeserializer : DictionaryDeserializer, <1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer
	{
		private readonly StaticObjectFactory _objectFactory;

		public StaticDictionaryNodeDeserializer(StaticObjectFactory objectFactory, bool duplicateKeyChecking)
			: base(duplicateKeyChecking)
		{
			_objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		public bool Deserialize(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser reader, Type expectedType, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser, Type, object> nestedObjectDeserializer, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] out object value)
		{
			if (_objectFactory.IsDictionary(expectedType))
			{
				if (!(_objectFactory.Create(expectedType) is IDictionary dictionary))
				{
					value = null;
					return false;
				}
				Type keyType = _objectFactory.GetKeyType(expectedType);
				Type valueType = _objectFactory.GetValueType(expectedType);
				value = dictionary;
				base.Deserialize(keyType, valueType, reader, nestedObjectDeserializer, dictionary);
				return true;
			}
			value = null;
			return false;
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <6b23cfcb-093c-4338-af8b-9b06e9fa8693>TypeConverterNodeDeserializer : <1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer
	{
		private readonly IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> converters;

		public <6b23cfcb-093c-4338-af8b-9b06e9fa8693>TypeConverterNodeDeserializer(IEnumerable<<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter> converters)
		{
			this.converters = converters ?? throw new ArgumentNullException("converters");
		}

		public bool Deserialize(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type expectedType, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser, Type, object> nestedObjectDeserializer, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] out object value)
		{
			<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter <ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter = converters.FirstOrDefault([<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] (<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter c) => c.Accepts(expectedType));
			if (<ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter == null)
			{
				value = null;
				return false;
			}
			value = <ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter.ReadYaml(parser, expectedType);
			return true;
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <52e06420-a414-44c5-b050-32f8c50d3c73>YamlConvertibleNodeDeserializer : <1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer
	{
		private readonly <2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory objectFactory;

		public <52e06420-a414-44c5-b050-32f8c50d3c73>YamlConvertibleNodeDeserializer(<2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type expectedType, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser, Type, object> nestedObjectDeserializer, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] out object value)
		{
			if (typeof(<f8718f3a-c5b2-48c8-81a0-662be8a96cd4>IYamlConvertible).IsAssignableFrom(expectedType))
			{
				<f8718f3a-c5b2-48c8-81a0-662be8a96cd4>IYamlConvertible <f8718f3a-c5b2-48c8-81a0-662be8a96cd4>IYamlConvertible = (<f8718f3a-c5b2-48c8-81a0-662be8a96cd4>IYamlConvertible)objectFactory.Create(expectedType);
				<f8718f3a-c5b2-48c8-81a0-662be8a96cd4>IYamlConvertible.Read(parser, expectedType, [return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] (Type type) => nestedObjectDeserializer(parser, type));
				value = <f8718f3a-c5b2-48c8-81a0-662be8a96cd4>IYamlConvertible;
				return true;
			}
			value = null;
			return false;
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <91d47f48-768b-4156-878e-5db746f252b1>YamlSerializableNodeDeserializer : <1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer
	{
		private readonly <2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory objectFactory;

		public <91d47f48-768b-4156-878e-5db746f252b1>YamlSerializableNodeDeserializer(<2bc27fe1-3cae-4acb-9547-28e99211c3fa>IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type expectedType, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser, Type, object> nestedObjectDeserializer, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] out object value)
		{
			if (typeof(<4b6fe5f2-3b66-4371-b16f-70d5594285af>IYamlSerializable).IsAssignableFrom(expectedType))
			{
				<4b6fe5f2-3b66-4371-b16f-70d5594285af>IYamlSerializable <4b6fe5f2-3b66-4371-b16f-70d5594285af>IYamlSerializable = (<4b6fe5f2-3b66-4371-b16f-70d5594285af>IYamlSerializable)objectFactory.Create(expectedType);
				<4b6fe5f2-3b66-4371-b16f-70d5594285af>IYamlSerializable.ReadYaml(parser);
				value = <4b6fe5f2-3b66-4371-b16f-70d5594285af>IYamlSerializable;
				return true;
			}
			value = null;
			return false;
		}
	}
}
namespace YamlDotNet.Serialization.NamingConventions
{
	internal sealed class <dd2ffcaf-d10d-4678-b250-96c3362cac81>CamelCaseNamingConvention : <4ecad175-097b-490b-92b5-e349039d0335>INamingConvention
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)]
		public static readonly <4ecad175-097b-490b-92b5-e349039d0335>INamingConvention Instance = new <dd2ffcaf-d10d-4678-b250-96c3362cac81>CamelCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public <dd2ffcaf-d10d-4678-b250-96c3362cac81>CamelCaseNamingConvention()
		{
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public string Apply(string value)
		{
			return <f9ad53fc-722b-4cfe-a20e-bc720aec636c>StringExtensions.ToCamelCase(value);
		}
	}
	internal sealed class <6e998642-c1fd-4860-877b-aa18bb6f2d3c>HyphenatedNamingConvention : <4ecad175-097b-490b-92b5-e349039d0335>INamingConvention
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)]
		public static readonly <4ecad175-097b-490b-92b5-e349039d0335>INamingConvention Instance = new <6e998642-c1fd-4860-877b-aa18bb6f2d3c>HyphenatedNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public <6e998642-c1fd-4860-877b-aa18bb6f2d3c>HyphenatedNamingConvention()
		{
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public string Apply(string value)
		{
			return <f9ad53fc-722b-4cfe-a20e-bc720aec636c>StringExtensions.FromCamelCase(value, "-");
		}
	}
	internal sealed class <d11ec7b6-c7bc-46a8-aff7-0d3e74503d6a>LowerCaseNamingConvention : <4ecad175-097b-490b-92b5-e349039d0335>INamingConvention
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)]
		public static readonly <4ecad175-097b-490b-92b5-e349039d0335>INamingConvention Instance = new <d11ec7b6-c7bc-46a8-aff7-0d3e74503d6a>LowerCaseNamingConvention();

		private <d11ec7b6-c7bc-46a8-aff7-0d3e74503d6a>LowerCaseNamingConvention()
		{
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public string Apply(string value)
		{
			return <f9ad53fc-722b-4cfe-a20e-bc720aec636c>StringExtensions.ToCamelCase(value).ToLower();
		}
	}
	internal sealed class <74573528-4a43-4f7f-868c-a260d880c43a>NullNamingConvention : <4ecad175-097b-490b-92b5-e349039d0335>INamingConvention
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)]
		public static readonly <4ecad175-097b-490b-92b5-e349039d0335>INamingConvention Instance = new <74573528-4a43-4f7f-868c-a260d880c43a>NullNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public <74573528-4a43-4f7f-868c-a260d880c43a>NullNamingConvention()
		{
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public string Apply(string value)
		{
			return value;
		}
	}
	internal sealed class <538de7de-8f4d-492d-9c28-60635cc391cb>PascalCaseNamingConvention : <4ecad175-097b-490b-92b5-e349039d0335>INamingConvention
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)]
		public static readonly <4ecad175-097b-490b-92b5-e349039d0335>INamingConvention Instance = new <538de7de-8f4d-492d-9c28-60635cc391cb>PascalCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public <538de7de-8f4d-492d-9c28-60635cc391cb>PascalCaseNamingConvention()
		{
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public string Apply(string value)
		{
			return <f9ad53fc-722b-4cfe-a20e-bc720aec636c>StringExtensions.ToPascalCase(value);
		}
	}
	internal sealed class <2c2a2d2a-04f2-4824-a260-667e01402c77>UnderscoredNamingConvention : <4ecad175-097b-490b-92b5-e349039d0335>INamingConvention
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)]
		public static readonly <4ecad175-097b-490b-92b5-e349039d0335>INamingConvention Instance = new <2c2a2d2a-04f2-4824-a260-667e01402c77>UnderscoredNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public <2c2a2d2a-04f2-4824-a260-667e01402c77>UnderscoredNamingConvention()
		{
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public string Apply(string value)
		{
			return <f9ad53fc-722b-4cfe-a20e-bc720aec636c>StringExtensions.FromCamelCase(value, "_");
		}
	}
}
namespace YamlDotNet.Serialization.EventEmitters
{
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal abstract class <adc36387-45fd-4f60-81d4-00c5e6baf6bb>ChainedEventEmitter : <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter
	{
		protected readonly <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter nextEmitter;

		protected <adc36387-45fd-4f60-81d4-00c5e6baf6bb>ChainedEventEmitter(<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter nextEmitter)
		{
			this.nextEmitter = nextEmitter ?? throw new ArgumentNullException("nextEmitter");
		}

		public virtual void Emit(<f4cbcba3-c718-4c5d-8fe8-dc444ac4fa0d>AliasEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(<4f19da32-6bd3-477f-8fb8-71554a9f7201>ScalarEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(<808a48ba-4a82-4d7c-9d8a-7016aba735c4>MappingStartEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(<c472ed17-bdcd-472b-9699-e0216ea33fe7>MappingEndEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(<b57e9ab0-e846-43da-873c-969a61caa7de>SequenceStartEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(<0b6d516e-249c-42e6-bb74-a0db4a9b3ce8>SequenceEndEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <a013011b-1d74-4c39-8dc3-1737c7dda292>JsonEventEmitter : <adc36387-45fd-4f60-81d4-00c5e6baf6bb>ChainedEventEmitter
	{
		public <a013011b-1d74-4c39-8dc3-1737c7dda292>JsonEventEmitter(<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter nextEmitter)
			: base(nextEmitter)
		{
		}

		public override void Emit(<f4cbcba3-c718-4c5d-8fe8-dc444ac4fa0d>AliasEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter)
		{
			eventInfo.NeedsExpansion = true;
		}

		public override void Emit(<4f19da32-6bd3-477f-8fb8-71554a9f7201>ScalarEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter)
		{
			eventInfo.IsPlainImplicit = true;
			eventInfo.Style = <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Plain;
			object value = eventInfo.Source.Value;
			if (value == null)
			{
				eventInfo.RenderedValue = "null";
			}
			else
			{
				TypeCode typeCode = <397f8e31-bc53-4ed5-b3c2-66ee3558e043>ReflectionExtensions.GetTypeCode(eventInfo.Source.Type);
				switch (typeCode)
				{
				case TypeCode.Boolean:
					eventInfo.RenderedValue = <871006a4-e3e9-4119-89bb-05c311a2f23b>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 (<397f8e31-bc53-4ed5-b3c2-66ee3558e043>ReflectionExtensions.IsEnum(eventInfo.Source.Type))
					{
						eventInfo.RenderedValue = value.ToString();
						eventInfo.Style = <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.DoubleQuoted;
					}
					else
					{
						eventInfo.RenderedValue = <871006a4-e3e9-4119-89bb-05c311a2f23b>YamlFormatter.FormatNumber(value);
					}
					break;
				case TypeCode.Single:
				case TypeCode.Double:
				case TypeCode.Decimal:
					eventInfo.RenderedValue = <871006a4-e3e9-4119-89bb-05c311a2f23b>YamlFormatter.FormatNumber(value);
					break;
				case TypeCode.Char:
				case TypeCode.String:
					eventInfo.RenderedValue = value.ToString();
					eventInfo.Style = <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.DoubleQuoted;
					break;
				case TypeCode.DateTime:
					eventInfo.RenderedValue = <871006a4-e3e9-4119-89bb-05c311a2f23b>YamlFormatter.FormatDateTime(value);
					break;
				case TypeCode.Empty:
					eventInfo.RenderedValue = "null";
					break;
				default:
					if (eventInfo.Source.Type == typeof(TimeSpan))
					{
						eventInfo.RenderedValue = <871006a4-e3e9-4119-89bb-05c311a2f23b>YamlFormatter.FormatTimeSpan(value);
						break;
					}
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
			}
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(<808a48ba-4a82-4d7c-9d8a-7016aba735c4>MappingStartEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter)
		{
			eventInfo.Style = <5bdd0818-2e61-4148-a2dc-8d667b816026>MappingStyle.Flow;
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(<b57e9ab0-e846-43da-873c-969a61caa7de>SequenceStartEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter)
		{
			eventInfo.Style = <633aecbb-227c-4a56-bde3-6176f414312f>SequenceStyle.Flow;
			base.Emit(eventInfo, emitter);
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <0162706c-c168-4372-b87d-6cd624ba9304>TypeAssigningEventEmitter : <adc36387-45fd-4f60-81d4-00c5e6baf6bb>ChainedEventEmitter
	{
		private readonly bool requireTagWhenStaticAndActualTypesAreDifferent;

		private readonly IDictionary<Type, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName> tagMappings;

		private readonly bool quoteNecessaryStrings;

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		private readonly Regex isSpecialStringValue_Regex;

		private static readonly string SpecialStrings_Pattern = "^(null|Null|NULL|\\~|true|True|TRUE|false|False|FALSE|[-+]?[0-9]+|0o[0-7]+|0x[0-9a-fA-F]+|[-+]?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?|[-+]?(\\.inf|\\.Inf|\\.INF)|\\.nan|\\.NaN|\\.NAN)$";

		private static readonly string CombinedYaml1_1SpecialStrings_Pattern = "^(null|Null|NULL|\\~|true|True|TRUE|false|False|FALSE|y|Y|yes|Yes|YES|n|N|no|No|NO|on|On|ON|off|Off|OFF|[-+]?0b[0-1_]+|[-+]?0o?[0-7_]+|[-+]?(0|[1-9][0-9_]*)|[-+]?0x[0-9a-fA-F_]+|[-+]?[1-9][0-9_]*(:[0-5]?[0-9])+|[-+]?([0-9][0-9_]*)?\\.[0-9_]*([eE][-+][0-9]+)?|[-+]?[0-9][0-9_]*(:[0-5]?[0-9])+\\.[0-9_]*|[-+]?\\.(inf|Inf|INF)|\\.(nan|NaN|NAN))$";

		public <0162706c-c168-4372-b87d-6cd624ba9304>TypeAssigningEventEmitter(<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter nextEmitter, bool requireTagWhenStaticAndActualTypesAreDifferent, IDictionary<Type, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName> tagMappings, bool quoteNecessaryStrings, bool quoteYaml1_1Strings)
			: this(nextEmitter, requireTagWhenStaticAndActualTypesAreDifferent, tagMappings)
		{
			this.quoteNecessaryStrings = quoteNecessaryStrings;
			isSpecialStringValue_Regex = new Regex(quoteYaml1_1Strings ? CombinedYaml1_1SpecialStrings_Pattern : SpecialStrings_Pattern, RegexOptions.Compiled);
		}

		public <0162706c-c168-4372-b87d-6cd624ba9304>TypeAssigningEventEmitter(<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter nextEmitter, bool requireTagWhenStaticAndActualTypesAreDifferent, IDictionary<Type, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName> tagMappings, bool quoteNecessaryStrings)
			: this(nextEmitter, requireTagWhenStaticAndActualTypesAreDifferent, tagMappings)
		{
			this.quoteNecessaryStrings = quoteNecessaryStrings;
			isSpecialStringValue_Regex = new Regex(SpecialStrings_Pattern, RegexOptions.Compiled);
		}

		public <0162706c-c168-4372-b87d-6cd624ba9304>TypeAssigningEventEmitter(<95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter nextEmitter, bool requireTagWhenStaticAndActualTypesAreDifferent, IDictionary<Type, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName> tagMappings)
			: base(nextEmitter)
		{
			this.requireTagWhenStaticAndActualTypesAreDifferent = requireTagWhenStaticAndActualTypesAreDifferent;
			this.tagMappings = tagMappings ?? throw new ArgumentNullException("tagMappings");
		}

		public override void Emit(<4f19da32-6bd3-477f-8fb8-71554a9f7201>ScalarEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter)
		{
			<04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle style = <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Plain;
			object value = eventInfo.Source.Value;
			if (value == null)
			{
				eventInfo.Tag = <fe4ef112-43d5-48b5-a3a3-86cc5a0fcc5b>JsonSchema.Tags.Null;
				eventInfo.RenderedValue = "";
			}
			else
			{
				TypeCode typeCode = <397f8e31-bc53-4ed5-b3c2-66ee3558e043>ReflectionExtensions.GetTypeCode(eventInfo.Source.Type);
				switch (typeCode)
				{
				case TypeCode.Boolean:
					eventInfo.Tag = <fe4ef112-43d5-48b5-a3a3-86cc5a0fcc5b>JsonSchema.Tags.Bool;
					eventInfo.RenderedValue = <871006a4-e3e9-4119-89bb-05c311a2f23b>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 (eventInfo.Source.Type.IsEnum)
					{
						eventInfo.Tag = <4cc800bb-1836-48cd-a3e0-17306397eb4e>FailsafeSchema.Tags.Str;
						eventInfo.RenderedValue = value.ToString();
						style = ((quoteNecessaryStrings && IsSpecialStringValue(eventInfo.RenderedValue)) ? <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.DoubleQuoted : <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Any);
					}
					else
					{
						eventInfo.Tag = <fe4ef112-43d5-48b5-a3a3-86cc5a0fcc5b>JsonSchema.Tags.Int;
						eventInfo.RenderedValue = <871006a4-e3e9-4119-89bb-05c311a2f23b>YamlFormatter.FormatNumber(value);
					}
					break;
				case TypeCode.Single:
					eventInfo.Tag = <fe4ef112-43d5-48b5-a3a3-86cc5a0fcc5b>JsonSchema.Tags.Float;
					eventInfo.RenderedValue = <871006a4-e3e9-4119-89bb-05c311a2f23b>YamlFormatter.FormatNumber((float)value);
					break;
				case TypeCode.Double:
					eventInfo.Tag = <fe4ef112-43d5-48b5-a3a3-86cc5a0fcc5b>JsonSchema.Tags.Float;
					eventInfo.RenderedValue = <871006a4-e3e9-4119-89bb-05c311a2f23b>YamlFormatter.FormatNumber((double)value);
					break;
				case TypeCode.Decimal:
					eventInfo.Tag = <fe4ef112-43d5-48b5-a3a3-86cc5a0fcc5b>JsonSchema.Tags.Float;
					eventInfo.RenderedValue = <871006a4-e3e9-4119-89bb-05c311a2f23b>YamlFormatter.FormatNumber(value);
					break;
				case TypeCode.Char:
				case TypeCode.String:
					eventInfo.Tag = <4cc800bb-1836-48cd-a3e0-17306397eb4e>FailsafeSchema.Tags.Str;
					eventInfo.RenderedValue = value.ToString();
					style = ((quoteNecessaryStrings && IsSpecialStringValue(eventInfo.RenderedValue)) ? <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.DoubleQuoted : <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Any);
					break;
				case TypeCode.DateTime:
					eventInfo.Tag = <81f08b43-1c97-4f9b-b979-a743caedabb3>DefaultSchema.Tags.Timestamp;
					eventInfo.RenderedValue = <871006a4-e3e9-4119-89bb-05c311a2f23b>YamlFormatter.FormatDateTime(value);
					break;
				case TypeCode.Empty:
					eventInfo.Tag = <fe4ef112-43d5-48b5-a3a3-86cc5a0fcc5b>JsonSchema.Tags.Null;
					eventInfo.RenderedValue = "";
					break;
				default:
					if (eventInfo.Source.Type == typeof(TimeSpan))
					{
						eventInfo.RenderedValue = <871006a4-e3e9-4119-89bb-05c311a2f23b>YamlFormatter.FormatTimeSpan(value);
						break;
					}
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
			}
			eventInfo.IsPlainImplicit = true;
			if (eventInfo.Style == <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Any)
			{
				eventInfo.Style = style;
			}
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(<808a48ba-4a82-4d7c-9d8a-7016aba735c4>MappingStartEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter)
		{
			AssignTypeIfNeeded(eventInfo);
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(<b57e9ab0-e846-43da-873c-969a61caa7de>SequenceStartEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter)
		{
			AssignTypeIfNeeded(eventInfo);
			base.Emit(eventInfo, emitter);
		}

		private void AssignTypeIfNeeded(<4f252c9c-9664-4495-9ef7-6fe67855a8cf>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 <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>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 + "));");
			}
		}

		private bool IsSpecialStringValue(string value)
		{
			if (value.Trim() == string.Empty)
			{
				return true;
			}
			return isSpecialStringValue_Regex?.IsMatch(value) ?? false;
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <7f037384-521e-4d90-8f63-105fac34d3ce>WriterEventEmitter : <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter
	{
		void <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter.Emit(<f4cbcba3-c718-4c5d-8fe8-dc444ac4fa0d>AliasEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter)
		{
			emitter.Emit(new <4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias(eventInfo.Alias));
		}

		void <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter.Emit(<4f19da32-6bd3-477f-8fb8-71554a9f7201>ScalarEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter)
		{
			emitter.Emit(new <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar(eventInfo.Anchor, eventInfo.Tag, eventInfo.RenderedValue, eventInfo.Style, eventInfo.IsPlainImplicit, eventInfo.IsQuotedImplicit));
		}

		void <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter.Emit(<808a48ba-4a82-4d7c-9d8a-7016aba735c4>MappingStartEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter)
		{
			emitter.Emit(new <fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart(eventInfo.Anchor, eventInfo.Tag, eventInfo.IsImplicit, eventInfo.Style));
		}

		void <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter.Emit(<c472ed17-bdcd-472b-9699-e0216ea33fe7>MappingEndEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter)
		{
			emitter.Emit(new <d66b1b5c-22da-4393-8f8d-68d3635cb59f>MappingEnd());
		}

		void <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter.Emit(<b57e9ab0-e846-43da-873c-969a61caa7de>SequenceStartEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter)
		{
			emitter.Emit(new <743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart(eventInfo.Anchor, eventInfo.Tag, eventInfo.IsImplicit, eventInfo.Style));
		}

		void <95bf0512-d0e3-421e-aa65-7291934fb925>IEventEmitter.Emit(<0b6d516e-249c-42e6-bb74-a0db4a9b3ce8>SequenceEndEventInfo eventInfo, <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter)
		{
			emitter.Emit(new <7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd());
		}
	}
}
namespace YamlDotNet.Serialization.Converters
{
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal class <f913999a-7bed-4589-ae4f-dd322e04e734>DateTimeConverter : <ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter
	{
		private readonly DateTimeKind kind;

		private readonly IFormatProvider provider;

		private readonly bool doubleQuotes;

		private readonly string[] formats;

		public <f913999a-7bed-4589-ae4f-dd322e04e734>DateTimeConverter(DateTimeKind kind = DateTimeKind.Utc, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] IFormatProvider provider = null, bool doubleQuotes = false, params string[] formats)
		{
			this.kind = ((kind == DateTimeKind.Unspecified) ? DateTimeKind.Utc : kind);
			this.provider = provider ?? CultureInfo.InvariantCulture;
			this.doubleQuotes = doubleQuotes;
			this.formats = formats.DefaultIfEmpty("G").ToArray();
		}

		public bool Accepts(Type type)
		{
			return type == typeof(DateTime);
		}

		public object ReadYaml(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type type)
		{
			return EnsureDateTimeKind(DateTime.ParseExact(parser.Consume<<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar>().Value, style: (kind == DateTimeKind.Local) ? DateTimeStyles.AssumeLocal : DateTimeStyles.AssumeUniversal, formats: formats, provider: provider), kind);
		}

		public void WriteYaml(<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>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 <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName.Empty, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName.Empty, value2, doubleQuotes ? <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.DoubleQuoted : <04315b26-e1c8-4e5a-93f2-a3194d527695>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;
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal class <2d47cdac-8cd8-47ea-80bc-fc9e84fda98a>GuidConverter : <ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter
	{
		private readonly bool jsonCompatible;

		public <2d47cdac-8cd8-47ea-80bc-fc9e84fda98a>GuidConverter(bool jsonCompatible)
		{
			this.jsonCompatible = jsonCompatible;
		}

		public bool Accepts(Type type)
		{
			return type == typeof(Guid);
		}

		public object ReadYaml(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type type)
		{
			return new Guid(parser.Consume<<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar>().Value);
		}

		public void WriteYaml(<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object value, Type type)
		{
			Guid guid = (Guid)value;
			emitter.Emit(new <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName.Empty, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName.Empty, guid.ToString("D"), jsonCompatible ? <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.DoubleQuoted : <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal class <a965b595-6158-457a-83bb-f3cb9cd014d7>SystemTypeConverter : <ddaaa542-dd60-4d14-a733-9acfc1784a67>IYamlTypeConverter
	{
		public bool Accepts(Type type)
		{
			return typeof(Type).IsAssignableFrom(type);
		}

		public object ReadYaml(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type type)
		{
			return Type.GetType(parser.Consume<<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar>().Value, throwOnError: true);
		}

		public void WriteYaml(<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] object value, Type type)
		{
			Type type2 = (Type)value;
			emitter.Emit(new <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName.Empty, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName.Empty, type2.AssemblyQualifiedName, <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
}
namespace YamlDotNet.Serialization.BufferedDeserialization
{
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface ITypeDiscriminatingNodeDeserializerOptions
	{
		void AddTypeDiscriminator(ITypeDiscriminator discriminator);

		void AddKeyValueTypeDiscriminator<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] T>(string discriminatorKey, IDictionary<string, Type> valueTypeMapping);

		void AddUniqueKeyTypeDiscriminator<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] T>(IDictionary<string, Type> uniqueKeyTypeMapping);
	}
	internal class ParserBuffer : <407d9ba3-b48b-4abf-9738-5195e80ae436>IParser
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)]
		private readonly LinkedList<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> buffer;

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 2, 1 })]
		private LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> current;

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent Current
		{
			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
			get
			{
				return current?.Value;
			}
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public ParserBuffer(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parserToBuffer, int maxDepth, int maxLength)
		{
			buffer = new LinkedList<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent>();
			buffer.AddLast(parserToBuffer.Consume<<fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart>());
			int num = 0;
			do
			{
				<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent = parserToBuffer.Consume<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent>();
				num += <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent.NestingIncrease;
				buffer.AddLast(<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent);
				if (maxDepth > -1 && num > maxDepth)
				{
					throw new ArgumentOutOfRangeException("parserToBuffer", "Parser buffer exceeded max depth");
				}
				if (maxLength > -1 && buffer.Count > maxLength)
				{
					throw new ArgumentOutOfRangeException("parserToBuffer", "Parser buffer exceeded max length");
				}
			}
			while (num >= 0);
			current = buffer.First;
		}

		public bool MoveNext()
		{
			current = current?.Next;
			return current != null;
		}

		public void Reset()
		{
			current = buffer.First;
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal class TypeDiscriminatingNodeDeserializer : <1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer
	{
		private readonly IList<<1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer> innerDeserializers;

		private readonly IList<ITypeDiscriminator> typeDiscriminators;

		private readonly int maxDepthToBuffer;

		private readonly int maxLengthToBuffer;

		public TypeDiscriminatingNodeDeserializer(IList<<1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer> innerDeserializers, IList<ITypeDiscriminator> typeDiscriminators, int maxDepthToBuffer, int maxLengthToBuffer)
		{
			this.innerDeserializers = innerDeserializers;
			this.typeDiscriminators = typeDiscriminators;
			this.maxDepthToBuffer = maxDepthToBuffer;
			this.maxLengthToBuffer = maxLengthToBuffer;
		}

		public bool Deserialize(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser reader, Type expectedType, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser, Type, object> nestedObjectDeserializer, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] out object value)
		{
			if (!reader.Accept<<fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart>(out var _))
			{
				value = null;
				return false;
			}
			IEnumerable<ITypeDiscriminator> enumerable = typeDiscriminators.Where([<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] (ITypeDiscriminator t) => t.BaseType.IsAssignableFrom(expectedType));
			if (!enumerable.Any())
			{
				value = null;
				return false;
			}
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = reader.Current.Start;
			Type expectedType2 = expectedType;
			ParserBuffer parserBuffer;
			try
			{
				parserBuffer = new ParserBuffer(reader, maxDepthToBuffer, maxLengthToBuffer);
			}
			catch (Exception innerException)
			{
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = reader.Current.End;
				throw new <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException(in start, in end, "Failed to buffer yaml node", innerException);
			}
			try
			{
				foreach (ITypeDiscriminator item in enumerable)
				{
					parserBuffer.Reset();
					if (item.TryDiscriminate(parserBuffer, out var suggestedType))
					{
						expectedType2 = suggestedType;
						break;
					}
				}
			}
			catch (Exception innerException2)
			{
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = reader.Current.End;
				throw new <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException(in start, in end, "Failed to discriminate type", innerException2);
			}
			parserBuffer.Reset();
			foreach (<1bc1410e-9997-4c8a-b647-73d87f5cc948>INodeDeserializer innerDeserializer in innerDeserializers)
			{
				if (innerDeserializer.Deserialize(parserBuffer, expectedType2, nestedObjectDeserializer, out value))
				{
					return true;
				}
			}
			value = null;
			return false;
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal class TypeDiscriminatingNodeDeserializerOptions : ITypeDiscriminatingNodeDeserializerOptions
	{
		internal readonly List<ITypeDiscriminator> discriminators = new List<ITypeDiscriminator>();

		public void AddTypeDiscriminator(ITypeDiscriminator discriminator)
		{
			discriminators.Add(discriminator);
		}

		public void AddKeyValueTypeDiscriminator<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] T>(string discriminatorKey, IDictionary<string, Type> valueTypeMapping)
		{
			discriminators.Add(new KeyValueTypeDiscriminator(typeof(T), discriminatorKey, valueTypeMapping));
		}

		public void AddUniqueKeyTypeDiscriminator<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] T>(IDictionary<string, Type> uniqueKeyTypeMapping)
		{
			discriminators.Add(new UniqueKeyTypeDiscriminator(typeof(T), uniqueKeyTypeMapping));
		}
	}
}
namespace YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators
{
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface ITypeDiscriminator
	{
		Type BaseType { get; }

		bool TryDiscriminate(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser buffer, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] out Type suggestedType);
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal class KeyValueTypeDiscriminator : ITypeDiscriminator
	{
		private readonly string targetKey;

		private readonly IDictionary<string, Type> typeMapping;

		public Type BaseType { get; private set; }

		public KeyValueTypeDiscriminator(Type baseType, string targetKey, IDictionary<string, Type> typeMapping)
		{
			foreach (KeyValuePair<string, Type> item in typeMapping)
			{
				if (!baseType.IsAssignableFrom(item.Value))
				{
					throw new ArgumentOutOfRangeException("typeMapping", $"{item.Value} is not a assignable to {baseType}");
				}
			}
			BaseType = baseType;
			this.targetKey = targetKey;
			this.typeMapping = typeMapping;
		}

		public bool TryDiscriminate(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] out Type suggestedType)
		{
			if (parser.TryFindMappingEntry((<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar scalar) => targetKey == scalar.Value, out var _, out var value) && value is <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar && typeMapping.TryGetValue(<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar.Value, out var value2))
			{
				suggestedType = value2;
				return true;
			}
			suggestedType = null;
			return false;
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal class UniqueKeyTypeDiscriminator : ITypeDiscriminator
	{
		private readonly IDictionary<string, Type> typeMapping;

		public Type BaseType { get; private set; }

		public UniqueKeyTypeDiscriminator(Type baseType, IDictionary<string, Type> typeMapping)
		{
			foreach (KeyValuePair<string, Type> item in typeMapping)
			{
				if (!baseType.IsAssignableFrom(item.Value))
				{
					throw new ArgumentOutOfRangeException("typeMapping", $"{item.Value} is not a assignable to {baseType}");
				}
			}
			BaseType = baseType;
			this.typeMapping = typeMapping;
		}

		public bool TryDiscriminate(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] out Type suggestedType)
		{
			if (parser.TryFindMappingEntry((<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar scalar) => typeMapping.ContainsKey(scalar.Value), out var key, out var _))
			{
				suggestedType = typeMapping[key.Value];
				return true;
			}
			suggestedType = null;
			return false;
		}
	}
}
namespace YamlDotNet.RepresentationModel
{
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal class <7506c752-d234-4f88-bfa1-d454d856079b>DocumentLoadingState
	{
		private readonly IDictionary<<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> anchors = new Dictionary<<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode>();

		private readonly IList<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> nodesWithUnresolvedAliases = new List<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode>();

		public void AddAnchor(<baea0867-7910-48aa-b296-31b4ec94d386>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 <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode GetNode(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName anchor, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
		{
			if (anchors.TryGetValue(anchor, out var value))
			{
				return value;
			}
			throw new <4f2cacbe-02ea-431a-887c-d7f399046b70>AnchorNotFoundException(in start, in end, $"The anchor '{anchor}' does not exists");
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		public bool TryGetNode(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName anchor, [<4240ea5d-1d18-4a74-bdd9-8446445c7160>NotNullWhen(true)] out <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode node)
		{
			return anchors.TryGetValue(anchor, out node);
		}

		public void AddNodeWithUnresolvedAliases(<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode node)
		{
			nodesWithUnresolvedAliases.Add(node);
		}

		public void ResolveAliases()
		{
			foreach (<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode nodesWithUnresolvedAlias in nodesWithUnresolvedAliases)
			{
				nodesWithUnresolvedAlias.ResolveAliases(this);
			}
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal class <a7df5b9a-6555-46b0-b1d1-7446fa4d73e2>EmitterState
	{
		public HashSet<<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName> EmittedAnchors { get; } = new HashSet<<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName>();

	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface <5f0b6a4d-0afb-44d8-bc8e-0dd316c6a6b5>IYamlVisitor
	{
		void Visit(<5869c9fb-e391-418e-aaac-5de81b4a93bf>YamlStream stream);

		void Visit(<80682ba2-0354-464b-979a-4e38d218837b>YamlDocument document);

		void Visit(<684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode scalar);

		void Visit(<1eaf8499-b05e-49d4-9327-336a1edacbc5>YamlSequenceNode sequence);

		void Visit(<db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode mapping);
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal class <5bd3f052-ff5b-4c18-989c-cada33383738>LibYamlEventStream
	{
		private readonly <407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser;

		public <5bd3f052-ff5b-4c18-989c-cada33383738>LibYamlEventStream(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser iParser)
		{
			parser = iParser ?? throw new ArgumentNullException("iParser");
		}

		public void WriteTo(TextWriter textWriter)
		{
			while (parser.MoveNext())
			{
				<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent current = parser.Current;
				if (!(current is <4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias <4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias))
				{
					if (!(current is <c51742f9-fbb1-469d-bb0b-e52d59018ce6>DocumentEnd <c51742f9-fbb1-469d-bb0b-e52d59018ce6>DocumentEnd))
					{
						if (!(current is <b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart <b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart))
						{
							if (!(current is <d66b1b5c-22da-4393-8f8d-68d3635cb59f>MappingEnd))
							{
								if (!(current is <fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart nodeEvent))
								{
									if (!(current is <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar))
									{
										if (!(current is <7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd))
										{
											if (!(current is <743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart nodeEvent2))
											{
												if (!(current is <639c5f87-0aee-41c1-9e7d-0f8ace8688c9>StreamEnd))
												{
													if (current is <b0b23517-beda-496a-8223-4c3554a848bc>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, <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar);
										switch (<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar.Style)
										{
										case <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.DoubleQuoted:
											textWriter.Write(" \"");
											break;
										case <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.SingleQuoted:
											textWriter.Write(" '");
											break;
										case <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Folded:
											textWriter.Write(" >");
											break;
										case <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Literal:
											textWriter.Write(" |");
											break;
										default:
											textWriter.Write(" :");
											break;
										}
										string value = <6de52a3a-4363-4642-b572-ff69e9dc189e>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 (!<b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart.IsImplicit)
							{
								textWriter.Write(" ---");
							}
						}
					}
					else
					{
						textWriter.Write("-DOC");
						if (!<c51742f9-fbb1-469d-bb0b-e52d59018ce6>DocumentEnd.IsImplicit)
						{
							textWriter.Write(" ...");
						}
					}
				}
				else
				{
					textWriter.Write("=ALI *");
					textWriter.Write(<4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias.Value);
				}
				textWriter.WriteLine();
			}
		}

		private void WriteAnchorAndTag(TextWriter textWriter, <17b80f1e-db12-4b74-94e4-11fb84cb3a26>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(">");
			}
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal class <0c1c94fb-c9a7-42d2-b4c5-6cf925fd88ba>YamlAliasNode : <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode
	{
		public override <0c16c96b-61f1-4e07-8c68-ccc5f128c522>YamlNodeType NodeType => <0c16c96b-61f1-4e07-8c68-ccc5f128c522>YamlNodeType.Alias;

		internal <0c1c94fb-c9a7-42d2-b4c5-6cf925fd88ba>YamlAliasNode(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName anchor)
		{
			base.Anchor = anchor;
		}

		internal override void ResolveAliases(<7506c752-d234-4f88-bfa1-d454d856079b>DocumentLoadingState state)
		{
			throw new NotSupportedException("Resolving an alias on an alias node does not make sense");
		}

		internal override void Emit(<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, <a7df5b9a-6555-46b0-b1d1-7446fa4d73e2>EmitterState state)
		{
			throw new NotSupportedException("A YamlAliasNode is an implementation detail and should never be saved.");
		}

		public override void Accept(<5f0b6a4d-0afb-44d8-bc8e-0dd316c6a6b5>IYamlVisitor visitor)
		{
			throw new NotSupportedException("A YamlAliasNode is an implementation detail and should never be visited.");
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (obj is <0c1c94fb-c9a7-42d2-b4c5-6cf925fd88ba>YamlAliasNode <0c1c94fb-c9a7-42d2-b4c5-6cf925fd88ba>YamlAliasNode2 && Equals(<0c1c94fb-c9a7-42d2-b4c5-6cf925fd88ba>YamlAliasNode2))
			{
				return object.Equals(base.Anchor, <0c1c94fb-c9a7-42d2-b4c5-6cf925fd88ba>YamlAliasNode2.Anchor);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		internal override string ToString(<b9d7e607-dcfe-4df1-bf3c-9b1dc2a136dc>RecursionLevel level)
		{
			return "*" + base.Anchor.ToString();
		}

		internal override IEnumerable<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> SafeAllNodes(<b9d7e607-dcfe-4df1-bf3c-9b1dc2a136dc>RecursionLevel level)
		{
			yield return this;
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal class <80682ba2-0354-464b-979a-4e38d218837b>YamlDocument
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
		private class AnchorAssigningVisitor : <c260cd84-e678-44ea-bbe9-8343b65b5b70>YamlVisitorBase
		{
			private readonly HashSet<<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName> existingAnchors = new HashSet<<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName>();

			private readonly Dictionary<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, bool> visitedNodes = new Dictionary<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, bool>();

			public void AssignAnchors(<80682ba2-0354-464b-979a-4e38d218837b>YamlDocument document)
			{
				existingAnchors.Clear();
				visitedNodes.Clear();
				document.Accept(this);
				Random random = new Random();
				foreach (KeyValuePair<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, bool> visitedNode in visitedNodes)
				{
					if (!visitedNode.Value)
					{
						continue;
					}
					<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName;
					if (!visitedNode.Key.Anchor.IsEmpty && !existingAnchors.Contains(visitedNode.Key.Anchor))
					{
						<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName = visitedNode.Key.Anchor;
					}
					else
					{
						do
						{
							<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName = new <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName(random.Next().ToString(CultureInfo.InvariantCulture));
						}
						while (existingAnchors.Contains(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName));
					}
					existingAnchors.Add(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName);
					visitedNode.Key.Anchor = <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName;
				}
			}

			private bool VisitNodeAndFindDuplicates(<baea0867-7910-48aa-b296-31b4ec94d386>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(<684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode scalar)
			{
				VisitNodeAndFindDuplicates(scalar);
			}

			public override void Visit(<db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode mapping)
			{
				if (!VisitNodeAndFindDuplicates(mapping))
				{
					base.Visit(mapping);
				}
			}

			public override void Visit(<1eaf8499-b05e-49d4-9327-336a1edacbc5>YamlSequenceNode sequence)
			{
				if (!VisitNodeAndFindDuplicates(sequence))
				{
					base.Visit(sequence);
				}
			}
		}

		public <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode RootNode { get; private set; }

		public IEnumerable<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> AllNodes => RootNode.AllNodes;

		public <80682ba2-0354-464b-979a-4e38d218837b>YamlDocument(<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode rootNode)
		{
			RootNode = rootNode;
		}

		public <80682ba2-0354-464b-979a-4e38d218837b>YamlDocument(string rootNode)
		{
			RootNode = new <684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode(rootNode);
		}

		internal <80682ba2-0354-464b-979a-4e38d218837b>YamlDocument(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser)
		{
			<7506c752-d234-4f88-bfa1-d454d856079b>DocumentLoadingState <7506c752-d234-4f88-bfa1-d454d856079b>DocumentLoadingState2 = new <7506c752-d234-4f88-bfa1-d454d856079b>DocumentLoadingState();
			parser.Consume<<b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart>();
			<c51742f9-fbb1-469d-bb0b-e52d59018ce6>DocumentEnd @event;
			while (!parser.TryConsume<<c51742f9-fbb1-469d-bb0b-e52d59018ce6>DocumentEnd>(out @event))
			{
				RootNode = <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode.ParseNode(parser, <7506c752-d234-4f88-bfa1-d454d856079b>DocumentLoadingState2);
				if (RootNode is <0c1c94fb-c9a7-42d2-b4c5-6cf925fd88ba>YamlAliasNode)
				{
					throw new <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException("A document cannot contain only an alias");
				}
			}
			<7506c752-d234-4f88-bfa1-d454d856079b>DocumentLoadingState2.ResolveAliases();
			if (RootNode == null)
			{
				throw new ArgumentException("Atempted to parse an empty document");
			}
		}

		private void AssignAnchors()
		{
			new AnchorAssigningVisitor().AssignAnchors(this);
		}

		internal void Save(<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, bool assignAnchors = true)
		{
			if (assignAnchors)
			{
				AssignAnchors();
			}
			emitter.Emit(new <b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart());
			RootNode.Save(emitter, new <a7df5b9a-6555-46b0-b1d1-7446fa4d73e2>EmitterState());
			emitter.Emit(new <c51742f9-fbb1-469d-bb0b-e52d59018ce6>DocumentEnd(isImplicit: false));
		}

		public void Accept(<5f0b6a4d-0afb-44d8-bc8e-0dd316c6a6b5>IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode : <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, IEnumerable<KeyValuePair<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode>>, IEnumerable, <f8718f3a-c5b2-48c8-81a0-662be8a96cd4>IYamlConvertible
	{
		private readonly <5d16835c-be2f-4a0e-b3a3-7dcd638944d5>OrderedDictionary<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> children = new <5d16835c-be2f-4a0e-b3a3-7dcd638944d5>OrderedDictionary<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode>();

		public <f6af5cd1-a558-4895-8a20-098f874d255c>IOrderedDictionary<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> Children => children;

		public <5bdd0818-2e61-4148-a2dc-8d667b816026>MappingStyle Style { get; set; }

		public override <0c16c96b-61f1-4e07-8c68-ccc5f128c522>YamlNodeType NodeType => <0c16c96b-61f1-4e07-8c68-ccc5f128c522>YamlNodeType.Mapping;

		internal <db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, <7506c752-d234-4f88-bfa1-d454d856079b>DocumentLoadingState state)
		{
			Load(parser, state);
		}

		private void Load(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, <7506c752-d234-4f88-bfa1-d454d856079b>DocumentLoadingState state)
		{
			<fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart <fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart = parser.Consume<<fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart>();
			Load(<fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart, state);
			Style = <fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart.Style;
			bool flag = false;
			<d66b1b5c-22da-4393-8f8d-68d3635cb59f>MappingEnd @event;
			while (!parser.TryConsume<<d66b1b5c-22da-4393-8f8d-68d3635cb59f>MappingEnd>(out @event))
			{
				<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode2 = <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode.ParseNode(parser, state);
				<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode3 = <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode.ParseNode(parser, state);
				try
				{
					children.Add(<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode2, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode3);
				}
				catch (ArgumentException innerException)
				{
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode2.Start;
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode2.End;
					throw new <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException(in start, in end, "Duplicate key", innerException);
				}
				flag = flag || <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode2 is <0c1c94fb-c9a7-42d2-b4c5-6cf925fd88ba>YamlAliasNode || <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode3 is <0c1c94fb-c9a7-42d2-b4c5-6cf925fd88ba>YamlAliasNode;
			}
			if (flag)
			{
				state.AddNodeWithUnresolvedAliases(this);
			}
		}

		public <db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode()
		{
		}

		public <db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 0, 1, 1 })] params KeyValuePair<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode>[] children)
			: this((IEnumerable<KeyValuePair<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode>>)children)
		{
		}

		public <db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 0, 1, 1 })] IEnumerable<KeyValuePair<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode>> children)
		{
			foreach (KeyValuePair<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> child in children)
			{
				this.children.Add(child);
			}
		}

		public <db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode(params <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode[] children)
			: this((IEnumerable<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode>)children)
		{
		}

		public <db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode(IEnumerable<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> children)
		{
			using IEnumerator<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> enumerator = children.GetEnumerator();
			while (enumerator.MoveNext())
			{
				<baea0867-7910-48aa-b296-31b4ec94d386>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(<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode key, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode value)
		{
			children.Add(key, value);
		}

		public void Add(string key, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode value)
		{
			children.Add(new <684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode(key), value);
		}

		public void Add(<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode key, string value)
		{
			children.Add(key, new <684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode(value));
		}

		public void Add(string key, string value)
		{
			children.Add(new <684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode(key), new <684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode(value));
		}

		internal override void ResolveAliases(<7506c752-d234-4f88-bfa1-d454d856079b>DocumentLoadingState state)
		{
			Dictionary<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> dictionary = null;
			Dictionary<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> dictionary2 = null;
			foreach (KeyValuePair<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> child in children)
			{
				if (child.Key is <0c1c94fb-c9a7-42d2-b4c5-6cf925fd88ba>YamlAliasNode)
				{
					if (dictionary == null)
					{
						dictionary = new Dictionary<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode>();
					}
					dictionary.Add(child.Key, state.GetNode(child.Key.Anchor, child.Key.Start, child.Key.End));
				}
				if (child.Value is <0c1c94fb-c9a7-42d2-b4c5-6cf925fd88ba>YamlAliasNode)
				{
					if (dictionary2 == null)
					{
						dictionary2 = new Dictionary<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode>();
					}
					dictionary2.Add(child.Key, state.GetNode(child.Value.Anchor, child.Value.Start, child.Value.End));
				}
			}
			if (dictionary2 != null)
			{
				foreach (KeyValuePair<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> item in dictionary2)
				{
					children[item.Key] = item.Value;
				}
			}
			if (dictionary == null)
			{
				return;
			}
			foreach (KeyValuePair<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> item2 in dictionary)
			{
				<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode value = children[item2.Key];
				children.Remove(item2.Key);
				children.Add(item2.Value, value);
			}
		}

		internal override void Emit(<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, <a7df5b9a-6555-46b0-b1d1-7446fa4d73e2>EmitterState state)
		{
			emitter.Emit(new <fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart(base.Anchor, base.Tag, isImplicit: true, Style));
			foreach (KeyValuePair<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> child in children)
			{
				child.Key.Save(emitter, state);
				child.Value.Save(emitter, state);
			}
			emitter.Emit(new <d66b1b5c-22da-4393-8f8d-68d3635cb59f>MappingEnd());
		}

		public override void Accept(<5f0b6a4d-0afb-44d8-bc8e-0dd316c6a6b5>IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (!(obj is <db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode <db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode2) || !object.Equals(base.Tag, <db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode2.Tag) || children.Count != <db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode2.children.Count)
			{
				return false;
			}
			foreach (KeyValuePair<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> child in children)
			{
				if (!<db31f6e9-d5d5-40db-8d1e-3615c465f1aa>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<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> child in children)
			{
				num = <21fc5b2a-a319-41bc-aa9e-d22bcde3f1bb>HashCode.CombineHashCodes(num, child.Key);
				num = <21fc5b2a-a319-41bc-aa9e-d22bcde3f1bb>HashCode.CombineHashCodes(num, child.Value);
			}
			return num;
		}

		internal override IEnumerable<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> SafeAllNodes(<b9d7e607-dcfe-4df1-bf3c-9b1dc2a136dc>RecursionLevel level)
		{
			level.Increment();
			yield return this;
			foreach (KeyValuePair<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> child in children)
			{
				foreach (<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode item in child.Key.SafeAllNodes(level))
				{
					yield return item;
				}
				foreach (<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode item2 in child.Value.SafeAllNodes(level))
				{
					yield return item2;
				}
			}
			level.Decrement();
		}

		internal override string ToString(<b9d7e607-dcfe-4df1-bf3c-9b1dc2a136dc>RecursionLevel level)
		{
			if (!level.TryIncrement())
			{
				return "WARNING! INFINITE RECURSION!";
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				builder.Append("{ ");
				foreach (KeyValuePair<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> child in children)
				{
					if (builder.Length > 2)
					{
						builder.Append(", ");
					}
					builder.Append("{ ").Append(child.Key.ToString(level)).Append(", ")
						.Append(child.Value.ToString(level))
						.Append(" }");
				}
				builder.Append(" }");
				level.Decrement();
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 0, 1, 1 })]
		public IEnumerator<KeyValuePair<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode>> GetEnumerator()
		{
			return children.GetEnumerator();
		}

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

		void <f8718f3a-c5b2-48c8-81a0-662be8a96cd4>IYamlConvertible.Read(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type expectedType, <97d1143a-e250-473f-8f49-4efad2c2274e>ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new <7506c752-d234-4f88-bfa1-d454d856079b>DocumentLoadingState());
		}

		void <f8718f3a-c5b2-48c8-81a0-662be8a96cd4>IYamlConvertible.Write(<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, <50dc5b9c-d2ff-457e-b37e-4022fe8e6bb7>ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new <a7df5b9a-6555-46b0-b1d1-7446fa4d73e2>EmitterState());
		}

		public static <db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode FromObject(object mapping)
		{
			if (mapping == null)
			{
				throw new ArgumentNullException("mapping");
			}
			<db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode <db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode2 = new <db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode();
			foreach (PropertyInfo publicProperty in <397f8e31-bc53-4ed5-b3c2-66ee3558e043>ReflectionExtensions.GetPublicProperties(mapping.GetType()))
			{
				if (publicProperty.CanRead && publicProperty.GetGetMethod(nonPublic: false).GetParameters().Length == 0)
				{
					object value = publicProperty.GetValue(mapping, null);
					<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode2 = value as <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode;
					if (<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode2 == null)
					{
						<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode2 = Convert.ToString(value) ?? string.Empty;
					}
					<db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode2.Add(publicProperty.Name, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode2);
				}
			}
			return <db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode2;
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal abstract class <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode
	{
		private const int MaximumRecursionLevel = 1000;

		internal const string MaximumRecursionLevelReachedToStringValue = "WARNING! INFINITE RECURSION!";

		public <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName Anchor { get; set; }

		public <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName Tag { get; set; }

		public <b3f32382-dd1c-454c-b573-36801723d8c1>Mark Start { get; private set; } = <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;


		public <b3f32382-dd1c-454c-b573-36801723d8c1>Mark End { get; private set; } = <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;


		public IEnumerable<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> AllNodes
		{
			get
			{
				<b9d7e607-dcfe-4df1-bf3c-9b1dc2a136dc>RecursionLevel level = new <b9d7e607-dcfe-4df1-bf3c-9b1dc2a136dc>RecursionLevel(1000);
				return SafeAllNodes(level);
			}
		}

		public abstract <0c16c96b-61f1-4e07-8c68-ccc5f128c522>YamlNodeType NodeType { get; }

		public <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode this[int index]
		{
			get
			{
				if (!(this is <1eaf8499-b05e-49d4-9327-336a1edacbc5>YamlSequenceNode <1eaf8499-b05e-49d4-9327-336a1edacbc5>YamlSequenceNode2))
				{
					throw new ArgumentException($"Accessed '{NodeType}' with an invalid index: {index}. Only Sequences can be indexed by number.");
				}
				return <1eaf8499-b05e-49d4-9327-336a1edacbc5>YamlSequenceNode2.Children[index];
			}
		}

		public <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode this[<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode key]
		{
			get
			{
				if (!(this is <db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode <db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode2))
				{
					throw new ArgumentException($"Accessed '{NodeType}' with an invalid index: {key}. Only Mappings can be indexed by key.");
				}
				return <db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode2.Children[key];
			}
		}

		internal void Load(<17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent yamlEvent, <7506c752-d234-4f88-bfa1-d454d856079b>DocumentLoadingState state)
		{
			Tag = yamlEvent.Tag;
			if (!yamlEvent.Anchor.IsEmpty)
			{
				Anchor = yamlEvent.Anchor;
				state.AddAnchor(this);
			}
			Start = yamlEvent.Start;
			End = yamlEvent.End;
		}

		internal static <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode ParseNode(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, <7506c752-d234-4f88-bfa1-d454d856079b>DocumentLoadingState state)
		{
			if (parser.Accept<<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar>(out var _))
			{
				return new <684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode(parser, state);
			}
			if (parser.Accept<<743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart>(out var _))
			{
				return new <1eaf8499-b05e-49d4-9327-336a1edacbc5>YamlSequenceNode(parser, state);
			}
			if (parser.Accept<<fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart>(out var _))
			{
				return new <db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode(parser, state);
			}
			if (parser.TryConsume<<4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias>(out var event4))
			{
				if (!state.TryGetNode(event4.Value, out var node))
				{
					return new <0c1c94fb-c9a7-42d2-b4c5-6cf925fd88ba>YamlAliasNode(event4.Value);
				}
				return node;
			}
			throw new ArgumentException("The current event is of an unsupported type.", "parser");
		}

		internal abstract void ResolveAliases(<7506c752-d234-4f88-bfa1-d454d856079b>DocumentLoadingState state);

		internal void Save(<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, <a7df5b9a-6555-46b0-b1d1-7446fa4d73e2>EmitterState state)
		{
			if (!Anchor.IsEmpty && !state.EmittedAnchors.Add(Anchor))
			{
				emitter.Emit(new <4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias(Anchor));
			}
			else
			{
				Emit(emitter, state);
			}
		}

		internal abstract void Emit(<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, <a7df5b9a-6555-46b0-b1d1-7446fa4d73e2>EmitterState state);

		public abstract void Accept(<5f0b6a4d-0afb-44d8-bc8e-0dd316c6a6b5>IYamlVisitor visitor);

		public override string ToString()
		{
			<b9d7e607-dcfe-4df1-bf3c-9b1dc2a136dc>RecursionLevel <b9d7e607-dcfe-4df1-bf3c-9b1dc2a136dc>RecursionLevel = new <b9d7e607-dcfe-4df1-bf3c-9b1dc2a136dc>RecursionLevel(1000);
			return ToString(<b9d7e607-dcfe-4df1-bf3c-9b1dc2a136dc>RecursionLevel);
		}

		internal abstract string ToString(<b9d7e607-dcfe-4df1-bf3c-9b1dc2a136dc>RecursionLevel level);

		internal abstract IEnumerable<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> SafeAllNodes(<b9d7e607-dcfe-4df1-bf3c-9b1dc2a136dc>RecursionLevel level);

		public static implicit operator <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode(string value)
		{
			return new <684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode(value);
		}

		public static implicit operator <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode(string[] sequence)
		{
			return new <1eaf8499-b05e-49d4-9327-336a1edacbc5>YamlSequenceNode(((IEnumerable<string>)sequence).Select((Func<string, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode>)([<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] (string i) => i)));
		}

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public static explicit operator string(<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode node)
		{
			if (!(node is <684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode <684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode2))
			{
				throw new ArgumentException($"Attempted to convert a '{node.NodeType}' to string. This conversion is valid only for Scalars.");
			}
			return <684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode2.Value;
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <1b75ae0e-9d33-4f9a-b1c5-6f778c554459>YamlNodeIdentityEqualityComparer : IEqualityComparer<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode>
	{
		public bool Equals([<590afc20-c427-4b92-bf6f-e96ab746b8e2>AllowNull] <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode x, [<590afc20-c427-4b92-bf6f-e96ab746b8e2>AllowNull] <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode y)
		{
			return x == y;
		}

		public int GetHashCode(<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode obj)
		{
			return obj.GetHashCode();
		}
	}
	internal enum <0c16c96b-61f1-4e07-8c68-ccc5f128c522>YamlNodeType
	{
		Alias,
		Mapping,
		Scalar,
		Sequence
	}
	[DebuggerDisplay("{Value}")]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode : <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, <f8718f3a-c5b2-48c8-81a0-662be8a96cd4>IYamlConvertible
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		[field: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public string Value
		{
			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
			get;
			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
			set;
		}

		public <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle Style { get; set; }

		public override <0c16c96b-61f1-4e07-8c68-ccc5f128c522>YamlNodeType NodeType => <0c16c96b-61f1-4e07-8c68-ccc5f128c522>YamlNodeType.Scalar;

		internal <684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, <7506c752-d234-4f88-bfa1-d454d856079b>DocumentLoadingState state)
		{
			Load(parser, state);
		}

		private void Load(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, <7506c752-d234-4f88-bfa1-d454d856079b>DocumentLoadingState state)
		{
			<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar = parser.Consume<<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar>();
			Load(<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar, state);
			Value = <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar.Value;
			Style = <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar.Style;
		}

		public <684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode()
		{
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		public <684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode(string value)
		{
			Value = value;
		}

		internal override void ResolveAliases(<7506c752-d234-4f88-bfa1-d454d856079b>DocumentLoadingState state)
		{
			throw new NotSupportedException("Resolving an alias on a scalar node does not make sense");
		}

		internal override void Emit(<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, <a7df5b9a-6555-46b0-b1d1-7446fa4d73e2>EmitterState state)
		{
			emitter.Emit(new <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar(base.Anchor, base.Tag, Value ?? string.Empty, Style, base.Tag.IsEmpty, isQuotedImplicit: false));
		}

		public override void Accept(<5f0b6a4d-0afb-44d8-bc8e-0dd316c6a6b5>IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (obj is <684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode <684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode2 && object.Equals(base.Tag, <684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode2.Tag))
			{
				return object.Equals(Value, <684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode2.Value);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return <21fc5b2a-a319-41bc-aa9e-d22bcde3f1bb>HashCode.CombineHashCodes(base.Tag.GetHashCode(), Value);
		}

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public static explicit operator string(<684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode value)
		{
			return value.Value;
		}

		internal override string ToString(<b9d7e607-dcfe-4df1-bf3c-9b1dc2a136dc>RecursionLevel level)
		{
			return Value ?? string.Empty;
		}

		internal override IEnumerable<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> SafeAllNodes(<b9d7e607-dcfe-4df1-bf3c-9b1dc2a136dc>RecursionLevel level)
		{
			yield return this;
		}

		void <f8718f3a-c5b2-48c8-81a0-662be8a96cd4>IYamlConvertible.Read(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type expectedType, <97d1143a-e250-473f-8f49-4efad2c2274e>ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new <7506c752-d234-4f88-bfa1-d454d856079b>DocumentLoadingState());
		}

		void <f8718f3a-c5b2-48c8-81a0-662be8a96cd4>IYamlConvertible.Write(<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, <50dc5b9c-d2ff-457e-b37e-4022fe8e6bb7>ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new <a7df5b9a-6555-46b0-b1d1-7446fa4d73e2>EmitterState());
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[DebuggerDisplay("Count = {children.Count}")]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <1eaf8499-b05e-49d4-9327-336a1edacbc5>YamlSequenceNode : <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, IEnumerable<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode>, IEnumerable, <f8718f3a-c5b2-48c8-81a0-662be8a96cd4>IYamlConvertible
	{
		private readonly IList<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> children = new List<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode>();

		public IList<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> Children => children;

		public <633aecbb-227c-4a56-bde3-6176f414312f>SequenceStyle Style { get; set; }

		public override <0c16c96b-61f1-4e07-8c68-ccc5f128c522>YamlNodeType NodeType => <0c16c96b-61f1-4e07-8c68-ccc5f128c522>YamlNodeType.Sequence;

		internal <1eaf8499-b05e-49d4-9327-336a1edacbc5>YamlSequenceNode(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, <7506c752-d234-4f88-bfa1-d454d856079b>DocumentLoadingState state)
		{
			Load(parser, state);
		}

		private void Load(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, <7506c752-d234-4f88-bfa1-d454d856079b>DocumentLoadingState state)
		{
			<743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart <743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart = parser.Consume<<743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart>();
			Load(<743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart, state);
			Style = <743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart.Style;
			bool flag = false;
			<7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd @event;
			while (!parser.TryConsume<<7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd>(out @event))
			{
				<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode2 = <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode.ParseNode(parser, state);
				children.Add(<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode2);
				flag = flag || <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode2 is <0c1c94fb-c9a7-42d2-b4c5-6cf925fd88ba>YamlAliasNode;
			}
			if (flag)
			{
				state.AddNodeWithUnresolvedAliases(this);
			}
		}

		public <1eaf8499-b05e-49d4-9327-336a1edacbc5>YamlSequenceNode()
		{
		}

		public <1eaf8499-b05e-49d4-9327-336a1edacbc5>YamlSequenceNode(params <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode[] children)
			: this((IEnumerable<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode>)children)
		{
		}

		public <1eaf8499-b05e-49d4-9327-336a1edacbc5>YamlSequenceNode(IEnumerable<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> children)
		{
			foreach (<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode child in children)
			{
				this.children.Add(child);
			}
		}

		public void Add(<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode child)
		{
			children.Add(child);
		}

		public void Add(string child)
		{
			children.Add(new <684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode(child));
		}

		internal override void ResolveAliases(<7506c752-d234-4f88-bfa1-d454d856079b>DocumentLoadingState state)
		{
			for (int i = 0; i < children.Count; i++)
			{
				if (children[i] is <0c1c94fb-c9a7-42d2-b4c5-6cf925fd88ba>YamlAliasNode)
				{
					children[i] = state.GetNode(children[i].Anchor, children[i].Start, children[i].End);
				}
			}
		}

		internal override void Emit(<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, <a7df5b9a-6555-46b0-b1d1-7446fa4d73e2>EmitterState state)
		{
			emitter.Emit(new <743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart(base.Anchor, base.Tag, base.Tag.IsEmpty, Style));
			foreach (<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode child in children)
			{
				child.Save(emitter, state);
			}
			emitter.Emit(new <7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd());
		}

		public override void Accept(<5f0b6a4d-0afb-44d8-bc8e-0dd316c6a6b5>IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (!(obj is <1eaf8499-b05e-49d4-9327-336a1edacbc5>YamlSequenceNode <1eaf8499-b05e-49d4-9327-336a1edacbc5>YamlSequenceNode2) || !object.Equals(base.Tag, <1eaf8499-b05e-49d4-9327-336a1edacbc5>YamlSequenceNode2.Tag) || children.Count != <1eaf8499-b05e-49d4-9327-336a1edacbc5>YamlSequenceNode2.children.Count)
			{
				return false;
			}
			for (int i = 0; i < children.Count; i++)
			{
				if (!object.Equals(children[i], <1eaf8499-b05e-49d4-9327-336a1edacbc5>YamlSequenceNode2.children[i]))
				{
					return false;
				}
			}
			return true;
		}

		public override int GetHashCode()
		{
			int h = 0;
			foreach (<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode child in children)
			{
				h = <21fc5b2a-a319-41bc-aa9e-d22bcde3f1bb>HashCode.CombineHashCodes(h, child);
			}
			return <21fc5b2a-a319-41bc-aa9e-d22bcde3f1bb>HashCode.CombineHashCodes(h, base.Tag);
		}

		internal override IEnumerable<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> SafeAllNodes(<b9d7e607-dcfe-4df1-bf3c-9b1dc2a136dc>RecursionLevel level)
		{
			level.Increment();
			yield return this;
			foreach (<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode child in children)
			{
				foreach (<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode item in child.SafeAllNodes(level))
				{
					yield return item;
				}
			}
			level.Decrement();
		}

		internal override string ToString(<b9d7e607-dcfe-4df1-bf3c-9b1dc2a136dc>RecursionLevel level)
		{
			if (!level.TryIncrement())
			{
				return "WARNING! INFINITE RECURSION!";
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				builder.Append("[ ");
				foreach (<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode child in children)
				{
					if (builder.Length > 2)
					{
						builder.Append(", ");
					}
					builder.Append(child.ToString(level));
				}
				builder.Append(" ]");
				level.Decrement();
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		public IEnumerator<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> GetEnumerator()
		{
			return Children.GetEnumerator();
		}

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

		void <f8718f3a-c5b2-48c8-81a0-662be8a96cd4>IYamlConvertible.Read(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Type expectedType, <97d1143a-e250-473f-8f49-4efad2c2274e>ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new <7506c752-d234-4f88-bfa1-d454d856079b>DocumentLoadingState());
		}

		void <f8718f3a-c5b2-48c8-81a0-662be8a96cd4>IYamlConvertible.Write(<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, <50dc5b9c-d2ff-457e-b37e-4022fe8e6bb7>ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new <a7df5b9a-6555-46b0-b1d1-7446fa4d73e2>EmitterState());
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal class <5869c9fb-e391-418e-aaac-5de81b4a93bf>YamlStream : IEnumerable<<80682ba2-0354-464b-979a-4e38d218837b>YamlDocument>, IEnumerable
	{
		private readonly IList<<80682ba2-0354-464b-979a-4e38d218837b>YamlDocument> documents = new List<<80682ba2-0354-464b-979a-4e38d218837b>YamlDocument>();

		public IList<<80682ba2-0354-464b-979a-4e38d218837b>YamlDocument> Documents => documents;

		public <5869c9fb-e391-418e-aaac-5de81b4a93bf>YamlStream()
		{
		}

		public <5869c9fb-e391-418e-aaac-5de81b4a93bf>YamlStream(params <80682ba2-0354-464b-979a-4e38d218837b>YamlDocument[] documents)
			: this((IEnumerable<<80682ba2-0354-464b-979a-4e38d218837b>YamlDocument>)documents)
		{
		}

		public <5869c9fb-e391-418e-aaac-5de81b4a93bf>YamlStream(IEnumerable<<80682ba2-0354-464b-979a-4e38d218837b>YamlDocument> documents)
		{
			foreach (<80682ba2-0354-464b-979a-4e38d218837b>YamlDocument document in documents)
			{
				this.documents.Add(document);
			}
		}

		public void Add(<80682ba2-0354-464b-979a-4e38d218837b>YamlDocument document)
		{
			documents.Add(document);
		}

		public void Load(TextReader input)
		{
			Load(new <05269e02-726c-41a0-a367-bc46c1e60b64>Parser(input));
		}

		public void Load(<407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser)
		{
			documents.Clear();
			parser.Consume<<b0b23517-beda-496a-8223-4c3554a848bc>StreamStart>();
			<639c5f87-0aee-41c1-9e7d-0f8ace8688c9>StreamEnd @event;
			while (!parser.TryConsume<<639c5f87-0aee-41c1-9e7d-0f8ace8688c9>StreamEnd>(out @event))
			{
				<80682ba2-0354-464b-979a-4e38d218837b>YamlDocument item = new <80682ba2-0354-464b-979a-4e38d218837b>YamlDocument(parser);
				documents.Add(item);
			}
		}

		public void Save(TextWriter output)
		{
			Save(output, assignAnchors: true);
		}

		public void Save(TextWriter output, bool assignAnchors)
		{
			Save(new <ef4ea80d-be69-456f-ae89-a173cffd181f>Emitter(output), assignAnchors);
		}

		public void Save(<7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter emitter, bool assignAnchors)
		{
			emitter.Emit(new <b0b23517-beda-496a-8223-4c3554a848bc>StreamStart());
			foreach (<80682ba2-0354-464b-979a-4e38d218837b>YamlDocument document in documents)
			{
				document.Save(emitter, assignAnchors);
			}
			emitter.Emit(new <639c5f87-0aee-41c1-9e7d-0f8ace8688c9>StreamEnd());
		}

		public void Accept(<5f0b6a4d-0afb-44d8-bc8e-0dd316c6a6b5>IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public IEnumerator<<80682ba2-0354-464b-979a-4e38d218837b>YamlDocument> GetEnumerator()
		{
			return documents.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[Obsolete("Use YamlVisitorBase")]
	internal abstract class <f6b948c0-7492-4f79-abd0-44f5e47bbae4>YamlVisitor : <5f0b6a4d-0afb-44d8-bc8e-0dd316c6a6b5>IYamlVisitor
	{
		protected virtual void Visit(<5869c9fb-e391-418e-aaac-5de81b4a93bf>YamlStream stream)
		{
		}

		protected virtual void Visited(<5869c9fb-e391-418e-aaac-5de81b4a93bf>YamlStream stream)
		{
		}

		protected virtual void Visit(<80682ba2-0354-464b-979a-4e38d218837b>YamlDocument document)
		{
		}

		protected virtual void Visited(<80682ba2-0354-464b-979a-4e38d218837b>YamlDocument document)
		{
		}

		protected virtual void Visit(<684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode scalar)
		{
		}

		protected virtual void Visited(<684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode scalar)
		{
		}

		protected virtual void Visit(<1eaf8499-b05e-49d4-9327-336a1edacbc5>YamlSequenceNode sequence)
		{
		}

		protected virtual void Visited(<1eaf8499-b05e-49d4-9327-336a1edacbc5>YamlSequenceNode sequence)
		{
		}

		protected virtual void Visit(<db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode mapping)
		{
		}

		protected virtual void Visited(<db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode mapping)
		{
		}

		protected virtual void VisitChildren(<5869c9fb-e391-418e-aaac-5de81b4a93bf>YamlStream stream)
		{
			foreach (<80682ba2-0354-464b-979a-4e38d218837b>YamlDocument document in stream.Documents)
			{
				document.Accept(this);
			}
		}

		protected virtual void VisitChildren(<80682ba2-0354-464b-979a-4e38d218837b>YamlDocument document)
		{
			if (document.RootNode != null)
			{
				document.RootNode.Accept(this);
			}
		}

		protected virtual void VisitChildren(<1eaf8499-b05e-49d4-9327-336a1edacbc5>YamlSequenceNode sequence)
		{
			foreach (<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode child in sequence.Children)
			{
				child.Accept(this);
			}
		}

		protected virtual void VisitChildren(<db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode mapping)
		{
			foreach (KeyValuePair<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> child in mapping.Children)
			{
				child.Key.Accept(this);
				child.Value.Accept(this);
			}
		}

		void <5f0b6a4d-0afb-44d8-bc8e-0dd316c6a6b5>IYamlVisitor.Visit(<5869c9fb-e391-418e-aaac-5de81b4a93bf>YamlStream stream)
		{
			Visit(stream);
			VisitChildren(stream);
			Visited(stream);
		}

		void <5f0b6a4d-0afb-44d8-bc8e-0dd316c6a6b5>IYamlVisitor.Visit(<80682ba2-0354-464b-979a-4e38d218837b>YamlDocument document)
		{
			Visit(document);
			VisitChildren(document);
			Visited(document);
		}

		void <5f0b6a4d-0afb-44d8-bc8e-0dd316c6a6b5>IYamlVisitor.Visit(<684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode scalar)
		{
			Visit(scalar);
			Visited(scalar);
		}

		void <5f0b6a4d-0afb-44d8-bc8e-0dd316c6a6b5>IYamlVisitor.Visit(<1eaf8499-b05e-49d4-9327-336a1edacbc5>YamlSequenceNode sequence)
		{
			Visit(sequence);
			VisitChildren(sequence);
			Visited(sequence);
		}

		void <5f0b6a4d-0afb-44d8-bc8e-0dd316c6a6b5>IYamlVisitor.Visit(<db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode mapping)
		{
			Visit(mapping);
			VisitChildren(mapping);
			Visited(mapping);
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal abstract class <c260cd84-e678-44ea-bbe9-8343b65b5b70>YamlVisitorBase : <5f0b6a4d-0afb-44d8-bc8e-0dd316c6a6b5>IYamlVisitor
	{
		public virtual void Visit(<5869c9fb-e391-418e-aaac-5de81b4a93bf>YamlStream stream)
		{
			VisitChildren(stream);
		}

		public virtual void Visit(<80682ba2-0354-464b-979a-4e38d218837b>YamlDocument document)
		{
			VisitChildren(document);
		}

		public virtual void Visit(<684a358a-2d1e-42bb-810a-d93db2470c71>YamlScalarNode scalar)
		{
		}

		public virtual void Visit(<1eaf8499-b05e-49d4-9327-336a1edacbc5>YamlSequenceNode sequence)
		{
			VisitChildren(sequence);
		}

		public virtual void Visit(<db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode mapping)
		{
			VisitChildren(mapping);
		}

		protected virtual void VisitPair(<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode key, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode value)
		{
			key.Accept(this);
			value.Accept(this);
		}

		protected virtual void VisitChildren(<5869c9fb-e391-418e-aaac-5de81b4a93bf>YamlStream stream)
		{
			foreach (<80682ba2-0354-464b-979a-4e38d218837b>YamlDocument document in stream.Documents)
			{
				document.Accept(this);
			}
		}

		protected virtual void VisitChildren(<80682ba2-0354-464b-979a-4e38d218837b>YamlDocument document)
		{
			if (document.RootNode != null)
			{
				document.RootNode.Accept(this);
			}
		}

		protected virtual void VisitChildren(<1eaf8499-b05e-49d4-9327-336a1edacbc5>YamlSequenceNode sequence)
		{
			foreach (<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode child in sequence.Children)
			{
				child.Accept(this);
			}
		}

		protected virtual void VisitChildren(<db31f6e9-d5d5-40db-8d1e-3615c465f1aa>YamlMappingNode mapping)
		{
			foreach (KeyValuePair<<baea0867-7910-48aa-b296-31b4ec94d386>YamlNode, <baea0867-7910-48aa-b296-31b4ec94d386>YamlNode> child in mapping.Children)
			{
				VisitPair(child.Key, child.Value);
			}
		}
	}
}
namespace YamlDotNet.Helpers
{
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[DebuggerStepThrough]
	internal sealed class ConcurrentObjectPool<T> where T : class
	{
		[DebuggerDisplay("{value,nq}")]
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)]
		private struct Element
		{
			[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
			internal T value;
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)]
		internal delegate T Factory();

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		private T firstItem;

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 0, 0 })]
		private readonly Element[] items;

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 0 })]
		private readonly Factory factory;

		internal ConcurrentObjectPool([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 0 })] Factory factory)
			: this(factory, Environment.ProcessorCount * 2)
		{
		}

		internal ConcurrentObjectPool([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 0 })] Factory factory, int size)
		{
			this.factory = factory;
			items = new Element[size - 1];
		}

		private T CreateInstance()
		{
			return factory();
		}

		internal T Allocate()
		{
			T val = firstItem;
			if (val == null || val != Interlocked.CompareExchange(ref firstItem, null, val))
			{
				val = AllocateSlow();
			}
			return val;
		}

		private T AllocateSlow()
		{
			Element[] array = items;
			for (int i = 0; i < array.Length; i++)
			{
				T value = array[i].value;
				if (value != null && value == Interlocked.CompareExchange(ref array[i].value, null, value))
				{
					return value;
				}
			}
			return CreateInstance();
		}

		internal void Free(T obj)
		{
			if (firstItem == null)
			{
				firstItem = obj;
			}
			else
			{
				FreeSlow(obj);
			}
		}

		private void FreeSlow(T obj)
		{
			Element[] array = items;
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i].value == null)
				{
					array[i].value = obj;
					break;
				}
			}
		}

		[Conditional("DEBUG")]
		private void Validate(object obj)
		{
			Element[] array = items;
			for (int i = 0; i < array.Length && array[i].value != null; i++)
			{
			}
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal static class <1873258d-de35-4233-8cfd-9997f357849b>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: <5efc7cea-0044-4fef-8184-8756b06de675>MaybeNull]
		private static TMemberInfo TryGetMemberExpression<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>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;
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <47a35ba7-75bb-4ee1-b33f-a14d832c4eb8>GenericCollectionToNonGenericAdapter<T> : IList, ICollection, IEnumerable
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>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();
			}
		}

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)]
		public object SyncRoot
		{
			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
			get
			{
				throw new NotSupportedException();
			}
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public <47a35ba7-75bb-4ee1-b33f-a14d832c4eb8>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();
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public void CopyTo(Array array, int index)
		{
			throw new NotSupportedException();
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public IEnumerator GetEnumerator()
		{
			return genericCollection.GetEnumerator();
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <9e2ccdfe-7c5e-4e1f-9e3c-278d3016bfbd>GenericDictionaryToNonGenericAdapter<TKey, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TValue> : IDictionary, ICollection, IEnumerable
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
		private class DictionaryEnumerator : IDictionaryEnumerator, IEnumerator
		{
			[<0d606795-0ee1-47ee-aaaa-2df0804da96c>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;

			[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
			public object Value
			{
				[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
				get
				{
					return enumerator.Current.Value;
				}
			}

			public object Current => Entry;

			public DictionaryEnumerator([<0d606795-0ee1-47ee-aaaa-2df0804da96c>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();
			}
		}

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public object this[object key]
		{
			[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
			get
			{
				throw new NotSupportedException();
			}
			[param: <0d606795-0ee1-47ee-aaaa-2df0804da96c>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 <9e2ccdfe-7c5e-4e1f-9e3c-278d3016bfbd>GenericDictionaryToNonGenericAdapter(IDictionary<TKey, TValue> genericDictionary)
		{
			this.genericDictionary = genericDictionary ?? throw new ArgumentNullException("genericDictionary");
		}

		public void Add(object key, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>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();
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface <f6af5cd1-a558-4895-8a20-098f874d255c>IOrderedDictionary<TKey, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 0, 1, 1 })]
		KeyValuePair<TKey, TValue> this[int index]
		{
			[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 0, 1, 1 })]
			get;
			[param: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 0, 1, 1 })]
			set;
		}

		void Insert(int index, TKey key, TValue value);

		void RemoveAt(int index);
	}
	internal static class <c9152463-9623-4cac-815e-6627ed5fb210>NumberExtensions
	{
		public static bool IsPowerOfTwo(this int value)
		{
			return (value & (value - 1)) == 0;
		}
	}
	[Serializable]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <5d16835c-be2f-4a0e-b3a3-7dcd638944d5>OrderedDictionary<TKey, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TValue> : <f6af5cd1-a558-4895-8a20-098f874d255c>IOrderedDictionary<TKey, TValue>, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
		private class KeyCollection : ICollection<TKey>, IEnumerable<TKey>, IEnumerable
		{
			private readonly <5d16835c-be2f-4a0e-b3a3-7dcd638944d5>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(<5d16835c-be2f-4a0e-b3a3-7dcd638944d5>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([<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] (KeyValuePair<TKey, TValue> kvp) => kvp.Key).GetEnumerator();
			}

			public bool Remove(TKey item)
			{
				throw new NotSupportedException();
			}

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

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
		private class ValueCollection : ICollection<TValue>, IEnumerable<TValue>, IEnumerable
		{
			private readonly <5d16835c-be2f-4a0e-b3a3-7dcd638944d5>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(<5d16835c-be2f-4a0e-b3a3-7dcd638944d5>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([<b36caba6-ec7b-49e8-8641-5a4015501a0a>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;

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>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(([<0d606795-0ee1-47ee-aaaa-2df0804da96c>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;

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 0, 1, 1 })]
		public KeyValuePair<TKey, TValue> this[int index]
		{
			[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 0, 1, 1 })]
			get
			{
				return list[index];
			}
			[param: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 0, 1, 1 })]
			set
			{
				list[index] = value;
			}
		}

		public <5d16835c-be2f-4a0e-b3a3-7dcd638944d5>OrderedDictionary()
			: this((IEqualityComparer<TKey>)EqualityComparer<TKey>.Default)
		{
		}

		public <5d16835c-be2f-4a0e-b3a3-7dcd638944d5>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([<0d606795-0ee1-47ee-aaaa-2df0804da96c>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([<0d606795-0ee1-47ee-aaaa-2df0804da96c>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([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 1, 0, 1, 1 })] KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			list.CopyTo(array, arrayIndex);
		}

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>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(([<0d606795-0ee1-47ee-aaaa-2df0804da96c>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([<0d606795-0ee1-47ee-aaaa-2df0804da96c>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, [<6977aacd-47a7-4a01-9bad-79c003aa1e36>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;
			}
		}
	}
	[DebuggerStepThrough]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal static class StringBuilderPool
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
		internal readonly struct BuilderWrapper : IDisposable
		{
			public readonly StringBuilder Builder;

			private readonly ConcurrentObjectPool<StringBuilder> _pool;

			public BuilderWrapper(StringBuilder builder, ConcurrentObjectPool<StringBuilder> pool)
			{
				Builder = builder;
				_pool = pool;
			}

			public override string ToString()
			{
				return Builder.ToString();
			}

			public void Dispose()
			{
				StringBuilder builder = Builder;
				if (builder.Capacity <= 1024)
				{
					builder.Length = 0;
					_pool.Free(builder);
				}
			}
		}

		private static readonly ConcurrentObjectPool<StringBuilder> Pool;

		static StringBuilderPool()
		{
			Pool = new ConcurrentObjectPool<StringBuilder>(() => new StringBuilder());
		}

		public static BuilderWrapper Rent()
		{
			return new BuilderWrapper(Pool.Allocate(), Pool);
		}
	}
	internal static class ThrowHelper
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public static void ThrowArgumentOutOfRangeException(string paramName, string message)
		{
			throw new ArgumentOutOfRangeException(paramName, message);
		}
	}
	internal static class <621f2e01-d9a5-4e7b-aa22-5e15ec569296>Lazy
	{
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public static Lazy<T> FromValue<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] T>(T value)
		{
			Lazy<T> lazy = new Lazy<T>(() => value, isThreadSafe: false);
			_ = lazy.Value;
			return lazy;
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal static class <7b52a132-8629-4748-b32b-2252341f9d5c>ReadOnlyCollectionExtensions
	{
		public static IReadOnlyList<T> AsReadonlyList<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] T>(this List<T> list)
		{
			return list;
		}

		public static IReadOnlyDictionary<TKey, TValue> AsReadonlyDictionary<TKey, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TValue>(this Dictionary<TKey, TValue> dictionary)
		{
			return dictionary;
		}
	}
}
namespace YamlDotNet.Core
{
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal struct <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName : IEquatable<<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName>
	{
		public static readonly <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName Empty = default(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName);

		private static readonly Regex AnchorPattern = new Regex("^[^\\[\\]\\{\\},]+$", RegexOptions.Compiled);

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>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 <1694e2bc-fd5a-4057-8be0-f52199c1f0da>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(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName other)
		{
			return object.Equals(value, other.value);
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (obj is <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return value?.GetHashCode() ?? 0;
		}

		public static bool operator ==(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName left, <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName left, <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName right)
		{
			return !(left == right);
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		public static implicit operator <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName(string value)
		{
			if (value != null)
			{
				return new <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName(value);
			}
			return Empty;
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal class <4f2cacbe-02ea-431a-887c-d7f399046b70>AnchorNotFoundException : <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException
	{
		public <4f2cacbe-02ea-431a-887c-d7f399046b70>AnchorNotFoundException(string message)
			: base(message)
		{
		}

		public <4f2cacbe-02ea-431a-887c-d7f399046b70>AnchorNotFoundException(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public <4f2cacbe-02ea-431a-887c-d7f399046b70>AnchorNotFoundException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[DebuggerStepThrough]
	internal sealed class <479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer<TBuffer> where TBuffer : class, <10ae47d8-7da4-45c7-954a-2760d6b5fadf>ILookAheadBuffer
	{
		public TBuffer Buffer { get; }

		public bool EndOfInput => Buffer.EndOfInput;

		public <479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>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 <44582626-f33b-4b53-a1c9-05b9928e92a7>Constants
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)]
		public static readonly <58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective[] DefaultTagDirectives = new <58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective[2]
		{
			new <58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective("!", "!"),
			new <58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective("!!", "tag:yaml.org,2002:")
		};

		public const int MajorVersion = 1;

		public const int MinorVersion = 3;
	}
	[DebuggerStepThrough]
	internal sealed class <4e6c69f4-459d-4c9c-a981-fcb61792fc4d>Cursor
	{
		public int Index { get; private set; }

		public int Line { get; private set; }

		public int LineOffset { get; private set; }

		public <4e6c69f4-459d-4c9c-a981-fcb61792fc4d>Cursor()
		{
			Line = 1;
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public <4e6c69f4-459d-4c9c-a981-fcb61792fc4d>Cursor(<4e6c69f4-459d-4c9c-a981-fcb61792fc4d>Cursor cursor)
		{
			Index = cursor.Index;
			Line = cursor.Line;
			LineOffset = cursor.LineOffset;
		}

		public <b3f32382-dd1c-454c-b573-36801723d8c1>Mark Mark()
		{
			return new <b3f32382-dd1c-454c-b573-36801723d8c1>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;
			}
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal class <ef4ea80d-be69-456f-ae89-a173cffd181f>Emitter : <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter
	{
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)]
		private class AnchorData
		{
			public <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName Anchor;

			public bool IsAlias;
		}

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		private class TagData
		{
			public string Handle;

			public string Suffix;
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)]
		private class ScalarData
		{
			[<0d606795-0ee1-47ee-aaaa-2df0804da96c>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 <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle Style;
		}

		private static readonly Regex UriReplacer = new Regex("[^0-9A-Za-z_\\-;?@=$~\\\\\\)\\]/:&+,\\.\\*\\(\\[!]", RegexOptions.Compiled | RegexOptions.Singleline);

		private static readonly string[] newLineSeparators = new string[3] { "\r\n", "\r", "\n" };

		private readonly TextWriter output;

		private readonly bool outputUsesUnicodeEncoding;

		private readonly int maxSimpleKeyLength;

		private readonly bool isCanonical;

		private readonly bool skipAnchorName;

		private readonly int bestIndent;

		private readonly int bestWidth;

		private <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState state;

		private readonly Stack<<69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState> states = new Stack<<69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState>();

		private readonly Queue<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> events = new Queue<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent>();

		private readonly Stack<int> indents = new Stack<int>();

		private readonly <229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection tagDirectives = new <229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection();

		private int indent;

		private int flowLevel;

		private bool isMappingContext;

		private bool isSimpleKeyContext;

		private int column;

		private bool isWhitespace;

		private bool isIndentation;

		private readonly bool forceIndentLess;

		private readonly string newLine;

		private bool isDocumentEndWritten;

		private readonly AnchorData anchorData = new AnchorData();

		private readonly TagData tagData = new TagData();

		private readonly ScalarData scalarData = new ScalarData();

		public <ef4ea80d-be69-456f-ae89-a173cffd181f>Emitter(TextWriter output)
			: this(output, <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings.Default)
		{
		}

		public <ef4ea80d-be69-456f-ae89-a173cffd181f>Emitter(TextWriter output, int bestIndent)
			: this(output, bestIndent, int.MaxValue)
		{
		}

		public <ef4ea80d-be69-456f-ae89-a173cffd181f>Emitter(TextWriter output, int bestIndent, int bestWidth)
			: this(output, bestIndent, bestWidth, isCanonical: false)
		{
		}

		public <ef4ea80d-be69-456f-ae89-a173cffd181f>Emitter(TextWriter output, int bestIndent, int bestWidth, bool isCanonical)
			: this(output, new <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings(bestIndent, bestWidth, isCanonical, 1024))
		{
		}

		public <ef4ea80d-be69-456f-ae89-a173cffd181f>Emitter(TextWriter output, <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings settings)
		{
			bestIndent = settings.BestIndent;
			bestWidth = settings.BestWidth;
			isCanonical = settings.IsCanonical;
			maxSimpleKeyLength = settings.MaxSimpleKeyLength;
			skipAnchorName = settings.SkipAnchorName;
			forceIndentLess = !settings.IndentSequences;
			newLine = settings.NewLine;
			this.output = output;
			outputUsesUnicodeEncoding = IsUnicode(output.Encoding);
		}

		public void Emit(<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent @event)
		{
			events.Enqueue(@event);
			while (!NeedMoreEvents())
			{
				<83ef3299-9efa-4d51-b8c1-ad9f887f306d>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 <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.DocumentStart:
				num = 1;
				break;
			case <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.SequenceStart:
				num = 2;
				break;
			case <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.MappingStart:
				num = 3;
				break;
			default:
				return false;
			}
			if (events.Count > num)
			{
				return false;
			}
			int num2 = 0;
			using (Queue<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent>.Enumerator enumerator = events.GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					switch (enumerator.Current.Type)
					{
					case <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.DocumentStart:
					case <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.SequenceStart:
					case <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.MappingStart:
						num2++;
						break;
					case <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.DocumentEnd:
					case <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.SequenceEnd:
					case <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.MappingEnd:
						num2--;
						break;
					}
					if (num2 == 0)
					{
						return false;
					}
				}
			}
			return true;
		}

		private void AnalyzeEvent(<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent evt)
		{
			anchorData.Anchor = <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName.Empty;
			tagData.Handle = null;
			tagData.Suffix = null;
			if (evt is <4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias <4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias)
			{
				AnalyzeAnchor(<4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias.Value, isAlias: true);
			}
			else if (evt is <17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent <17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent)
			{
				if (evt is <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar scalar)
				{
					AnalyzeScalar(scalar);
				}
				AnalyzeAnchor(<17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent.Anchor, isAlias: false);
				if (!<17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent.Tag.IsEmpty && (isCanonical || <17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent.IsCanonical))
				{
					AnalyzeTag(<17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent.Tag);
				}
			}
		}

		private void AnalyzeAnchor(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName anchor, bool isAlias)
		{
			anchorData.Anchor = anchor;
			anchorData.IsAlias = isAlias;
		}

		private void AnalyzeScalar(<6de52a3a-4363-4642-b572-ff69e9dc189e>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;
			}
			<479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer<<2cc771de-93df-4205-b708-fff03826b04a>StringLookAheadBuffer> <479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer2 = new <479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer<<2cc771de-93df-4205-b708-fff03826b04a>StringLookAheadBuffer>(new <2cc771de-93df-4205-b708-fff03826b04a>StringLookAheadBuffer(value));
			bool flag3 = true;
			bool flag4 = <479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>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 (!<479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer2.EndOfInput)
			{
				if (flag19)
				{
					if (<479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer2.Check("#,[]{}&*!|>\\\"%@`'"))
					{
						flag = true;
						flag2 = true;
						flag9 = <479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer2.Check('\'');
						flag17 |= <479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer2.Check('\'');
					}
					if (<479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer2.Check("?:"))
					{
						flag = true;
						if (flag4)
						{
							flag2 = true;
						}
					}
					if (<479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer2.Check('-') && flag4)
					{
						flag = true;
						flag2 = true;
					}
				}
				else
				{
					if (<479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer2.Check(",?[]{}"))
					{
						flag = true;
					}
					if (<479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer2.Check(':'))
					{
						flag = true;
						if (flag4)
						{
							flag2 = true;
						}
					}
					if (<479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer2.Check('#') && flag3)
					{
						flag = true;
						flag2 = true;
					}
					flag17 |= <479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer2.Check('\'');
				}
				if (!flag16 && !<479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer2.IsPrintable())
				{
					flag16 = true;
				}
				if (<479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer2.IsBreak())
				{
					flag15 = true;
				}
				if (<479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer2.IsSpace())
				{
					if (flag19)
					{
						flag5 = true;
					}
					if (<479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer2.Buffer.Position >= <479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer2.Buffer.Length - 1)
					{
						flag7 = true;
					}
					if (flag13)
					{
						flag10 = true;
						flag14 = true;
					}
					flag12 = true;
					flag13 = false;
				}
				else if (<479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer2.IsBreak())
				{
					if (flag19)
					{
						flag6 = true;
					}
					if (<479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer2.Buffer.Position >= <479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>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 = <479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer2.IsWhiteBreakOrZero();
				<479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer2.Skip(1);
				if (!<479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer2.EndOfInput)
				{
					flag4 = <479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>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(<baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName tag)
		{
			tagData.Handle = tag.Value;
			foreach (<58abd5fa-9e18-414c-8a43-c981d0df3154>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(<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent evt)
		{
			if (evt is <5332d915-103b-4367-bd24-5d21f0bd7d9a>Comment comment)
			{
				EmitComment(comment);
				return;
			}
			switch (state)
			{
			case <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.StreamStart:
				EmitStreamStart(evt);
				break;
			case <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.FirstDocumentStart:
				EmitDocumentStart(evt, isFirst: true);
				break;
			case <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.DocumentStart:
				EmitDocumentStart(evt, isFirst: false);
				break;
			case <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.DocumentContent:
				EmitDocumentContent(evt);
				break;
			case <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.DocumentEnd:
				EmitDocumentEnd(evt);
				break;
			case <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.FlowSequenceFirstItem:
				EmitFlowSequenceItem(evt, isFirst: true);
				break;
			case <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.FlowSequenceItem:
				EmitFlowSequenceItem(evt, isFirst: false);
				break;
			case <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.FlowMappingFirstKey:
				EmitFlowMappingKey(evt, isFirst: true);
				break;
			case <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.FlowMappingKey:
				EmitFlowMappingKey(evt, isFirst: false);
				break;
			case <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.FlowMappingSimpleValue:
				EmitFlowMappingValue(evt, isSimple: true);
				break;
			case <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.FlowMappingValue:
				EmitFlowMappingValue(evt, isSimple: false);
				break;
			case <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.BlockSequenceFirstItem:
				EmitBlockSequenceItem(evt, isFirst: true);
				break;
			case <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.BlockSequenceItem:
				EmitBlockSequenceItem(evt, isFirst: false);
				break;
			case <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.BlockMappingFirstKey:
				EmitBlockMappingKey(evt, isFirst: true);
				break;
			case <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.BlockMappingKey:
				EmitBlockMappingKey(evt, isFirst: false);
				break;
			case <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.BlockMappingSimpleValue:
				EmitBlockMappingValue(evt, isSimple: true);
				break;
			case <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.BlockMappingValue:
				EmitBlockMappingValue(evt, isSimple: false);
				break;
			case <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.StreamEnd:
				throw new <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException("Expected nothing after STREAM-END");
			default:
				throw new InvalidOperationException();
			}
		}

		private void EmitComment(<5332d915-103b-4367-bd24-5d21f0bd7d9a>Comment comment)
		{
			if (flowLevel > 0 || state == <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.FlowMappingFirstKey || state == <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.FlowSequenceFirstItem)
			{
				return;
			}
			string[] array = comment.Value.Split(newLineSeparators, StringSplitOptions.None);
			if (comment.IsInline)
			{
				Write(" # ");
				Write(string.Join(" ", array));
			}
			else
			{
				bool flag = state == <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.BlockMappingFirstKey;
				if (flag)
				{
					IncreaseIndent(isFlow: false, isIndentless: false);
				}
				string[] array2 = array;
				foreach (string value in array2)
				{
					WriteIndent();
					Write("# ");
					Write(value);
					WriteBreak();
				}
				if (flag)
				{
					indent = indents.Pop();
				}
			}
			isIndentation = true;
		}

		private void EmitStreamStart(<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent evt)
		{
			if (!(evt is <b0b23517-beda-496a-8223-4c3554a848bc>StreamStart))
			{
				throw new ArgumentException("Expected STREAM-START.", "evt");
			}
			indent = -1;
			column = 0;
			isWhitespace = true;
			isIndentation = true;
			state = <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.FirstDocumentStart;
		}

		private void EmitDocumentStart(<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent evt, bool isFirst)
		{
			if (evt is <b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart <b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart)
			{
				bool flag = <b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart.IsImplicit && isFirst && !isCanonical;
				<229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection <229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection2 = NonDefaultTagsAmong(<b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart.Tags);
				if (!isFirst && !isDocumentEndWritten && (<b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart.Version != null || <229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection2.Count > 0))
				{
					isDocumentEndWritten = false;
					WriteIndicator("...", needWhitespace: true, whitespace: false, indentation: false);
					WriteIndent();
				}
				if (<b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart.Version != null)
				{
					AnalyzeVersionDirective(<b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart.Version);
					<6803d8e0-a57c-4ba7-ada8-bd55856c55ec>Version version = <b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart.Version.Version;
					flag = false;
					WriteIndicator("%YAML", needWhitespace: true, whitespace: false, indentation: false);
					WriteIndicator(string.Format(CultureInfo.InvariantCulture, "{0}.{1}", version.Major, version.Minor), needWhitespace: true, whitespace: false, indentation: false);
					WriteIndent();
				}
				foreach (<58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective item in <229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection2)
				{
					AppendTagDirectiveTo(item, allowDuplicates: false, tagDirectives);
				}
				<58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective[] defaultTagDirectives = <44582626-f33b-4b53-a1c9-05b9928e92a7>Constants.DefaultTagDirectives;
				for (int i = 0; i < defaultTagDirectives.Length; i++)
				{
					AppendTagDirectiveTo(defaultTagDirectives[i], allowDuplicates: true, tagDirectives);
				}
				if (<229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection2.Count > 0)
				{
					flag = false;
					defaultTagDirectives = <44582626-f33b-4b53-a1c9-05b9928e92a7>Constants.DefaultTagDirectives;
					for (int i = 0; i < defaultTagDirectives.Length; i++)
					{
						AppendTagDirectiveTo(defaultTagDirectives[i], allowDuplicates: true, <229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection2);
					}
					foreach (<58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective item2 in <229911d9-05f5-4872-8a6d-a793f001d058>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 = <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.DocumentContent;
			}
			else
			{
				if (!(evt is <639c5f87-0aee-41c1-9e7d-0f8ace8688c9>StreamEnd))
				{
					throw new <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException("Expected DOCUMENT-START or STREAM-END");
				}
				state = <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.StreamEnd;
			}
		}

		private <229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection NonDefaultTagsAmong([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 2, 1 })] IEnumerable<<58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective> tagCollection)
		{
			<229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection <229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection2 = new <229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection();
			if (tagCollection == null)
			{
				return <229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection2;
			}
			foreach (<58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective item2 in tagCollection)
			{
				AppendTagDirectiveTo(item2, allowDuplicates: false, <229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection2);
			}
			<58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective[] defaultTagDirectives = <44582626-f33b-4b53-a1c9-05b9928e92a7>Constants.DefaultTagDirectives;
			foreach (<58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective item in defaultTagDirectives)
			{
				<229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection2.Remove(item);
			}
			return <229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection2;
		}

		private void AnalyzeVersionDirective(<af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective versionDirective)
		{
			if (versionDirective.Version.Major != 1 || versionDirective.Version.Minor > 3)
			{
				throw new <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException("Incompatible %YAML directive");
			}
		}

		private static void AppendTagDirectiveTo(<58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective value, bool allowDuplicates, <229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection tagDirectives)
		{
			if (tagDirectives.Contains(value))
			{
				if (!allowDuplicates)
				{
					throw new <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException("Duplicate %TAG directive.");
				}
			}
			else
			{
				tagDirectives.Add(value);
			}
		}

		private void EmitDocumentContent(<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent evt)
		{
			states.Push(<69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.DocumentEnd);
			EmitNode(evt, isMapping: false, isSimpleKey: false);
		}

		private void EmitNode(<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent evt, bool isMapping, bool isSimpleKey)
		{
			isMappingContext = isMapping;
			isSimpleKeyContext = isSimpleKey;
			switch (evt.Type)
			{
			case <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.Alias:
				EmitAlias();
				break;
			case <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.Scalar:
				EmitScalar(evt);
				break;
			case <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.SequenceStart:
				EmitSequenceStart(evt);
				break;
			case <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.MappingStart:
				EmitMappingStart(evt);
				break;
			default:
				throw new <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException($"Expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS, got {evt.Type}");
			}
		}

		private void EmitAlias()
		{
			ProcessAnchor();
			state = states.Pop();
		}

		private void EmitScalar(<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent evt)
		{
			SelectScalarStyle(evt);
			ProcessAnchor();
			ProcessTag();
			IncreaseIndent(isFlow: true, isIndentless: false);
			ProcessScalar();
			indent = indents.Pop();
			state = states.Pop();
		}

		private void SelectScalarStyle(<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent evt)
		{
			<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar = (<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar)evt;
			<04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle2 = <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar.Style;
			bool flag = tagData.Handle == null && tagData.Suffix == null;
			if (flag && !<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar.IsPlainImplicit && !<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar.IsQuotedImplicit)
			{
				throw new <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException("Neither tag nor isImplicit flags are specified.");
			}
			if (<04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle2 == <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Any)
			{
				<04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle2 = ((!scalarData.IsMultiline) ? <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Plain : <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Folded);
			}
			if (isCanonical)
			{
				<04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle2 = <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.DoubleQuoted;
			}
			if (isSimpleKeyContext && scalarData.IsMultiline)
			{
				<04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle2 = <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.DoubleQuoted;
			}
			if (<04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle2 == <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Plain)
			{
				if ((flowLevel != 0 && !scalarData.IsFlowPlainAllowed) || (flowLevel == 0 && !scalarData.IsBlockPlainAllowed))
				{
					<04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle2 = ((scalarData.IsSingleQuotedAllowed && !scalarData.HasSingleQuotes) ? <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.SingleQuoted : <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.DoubleQuoted);
				}
				if (string.IsNullOrEmpty(scalarData.Value) && (flowLevel != 0 || isSimpleKeyContext))
				{
					<04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle2 = <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.SingleQuoted;
				}
				if (flag && !<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar.IsPlainImplicit)
				{
					<04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle2 = <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.SingleQuoted;
				}
			}
			if (<04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle2 == <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.SingleQuoted && !scalarData.IsSingleQuotedAllowed)
			{
				<04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle2 = <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.DoubleQuoted;
			}
			if ((<04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle2 == <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Literal || <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle2 == <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Folded) && (!scalarData.IsBlockAllowed || flowLevel != 0 || isSimpleKeyContext))
			{
				<04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle2 = <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.DoubleQuoted;
			}
			scalarData.Style = <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle2;
		}

		private void ProcessScalar()
		{
			switch (scalarData.Style)
			{
			case <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Plain:
				WritePlainScalar(scalarData.Value, !isSimpleKeyContext);
				break;
			case <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.SingleQuoted:
				WriteSingleQuotedScalar(scalarData.Value, !isSimpleKeyContext);
				break;
			case <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.DoubleQuoted:
				WriteDoubleQuotedScalar(scalarData.Value, !isSimpleKeyContext);
				break;
			case <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Literal:
				WriteLiteralScalar(scalarData.Value);
				break;
			case <04315b26-e1c8-4e5a-93f2-a3194d527695>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 <ca493ed7-1693-464e-a1a2-e6a1500d8a67>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 (c == '\r' && i + 1 < value.Length && value[i + 1] == '\n')
					{
						continue;
					}
					if (!flag && !flag2 && breakChar == '\n')
					{
						int j;
						char breakChar2;
						for (j = 0; i + j < value.Length && IsBreak(value[i + j], out breakChar2); j++)
						{
						}
						if (i + j < value.Length && !IsBlank(value[i + j]) && !IsBreak(value[i + j], out breakChar2))
						{
							WriteBreak();
						}
					}
					WriteBreak(breakChar);
					isIndentation = true;
					flag = true;
				}
				else
				{
					if (flag)
					{
						WriteIndent();
						flag2 = IsBlank(c);
					}
					if (!flag && c == ' ' && i + 1 < value.Length && value[i + 1] != ' ' && column > bestWidth)
					{
						WriteIndent();
					}
					else
					{
						Write(c);
					}
					isIndentation = false;
					flag = false;
				}
			}
		}

		private static bool IsSpace(char character)
		{
			return character == ' ';
		}

		private static bool IsBreak(char character, out char breakChar)
		{
			switch (character)
			{
			case '\n':
			case '\r':
			case '\u0085':
				breakChar = '\n';
				return true;
			case '\u2028':
			case '\u2029':
				breakChar = character;
				return true;
			default:
				breakChar = '\0';
				return false;
			}
		}

		private static bool IsBlank(char character)
		{
			if (character != ' ')
			{
				return character == '\t';
			}
			return true;
		}

		private static bool IsPrintable(char character)
		{
			switch (character)
			{
			default:
				if (character != '\u0085' && (character < '\u00a0' || character > '\ud7ff'))
				{
					if (character >= '\ue000')
					{
						return character <= '\ufffd';
					}
					return false;
				}
				break;
			case '\t':
			case '\n':
			case '\r':
			case ' ':
			case '!':
			case '"':
			case '#':
			case '$':
			case '%':
			case '&':
			case '\'':
			case '(':
			case ')':
			case '*':
			case '+':
			case ',':
			case '-':
			case '.':
			case '/':
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			case ':':
			case ';':
			case '<':
			case '=':
			case '>':
			case '?':
			case '@':
			case 'A':
			case 'B':
			case 'C':
			case 'D':
			case 'E':
			case 'F':
			case 'G':
			case 'H':
			case 'I':
			case 'J':
			case 'K':
			case 'L':
			case 'M':
			case 'N':
			case 'O':
			case 'P':
			case 'Q':
			case 'R':
			case 'S':
			case 'T':
			case 'U':
			case 'V':
			case 'W':
			case 'X':
			case 'Y':
			case 'Z':
			case '[':
			case '\\':
			case ']':
			case '^':
			case '_':
			case '`':
			case 'a':
			case 'b':
			case 'c':
			case 'd':
			case 'e':
			case 'f':
			case 'g':
			case 'h':
			case 'i':
			case 'j':
			case 'k':
			case 'l':
			case 'm':
			case 'n':
			case 'o':
			case 'p':
			case 'q':
			case 'r':
			case 's':
			case 't':
			case 'u':
			case 'v':
			case 'w':
			case 'x':
			case 'y':
			case 'z':
			case '{':
			case '|':
			case '}':
			case '~':
				break;
			}
			return true;
		}

		private static bool IsHighSurrogate(char c)
		{
			if ('\ud800' <= c)
			{
				return c <= '\udbff';
			}
			return false;
		}

		private static bool IsLowSurrogate(char c)
		{
			if ('\udc00' <= c)
			{
				return c <= '\udfff';
			}
			return false;
		}

		private void EmitSequenceStart(<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent evt)
		{
			ProcessAnchor();
			ProcessTag();
			<743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart <743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart = (<743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart)evt;
			if (flowLevel != 0 || isCanonical || <743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart.Style == <633aecbb-227c-4a56-bde3-6176f414312f>SequenceStyle.Flow || CheckEmptySequence())
			{
				state = <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.FlowSequenceFirstItem;
			}
			else
			{
				state = <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.BlockSequenceFirstItem;
			}
		}

		private void EmitMappingStart(<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent evt)
		{
			ProcessAnchor();
			ProcessTag();
			<fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart <fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart = (<fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart)evt;
			if (flowLevel != 0 || isCanonical || <fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart.Style == <5bdd0818-2e61-4148-a2dc-8d667b816026>MappingStyle.Flow || CheckEmptyMapping())
			{
				state = <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.FlowMappingFirstKey;
			}
			else
			{
				state = <69c17cd6-cc43-4718-8988-a73268a011c7>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(<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent evt)
		{
			if (evt is <c51742f9-fbb1-469d-bb0b-e52d59018ce6>DocumentEnd <c51742f9-fbb1-469d-bb0b-e52d59018ce6>DocumentEnd)
			{
				WriteIndent();
				if (!<c51742f9-fbb1-469d-bb0b-e52d59018ce6>DocumentEnd.IsImplicit)
				{
					WriteIndicator("...", needWhitespace: true, whitespace: false, indentation: false);
					WriteIndent();
					isDocumentEndWritten = true;
				}
				state = <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.DocumentStart;
				tagDirectives.Clear();
				return;
			}
			throw new <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException("Expected DOCUMENT-END.");
		}

		private void EmitFlowSequenceItem(<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				WriteIndicator("[", needWhitespace: true, whitespace: true, indentation: false);
				IncreaseIndent(isFlow: true, isIndentless: false);
				flowLevel++;
			}
			if (evt is <7f287aeb-12e4-4f76-8c9e-f7622d066f5d>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(<69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.FlowSequenceItem);
				EmitNode(evt, isMapping: false, isSimpleKey: false);
			}
		}

		private void EmitFlowMappingKey(<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				WriteIndicator("{", needWhitespace: true, whitespace: true, indentation: false);
				IncreaseIndent(isFlow: true, isIndentless: false);
				flowLevel++;
			}
			if (evt is <d66b1b5c-22da-4393-8f8d-68d3635cb59f>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(<69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.FlowMappingSimpleValue);
				EmitNode(evt, isMapping: true, isSimpleKey: true);
			}
			else
			{
				WriteIndicator("?", needWhitespace: true, whitespace: false, indentation: false);
				states.Push(<69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.FlowMappingValue);
				EmitNode(evt, isMapping: true, isSimpleKey: false);
			}
		}

		private void EmitFlowMappingValue(<83ef3299-9efa-4d51-b8c1-ad9f887f306d>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(<69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.FlowMappingKey);
			EmitNode(evt, isMapping: true, isSimpleKey: false);
		}

		private void EmitBlockSequenceItem(<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				IncreaseIndent(isFlow: false, isMappingContext && !isIndentation);
			}
			if (evt is <7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd)
			{
				indent = indents.Pop();
				state = states.Pop();
				return;
			}
			WriteIndent();
			WriteIndicator("-", needWhitespace: true, whitespace: false, indentation: true);
			states.Push(<69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.BlockSequenceItem);
			EmitNode(evt, isMapping: false, isSimpleKey: false);
		}

		private void EmitBlockMappingKey(<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				IncreaseIndent(isFlow: false, isIndentless: false);
			}
			if (evt is <d66b1b5c-22da-4393-8f8d-68d3635cb59f>MappingEnd)
			{
				indent = indents.Pop();
				state = states.Pop();
				return;
			}
			WriteIndent();
			if (CheckSimpleKey())
			{
				states.Push(<69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.BlockMappingSimpleValue);
				EmitNode(evt, isMapping: true, isSimpleKey: true);
			}
			else
			{
				WriteIndicator("?", needWhitespace: true, whitespace: false, indentation: true);
				states.Push(<69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState.BlockMappingValue);
				EmitNode(evt, isMapping: true, isSimpleKey: false);
			}
		}

		private void EmitBlockMappingValue(<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent evt, bool isSimple)
		{
			if (isSimple)
			{
				WriteIndicator(":", needWhitespace: false, whitespace: false, indentation: false);
			}
			else
			{
				WriteIndent();
				WriteIndicator(":", needWhitespace: true, whitespace: false, indentation: true);
			}
			states.Push(<69c17cd6-cc43-4718-8988-a73268a011c7>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 (<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent @event in events)
			{
				num++;
				if (num == 2)
				{
					if (@event is <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar)
					{
						return string.IsNullOrEmpty(<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar.Value);
					}
					break;
				}
			}
			return false;
		}

		private bool CheckSimpleKey()
		{
			if (events.Count < 1)
			{
				return false;
			}
			int num;
			switch (events.Peek().Type)
			{
			case <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.Alias:
				num = AnchorNameLength(anchorData.Anchor);
				break;
			case <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.Scalar:
				if (scalarData.IsMultiline)
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix) + SafeStringLength(scalarData.Value);
				break;
			case <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.SequenceStart:
				if (!CheckEmptySequence())
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix);
				break;
			case <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>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(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName value)
		{
			if (!value.IsEmpty)
			{
				return value.Value.Length;
			}
			return 0;
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		private int SafeStringLength(string value)
		{
			return value?.Length ?? 0;
		}

		private bool CheckEmptySequence()
		{
			return CheckEmptyStructure<<743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart, <7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd>();
		}

		private bool CheckEmptyMapping()
		{
			return CheckEmptyStructure<<fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart, <d66b1b5c-22da-4393-8f8d-68d3635cb59f>MappingEnd>();
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)]
		private bool CheckEmptyStructure<TStart, TEnd>() where TStart : <17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent where TEnd : <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent
		{
			if (events.Count < 2)
			{
				return false;
			}
			using Queue<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent>.Enumerator enumerator = events.GetEnumerator();
			return enumerator.MoveNext() && enumerator.Current is TStart && enumerator.MoveNext() && enumerator.Current is TEnd;
		}

		private void WriteBlockScalarHints(string value)
		{
			<479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer<<2cc771de-93df-4205-b708-fff03826b04a>StringLookAheadBuffer> <479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer2 = new <479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer<<2cc771de-93df-4205-b708-fff03826b04a>StringLookAheadBuffer>(new <2cc771de-93df-4205-b708-fff03826b04a>StringLookAheadBuffer(value));
			if (<479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer2.IsSpace() || <479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>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 || !<479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer2.IsBreak(value.Length - 1))
			{
				text = "-";
			}
			else if (value.Length >= 2 && <479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>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(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName value)
		{
			Write(value.Value);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteTagHandle(string value)
		{
			if (!isWhitespace)
			{
				Write(' ');
			}
			Write(value);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteTagContent(string value, bool needsWhitespace)
		{
			if (needsWhitespace && !isWhitespace)
			{
				Write(' ');
			}
			Write(UrlEncode(value));
			isWhitespace = false;
			isIndentation = false;
		}

		private static string UrlEncode(string text)
		{
			return UriReplacer.Replace(text, [<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] ([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)] Match match) =>
			{
				StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder = builderWrapper.Builder;
					byte[] bytes = Encoding.UTF8.GetBytes(match.Value);
					foreach (byte b in bytes)
					{
						builder.AppendFormat("%{0:X02}", b);
					}
					return builder.ToString();
				}
				finally
				{
					((IDisposable)builderWrapper).Dispose();
				}
			});
		}

		private void Write(char value)
		{
			output.Write(value);
			column++;
		}

		private void Write(string value)
		{
			output.Write(value);
			column += value.Length;
		}

		private void WriteBreak(char breakCharacter = '\n')
		{
			if (breakCharacter == '\n')
			{
				output.Write(newLine);
			}
			else
			{
				output.Write(breakCharacter);
			}
			column = 0;
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings
	{
		public static readonly <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings Default = new <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings();

		public int BestIndent { get; } = 2;


		public int BestWidth { get; } = int.MaxValue;


		public string NewLine { get; } = Environment.NewLine;


		public bool IsCanonical { get; }

		public bool SkipAnchorName { get; private set; }

		public int MaxSimpleKeyLength { get; } = 1024;


		public bool IndentSequences { get; }

		public <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings()
		{
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		public <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings(int bestIndent, int bestWidth, bool isCanonical, int maxSimpleKeyLength, bool skipAnchorName = false, bool indentSequences = false, string newLine = null)
		{
			if (bestIndent < 2 || bestIndent > 9)
			{
				throw new ArgumentOutOfRangeException("bestIndent", "BestIndent must be between 2 and 9, inclusive");
			}
			if (bestWidth <= bestIndent * 2)
			{
				throw new ArgumentOutOfRangeException("bestWidth", "BestWidth must be greater than BestIndent x 2.");
			}
			if (maxSimpleKeyLength < 0)
			{
				throw new ArgumentOutOfRangeException("maxSimpleKeyLength", "MaxSimpleKeyLength must be >= 0");
			}
			BestIndent = bestIndent;
			BestWidth = bestWidth;
			IsCanonical = isCanonical;
			MaxSimpleKeyLength = maxSimpleKeyLength;
			SkipAnchorName = skipAnchorName;
			IndentSequences = indentSequences;
			NewLine = newLine ?? Environment.NewLine;
		}

		public <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings WithBestIndent(int bestIndent)
		{
			return new <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings(bestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine);
		}

		public <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings WithBestWidth(int bestWidth)
		{
			return new <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings(BestIndent, bestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine);
		}

		public <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings WithMaxSimpleKeyLength(int maxSimpleKeyLength)
		{
			return new <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings(BestIndent, BestWidth, IsCanonical, maxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine);
		}

		public <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings WithNewLine(string newLine)
		{
			return new <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, newLine);
		}

		public <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings Canonical()
		{
			return new <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings(BestIndent, BestWidth, isCanonical: true, MaxSimpleKeyLength, SkipAnchorName);
		}

		public <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings WithoutAnchorName()
		{
			return new <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, skipAnchorName: true, IndentSequences, NewLine);
		}

		public <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings WithIndentedSequences()
		{
			return new <8df785d1-5487-4aa1-a0fb-7e7a9205ccf4>EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, indentSequences: true, NewLine);
		}
	}
	internal enum <69c17cd6-cc43-4718-8988-a73268a011c7>EmitterState
	{
		StreamStart,
		StreamEnd,
		FirstDocumentStart,
		DocumentStart,
		DocumentContent,
		DocumentEnd,
		FlowSequenceFirstItem,
		FlowSequenceItem,
		FlowMappingFirstKey,
		FlowMappingKey,
		FlowMappingSimpleValue,
		FlowMappingValue,
		BlockSequenceFirstItem,
		BlockSequenceItem,
		BlockMappingFirstKey,
		BlockMappingKey,
		BlockMappingSimpleValue,
		BlockMappingValue
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <8e1ea460-52d7-43bb-8be5-0bc54fc77271>ForwardAnchorNotSupportedException : <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException
	{
		public <8e1ea460-52d7-43bb-8be5-0bc54fc77271>ForwardAnchorNotSupportedException(string message)
			: base(message)
		{
		}

		public <8e1ea460-52d7-43bb-8be5-0bc54fc77271>ForwardAnchorNotSupportedException(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public <8e1ea460-52d7-43bb-8be5-0bc54fc77271>ForwardAnchorNotSupportedException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
	internal static class <21fc5b2a-a319-41bc-aa9e-d22bcde3f1bb>HashCode
	{
		public static int CombineHashCodes(int h1, int h2)
		{
			return ((h1 << 5) + h1) ^ h2;
		}

		public static int CombineHashCodes(int h1, object o2)
		{
			return CombineHashCodes(h1, GetHashCode(o2));
		}

		private static int GetHashCode(object obj)
		{
			return obj?.GetHashCode() ?? 0;
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface <7ce2b198-d1da-4fdd-93fe-4a39c4e001e6>IEmitter
	{
		void Emit(<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent @event);
	}
	internal interface <10ae47d8-7da4-45c7-954a-2760d6b5fadf>ILookAheadBuffer
	{
		bool EndOfInput { get; }

		char Peek(int offset);

		void Skip(int length);
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <67514162-06bc-4d73-9367-d6c8c285bf82>InsertionQueue<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>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 <67514162-06bc-4d73-9367-d6c8c285bf82>InsertionQueue(int initialCapacity = 128)
		{
			if (initialCapacity <= 0)
			{
				throw new ArgumentOutOfRangeException("initialCapacity", "The initial capacity must be a positive number.");
			}
			if (!<c9152463-9623-4cac-815e-6627ed5fb210>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();
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
	internal interface <407d9ba3-b48b-4abf-9738-5195e80ae436>IParser
	{
		<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent Current { get; }

		bool MoveNext();
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
	internal interface <43801baf-9d5a-4c2b-a4de-b76127205b43>IScanner
	{
		<b3f32382-dd1c-454c-b573-36801723d8c1>Mark CurrentPosition { get; }

		<abd144ac-e219-4ca9-8443-aea408941dd7>Token Current { get; }

		bool MoveNext();

		bool MoveNextWithoutConsuming();

		void ConsumeCurrent();
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[DebuggerStepThrough]
	internal sealed class <f0cb7c58-51b8-4c7a-99e1-62a7d71aea68>LookAheadBuffer : <10ae47d8-7da4-45c7-954a-2760d6b5fadf>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 <f0cb7c58-51b8-4c7a-99e1-62a7d71aea68>LookAheadBuffer(TextReader input, int capacity)
		{
			if (capacity < 1)
			{
				throw new ArgumentOutOfRangeException("capacity", "The capacity must be positive.");
			}
			if (!<c9152463-9623-4cac-815e-6627ed5fb210>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;
		}
	}
	internal readonly struct <b3f32382-dd1c-454c-b573-36801723d8c1>Mark : IEquatable<<b3f32382-dd1c-454c-b573-36801723d8c1>Mark>, IComparable<<b3f32382-dd1c-454c-b573-36801723d8c1>Mark>, IComparable
	{
		public static readonly <b3f32382-dd1c-454c-b573-36801723d8c1>Mark Empty = new <b3f32382-dd1c-454c-b573-36801723d8c1>Mark(0, 1, 1);

		public int Index { get; }

		public int Line { get; }

		public int Column { get; }

		public <b3f32382-dd1c-454c-b573-36801723d8c1>Mark(int index, int line, int column)
		{
			if (index < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("index", "Index must be greater than or equal to zero.");
			}
			if (line < 1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("line", "Line must be greater than or equal to 1.");
			}
			if (column < 1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("column", "Column must be greater than or equal to 1.");
			}
			Index = index;
			Line = line;
			Column = column;
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public override string ToString()
		{
			return $"Line: {Line}, Col: {Column}, Idx: {Index}";
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		public override bool Equals(object obj)
		{
			return Equals((<b3f32382-dd1c-454c-b573-36801723d8c1>Mark)(obj ?? ((object)Empty)));
		}

		public bool Equals(<b3f32382-dd1c-454c-b573-36801723d8c1>Mark other)
		{
			if (Index == other.Index && Line == other.Line)
			{
				return Column == other.Column;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return <21fc5b2a-a319-41bc-aa9e-d22bcde3f1bb>HashCode.CombineHashCodes(Index.GetHashCode(), <21fc5b2a-a319-41bc-aa9e-d22bcde3f1bb>HashCode.CombineHashCodes(Line.GetHashCode(), Column.GetHashCode()));
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		public int CompareTo(object obj)
		{
			return CompareTo((<b3f32382-dd1c-454c-b573-36801723d8c1>Mark)(obj ?? ((object)Empty)));
		}

		public int CompareTo(<b3f32382-dd1c-454c-b573-36801723d8c1>Mark other)
		{
			int num = Line.CompareTo(other.Line);
			if (num == 0)
			{
				num = Column.CompareTo(other.Column);
			}
			return num;
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <e1f13554-13ac-4c5c-b7d5-4ebc5f732030>MaximumRecursionLevelReachedException : <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException
	{
		public <e1f13554-13ac-4c5c-b7d5-4ebc5f732030>MaximumRecursionLevelReachedException(string message)
			: base(message)
		{
		}

		public <e1f13554-13ac-4c5c-b7d5-4ebc5f732030>MaximumRecursionLevelReachedException(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public <e1f13554-13ac-4c5c-b7d5-4ebc5f732030>MaximumRecursionLevelReachedException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <07efca6f-0f75-4a94-aa15-d98a923f1c3f>MergingParser : <407d9ba3-b48b-4abf-9738-5195e80ae436>IParser
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
		private sealed class ParsingEventCollection : IEnumerable<LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent>>, IEnumerable
		{
			private readonly LinkedList<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> events;

			private readonly HashSet<LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent>> deleted;

			private readonly Dictionary<<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName, LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent>> references;

			public ParsingEventCollection()
			{
				events = new LinkedList<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent>();
				deleted = new HashSet<LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent>>();
				references = new Dictionary<<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName, LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent>>();
			}

			public void AddAfter(LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> node, IEnumerable<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> items)
			{
				foreach (<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent item in items)
				{
					node = events.AddAfter(node, item);
				}
			}

			public void Add(<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent item)
			{
				LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> node = events.AddLast(item);
				AddReference(item, node);
			}

			public void MarkDeleted(LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> node)
			{
				deleted.Add(node);
			}

			public void CleanMarked()
			{
				foreach (LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> item in deleted)
				{
					events.Remove(item);
				}
			}

			public IEnumerable<LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent>> FromAnchor(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName anchor)
			{
				LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> next = references[anchor].Next;
				return Enumerate(next);
			}

			public IEnumerator<LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent>> GetEnumerator()
			{
				return Enumerate(events.First).GetEnumerator();
			}

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

			private IEnumerable<LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent>> Enumerate([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 2, 1 })] LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> node)
			{
				while (node != null)
				{
					yield return node;
					node = node.Next;
				}
			}

			private void AddReference(<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent item, LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> node)
			{
				if (item is <fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart <fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart)
				{
					<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName anchor = <fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart.Anchor;
					if (!anchor.IsEmpty)
					{
						references[anchor] = node;
					}
				}
			}
		}

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
		private sealed class ParsingEventCloner : <816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor
		{
			[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
			private <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent clonedEvent;

			public <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent Clone(<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent e)
			{
				e.Accept(this);
				if (clonedEvent == null)
				{
					throw new InvalidOperationException($"Could not clone event of type '{e.Type}'");
				}
				return clonedEvent;
			}

			void <816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor.Visit(<4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias e)
			{
				clonedEvent = new <4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias(e.Value, e.Start, e.End);
			}

			void <816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor.Visit(<b0b23517-beda-496a-8223-4c3554a848bc>StreamStart e)
			{
				throw new NotSupportedException();
			}

			void <816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor.Visit(<639c5f87-0aee-41c1-9e7d-0f8ace8688c9>StreamEnd e)
			{
				throw new NotSupportedException();
			}

			void <816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor.Visit(<b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart e)
			{
				throw new NotSupportedException();
			}

			void <816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor.Visit(<c51742f9-fbb1-469d-bb0b-e52d59018ce6>DocumentEnd e)
			{
				throw new NotSupportedException();
			}

			void <816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor.Visit(<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar e)
			{
				clonedEvent = new <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName.Empty, e.Tag, e.Value, e.Style, e.IsPlainImplicit, e.IsQuotedImplicit, e.Start, e.End);
			}

			void <816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor.Visit(<743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart e)
			{
				clonedEvent = new <743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
			}

			void <816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor.Visit(<7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd e)
			{
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = e.Start;
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = e.End;
				clonedEvent = new <7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd(in start, in end);
			}

			void <816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor.Visit(<fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart e)
			{
				clonedEvent = new <fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
			}

			void <816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor.Visit(<d66b1b5c-22da-4393-8f8d-68d3635cb59f>MappingEnd e)
			{
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = e.Start;
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = e.End;
				clonedEvent = new <d66b1b5c-22da-4393-8f8d-68d3635cb59f>MappingEnd(in start, in end);
			}

			void <816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor.Visit(<5332d915-103b-4367-bd24-5d21f0bd7d9a>Comment e)
			{
				throw new NotSupportedException();
			}
		}

		private readonly ParsingEventCollection events;

		private readonly <407d9ba3-b48b-4abf-9738-5195e80ae436>IParser innerParser;

		private IEnumerator<LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent>> iterator;

		private bool merged;

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent Current
		{
			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
			get
			{
				return iterator.Current?.Value;
			}
		}

		public <07efca6f-0f75-4a94-aa15-d98a923f1c3f>MergingParser(<407d9ba3-b48b-4abf-9738-5195e80ae436>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<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> @event in events)
			{
				if (IsMergeToken(@event))
				{
					events.MarkDeleted(@event);
					if (!HandleMerge(@event.Next))
					{
						<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = @event.Value.Start;
						<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = @event.Value.End;
						throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in start, in end, "Unrecognized merge key pattern");
					}
				}
			}
		}

		private bool HandleMerge([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 2, 1 })] LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> node)
		{
			if (node == null)
			{
				return false;
			}
			if (node.Value is <4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias anchorAlias)
			{
				return HandleAnchorAlias(node, node, anchorAlias);
			}
			if (node.Value is <743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart)
			{
				return HandleSequence(node);
			}
			return false;
		}

		private bool HandleMergeSequence(LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> sequenceStart, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 2, 1 })] LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> node)
		{
			if (node == null)
			{
				return false;
			}
			if (node.Value is <4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias anchorAlias)
			{
				return HandleAnchorAlias(sequenceStart, node, anchorAlias);
			}
			if (node.Value is <743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart)
			{
				return HandleSequence(node);
			}
			return false;
		}

		private bool IsMergeToken(LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> node)
		{
			if (node.Value is <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar)
			{
				return <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar.Value == "<<";
			}
			return false;
		}

		private bool HandleAnchorAlias(LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> node, LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> anchorNode, <4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias anchorAlias)
		{
			IEnumerable<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> mappingEvents = GetMappingEvents(anchorAlias.Value);
			events.AddAfter(node, mappingEvents);
			events.MarkDeleted(anchorNode);
			return true;
		}

		private bool HandleSequence(LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> node)
		{
			events.MarkDeleted(node);
			LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> linkedListNode = node;
			while (linkedListNode != null)
			{
				if (linkedListNode.Value is <7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd && linkedListNode.Value.Start.Line >= node.Value.Start.Line)
				{
					events.MarkDeleted(linkedListNode);
					return true;
				}
				LinkedListNode<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> next = linkedListNode.Next;
				HandleMergeSequence(node, next);
				linkedListNode = next;
			}
			return true;
		}

		private IEnumerable<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> GetMappingEvents(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName anchor)
		{
			ParsingEventCloner cloner = new ParsingEventCloner();
			int nesting = 0;
			return from e in (from e in events.FromAnchor(anchor)
					select e.Value).TakeWhile([<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(0)] (<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent e) => (nesting += e.NestingIncrease) >= 0)
				select cloner.Clone(e);
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal class <05269e02-726c-41a0-a367-bc46c1e60b64>Parser : <407d9ba3-b48b-4abf-9738-5195e80ae436>IParser
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
		private class EventQueue
		{
			private readonly Queue<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> highPriorityEvents = new Queue<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent>();

			private readonly Queue<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent> normalPriorityEvents = new Queue<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent>();

			public int Count => highPriorityEvents.Count + normalPriorityEvents.Count;

			public void Enqueue(<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent @event)
			{
				<c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType type = @event.Type;
				if (type == <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.StreamStart || type == <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.DocumentStart)
				{
					highPriorityEvents.Enqueue(@event);
				}
				else
				{
					normalPriorityEvents.Enqueue(@event);
				}
			}

			public <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent Dequeue()
			{
				if (highPriorityEvents.Count <= 0)
				{
					return normalPriorityEvents.Dequeue();
				}
				return highPriorityEvents.Dequeue();
			}
		}

		private readonly Stack<<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState> states = new Stack<<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState>();

		private readonly <229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection tagDirectives = new <229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection();

		private <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState state;

		private readonly <43801baf-9d5a-4c2b-a4de-b76127205b43>IScanner scanner;

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		private <abd144ac-e219-4ca9-8443-aea408941dd7>Token currentToken;

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		private <af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective version;

		private readonly EventQueue pendingEvents = new EventQueue();

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		[field: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent Current
		{
			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
			get;
			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
			private set;
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		private <abd144ac-e219-4ca9-8443-aea408941dd7>Token GetCurrentToken()
		{
			if (currentToken == null)
			{
				while (scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (!(currentToken is <92aa2da2-df07-44ac-b284-eaa9be1f2036>Comment <92aa2da2-df07-44ac-b284-eaa9be1f2036>Comment))
					{
						break;
					}
					pendingEvents.Enqueue(new <5332d915-103b-4367-bd24-5d21f0bd7d9a>Comment(<92aa2da2-df07-44ac-b284-eaa9be1f2036>Comment.Value, <92aa2da2-df07-44ac-b284-eaa9be1f2036>Comment.IsInline, <92aa2da2-df07-44ac-b284-eaa9be1f2036>Comment.Start, <92aa2da2-df07-44ac-b284-eaa9be1f2036>Comment.End));
					scanner.ConsumeCurrent();
				}
			}
			return currentToken;
		}

		public <05269e02-726c-41a0-a367-bc46c1e60b64>Parser(TextReader input)
			: this(new <d079a2d7-b960-4e6b-88be-b46e132dc590>Scanner(input))
		{
		}

		public <05269e02-726c-41a0-a367-bc46c1e60b64>Parser(<43801baf-9d5a-4c2b-a4de-b76127205b43>IScanner scanner)
		{
			this.scanner = scanner;
		}

		public bool MoveNext()
		{
			if (state == <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.StreamEnd)
			{
				Current = null;
				return false;
			}
			if (pendingEvents.Count == 0)
			{
				pendingEvents.Enqueue(StateMachine());
			}
			Current = pendingEvents.Dequeue();
			return true;
		}

		private <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent StateMachine()
		{
			return state switch
			{
				<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.StreamStart => ParseStreamStart(), 
				<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.ImplicitDocumentStart => ParseDocumentStart(isImplicit: true), 
				<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.DocumentStart => ParseDocumentStart(isImplicit: false), 
				<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.DocumentContent => ParseDocumentContent(), 
				<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.DocumentEnd => ParseDocumentEnd(), 
				<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.BlockNode => ParseNode(isBlock: true, isIndentlessSequence: false), 
				<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.BlockNodeOrIndentlessSequence => ParseNode(isBlock: true, isIndentlessSequence: true), 
				<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowNode => ParseNode(isBlock: false, isIndentlessSequence: false), 
				<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.BlockSequenceFirstEntry => ParseBlockSequenceEntry(isFirst: true), 
				<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.BlockSequenceEntry => ParseBlockSequenceEntry(isFirst: false), 
				<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.IndentlessSequenceEntry => ParseIndentlessSequenceEntry(), 
				<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.BlockMappingFirstKey => ParseBlockMappingKey(isFirst: true), 
				<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.BlockMappingKey => ParseBlockMappingKey(isFirst: false), 
				<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.BlockMappingValue => ParseBlockMappingValue(), 
				<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowSequenceFirstEntry => ParseFlowSequenceEntry(isFirst: true), 
				<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowSequenceEntry => ParseFlowSequenceEntry(isFirst: false), 
				<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowSequenceEntryMappingKey => ParseFlowSequenceEntryMappingKey(), 
				<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowSequenceEntryMappingValue => ParseFlowSequenceEntryMappingValue(), 
				<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowSequenceEntryMappingEnd => ParseFlowSequenceEntryMappingEnd(), 
				<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowMappingFirstKey => ParseFlowMappingKey(isFirst: true), 
				<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowMappingKey => ParseFlowMappingKey(isFirst: false), 
				<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowMappingValue => ParseFlowMappingValue(isEmpty: false), 
				<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowMappingEmptyValue => ParseFlowMappingValue(isEmpty: true), 
				_ => throw new InvalidOperationException(), 
			};
		}

		private void Skip()
		{
			if (currentToken != null)
			{
				currentToken = null;
				scanner.ConsumeCurrent();
			}
		}

		private <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent ParseStreamStart()
		{
			<abd144ac-e219-4ca9-8443-aea408941dd7>Token <abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken();
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start;
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end;
			if (!(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <9732b3ee-7084-48fe-a728-33d8b4c4576f>StreamStart <9732b3ee-7084-48fe-a728-33d8b4c4576f>StreamStart))
			{
				start = <abd144ac-e219-4ca9-8443-aea408941dd7>Token?.Start ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
				end = <abd144ac-e219-4ca9-8443-aea408941dd7>Token?.End ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
				throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in start, in end, "Did not find expected <stream-start>.");
			}
			Skip();
			state = <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.ImplicitDocumentStart;
			start = <9732b3ee-7084-48fe-a728-33d8b4c4576f>StreamStart.Start;
			end = <9732b3ee-7084-48fe-a728-33d8b4c4576f>StreamStart.End;
			return new <b0b23517-beda-496a-8223-4c3554a848bc>StreamStart(in start, in end);
		}

		private <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent ParseDocumentStart(bool isImplicit)
		{
			if (currentToken is <af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective)
			{
				throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException("While parsing a document start node, could not find document end marker before version directive.");
			}
			<abd144ac-e219-4ca9-8443-aea408941dd7>Token <abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken();
			if (!isImplicit)
			{
				while (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <5507821e-8467-4a48-865d-95beb56e50bf>DocumentEnd)
				{
					Skip();
					<abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken();
				}
			}
			if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token == null)
			{
				throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException("Reached the end of the stream while parsing a document start.");
			}
			if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar && (state == <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.ImplicitDocumentStart || state == <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.DocumentStart))
			{
				isImplicit = true;
			}
			if ((isImplicit && !(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective) && !(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective) && !(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <04c3436e-0564-48ea-a8a0-16c0763f715a>DocumentStart) && !(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <d9dfed6c-4441-4064-a28b-ae9e56d8221b>StreamEnd) && !(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <5507821e-8467-4a48-865d-95beb56e50bf>DocumentEnd)) || <abd144ac-e219-4ca9-8443-aea408941dd7>Token is <3e24c425-24f0-498d-91dc-9781486bb4fa>BlockMappingStart)
			{
				<229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection tags = new <229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection();
				ProcessDirectives(tags);
				states.Push(<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.DocumentEnd);
				state = <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.BlockNode;
				return new <b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart(null, tags, isImplicit: true, <abd144ac-e219-4ca9-8443-aea408941dd7>Token.Start, <abd144ac-e219-4ca9-8443-aea408941dd7>Token.End);
			}
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start2;
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end;
			if (!(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <d9dfed6c-4441-4064-a28b-ae9e56d8221b>StreamEnd) && !(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <5507821e-8467-4a48-865d-95beb56e50bf>DocumentEnd))
			{
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = <abd144ac-e219-4ca9-8443-aea408941dd7>Token.Start;
				<229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection tags2 = new <229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection();
				<af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective <af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective = ProcessDirectives(tags2);
				<abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken() ?? throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException("Reached the end of the stream while parsing a document start");
				if (!(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <04c3436e-0564-48ea-a8a0-16c0763f715a>DocumentStart))
				{
					start2 = <abd144ac-e219-4ca9-8443-aea408941dd7>Token.Start;
					end = <abd144ac-e219-4ca9-8443-aea408941dd7>Token.End;
					throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in start2, in end, "Did not find expected <document start>.");
				}
				states.Push(<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.DocumentEnd);
				state = <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.DocumentContent;
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end2 = <abd144ac-e219-4ca9-8443-aea408941dd7>Token.End;
				Skip();
				return new <b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart(<af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective, tags2, isImplicit: false, start, end2);
			}
			if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <5507821e-8467-4a48-865d-95beb56e50bf>DocumentEnd)
			{
				Skip();
			}
			state = <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.StreamEnd;
			<abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken() ?? throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException("Reached the end of the stream while parsing a document start");
			start2 = <abd144ac-e219-4ca9-8443-aea408941dd7>Token.Start;
			end = <abd144ac-e219-4ca9-8443-aea408941dd7>Token.End;
			<639c5f87-0aee-41c1-9e7d-0f8ace8688c9>StreamEnd result = new <639c5f87-0aee-41c1-9e7d-0f8ace8688c9>StreamEnd(in start2, in end);
			if (scanner.MoveNextWithoutConsuming())
			{
				throw new InvalidOperationException("The scanner should contain no more tokens.");
			}
			return result;
		}

		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		private <af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective ProcessDirectives(<229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection tags)
		{
			bool flag = false;
			<af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective result = null;
			while (true)
			{
				if (GetCurrentToken() is <af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective <af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective)
				{
					if (version != null)
					{
						<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = <af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective.Start;
						<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = <af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective.End;
						throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in start, in end, "Found duplicate %YAML directive.");
					}
					if (<af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective.Version.Major != 1 || <af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective.Version.Minor > 3)
					{
						<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = <af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective.Start;
						<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = <af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective.End;
						throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in start, in end, "Found incompatible YAML document.");
					}
					result = (version = <af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective);
					flag = true;
				}
				else
				{
					if (!(GetCurrentToken() is <58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective <58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective))
					{
						break;
					}
					if (tags.Contains(<58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective.Handle))
					{
						<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = <58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective.Start;
						<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = <58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective.End;
						throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in start, in end, "Found duplicate %TAG directive.");
					}
					tags.Add(<58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective);
					flag = true;
				}
				Skip();
			}
			if (GetCurrentToken() is <04c3436e-0564-48ea-a8a0-16c0763f715a>DocumentStart && (version == null || (version.Version.Major == 1 && version.Version.Minor > 1)))
			{
				if (GetCurrentToken() is <04c3436e-0564-48ea-a8a0-16c0763f715a>DocumentStart && version == null)
				{
					version = new <af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective(new <6803d8e0-a57c-4ba7-ada8-bd55856c55ec>Version(1, 2));
				}
				flag = true;
			}
			AddTagDirectives(tags, <44582626-f33b-4b53-a1c9-05b9928e92a7>Constants.DefaultTagDirectives);
			if (flag)
			{
				tagDirectives.Clear();
			}
			AddTagDirectives(tagDirectives, tags);
			return result;
		}

		private static void AddTagDirectives(<229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection directives, IEnumerable<<58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective> source)
		{
			foreach (<58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective item in source)
			{
				if (!directives.Contains(item))
				{
					directives.Add(item);
				}
			}
		}

		private <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent ParseDocumentContent()
		{
			if (GetCurrentToken() is <af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective || GetCurrentToken() is <58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective || GetCurrentToken() is <04c3436e-0564-48ea-a8a0-16c0763f715a>DocumentStart || GetCurrentToken() is <5507821e-8467-4a48-865d-95beb56e50bf>DocumentEnd || GetCurrentToken() is <d9dfed6c-4441-4064-a28b-ae9e56d8221b>StreamEnd)
			{
				state = states.Pop();
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark position = scanner.CurrentPosition;
				return ProcessEmptyScalar(in position);
			}
			return ParseNode(isBlock: true, isIndentlessSequence: false);
		}

		private static <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent ProcessEmptyScalar(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark position)
		{
			return new <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName.Empty, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName.Empty, string.Empty, <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Plain, isPlainImplicit: true, isQuotedImplicit: false, position, position);
		}

		private <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent ParseNode(bool isBlock, bool isIndentlessSequence)
		{
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start;
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end;
			if (GetCurrentToken() is <a5e78112-ae12-4536-8694-db0ef70e0007>Error <a5e78112-ae12-4536-8694-db0ef70e0007>Error)
			{
				start = <a5e78112-ae12-4536-8694-db0ef70e0007>Error.Start;
				end = <a5e78112-ae12-4536-8694-db0ef70e0007>Error.End;
				throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in start, in end, <a5e78112-ae12-4536-8694-db0ef70e0007>Error.Value);
			}
			<abd144ac-e219-4ca9-8443-aea408941dd7>Token <abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken() ?? throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException("Reached the end of the stream while parsing a node");
			if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <494b1633-c4c7-4739-8261-1dc286ac3d3e>AnchorAlias <494b1633-c4c7-4739-8261-1dc286ac3d3e>AnchorAlias)
			{
				state = states.Pop();
				<4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias result = new <4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias(<494b1633-c4c7-4739-8261-1dc286ac3d3e>AnchorAlias.Value, <494b1633-c4c7-4739-8261-1dc286ac3d3e>AnchorAlias.Start, <494b1633-c4c7-4739-8261-1dc286ac3d3e>AnchorAlias.End);
				Skip();
				return result;
			}
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start2 = <abd144ac-e219-4ca9-8443-aea408941dd7>Token.Start;
			<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName anchor = <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName.Empty;
			<baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName tag = <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName.Empty;
			<d9b36862-7f6c-45a8-b65a-ec623dcc4cf3>Anchor <d9b36862-7f6c-45a8-b65a-ec623dcc4cf3>Anchor = null;
			<59c04d0a-eac2-4f44-b453-d7a0ff6f0dd8>Tag <59c04d0a-eac2-4f44-b453-d7a0ff6f0dd8>Tag = null;
			while (true)
			{
				if (anchor.IsEmpty && <abd144ac-e219-4ca9-8443-aea408941dd7>Token is <d9b36862-7f6c-45a8-b65a-ec623dcc4cf3>Anchor <d9b36862-7f6c-45a8-b65a-ec623dcc4cf3>Anchor2)
				{
					<d9b36862-7f6c-45a8-b65a-ec623dcc4cf3>Anchor = <d9b36862-7f6c-45a8-b65a-ec623dcc4cf3>Anchor2;
					anchor = <d9b36862-7f6c-45a8-b65a-ec623dcc4cf3>Anchor2.Value;
					Skip();
				}
				else
				{
					if (!tag.IsEmpty || !(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <59c04d0a-eac2-4f44-b453-d7a0ff6f0dd8>Tag <59c04d0a-eac2-4f44-b453-d7a0ff6f0dd8>Tag2))
					{
						if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <d9b36862-7f6c-45a8-b65a-ec623dcc4cf3>Anchor <d9b36862-7f6c-45a8-b65a-ec623dcc4cf3>Anchor3)
						{
							start = <d9b36862-7f6c-45a8-b65a-ec623dcc4cf3>Anchor3.Start;
							end = <d9b36862-7f6c-45a8-b65a-ec623dcc4cf3>Anchor3.End;
							throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in start, in end, "While parsing a node, found more than one anchor.");
						}
						if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <494b1633-c4c7-4739-8261-1dc286ac3d3e>AnchorAlias <494b1633-c4c7-4739-8261-1dc286ac3d3e>AnchorAlias2)
						{
							start = <494b1633-c4c7-4739-8261-1dc286ac3d3e>AnchorAlias2.Start;
							end = <494b1633-c4c7-4739-8261-1dc286ac3d3e>AnchorAlias2.End;
							throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in start, in end, "While parsing a node, did not find expected token.");
						}
						if (!(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <a5e78112-ae12-4536-8694-db0ef70e0007>Error <a5e78112-ae12-4536-8694-db0ef70e0007>Error2))
						{
							break;
						}
						if (<59c04d0a-eac2-4f44-b453-d7a0ff6f0dd8>Tag != null && <d9b36862-7f6c-45a8-b65a-ec623dcc4cf3>Anchor != null && !anchor.IsEmpty)
						{
							return new <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar(anchor, default(<baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName), string.Empty, <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Any, isPlainImplicit: false, isQuotedImplicit: false, <d9b36862-7f6c-45a8-b65a-ec623dcc4cf3>Anchor.Start, <d9b36862-7f6c-45a8-b65a-ec623dcc4cf3>Anchor.End);
						}
						start = <a5e78112-ae12-4536-8694-db0ef70e0007>Error2.Start;
						end = <a5e78112-ae12-4536-8694-db0ef70e0007>Error2.End;
						throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in start, in end, <a5e78112-ae12-4536-8694-db0ef70e0007>Error2.Value);
					}
					<59c04d0a-eac2-4f44-b453-d7a0ff6f0dd8>Tag = <59c04d0a-eac2-4f44-b453-d7a0ff6f0dd8>Tag2;
					if (string.IsNullOrEmpty(<59c04d0a-eac2-4f44-b453-d7a0ff6f0dd8>Tag2.Handle))
					{
						tag = new <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName(<59c04d0a-eac2-4f44-b453-d7a0ff6f0dd8>Tag2.Suffix);
					}
					else
					{
						if (!tagDirectives.Contains(<59c04d0a-eac2-4f44-b453-d7a0ff6f0dd8>Tag2.Handle))
						{
							start = <59c04d0a-eac2-4f44-b453-d7a0ff6f0dd8>Tag2.Start;
							end = <59c04d0a-eac2-4f44-b453-d7a0ff6f0dd8>Tag2.End;
							throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in start, in end, "While parsing a node, found undefined tag handle.");
						}
						tag = new <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName(tagDirectives[<59c04d0a-eac2-4f44-b453-d7a0ff6f0dd8>Tag2.Handle].Prefix + <59c04d0a-eac2-4f44-b453-d7a0ff6f0dd8>Tag2.Suffix);
					}
					Skip();
				}
				<abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken() ?? throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException("Reached the end of the stream while parsing a node");
			}
			bool isEmpty = tag.IsEmpty;
			if (isIndentlessSequence && GetCurrentToken() is <972aac28-5023-4fe4-b801-8d51065b4a71>BlockEntry)
			{
				state = <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.IndentlessSequenceEntry;
				return new <743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart(anchor, tag, isEmpty, <633aecbb-227c-4a56-bde3-6176f414312f>SequenceStyle.Block, start2, <abd144ac-e219-4ca9-8443-aea408941dd7>Token.End);
			}
			if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar <d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar)
			{
				bool isPlainImplicit = false;
				bool isQuotedImplicit = false;
				if ((<d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar.Style == <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Plain && tag.IsEmpty) || tag.IsNonSpecific)
				{
					isPlainImplicit = true;
				}
				else if (tag.IsEmpty)
				{
					isQuotedImplicit = true;
				}
				state = states.Pop();
				Skip();
				<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar result2 = new <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar(anchor, tag, <d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar.Value, <d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar.Style, isPlainImplicit, isQuotedImplicit, start2, <d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar.End, <d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar.IsKey);
				if (!anchor.IsEmpty && scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (currentToken is <a5e78112-ae12-4536-8694-db0ef70e0007>Error)
					{
						<a5e78112-ae12-4536-8694-db0ef70e0007>Error <a5e78112-ae12-4536-8694-db0ef70e0007>Error3 = currentToken as <a5e78112-ae12-4536-8694-db0ef70e0007>Error;
						start = <a5e78112-ae12-4536-8694-db0ef70e0007>Error3.Start;
						end = <a5e78112-ae12-4536-8694-db0ef70e0007>Error3.End;
						throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in start, in end, <a5e78112-ae12-4536-8694-db0ef70e0007>Error3.Value);
					}
				}
				if (state == <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowMappingKey && scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (currentToken != null && !(currentToken is <c8290e94-df8b-41c8-a128-37ae18eb8c76>FlowEntry) && !(currentToken is <4856c899-60f1-4941-9a16-ec90d3b9388c>FlowMappingEnd))
					{
						start = currentToken.Start;
						end = currentToken.End;
						throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in start, in end, "While parsing a flow mapping, did not find expected ',' or '}'.");
					}
				}
				return result2;
			}
			if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <f6883492-5e52-4549-99ec-ae704a8fea1c>FlowSequenceStart <f6883492-5e52-4549-99ec-ae704a8fea1c>FlowSequenceStart)
			{
				state = <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowSequenceFirstEntry;
				return new <743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart(anchor, tag, isEmpty, <633aecbb-227c-4a56-bde3-6176f414312f>SequenceStyle.Flow, start2, <f6883492-5e52-4549-99ec-ae704a8fea1c>FlowSequenceStart.End);
			}
			if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <659f91d9-8844-498c-8d5e-404d14b54a4e>FlowMappingStart <659f91d9-8844-498c-8d5e-404d14b54a4e>FlowMappingStart)
			{
				state = <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowMappingFirstKey;
				return new <fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart(anchor, tag, isEmpty, <5bdd0818-2e61-4148-a2dc-8d667b816026>MappingStyle.Flow, start2, <659f91d9-8844-498c-8d5e-404d14b54a4e>FlowMappingStart.End);
			}
			if (isBlock)
			{
				if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <6638cb55-a5b9-4f7a-8a52-327a39f518f9>BlockSequenceStart <6638cb55-a5b9-4f7a-8a52-327a39f518f9>BlockSequenceStart)
				{
					state = <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.BlockSequenceFirstEntry;
					return new <743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart(anchor, tag, isEmpty, <633aecbb-227c-4a56-bde3-6176f414312f>SequenceStyle.Block, start2, <6638cb55-a5b9-4f7a-8a52-327a39f518f9>BlockSequenceStart.End);
				}
				if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <3e24c425-24f0-498d-91dc-9781486bb4fa>BlockMappingStart <3e24c425-24f0-498d-91dc-9781486bb4fa>BlockMappingStart)
				{
					state = <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.BlockMappingFirstKey;
					return new <fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart(anchor, tag, isEmpty, <5bdd0818-2e61-4148-a2dc-8d667b816026>MappingStyle.Block, start2, <3e24c425-24f0-498d-91dc-9781486bb4fa>BlockMappingStart.End);
				}
			}
			if (!anchor.IsEmpty || !tag.IsEmpty)
			{
				state = states.Pop();
				return new <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar(anchor, tag, string.Empty, <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Plain, isEmpty, isQuotedImplicit: false, start2, <abd144ac-e219-4ca9-8443-aea408941dd7>Token.End);
			}
			start = <abd144ac-e219-4ca9-8443-aea408941dd7>Token.Start;
			end = <abd144ac-e219-4ca9-8443-aea408941dd7>Token.End;
			throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in start, in end, "While parsing a node, did not find expected node content.");
		}

		private <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent ParseDocumentEnd()
		{
			<abd144ac-e219-4ca9-8443-aea408941dd7>Token <abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken() ?? throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException("Reached the end of the stream while parsing a document end");
			bool isImplicit = true;
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = <abd144ac-e219-4ca9-8443-aea408941dd7>Token.Start;
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = start;
			if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <5507821e-8467-4a48-865d-95beb56e50bf>DocumentEnd)
			{
				end = <abd144ac-e219-4ca9-8443-aea408941dd7>Token.End;
				Skip();
				isImplicit = false;
			}
			else if (!(currentToken is <d9dfed6c-4441-4064-a28b-ae9e56d8221b>StreamEnd) && !(currentToken is <04c3436e-0564-48ea-a8a0-16c0763f715a>DocumentStart) && !(currentToken is <cc7d306f-49d8-4801-9c5f-1fcd6f24976f>FlowSequenceEnd) && !(currentToken is <af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective) && (!(Current is <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar) || !(currentToken is <a5e78112-ae12-4536-8694-db0ef70e0007>Error)))
			{
				throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in start, in end, "Did not find expected <document end>.");
			}
			if (version != null && version.Version.Major == 1 && version.Version.Minor > 1)
			{
				version = null;
			}
			state = <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.DocumentStart;
			return new <c51742f9-fbb1-469d-bb0b-e52d59018ce6>DocumentEnd(isImplicit, start, end);
		}

		private <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent ParseBlockSequenceEntry(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			<abd144ac-e219-4ca9-8443-aea408941dd7>Token <abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken();
			if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <972aac28-5023-4fe4-b801-8d51065b4a71>BlockEntry <972aac28-5023-4fe4-b801-8d51065b4a71>BlockEntry)
			{
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark position = <972aac28-5023-4fe4-b801-8d51065b4a71>BlockEntry.End;
				Skip();
				<abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken();
				if (!(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <972aac28-5023-4fe4-b801-8d51065b4a71>BlockEntry) && !(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <aa1f9abc-5d01-4049-bce9-7578a19e6e2d>BlockEnd))
				{
					states.Push(<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.BlockSequenceEntry);
					return ParseNode(isBlock: true, isIndentlessSequence: false);
				}
				state = <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.BlockSequenceEntry;
				return ProcessEmptyScalar(in position);
			}
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start;
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end;
			if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <aa1f9abc-5d01-4049-bce9-7578a19e6e2d>BlockEnd <aa1f9abc-5d01-4049-bce9-7578a19e6e2d>BlockEnd)
			{
				state = states.Pop();
				start = <aa1f9abc-5d01-4049-bce9-7578a19e6e2d>BlockEnd.Start;
				end = <aa1f9abc-5d01-4049-bce9-7578a19e6e2d>BlockEnd.End;
				<7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd result = new <7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd(in start, in end);
				Skip();
				return result;
			}
			start = <abd144ac-e219-4ca9-8443-aea408941dd7>Token?.Start ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
			end = <abd144ac-e219-4ca9-8443-aea408941dd7>Token?.End ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
			throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in start, in end, "While parsing a block collection, did not find expected '-' indicator.");
		}

		private <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent ParseIndentlessSequenceEntry()
		{
			<abd144ac-e219-4ca9-8443-aea408941dd7>Token <abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken();
			if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <972aac28-5023-4fe4-b801-8d51065b4a71>BlockEntry <972aac28-5023-4fe4-b801-8d51065b4a71>BlockEntry)
			{
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark position = <972aac28-5023-4fe4-b801-8d51065b4a71>BlockEntry.End;
				Skip();
				<abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken();
				if (!(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <972aac28-5023-4fe4-b801-8d51065b4a71>BlockEntry) && !(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <e12792f4-589e-46e6-baf2-85761126c7a5>Key) && !(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <d1c98b09-9c2f-4ca5-acd9-b7172526c3a0>Value) && !(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <aa1f9abc-5d01-4049-bce9-7578a19e6e2d>BlockEnd))
				{
					states.Push(<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.IndentlessSequenceEntry);
					return ParseNode(isBlock: true, isIndentlessSequence: false);
				}
				state = <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.IndentlessSequenceEntry;
				return ProcessEmptyScalar(in position);
			}
			state = states.Pop();
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = <abd144ac-e219-4ca9-8443-aea408941dd7>Token?.Start ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = <abd144ac-e219-4ca9-8443-aea408941dd7>Token?.End ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
			return new <7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd(in start, in end);
		}

		private <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent ParseBlockMappingKey(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			<abd144ac-e219-4ca9-8443-aea408941dd7>Token <abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken();
			if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <e12792f4-589e-46e6-baf2-85761126c7a5>Key <e12792f4-589e-46e6-baf2-85761126c7a5>Key)
			{
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark position = <e12792f4-589e-46e6-baf2-85761126c7a5>Key.End;
				Skip();
				<abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken();
				if (!(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <e12792f4-589e-46e6-baf2-85761126c7a5>Key) && !(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <d1c98b09-9c2f-4ca5-acd9-b7172526c3a0>Value) && !(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <aa1f9abc-5d01-4049-bce9-7578a19e6e2d>BlockEnd))
				{
					states.Push(<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.BlockMappingValue);
					return ParseNode(isBlock: true, isIndentlessSequence: true);
				}
				state = <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.BlockMappingValue;
				return ProcessEmptyScalar(in position);
			}
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark position2;
			if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <d1c98b09-9c2f-4ca5-acd9-b7172526c3a0>Value <d1c98b09-9c2f-4ca5-acd9-b7172526c3a0>Value)
			{
				Skip();
				position2 = <d1c98b09-9c2f-4ca5-acd9-b7172526c3a0>Value.End;
				return ProcessEmptyScalar(in position2);
			}
			if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <494b1633-c4c7-4739-8261-1dc286ac3d3e>AnchorAlias <494b1633-c4c7-4739-8261-1dc286ac3d3e>AnchorAlias)
			{
				Skip();
				return new <4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias(<494b1633-c4c7-4739-8261-1dc286ac3d3e>AnchorAlias.Value, <494b1633-c4c7-4739-8261-1dc286ac3d3e>AnchorAlias.Start, <494b1633-c4c7-4739-8261-1dc286ac3d3e>AnchorAlias.End);
			}
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end;
			if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <aa1f9abc-5d01-4049-bce9-7578a19e6e2d>BlockEnd <aa1f9abc-5d01-4049-bce9-7578a19e6e2d>BlockEnd)
			{
				state = states.Pop();
				position2 = <aa1f9abc-5d01-4049-bce9-7578a19e6e2d>BlockEnd.Start;
				end = <aa1f9abc-5d01-4049-bce9-7578a19e6e2d>BlockEnd.End;
				<d66b1b5c-22da-4393-8f8d-68d3635cb59f>MappingEnd result = new <d66b1b5c-22da-4393-8f8d-68d3635cb59f>MappingEnd(in position2, in end);
				Skip();
				return result;
			}
			if (GetCurrentToken() is <a5e78112-ae12-4536-8694-db0ef70e0007>Error <a5e78112-ae12-4536-8694-db0ef70e0007>Error)
			{
				position2 = <a5e78112-ae12-4536-8694-db0ef70e0007>Error.Start;
				end = <a5e78112-ae12-4536-8694-db0ef70e0007>Error.End;
				throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in position2, in end, <a5e78112-ae12-4536-8694-db0ef70e0007>Error.Value);
			}
			position2 = <abd144ac-e219-4ca9-8443-aea408941dd7>Token?.Start ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
			end = <abd144ac-e219-4ca9-8443-aea408941dd7>Token?.End ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
			throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in position2, in end, "While parsing a block mapping, did not find expected key.");
		}

		private <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent ParseBlockMappingValue()
		{
			<abd144ac-e219-4ca9-8443-aea408941dd7>Token <abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken();
			if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <d1c98b09-9c2f-4ca5-acd9-b7172526c3a0>Value <d1c98b09-9c2f-4ca5-acd9-b7172526c3a0>Value)
			{
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark position = <d1c98b09-9c2f-4ca5-acd9-b7172526c3a0>Value.End;
				Skip();
				<abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken();
				if (!(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <e12792f4-589e-46e6-baf2-85761126c7a5>Key) && !(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <d1c98b09-9c2f-4ca5-acd9-b7172526c3a0>Value) && !(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <aa1f9abc-5d01-4049-bce9-7578a19e6e2d>BlockEnd))
				{
					states.Push(<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.BlockMappingKey);
					return ParseNode(isBlock: true, isIndentlessSequence: true);
				}
				state = <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.BlockMappingKey;
				return ProcessEmptyScalar(in position);
			}
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start;
			if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <a5e78112-ae12-4536-8694-db0ef70e0007>Error <a5e78112-ae12-4536-8694-db0ef70e0007>Error)
			{
				start = <a5e78112-ae12-4536-8694-db0ef70e0007>Error.Start;
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = <a5e78112-ae12-4536-8694-db0ef70e0007>Error.End;
				throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in start, in end, <a5e78112-ae12-4536-8694-db0ef70e0007>Error.Value);
			}
			state = <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.BlockMappingKey;
			start = <abd144ac-e219-4ca9-8443-aea408941dd7>Token?.Start ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
			return ProcessEmptyScalar(in start);
		}

		private <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent ParseFlowSequenceEntry(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			<abd144ac-e219-4ca9-8443-aea408941dd7>Token <abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken();
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start;
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end;
			if (!(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <cc7d306f-49d8-4801-9c5f-1fcd6f24976f>FlowSequenceEnd))
			{
				if (!isFirst)
				{
					if (!(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <c8290e94-df8b-41c8-a128-37ae18eb8c76>FlowEntry))
					{
						start = <abd144ac-e219-4ca9-8443-aea408941dd7>Token?.Start ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
						end = <abd144ac-e219-4ca9-8443-aea408941dd7>Token?.End ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
						throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in start, in end, "While parsing a flow sequence, did not find expected ',' or ']'.");
					}
					Skip();
					<abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken();
				}
				if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <e12792f4-589e-46e6-baf2-85761126c7a5>Key)
				{
					state = <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowSequenceEntryMappingKey;
					<fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart result = new <fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName.Empty, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName.Empty, isImplicit: true, <5bdd0818-2e61-4148-a2dc-8d667b816026>MappingStyle.Flow);
					Skip();
					return result;
				}
				if (!(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <cc7d306f-49d8-4801-9c5f-1fcd6f24976f>FlowSequenceEnd))
				{
					states.Push(<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowSequenceEntry);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = states.Pop();
			start = <abd144ac-e219-4ca9-8443-aea408941dd7>Token?.Start ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
			end = <abd144ac-e219-4ca9-8443-aea408941dd7>Token?.End ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
			<7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd result2 = new <7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd(in start, in end);
			Skip();
			return result2;
		}

		private <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent ParseFlowSequenceEntryMappingKey()
		{
			<abd144ac-e219-4ca9-8443-aea408941dd7>Token <abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken();
			if (!(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <d1c98b09-9c2f-4ca5-acd9-b7172526c3a0>Value) && !(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <c8290e94-df8b-41c8-a128-37ae18eb8c76>FlowEntry) && !(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <cc7d306f-49d8-4801-9c5f-1fcd6f24976f>FlowSequenceEnd))
			{
				states.Push(<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowSequenceEntryMappingValue);
				return ParseNode(isBlock: false, isIndentlessSequence: false);
			}
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark position = <abd144ac-e219-4ca9-8443-aea408941dd7>Token?.End ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
			Skip();
			state = <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowSequenceEntryMappingValue;
			return ProcessEmptyScalar(in position);
		}

		private <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent ParseFlowSequenceEntryMappingValue()
		{
			<abd144ac-e219-4ca9-8443-aea408941dd7>Token <abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken();
			if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <d1c98b09-9c2f-4ca5-acd9-b7172526c3a0>Value)
			{
				Skip();
				<abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken();
				if (!(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <c8290e94-df8b-41c8-a128-37ae18eb8c76>FlowEntry) && !(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <cc7d306f-49d8-4801-9c5f-1fcd6f24976f>FlowSequenceEnd))
				{
					states.Push(<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowSequenceEntryMappingEnd);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowSequenceEntryMappingEnd;
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark position = <abd144ac-e219-4ca9-8443-aea408941dd7>Token?.Start ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
			return ProcessEmptyScalar(in position);
		}

		private <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent ParseFlowSequenceEntryMappingEnd()
		{
			state = <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowSequenceEntry;
			<abd144ac-e219-4ca9-8443-aea408941dd7>Token <abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken();
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = <abd144ac-e219-4ca9-8443-aea408941dd7>Token?.Start ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = <abd144ac-e219-4ca9-8443-aea408941dd7>Token?.End ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
			return new <d66b1b5c-22da-4393-8f8d-68d3635cb59f>MappingEnd(in start, in end);
		}

		private <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent ParseFlowMappingKey(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			<abd144ac-e219-4ca9-8443-aea408941dd7>Token <abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken();
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start;
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end;
			if (!(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <4856c899-60f1-4941-9a16-ec90d3b9388c>FlowMappingEnd))
			{
				if (!isFirst)
				{
					if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <c8290e94-df8b-41c8-a128-37ae18eb8c76>FlowEntry)
					{
						Skip();
						<abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken();
					}
					else if (!(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar))
					{
						start = <abd144ac-e219-4ca9-8443-aea408941dd7>Token?.Start ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
						end = <abd144ac-e219-4ca9-8443-aea408941dd7>Token?.End ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
						throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in start, in end, "While parsing a flow mapping,  did not find expected ',' or '}'.");
					}
				}
				if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <e12792f4-589e-46e6-baf2-85761126c7a5>Key)
				{
					Skip();
					<abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken();
					if (!(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <d1c98b09-9c2f-4ca5-acd9-b7172526c3a0>Value) && !(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <c8290e94-df8b-41c8-a128-37ae18eb8c76>FlowEntry) && !(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <4856c899-60f1-4941-9a16-ec90d3b9388c>FlowMappingEnd))
					{
						states.Push(<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowMappingValue);
						return ParseNode(isBlock: false, isIndentlessSequence: false);
					}
					state = <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowMappingValue;
					start = <abd144ac-e219-4ca9-8443-aea408941dd7>Token?.Start ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
					return ProcessEmptyScalar(in start);
				}
				if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar)
				{
					states.Push(<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowMappingValue);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
				if (!(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <4856c899-60f1-4941-9a16-ec90d3b9388c>FlowMappingEnd))
				{
					states.Push(<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowMappingEmptyValue);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = states.Pop();
			Skip();
			start = <abd144ac-e219-4ca9-8443-aea408941dd7>Token?.Start ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
			end = <abd144ac-e219-4ca9-8443-aea408941dd7>Token?.End ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
			return new <d66b1b5c-22da-4393-8f8d-68d3635cb59f>MappingEnd(in start, in end);
		}

		private <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent ParseFlowMappingValue(bool isEmpty)
		{
			<abd144ac-e219-4ca9-8443-aea408941dd7>Token <abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken();
			if (!isEmpty && <abd144ac-e219-4ca9-8443-aea408941dd7>Token is <d1c98b09-9c2f-4ca5-acd9-b7172526c3a0>Value)
			{
				Skip();
				<abd144ac-e219-4ca9-8443-aea408941dd7>Token = GetCurrentToken();
				if (!(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <c8290e94-df8b-41c8-a128-37ae18eb8c76>FlowEntry) && !(<abd144ac-e219-4ca9-8443-aea408941dd7>Token is <4856c899-60f1-4941-9a16-ec90d3b9388c>FlowMappingEnd))
				{
					states.Push(<4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowMappingKey);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>ParserState.FlowMappingKey;
			if (!isEmpty && <abd144ac-e219-4ca9-8443-aea408941dd7>Token is <d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar <d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar)
			{
				Skip();
				return new <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName.Empty, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName.Empty, <d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar.Value, <d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar.Style, isPlainImplicit: false, isQuotedImplicit: false, <abd144ac-e219-4ca9-8443-aea408941dd7>Token.Start, <d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar.End);
			}
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark position = <abd144ac-e219-4ca9-8443-aea408941dd7>Token?.Start ?? <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty;
			return ProcessEmptyScalar(in position);
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal static class <287f66bf-9246-4754-b301-f292daed9b73>ParserExtensions
	{
		public static T Consume<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] T>(this <407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser) where T : <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent
		{
			T result = parser.Require<T>();
			parser.MoveNext();
			return result;
		}

		public static bool TryConsume<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] T>(this <407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, [<6977aacd-47a7-4a01-9bad-79c003aa1e36>MaybeNullWhen(false)] out T @event) where T : <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent
		{
			if (parser.Accept<T>(out @event))
			{
				parser.MoveNext();
				return true;
			}
			return false;
		}

		public static T Require<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] T>(this <407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser) where T : <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent
		{
			if (!parser.Accept<T>(out var @event))
			{
				<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent current = parser.Current;
				if (current == null)
				{
					throw new <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException("Expected '" + typeof(T).Name + "', got nothing.");
				}
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = current.Start;
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = current.End;
				throw new <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException(in start, in end, $"Expected '{typeof(T).Name}', got '{current.GetType().Name}' (at {current.Start}).");
			}
			return @event;
		}

		public static bool Accept<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] T>(this <407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, [<6977aacd-47a7-4a01-9bad-79c003aa1e36>MaybeNullWhen(false)] out T @event) where T : <83ef3299-9efa-4d51-b8c1-ad9f887f306d>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 <407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser)
		{
			int num = 0;
			do
			{
				<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent = parser.Consume<<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent>();
				num += <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent.NestingIncrease;
			}
			while (num > 0);
		}

		[Obsolete("Please use Consume<T>() instead")]
		public static T Expect<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] T>(this <407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser) where T : <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent
		{
			return parser.Consume<T>();
		}

		[Obsolete("Please use TryConsume<T>(out var evt) instead")]
		[return: <5efc7cea-0044-4fef-8184-8756b06de675>MaybeNull]
		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public static T Allow<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] T>(this <407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser) where T : <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent
		{
			if (!parser.TryConsume<T>(out var @event))
			{
				return null;
			}
			return @event;
		}

		[Obsolete("Please use Accept<T>(out var evt) instead")]
		[return: <5efc7cea-0044-4fef-8184-8756b06de675>MaybeNull]
		[return: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public static T Peek<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] T>(this <407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser) where T : <83ef3299-9efa-4d51-b8c1-ad9f887f306d>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<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)] T>(this <407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser) where T : <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent
		{
			T @event;
			return parser.Accept<T>(out @event);
		}

		public static bool TryFindMappingEntry(this <407d9ba3-b48b-4abf-9738-5195e80ae436>IParser parser, Func<<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar, bool> selector, [<6977aacd-47a7-4a01-9bad-79c003aa1e36>MaybeNullWhen(false)][<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] out <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar key, [<6977aacd-47a7-4a01-9bad-79c003aa1e36>MaybeNullWhen(false)][<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] out <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent value)
		{
			if (parser.TryConsume<<fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart>(out var _))
			{
				while (parser.Current != null)
				{
					<83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent current = parser.Current;
					if (!(current is <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar))
					{
						if (current is <fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart || current is <743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart)
						{
							parser.SkipThisAndNestedEvents();
						}
						else
						{
							parser.MoveNext();
						}
						continue;
					}
					bool num = selector(<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar);
					parser.MoveNext();
					if (num)
					{
						value = parser.Current;
						key = <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar;
						return true;
					}
					parser.SkipThisAndNestedEvents();
				}
			}
			key = null;
			value = null;
			return false;
		}
	}
	internal enum <4e9f78ec-7a58-4561-8a79-9725c7cf4bd4>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 <b9d7e607-dcfe-4df1-bf3c-9b1dc2a136dc>RecursionLevel
	{
		private int current;

		public int Maximum { get; }

		public <b9d7e607-dcfe-4df1-bf3c-9b1dc2a136dc>RecursionLevel(int maximum)
		{
			Maximum = maximum;
		}

		public void Increment()
		{
			if (!TryIncrement())
			{
				throw new <e1f13554-13ac-4c5c-b7d5-4ebc5f732030>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 <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle
	{
		Any,
		Plain,
		SingleQuoted,
		DoubleQuoted,
		Literal,
		Folded
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal class <d079a2d7-b960-4e6b-88be-b46e132dc590>Scanner : <43801baf-9d5a-4c2b-a4de-b76127205b43>IScanner
	{
		private const int MaxVersionNumberLength = 9;

		private static readonly SortedDictionary<char, char> SimpleEscapeCodes = new SortedDictionary<char, char>
		{
			{ '0', '\0' },
			{ 'a', '\a' },
			{ 'b', '\b' },
			{ 't', '\t' },
			{ '\t', '\t' },
			{ 'n', '\n' },
			{ 'v', '\v' },
			{ 'f', '\f' },
			{ 'r', '\r' },
			{ 'e', '\u001b' },
			{ ' ', ' ' },
			{ '"', '"' },
			{ '\\', '\\' },
			{ '/', '/' },
			{ 'N', '\u0085' },
			{ '_', '\u00a0' },
			{ 'L', '\u2028' },
			{ 'P', '\u2029' }
		};

		private readonly Stack<int> indents = new Stack<int>();

		private readonly <67514162-06bc-4d73-9367-d6c8c285bf82>InsertionQueue<<abd144ac-e219-4ca9-8443-aea408941dd7>Token> tokens = new <67514162-06bc-4d73-9367-d6c8c285bf82>InsertionQueue<<abd144ac-e219-4ca9-8443-aea408941dd7>Token>();

		private readonly Stack<<983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey> simpleKeys = new Stack<<983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey>();

		private readonly <479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer<<f0cb7c58-51b8-4c7a-99e1-62a7d71aea68>LookAheadBuffer> analyzer;

		private readonly <4e6c69f4-459d-4c9c-a981-fcb61792fc4d>Cursor cursor;

		private bool streamStartProduced;

		private bool streamEndProduced;

		private bool plainScalarFollowedByComment;

		private int flowSequenceStartLine;

		private bool flowCollectionFetched;

		private bool startFlowCollectionFetched;

		private int indent = -1;

		private bool flowScalarFetched;

		private bool simpleKeyAllowed;

		private int flowLevel;

		private int tokensParsed;

		private bool tokenAvailable;

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		private <abd144ac-e219-4ca9-8443-aea408941dd7>Token previous;

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		private <d9b36862-7f6c-45a8-b65a-ec623dcc4cf3>Anchor previousAnchor;

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		private <d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar lastScalar;

		private static readonly byte[] EmptyBytes = new byte[0];

		public bool SkipComments { get; private set; }

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		[field: <0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)]
		public <abd144ac-e219-4ca9-8443-aea408941dd7>Token Current
		{
			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
			get;
			[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
			private set;
		}

		public <b3f32382-dd1c-454c-b573-36801723d8c1>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 <d079a2d7-b960-4e6b-88be-b46e132dc590>Scanner(TextReader input, bool skipComments = true)
		{
			analyzer = new <479dfb9a-989f-4f2b-95a1-18f4b5e67fa9>CharacterAnalyzer<<f0cb7c58-51b8-4c7a-99e1-62a7d71aea68>LookAheadBuffer>(new <f0cb7c58-51b8-4c7a-99e1-62a7d71aea68>LookAheadBuffer(input, 1024));
			cursor = new <4e6c69f4-459d-4c9c-a981-fcb61792fc4d>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 (<983f8dce-e3a2-4273-8462-2d6433865b29>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 (<983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey simpleKey in simpleKeys)
			{
				if (simpleKey.IsPossible && (simpleKey.Line < cursor.Line || simpleKey.Index + 1024 < cursor.Index))
				{
					if (simpleKey.IsRequired)
					{
						<b3f32382-dd1c-454c-b573-36801723d8c1>Mark <b3f32382-dd1c-454c-b573-36801723d8c1>Mark2 = cursor.Mark();
						tokens.Enqueue(new <a5e78112-ae12-4536-8694-db0ef70e0007>Error("While scanning a simple key, could not find expected ':'.", <b3f32382-dd1c-454c-b573-36801723d8c1>Mark2, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark2));
					}
					simpleKey.MarkAsImpossible();
				}
			}
		}

		private void FetchNextToken()
		{
			if (!streamStartProduced)
			{
				FetchStreamStart();
				return;
			}
			ScanToNextToken();
			StaleSimpleKeys();
			UnrollIndent(cursor.LineOffset);
			analyzer.Buffer.Cache(4);
			if (analyzer.Buffer.EndOfInput)
			{
				lastScalar = null;
				FetchStreamEnd();
			}
			if (cursor.LineOffset == 0 && analyzer.Check('%'))
			{
				lastScalar = null;
				FetchDirective();
				return;
			}
			if (IsDocumentStart())
			{
				lastScalar = null;
				FetchDocumentIndicator(isStartToken: true);
				return;
			}
			if (IsDocumentEnd())
			{
				lastScalar = null;
				FetchDocumentIndicator(isStartToken: false);
				return;
			}
			if (analyzer.Check('['))
			{
				lastScalar = null;
				FetchFlowCollectionStart(isSequenceToken: true);
				return;
			}
			if (analyzer.Check('{'))
			{
				lastScalar = null;
				FetchFlowCollectionStart(isSequenceToken: false);
				return;
			}
			if (analyzer.Check(']'))
			{
				lastScalar = null;
				FetchFlowCollectionEnd(isSequenceToken: true);
				return;
			}
			if (analyzer.Check('}'))
			{
				lastScalar = null;
				FetchFlowCollectionEnd(isSequenceToken: false);
				return;
			}
			if (analyzer.Check(','))
			{
				lastScalar = null;
				FetchFlowEntry();
				return;
			}
			if (analyzer.Check('-'))
			{
				if (analyzer.IsWhiteBreakOrZero(1))
				{
					FetchBlockEntry();
					return;
				}
				if (flowLevel > 0 && analyzer.Check(",[]{}", 1))
				{
					tokens.Enqueue(new <a5e78112-ae12-4536-8694-db0ef70e0007>Error("Invalid key indicator format.", cursor.Mark(), cursor.Mark()));
				}
			}
			if (analyzer.Check('?') && (flowLevel > 0 || analyzer.IsWhiteBreakOrZero(1)) && analyzer.IsWhiteBreakOrZero(1))
			{
				FetchKey();
			}
			else if (analyzer.Check(':') && (flowLevel > 0 || analyzer.IsWhiteBreakOrZero(1)) && (!simpleKeyAllowed || flowLevel <= 0) && (!flowScalarFetched || !analyzer.Check(':', 1)) && (analyzer.IsWhiteBreakOrZero(1) || analyzer.Check(',', 1) || flowScalarFetched || flowCollectionFetched || startFlowCollectionFetched))
			{
				if (lastScalar != null)
				{
					lastScalar.IsKey = true;
					lastScalar = null;
				}
				FetchValue();
			}
			else if (analyzer.Check('*'))
			{
				FetchAnchor(isAlias: true);
			}
			else if (analyzer.Check('&'))
			{
				FetchAnchor(isAlias: false);
			}
			else if (analyzer.Check('!'))
			{
				FetchTag();
			}
			else if (analyzer.Check('|') && flowLevel == 0)
			{
				FetchBlockScalar(isLiteral: true);
			}
			else if (analyzer.Check('>') && flowLevel == 0)
			{
				FetchBlockScalar(isLiteral: false);
			}
			else if (analyzer.Check('\''))
			{
				FetchFlowScalar(isSingleQuoted: true);
			}
			else if (analyzer.Check('"'))
			{
				FetchFlowScalar(isSingleQuoted: false);
			}
			else if ((!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("-?:,[]{}#&*!|>'\"%@`")) || (analyzer.Check('-') && !analyzer.IsWhite(1)) || (analyzer.Check("?:") && !analyzer.IsWhiteBreakOrZero(1)) || (simpleKeyAllowed && flowLevel > 0))
			{
				if (plainScalarFollowedByComment)
				{
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark <b3f32382-dd1c-454c-b573-36801723d8c1>Mark2 = cursor.Mark();
					tokens.Enqueue(new <a5e78112-ae12-4536-8694-db0ef70e0007>Error("While scanning plain scalar, found a comment between adjacent scalars.", <b3f32382-dd1c-454c-b573-36801723d8c1>Mark2, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark2));
				}
				if ((flowScalarFetched || (flowCollectionFetched && !startFlowCollectionFetched)) && analyzer.Check(':'))
				{
					Skip();
				}
				flowScalarFetched = false;
				flowCollectionFetched = false;
				startFlowCollectionFetched = false;
				plainScalarFollowedByComment = false;
				FetchPlainScalar();
			}
			else
			{
				if (simpleKeyAllowed && indent >= cursor.LineOffset && analyzer.IsTab())
				{
					throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException("While scanning a mapping, found invalid tab as indentation.");
				}
				if (!analyzer.IsWhiteBreakOrZero())
				{
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = cursor.Mark();
					Skip();
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
					throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning for the next token, found character that cannot start any token.");
				}
				Skip();
			}
		}

		private bool CheckWhiteSpace()
		{
			if (!analyzer.Check(' '))
			{
				if (flowLevel > 0 || !simpleKeyAllowed)
				{
					return analyzer.Check('\t');
				}
				return false;
			}
			return true;
		}

		private void Skip()
		{
			cursor.Skip();
			analyzer.Buffer.Skip(1);
		}

		private void SkipLine()
		{
			if (analyzer.IsCrLf())
			{
				cursor.SkipLineByOffset(2);
				analyzer.Buffer.Skip(2);
			}
			else if (analyzer.IsBreak())
			{
				cursor.SkipLineByOffset(1);
				analyzer.Buffer.Skip(1);
			}
			else if (!analyzer.IsZero())
			{
				throw new InvalidOperationException("Not at a break.");
			}
		}

		private void ScanToNextToken()
		{
			while (true)
			{
				if (CheckWhiteSpace())
				{
					Skip();
					continue;
				}
				ProcessComment();
				if (analyzer.IsBreak())
				{
					SkipLine();
					if (flowLevel == 0)
					{
						simpleKeyAllowed = true;
					}
					continue;
				}
				break;
			}
		}

		private void ProcessComment()
		{
			if (!analyzer.Check('#'))
			{
				return;
			}
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = cursor.Mark();
			Skip();
			while (analyzer.IsSpace())
			{
				Skip();
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				while (!analyzer.IsBreakOrZero())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (!SkipComments)
				{
					bool isInline = previous != null && previous.End.Line == start.Line && previous.End.Column != 1 && !(previous is <9732b3ee-7084-48fe-a728-33d8b4c4576f>StreamStart);
					tokens.Enqueue(new <92aa2da2-df07-44ac-b284-eaa9be1f2036>Comment(builder.ToString(), isInline, start, cursor.Mark()));
				}
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void FetchStreamStart()
		{
			simpleKeys.Push(new <983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey());
			simpleKeyAllowed = true;
			streamStartProduced = true;
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = cursor.Mark();
			tokens.Enqueue(new <9732b3ee-7084-48fe-a728-33d8b4c4576f>StreamStart(in start, in start));
		}

		private void UnrollIndent(int column)
		{
			if (flowLevel == 0)
			{
				while (indent > column)
				{
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = cursor.Mark();
					tokens.Enqueue(new <aa1f9abc-5d01-4049-bce9-7578a19e6e2d>BlockEnd(in start, in start));
					indent = indents.Pop();
				}
			}
		}

		private void FetchStreamEnd()
		{
			cursor.ForceSkipLineAfterNonBreak();
			UnrollIndent(-1);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			streamEndProduced = true;
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = cursor.Mark();
			tokens.Enqueue(new <d9dfed6c-4441-4064-a28b-ae9e56d8221b>StreamEnd(in start, in start));
		}

		private void FetchDirective()
		{
			UnrollIndent(-1);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			<abd144ac-e219-4ca9-8443-aea408941dd7>Token <abd144ac-e219-4ca9-8443-aea408941dd7>Token = ScanDirective();
			if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token != null)
			{
				tokens.Enqueue(<abd144ac-e219-4ca9-8443-aea408941dd7>Token);
			}
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		private <abd144ac-e219-4ca9-8443-aea408941dd7>Token ScanDirective()
		{
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = cursor.Mark();
			Skip();
			string text = ScanDirectiveName(in start);
			<abd144ac-e219-4ca9-8443-aea408941dd7>Token result;
			if (!(text == "YAML"))
			{
				if (!(text == "TAG"))
				{
					while (!analyzer.EndOfInput && !analyzer.Check('#') && !analyzer.IsBreak())
					{
						Skip();
					}
					return null;
				}
				result = ScanTagDirectiveValue(in start);
			}
			else
			{
				if (!(previous is <04c3436e-0564-48ea-a8a0-16c0763f715a>DocumentStart) && !(previous is <9732b3ee-7084-48fe-a728-33d8b4c4576f>StreamStart) && !(previous is <5507821e-8467-4a48-865d-95beb56e50bf>DocumentEnd))
				{
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
					throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in start, in end, "While scanning a version directive, did not find preceding <document end>.");
				}
				result = ScanVersionDirectiveValue(in start);
			}
			while (analyzer.IsWhite())
			{
				Skip();
			}
			ProcessComment();
			if (!analyzer.IsBreakOrZero())
			{
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
				throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a directive, did not find expected comment or line break.");
			}
			if (analyzer.IsBreak())
			{
				SkipLine();
			}
			return result;
		}

		private void FetchDocumentIndicator(bool isStartToken)
		{
			UnrollIndent(-1);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
			Skip();
			Skip();
			Skip();
			if (isStartToken)
			{
				<67514162-06bc-4d73-9367-d6c8c285bf82>InsertionQueue<<abd144ac-e219-4ca9-8443-aea408941dd7>Token> obj = tokens;
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end2 = cursor.Mark();
				obj.Enqueue(new <04c3436e-0564-48ea-a8a0-16c0763f715a>DocumentStart(in end, in end2));
				return;
			}
			<abd144ac-e219-4ca9-8443-aea408941dd7>Token <abd144ac-e219-4ca9-8443-aea408941dd7>Token = null;
			while (!analyzer.EndOfInput && !analyzer.IsBreak() && !analyzer.Check('#'))
			{
				if (!analyzer.IsWhite())
				{
					<abd144ac-e219-4ca9-8443-aea408941dd7>Token = new <a5e78112-ae12-4536-8694-db0ef70e0007>Error("While scanning a document end, found invalid content after '...' marker.", end, cursor.Mark());
					break;
				}
				Skip();
			}
			tokens.Enqueue(new <5507821e-8467-4a48-865d-95beb56e50bf>DocumentEnd(in end, in end));
			if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token != null)
			{
				tokens.Enqueue(<abd144ac-e219-4ca9-8443-aea408941dd7>Token);
			}
		}

		private void FetchFlowCollectionStart(bool isSequenceToken)
		{
			SaveSimpleKey();
			IncreaseFlowLevel();
			simpleKeyAllowed = true;
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = cursor.Mark();
			Skip();
			<abd144ac-e219-4ca9-8443-aea408941dd7>Token <abd144ac-e219-4ca9-8443-aea408941dd7>Token;
			if (isSequenceToken)
			{
				<abd144ac-e219-4ca9-8443-aea408941dd7>Token = new <f6883492-5e52-4549-99ec-ae704a8fea1c>FlowSequenceStart(in start, in start);
				flowSequenceStartLine = <abd144ac-e219-4ca9-8443-aea408941dd7>Token.Start.Line;
			}
			else
			{
				<abd144ac-e219-4ca9-8443-aea408941dd7>Token = new <659f91d9-8844-498c-8d5e-404d14b54a4e>FlowMappingStart(in start, in start);
			}
			tokens.Enqueue(<abd144ac-e219-4ca9-8443-aea408941dd7>Token);
			startFlowCollectionFetched = true;
		}

		private void IncreaseFlowLevel()
		{
			simpleKeys.Push(new <983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey());
			flowLevel++;
		}

		private void FetchFlowCollectionEnd(bool isSequenceToken)
		{
			RemoveSimpleKey();
			DecreaseFlowLevel();
			simpleKeyAllowed = false;
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = cursor.Mark();
			Skip();
			<abd144ac-e219-4ca9-8443-aea408941dd7>Token <abd144ac-e219-4ca9-8443-aea408941dd7>Token = null;
			<abd144ac-e219-4ca9-8443-aea408941dd7>Token item;
			if (isSequenceToken)
			{
				if (analyzer.Check('#'))
				{
					<abd144ac-e219-4ca9-8443-aea408941dd7>Token = new <a5e78112-ae12-4536-8694-db0ef70e0007>Error("While scanning a flow sequence end, found invalid comment after ']'.", start, start);
				}
				item = new <cc7d306f-49d8-4801-9c5f-1fcd6f24976f>FlowSequenceEnd(in start, in start);
			}
			else
			{
				item = new <4856c899-60f1-4941-9a16-ec90d3b9388c>FlowMappingEnd(in start, in start);
			}
			tokens.Enqueue(item);
			if (<abd144ac-e219-4ca9-8443-aea408941dd7>Token != null)
			{
				tokens.Enqueue(<abd144ac-e219-4ca9-8443-aea408941dd7>Token);
			}
			flowCollectionFetched = true;
		}

		private void DecreaseFlowLevel()
		{
			if (flowLevel > 0)
			{
				flowLevel--;
				simpleKeys.Pop();
			}
		}

		private void FetchFlowEntry()
		{
			RemoveSimpleKey();
			simpleKeyAllowed = true;
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = cursor.Mark();
			Skip();
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
			if (analyzer.Check('#'))
			{
				tokens.Enqueue(new <a5e78112-ae12-4536-8694-db0ef70e0007>Error("While scanning a flow entry, found invalid comment after comma.", start, end));
			}
			else
			{
				tokens.Enqueue(new <c8290e94-df8b-41c8-a128-37ae18eb8c76>FlowEntry(in start, in end));
			}
		}

		private void FetchBlockEntry()
		{
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start;
			if (flowLevel == 0)
			{
				if (!simpleKeyAllowed)
				{
					if (previousAnchor != null && previousAnchor.End.Line == cursor.Line)
					{
						start = previousAnchor.Start;
						<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = previousAnchor.End;
						throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in start, in end, "Anchor before sequence entry on same line is not allowed.");
					}
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark <b3f32382-dd1c-454c-b573-36801723d8c1>Mark2 = cursor.Mark();
					tokens.Enqueue(new <a5e78112-ae12-4536-8694-db0ef70e0007>Error("Block sequence entries are not allowed in this context.", <b3f32382-dd1c-454c-b573-36801723d8c1>Mark2, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark2));
				}
				RollIndent(cursor.LineOffset, -1, isSequence: true, cursor.Mark());
			}
			RemoveSimpleKey();
			simpleKeyAllowed = true;
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start2 = cursor.Mark();
			Skip();
			<67514162-06bc-4d73-9367-d6c8c285bf82>InsertionQueue<<abd144ac-e219-4ca9-8443-aea408941dd7>Token> obj = tokens;
			start = cursor.Mark();
			obj.Enqueue(new <972aac28-5023-4fe4-b801-8d51065b4a71>BlockEntry(in start2, in start));
		}

		private void FetchKey()
		{
			if (flowLevel == 0)
			{
				if (!simpleKeyAllowed)
				{
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = cursor.Mark();
					throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in start, "Mapping keys are not allowed in this context.");
				}
				RollIndent(cursor.LineOffset, -1, isSequence: false, cursor.Mark());
			}
			RemoveSimpleKey();
			simpleKeyAllowed = flowLevel == 0;
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start2 = cursor.Mark();
			Skip();
			<67514162-06bc-4d73-9367-d6c8c285bf82>InsertionQueue<<abd144ac-e219-4ca9-8443-aea408941dd7>Token> obj = tokens;
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
			obj.Enqueue(new <e12792f4-589e-46e6-baf2-85761126c7a5>Key(in start2, in end));
		}

		private void FetchValue()
		{
			<983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey <983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2 = simpleKeys.Peek();
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start;
			if (<983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2.IsPossible)
			{
				<67514162-06bc-4d73-9367-d6c8c285bf82>InsertionQueue<<abd144ac-e219-4ca9-8443-aea408941dd7>Token> obj = tokens;
				int index = <983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2.TokenNumber - tokensParsed;
				start = <983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2.Mark;
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = <983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2.Mark;
				obj.Insert(index, new <e12792f4-589e-46e6-baf2-85761126c7a5>Key(in start, in end));
				RollIndent(<983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2.LineOffset, <983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2.TokenNumber, isSequence: false, <983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2.Mark);
				<983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2.MarkAsImpossible();
				simpleKeyAllowed = false;
			}
			else
			{
				bool flag = flowLevel == 0;
				if (flag)
				{
					if (!simpleKeyAllowed)
					{
						<b3f32382-dd1c-454c-b573-36801723d8c1>Mark <b3f32382-dd1c-454c-b573-36801723d8c1>Mark2 = cursor.Mark();
						tokens.Enqueue(new <a5e78112-ae12-4536-8694-db0ef70e0007>Error("Mapping values are not allowed in this context.", <b3f32382-dd1c-454c-b573-36801723d8c1>Mark2, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark2));
						return;
					}
					RollIndent(cursor.LineOffset, -1, isSequence: false, cursor.Mark());
					if (cursor.LineOffset == 0 && <983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2.LineOffset == 0)
					{
						<67514162-06bc-4d73-9367-d6c8c285bf82>InsertionQueue<<abd144ac-e219-4ca9-8443-aea408941dd7>Token> obj2 = tokens;
						int count = tokens.Count;
						start = <983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2.Mark;
						<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = <983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2.Mark;
						obj2.Insert(count, new <e12792f4-589e-46e6-baf2-85761126c7a5>Key(in start, in end));
						flag = false;
					}
				}
				simpleKeyAllowed = flag;
			}
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start2 = cursor.Mark();
			Skip();
			<67514162-06bc-4d73-9367-d6c8c285bf82>InsertionQueue<<abd144ac-e219-4ca9-8443-aea408941dd7>Token> obj3 = tokens;
			start = cursor.Mark();
			obj3.Enqueue(new <d1c98b09-9c2f-4ca5-acd9-b7172526c3a0>Value(in start2, in start));
		}

		private void RollIndent(int column, int number, bool isSequence, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark position)
		{
			if (flowLevel <= 0 && indent < column)
			{
				indents.Push(indent);
				indent = column;
				<abd144ac-e219-4ca9-8443-aea408941dd7>Token item = ((!isSequence) ? ((<abd144ac-e219-4ca9-8443-aea408941dd7>Token)new <3e24c425-24f0-498d-91dc-9781486bb4fa>BlockMappingStart(in position, in position)) : ((<abd144ac-e219-4ca9-8443-aea408941dd7>Token)new <6638cb55-a5b9-4f7a-8a52-327a39f518f9>BlockSequenceStart(in position, in position)));
				if (number == -1)
				{
					tokens.Enqueue(item);
				}
				else
				{
					tokens.Insert(number - tokensParsed, item);
				}
			}
		}

		private void FetchAnchor(bool isAlias)
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			tokens.Enqueue(ScanAnchor(isAlias));
		}

		private <abd144ac-e219-4ca9-8443-aea408941dd7>Token ScanAnchor(bool isAlias)
		{
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = cursor.Mark();
			Skip();
			bool flag = false;
			if (isAlias)
			{
				<983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey <983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2 = simpleKeys.Peek();
				flag = <983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2.IsRequired && <983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2.IsPossible;
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				while (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("[]{},") && (!flag || !analyzer.Check(':') || !analyzer.IsWhiteBreakOrZero(1)))
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (builder.Length == 0 || (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("?:,]}%@`")))
				{
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
					throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning an anchor or alias, found value containing disallowed: []{},");
				}
				<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName value = new <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName(builder.ToString());
				if (isAlias)
				{
					return new <494b1633-c4c7-4739-8261-1dc286ac3d3e>AnchorAlias(value, start, cursor.Mark());
				}
				return previousAnchor = new <d9b36862-7f6c-45a8-b65a-ec623dcc4cf3>Anchor(value, start, cursor.Mark());
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void FetchTag()
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			tokens.Enqueue(ScanTag());
		}

		private <abd144ac-e219-4ca9-8443-aea408941dd7>Token ScanTag()
		{
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = cursor.Mark();
			string text;
			string text2;
			if (analyzer.Check('<', 1))
			{
				text = string.Empty;
				Skip();
				Skip();
				text2 = ScanTagUri(null, start);
				if (!analyzer.Check('>'))
				{
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
					throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a tag, did not find the expected '>'.");
				}
				Skip();
			}
			else
			{
				string text3 = ScanTagHandle(isDirective: false, start);
				if (text3.Length > 1 && text3[0] == '!' && text3[text3.Length - 1] == '!')
				{
					text = text3;
					text2 = ScanTagUri(null, start);
				}
				else
				{
					text2 = ScanTagUri(text3, start);
					text = "!";
					if (text2.Length == 0)
					{
						text2 = text;
						text = string.Empty;
					}
				}
			}
			if (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check(','))
			{
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
				throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a tag, did not find expected whitespace, comma or line break.");
			}
			return new <59c04d0a-eac2-4f44-b453-d7a0ff6f0dd8>Tag(text, text2, start, cursor.Mark());
		}

		private void FetchBlockScalar(bool isLiteral)
		{
			SaveSimpleKey();
			simpleKeyAllowed = true;
			tokens.Enqueue(ScanBlockScalar(isLiteral));
		}

		private <abd144ac-e219-4ca9-8443-aea408941dd7>Token ScanBlockScalar(bool isLiteral)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				StringBuilderPool.BuilderWrapper builderWrapper2 = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder2 = builderWrapper2.Builder;
					StringBuilderPool.BuilderWrapper builderWrapper3 = StringBuilderPool.Rent();
					try
					{
						StringBuilder builder3 = builderWrapper3.Builder;
						int num = 0;
						int num2 = 0;
						int currentIndent = 0;
						bool flag = false;
						bool? isFirstLine = null;
						<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = cursor.Mark();
						Skip();
						if (analyzer.Check("+-"))
						{
							num = (analyzer.Check('+') ? 1 : (-1));
							Skip();
							if (analyzer.IsDigit())
							{
								if (analyzer.Check('0'))
								{
									<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
									throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a block scalar, found an indentation indicator equal to 0.");
								}
								num2 = analyzer.AsDigit();
								Skip();
							}
						}
						else if (analyzer.IsDigit())
						{
							if (analyzer.Check('0'))
							{
								<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
								throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a block scalar, found an indentation indicator equal to 0.");
							}
							num2 = analyzer.AsDigit();
							Skip();
							if (analyzer.Check("+-"))
							{
								num = (analyzer.Check('+') ? 1 : (-1));
								Skip();
							}
						}
						if (analyzer.Check('#'))
						{
							<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
							throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a block scalar, found a comment without whtespace after '>' indicator.");
						}
						while (analyzer.IsWhite())
						{
							Skip();
						}
						ProcessComment();
						if (!analyzer.IsBreakOrZero())
						{
							<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
							throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a block scalar, did not find expected comment or line break.");
						}
						if (analyzer.IsBreak())
						{
							SkipLine();
							if (!isFirstLine.HasValue)
							{
								isFirstLine = true;
							}
							else if (isFirstLine == true)
							{
								isFirstLine = false;
							}
						}
						<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end2 = cursor.Mark();
						if (num2 != 0)
						{
							currentIndent = ((indent >= 0) ? (indent + num2) : num2);
						}
						currentIndent = ScanBlockScalarBreaks(currentIndent, builder3, isLiteral, ref end2, ref isFirstLine);
						isFirstLine = false;
						while (cursor.LineOffset == currentIndent && !analyzer.IsZero() && !IsDocumentEnd())
						{
							bool flag2 = analyzer.IsWhite();
							if (!isLiteral && StartsWith(builder2, '\n') && !flag && !flag2)
							{
								if (builder3.Length == 0)
								{
									builder.Append(' ');
								}
								builder2.Length = 0;
							}
							else
							{
								builder.Append(builder2.ToString());
								builder2.Length = 0;
							}
							builder.Append(builder3.ToString());
							builder3.Length = 0;
							flag = analyzer.IsWhite();
							while (!analyzer.IsBreakOrZero())
							{
								builder.Append(ReadCurrentCharacter());
							}
							char c = ReadLine();
							if (c != 0)
							{
								builder2.Append(c);
							}
							currentIndent = ScanBlockScalarBreaks(currentIndent, builder3, isLiteral, ref end2, ref isFirstLine);
						}
						if (num != -1)
						{
							builder.Append((object?)builder2);
						}
						if (num == 1)
						{
							builder.Append((object?)builder3);
						}
						<04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle style = (isLiteral ? <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Literal : <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Folded);
						return new <d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar(builder.ToString(), style, start, end2);
					}
					finally
					{
						((IDisposable)builderWrapper3).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private int ScanBlockScalarBreaks(int currentIndent, StringBuilder breaks, bool isLiteral, ref <b3f32382-dd1c-454c-b573-36801723d8c1>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)
			{
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end2 = cursor.Mark();
				throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in end, in end2, "While scanning a literal block scalar, found extra spaces in first line.");
			}
			if (!isLiteral && num > cursor.LineOffset && num2 > -1)
			{
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end2 = cursor.Mark();
				throw new <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in end, in end2, "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;
			flowScalarFetched = true;
			tokens.Enqueue(ScanFlowScalar(isSingleQuoted));
			if (!isSingleQuoted && analyzer.Check('#'))
			{
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark <b3f32382-dd1c-454c-b573-36801723d8c1>Mark2 = cursor.Mark();
				tokens.Enqueue(new <a5e78112-ae12-4536-8694-db0ef70e0007>Error("While scanning a flow sequence end, found invalid comment after double-quoted scalar.", <b3f32382-dd1c-454c-b573-36801723d8c1>Mark2, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark2));
			}
		}

		private <abd144ac-e219-4ca9-8443-aea408941dd7>Token ScanFlowScalar(bool isSingleQuoted)
		{
			<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = cursor.Mark();
			Skip();
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				StringBuilderPool.BuilderWrapper builderWrapper2 = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder2 = builderWrapper2.Builder;
					StringBuilderPool.BuilderWrapper builderWrapper3 = StringBuilderPool.Rent();
					try
					{
						StringBuilder builder3 = builderWrapper3.Builder;
						StringBuilderPool.BuilderWrapper builderWrapper4 = StringBuilderPool.Rent();
						try
						{
							StringBuilder builder4 = builderWrapper4.Builder;
							bool flag = false;
							while (true)
							{
								if (IsDocumentIndicator())
								{
									<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
									throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found unexpected document indicator.");
								}
								if (analyzer.IsZero())
								{
									<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
									throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found unexpected end of stream.");
								}
								if (flag && !isSingleQuoted && indent >= cursor.LineOffset)
								{
									<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
									throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a multi-line double-quoted scalar, found wrong indentation.");
								}
								flag = false;
								while (!analyzer.IsWhiteBreakOrZero())
								{
									if (isSingleQuoted && analyzer.Check('\'') && analyzer.Check('\'', 1))
									{
										builder.Append('\'');
										Skip();
										Skip();
										continue;
									}
									if (analyzer.Check(isSingleQuoted ? '\'' : '"'))
									{
										break;
									}
									if (!isSingleQuoted && analyzer.Check('\\') && analyzer.IsBreak(1))
									{
										Skip();
										SkipLine();
										flag = true;
										break;
									}
									if (!isSingleQuoted && analyzer.Check('\\'))
									{
										int num = 0;
										char c = analyzer.Peek(1);
										switch (c)
										{
										case 'x':
											num = 2;
											break;
										case 'u':
											num = 4;
											break;
										case 'U':
											num = 8;
											break;
										default:
										{
											if (SimpleEscapeCodes.TryGetValue(c, out var value))
											{
												builder.Append(value);
												break;
											}
											<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
											throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found unknown escape character.");
										}
										}
										Skip();
										Skip();
										if (num <= 0)
										{
											continue;
										}
										int num2 = 0;
										for (int i = 0; i < num; i++)
										{
											if (!analyzer.IsHex(i))
											{
												<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
												throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a quoted scalar, did not find expected hexadecimal number.");
											}
											num2 = (num2 << 4) + analyzer.AsHex(i);
										}
										if ((num2 >= 55296 && num2 <= 57343) || num2 > 1114111)
										{
											<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
											throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found invalid Unicode character escape code.");
										}
										builder.Append(char.ConvertFromUtf32(num2));
										for (int j = 0; j < num; j++)
										{
											Skip();
										}
									}
									else
									{
										builder.Append(ReadCurrentCharacter());
									}
								}
								if (analyzer.Check(isSingleQuoted ? '\'' : '"'))
								{
									break;
								}
								while (analyzer.IsWhite() || analyzer.IsBreak())
								{
									if (analyzer.IsWhite())
									{
										if (!flag)
										{
											builder2.Append(ReadCurrentCharacter());
										}
										else
										{
											Skip();
										}
									}
									else if (!flag)
									{
										builder2.Length = 0;
										builder3.Append(ReadLine());
										flag = true;
									}
									else
									{
										builder4.Append(ReadLine());
									}
								}
								if (flag)
								{
									if (StartsWith(builder3, '\n'))
									{
										if (builder4.Length == 0)
										{
											builder.Append(' ');
										}
										else
										{
											builder.Append(builder4.ToString());
										}
									}
									else
									{
										builder.Append(builder3.ToString());
										builder.Append(builder4.ToString());
									}
									builder3.Length = 0;
									builder4.Length = 0;
								}
								else
								{
									builder.Append(builder2.ToString());
									builder2.Length = 0;
								}
							}
							Skip();
							return new <d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar(builder.ToString(), isSingleQuoted ? <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.SingleQuoted : <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.DoubleQuoted, start, cursor.Mark());
						}
						finally
						{
							((IDisposable)builderWrapper4).Dispose();
						}
					}
					finally
					{
						((IDisposable)builderWrapper3).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void FetchPlainScalar()
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			bool isMultiline = false;
			<d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar item = (lastScalar = ScanPlainScalar(ref isMultiline));
			if (isMultiline && analyzer.Check(':') && flowLevel == 0 && indent < cursor.LineOffset)
			{
				tokens.Enqueue(new <a5e78112-ae12-4536-8694-db0ef70e0007>Error("While scanning a multiline plain scalar, found invalid mapping.", cursor.Mark(), cursor.Mark()));
			}
			tokens.Enqueue(item);
		}

		private <d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar ScanPlainScalar(ref bool isMultiline)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				StringBuilderPool.BuilderWrapper builderWrapper2 = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder2 = builderWrapper2.Builder;
					StringBuilderPool.BuilderWrapper builderWrapper3 = StringBuilderPool.Rent();
					try
					{
						StringBuilder builder3 = builderWrapper3.Builder;
						StringBuilderPool.BuilderWrapper builderWrapper4 = StringBuilderPool.Rent();
						try
						{
							StringBuilder builder4 = builderWrapper4.Builder;
							bool flag = false;
							int num = indent + 1;
							<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = cursor.Mark();
							<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = start;
							<983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey <983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2 = simpleKeys.Peek();
							while (!IsDocumentIndicator())
							{
								if (analyzer.Check('#'))
								{
									if (indent < 0 && flowLevel == 0)
									{
										plainScalarFollowedByComment = true;
									}
									break;
								}
								bool flag2 = analyzer.Check('*') && (!<983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2.IsPossible || !<983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2.IsRequired);
								while (!analyzer.IsWhiteBreakOrZero())
								{
									if ((analyzer.Check(':') && !flag2 && (analyzer.IsWhiteBreakOrZero(1) || (flowLevel > 0 && analyzer.Check(',', 1)))) || (flowLevel > 0 && analyzer.Check(",[]{}")))
									{
										if (flowLevel == 0 && !<983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2.IsPossible)
										{
											tokens.Enqueue(new <a5e78112-ae12-4536-8694-db0ef70e0007>Error("While scanning a plain scalar value, found invalid mapping.", cursor.Mark(), cursor.Mark()));
										}
										break;
									}
									if (flag || builder2.Length > 0)
									{
										if (flag)
										{
											if (StartsWith(builder3, '\n'))
											{
												if (builder4.Length == 0)
												{
													builder.Append(' ');
												}
												else
												{
													builder.Append((object?)builder4);
												}
											}
											else
											{
												builder.Append((object?)builder3);
												builder.Append((object?)builder4);
											}
											builder3.Length = 0;
											builder4.Length = 0;
											flag = false;
										}
										else
										{
											builder.Append((object?)builder2);
											builder2.Length = 0;
										}
									}
									if (flowLevel > 0 && cursor.LineOffset < num)
									{
										throw new Exception();
									}
									builder.Append(ReadCurrentCharacter());
									end = cursor.Mark();
								}
								if (!analyzer.IsWhite() && !analyzer.IsBreak())
								{
									break;
								}
								while (analyzer.IsWhite() || analyzer.IsBreak())
								{
									if (analyzer.IsWhite())
									{
										if (flag && cursor.LineOffset < num && analyzer.IsTab())
										{
											<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end2 = cursor.Mark();
											throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end2, "While scanning a plain scalar, found a tab character that violate indentation.");
										}
										if (!flag)
										{
											builder2.Append(ReadCurrentCharacter());
										}
										else
										{
											Skip();
										}
									}
									else
									{
										isMultiline = true;
										if (!flag)
										{
											builder2.Length = 0;
											builder3.Append(ReadLine());
											flag = true;
										}
										else
										{
											builder4.Append(ReadLine());
										}
									}
								}
								if (flowLevel == 0 && cursor.LineOffset < num)
								{
									break;
								}
							}
							if (flag)
							{
								simpleKeyAllowed = true;
							}
							return new <d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar(builder.ToString(), <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Plain, start, end);
						}
						finally
						{
							((IDisposable)builderWrapper4).Dispose();
						}
					}
					finally
					{
						((IDisposable)builderWrapper3).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void RemoveSimpleKey()
		{
			<983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey <983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2 = simpleKeys.Peek();
			if (<983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2.IsPossible && <983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2.IsRequired)
			{
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start = <983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2.Mark;
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = <983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2.Mark;
				throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a simple key, could not find expected ':'.");
			}
			<983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey2.MarkAsImpossible();
		}

		private string ScanDirectiveName(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				while (analyzer.IsAlphaNumericDashOrUnderscore())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (builder.Length == 0)
				{
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
					throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a directive, could not find expected directive name.");
				}
				if (analyzer.EndOfInput)
				{
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
					throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a directive, found unexpected end of stream.");
				}
				if (!analyzer.IsWhiteBreakOrZero())
				{
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
					throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a directive, found unexpected non-alphabetical character.");
				}
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void SkipWhitespaces()
		{
			while (analyzer.IsWhite())
			{
				Skip();
			}
		}

		private <abd144ac-e219-4ca9-8443-aea408941dd7>Token ScanVersionDirectiveValue(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start)
		{
			SkipWhitespaces();
			int major = ScanVersionDirectiveNumber(in start);
			if (!analyzer.Check('.'))
			{
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
				throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a %YAML directive, did not find expected digit or '.' character.");
			}
			Skip();
			int minor = ScanVersionDirectiveNumber(in start);
			return new <af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective(new <6803d8e0-a57c-4ba7-ada8-bd55856c55ec>Version(major, minor), start, start);
		}

		private <abd144ac-e219-4ca9-8443-aea408941dd7>Token ScanTagDirectiveValue(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start)
		{
			SkipWhitespaces();
			string handle = ScanTagHandle(isDirective: true, start);
			if (!analyzer.IsWhite())
			{
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
				throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a %TAG directive, did not find expected whitespace.");
			}
			SkipWhitespaces();
			string prefix = ScanTagUri(null, start);
			if (!analyzer.IsWhiteBreakOrZero())
			{
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
				throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a %TAG directive, did not find expected whitespace or line break.");
			}
			return new <58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective(handle, prefix, start, start);
		}

		private string ScanTagUri([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] string head, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				if (head != null && head.Length > 1)
				{
					builder.Append(head.Substring(1));
				}
				while (analyzer.IsAlphaNumericDashOrUnderscore() || analyzer.Check(";/?:@&=+$.!~*'()[]%") || (analyzer.Check(',') && !analyzer.IsBreak(1)))
				{
					if (analyzer.Check('%'))
					{
						builder.Append(ScanUriEscapes(in start));
					}
					else if (analyzer.Check('+'))
					{
						builder.Append(' ');
						Skip();
					}
					else
					{
						builder.Append(ReadCurrentCharacter());
					}
				}
				if (builder.Length == 0)
				{
					return string.Empty;
				}
				string text = builder.ToString();
				if (text.EndsWith(","))
				{
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark start2 = cursor.Mark();
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
					throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start2, in end, "Unexpected comma at end of tag");
				}
				return text;
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private string ScanUriEscapes(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start)
		{
			byte[] array = EmptyBytes;
			int count = 0;
			int num = 0;
			do
			{
				if (!analyzer.Check('%') || !analyzer.IsHex(1) || !analyzer.IsHex(2))
				{
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
					throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a tag, did not find URI escaped octet.");
				}
				int num2 = (analyzer.AsHex(1) << 4) + analyzer.AsHex(2);
				if (num == 0)
				{
					num = (((num2 & 0x80) == 0) ? 1 : (((num2 & 0xE0) == 192) ? 2 : (((num2 & 0xF0) == 224) ? 3 : (((num2 & 0xF8) == 240) ? 4 : 0))));
					if (num == 0)
					{
						<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
						throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a tag, found an incorrect leading UTF-8 octet.");
					}
					array = new byte[num];
				}
				else if ((num2 & 0xC0) != 128)
				{
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
					throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a tag, found an incorrect trailing UTF-8 octet.");
				}
				array[count++] = (byte)num2;
				Skip();
				Skip();
				Skip();
			}
			while (--num > 0);
			string @string = Encoding.UTF8.GetString(array, 0, count);
			if (@string.Length == 0 || @string.Length > 2)
			{
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
				throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a tag, found an incorrect UTF-8 sequence.");
			}
			return @string;
		}

		private string ScanTagHandle(bool isDirective, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start)
		{
			if (!analyzer.Check('!'))
			{
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
				throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a tag, did not find expected '!'.");
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				builder.Append(ReadCurrentCharacter());
				while (analyzer.IsAlphaNumericDashOrUnderscore())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (analyzer.Check('!'))
				{
					builder.Append(ReadCurrentCharacter());
				}
				else if (isDirective && (builder.Length != 1 || builder[0] != '!'))
				{
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
					throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a tag directive, did not find expected '!'.");
				}
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private int ScanVersionDirectiveNumber(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start)
		{
			int num = 0;
			int num2 = 0;
			while (analyzer.IsDigit())
			{
				if (++num2 > 9)
				{
					<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
					throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a %YAML directive, found extremely long version number.");
				}
				num = num * 10 + analyzer.AsDigit();
				Skip();
			}
			if (num2 == 0)
			{
				<b3f32382-dd1c-454c-b573-36801723d8c1>Mark end = cursor.Mark();
				throw new <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in start, in end, "While scanning a %YAML directive, did not find expected version number.");
			}
			return num;
		}

		private void SaveSimpleKey()
		{
			bool isRequired = flowLevel == 0 && indent == cursor.LineOffset;
			if (simpleKeyAllowed)
			{
				<983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey item = new <983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey(isRequired, tokensParsed + tokens.Count, cursor);
				RemoveSimpleKey();
				simpleKeys.Pop();
				simpleKeys.Push(item);
			}
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal class <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException : <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException
	{
		public <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(string message)
			: base(message)
		{
		}

		public <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public <5ccb325a-4206-4675-9607-cc5035211833>SemanticErrorException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey
	{
		private readonly <4e6c69f4-459d-4c9c-a981-fcb61792fc4d>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 <b3f32382-dd1c-454c-b573-36801723d8c1>Mark Mark => cursor.Mark();

		public void MarkAsImpossible()
		{
			IsPossible = false;
		}

		public <983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey()
		{
			cursor = new <4e6c69f4-459d-4c9c-a981-fcb61792fc4d>Cursor();
		}

		public <983f8dce-e3a2-4273-8462-2d6433865b29>SimpleKey(bool isRequired, int tokenNumber, <4e6c69f4-459d-4c9c-a981-fcb61792fc4d>Cursor cursor)
		{
			IsPossible = true;
			IsRequired = isRequired;
			TokenNumber = tokenNumber;
			this.cursor = new <4e6c69f4-459d-4c9c-a981-fcb61792fc4d>Cursor(cursor);
		}
	}
	internal sealed class <2cc771de-93df-4205-b708-fff03826b04a>StringLookAheadBuffer : <10ae47d8-7da4-45c7-954a-2760d6b5fadf>ILookAheadBuffer
	{
		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(1)]
		private readonly string value;

		public int Position { get; private set; }

		public int Length => value.Length;

		public bool EndOfInput => IsOutside(Position);

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public <2cc771de-93df-4205-b708-fff03826b04a>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;
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException : <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException
	{
		public <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(string message)
			: base(message)
		{
		}

		public <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public <ca493ed7-1693-464e-a1a2-e6a1500d8a67>SyntaxErrorException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 0, 1, 1 })]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection : KeyedCollection<string, <58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective>
	{
		public <229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection()
		{
		}

		public <229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection(IEnumerable<<58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective> tagDirectives)
		{
			foreach (<58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective tagDirective in tagDirectives)
			{
				Add(tagDirective);
			}
		}

		protected override string GetKeyForItem(<58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective item)
		{
			return item.Handle;
		}

		public new bool Contains(<58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective directive)
		{
			return Contains(GetKeyForItem(directive));
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal readonly struct <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName : IEquatable<<baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName>
	{
		public static readonly <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName Empty;

		[<0d606795-0ee1-47ee-aaaa-2df0804da96c>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 <baffffec-0e3a-40cd-94b0-5056fc2cc14e>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(<baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName other)
		{
			return object.Equals(value, other.value);
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (obj is <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return value?.GetHashCode() ?? 0;
		}

		public static bool operator ==(<baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName left, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(<baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName left, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName right)
		{
			return !(left == right);
		}

		public static bool operator ==(<baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName left, string right)
		{
			return object.Equals(left.value, right);
		}

		public static bool operator !=(<baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName left, string right)
		{
			return !(left == right);
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		public static implicit operator <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName(string value)
		{
			if (value != null)
			{
				return new <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName(value);
			}
			return Empty;
		}
	}
	internal sealed class <6803d8e0-a57c-4ba7-ada8-bd55856c55ec>Version
	{
		public int Major { get; }

		public int Minor { get; }

		public <6803d8e0-a57c-4ba7-ada8-bd55856c55ec>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;
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (obj is <6803d8e0-a57c-4ba7-ada8-bd55856c55ec>Version <6803d8e0-a57c-4ba7-ada8-bd55856c55ec>Version2 && Major == <6803d8e0-a57c-4ba7-ada8-bd55856c55ec>Version2.Major)
			{
				return Minor == <6803d8e0-a57c-4ba7-ada8-bd55856c55ec>Version2.Minor;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return <21fc5b2a-a319-41bc-aa9e-d22bcde3f1bb>HashCode.CombineHashCodes(Major.GetHashCode(), Minor.GetHashCode());
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal class <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException : Exception
	{
		public <b3f32382-dd1c-454c-b573-36801723d8c1>Mark Start { get; }

		public <b3f32382-dd1c-454c-b573-36801723d8c1>Mark End { get; }

		public <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException(string message)
			: this(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, message)
		{
		}

		public <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end, string message)
			: this(in start, in end, message, null)
		{
		}

		public <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end, string message, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] Exception innerException)
			: base(message, innerException)
		{
			Start = start;
			End = end;
		}

		public <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException(string message, Exception inner)
			: this(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, message, inner)
		{
		}

		public override string ToString()
		{
			return $"({Start}) - ({End}): {Message}";
		}
	}
}
namespace YamlDotNet.Core.Tokens
{
	internal class <d9b36862-7f6c-45a8-b65a-ec623dcc4cf3>Anchor : <abd144ac-e219-4ca9-8443-aea408941dd7>Token
	{
		public <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName Value { get; }

		public <d9b36862-7f6c-45a8-b65a-ec623dcc4cf3>Anchor(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName value)
			: this(value, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <d9b36862-7f6c-45a8-b65a-ec623dcc4cf3>Anchor(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName value, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
			if (value.IsEmpty)
			{
				throw new ArgumentNullException("value");
			}
			Value = value;
		}
	}
	internal sealed class <494b1633-c4c7-4739-8261-1dc286ac3d3e>AnchorAlias : <abd144ac-e219-4ca9-8443-aea408941dd7>Token
	{
		public <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName Value { get; }

		public <494b1633-c4c7-4739-8261-1dc286ac3d3e>AnchorAlias(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName value)
			: this(value, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <494b1633-c4c7-4739-8261-1dc286ac3d3e>AnchorAlias(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName value, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
			if (value.IsEmpty)
			{
				throw new ArgumentNullException("value");
			}
			Value = value;
		}
	}
	internal sealed class <aa1f9abc-5d01-4049-bce9-7578a19e6e2d>BlockEnd : <abd144ac-e219-4ca9-8443-aea408941dd7>Token
	{
		public <aa1f9abc-5d01-4049-bce9-7578a19e6e2d>BlockEnd()
			: this(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <aa1f9abc-5d01-4049-bce9-7578a19e6e2d>BlockEnd(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class <972aac28-5023-4fe4-b801-8d51065b4a71>BlockEntry : <abd144ac-e219-4ca9-8443-aea408941dd7>Token
	{
		public <972aac28-5023-4fe4-b801-8d51065b4a71>BlockEntry()
			: this(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <972aac28-5023-4fe4-b801-8d51065b4a71>BlockEntry(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class <3e24c425-24f0-498d-91dc-9781486bb4fa>BlockMappingStart : <abd144ac-e219-4ca9-8443-aea408941dd7>Token
	{
		public <3e24c425-24f0-498d-91dc-9781486bb4fa>BlockMappingStart()
			: this(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <3e24c425-24f0-498d-91dc-9781486bb4fa>BlockMappingStart(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class <6638cb55-a5b9-4f7a-8a52-327a39f518f9>BlockSequenceStart : <abd144ac-e219-4ca9-8443-aea408941dd7>Token
	{
		public <6638cb55-a5b9-4f7a-8a52-327a39f518f9>BlockSequenceStart()
			: this(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <6638cb55-a5b9-4f7a-8a52-327a39f518f9>BlockSequenceStart(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <92aa2da2-df07-44ac-b284-eaa9be1f2036>Comment : <abd144ac-e219-4ca9-8443-aea408941dd7>Token
	{
		public string Value { get; }

		public bool IsInline { get; }

		public <92aa2da2-df07-44ac-b284-eaa9be1f2036>Comment(string value, bool isInline)
			: this(value, isInline, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <92aa2da2-df07-44ac-b284-eaa9be1f2036>Comment(string value, bool isInline, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
			Value = value ?? throw new ArgumentNullException("value");
			IsInline = isInline;
		}
	}
	internal sealed class <5507821e-8467-4a48-865d-95beb56e50bf>DocumentEnd : <abd144ac-e219-4ca9-8443-aea408941dd7>Token
	{
		public <5507821e-8467-4a48-865d-95beb56e50bf>DocumentEnd()
			: this(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <5507821e-8467-4a48-865d-95beb56e50bf>DocumentEnd(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class <04c3436e-0564-48ea-a8a0-16c0763f715a>DocumentStart : <abd144ac-e219-4ca9-8443-aea408941dd7>Token
	{
		public <04c3436e-0564-48ea-a8a0-16c0763f715a>DocumentStart()
			: this(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <04c3436e-0564-48ea-a8a0-16c0763f715a>DocumentStart(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal class <a5e78112-ae12-4536-8694-db0ef70e0007>Error : <abd144ac-e219-4ca9-8443-aea408941dd7>Token
	{
		public string Value { get; }

		public <a5e78112-ae12-4536-8694-db0ef70e0007>Error(string value, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
			Value = value;
		}
	}
	internal sealed class <c8290e94-df8b-41c8-a128-37ae18eb8c76>FlowEntry : <abd144ac-e219-4ca9-8443-aea408941dd7>Token
	{
		public <c8290e94-df8b-41c8-a128-37ae18eb8c76>FlowEntry()
			: this(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <c8290e94-df8b-41c8-a128-37ae18eb8c76>FlowEntry(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class <4856c899-60f1-4941-9a16-ec90d3b9388c>FlowMappingEnd : <abd144ac-e219-4ca9-8443-aea408941dd7>Token
	{
		public <4856c899-60f1-4941-9a16-ec90d3b9388c>FlowMappingEnd()
			: this(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <4856c899-60f1-4941-9a16-ec90d3b9388c>FlowMappingEnd(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class <659f91d9-8844-498c-8d5e-404d14b54a4e>FlowMappingStart : <abd144ac-e219-4ca9-8443-aea408941dd7>Token
	{
		public <659f91d9-8844-498c-8d5e-404d14b54a4e>FlowMappingStart()
			: this(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <659f91d9-8844-498c-8d5e-404d14b54a4e>FlowMappingStart(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class <cc7d306f-49d8-4801-9c5f-1fcd6f24976f>FlowSequenceEnd : <abd144ac-e219-4ca9-8443-aea408941dd7>Token
	{
		public <cc7d306f-49d8-4801-9c5f-1fcd6f24976f>FlowSequenceEnd()
			: this(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <cc7d306f-49d8-4801-9c5f-1fcd6f24976f>FlowSequenceEnd(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class <f6883492-5e52-4549-99ec-ae704a8fea1c>FlowSequenceStart : <abd144ac-e219-4ca9-8443-aea408941dd7>Token
	{
		public <f6883492-5e52-4549-99ec-ae704a8fea1c>FlowSequenceStart()
			: this(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <f6883492-5e52-4549-99ec-ae704a8fea1c>FlowSequenceStart(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class <e12792f4-589e-46e6-baf2-85761126c7a5>Key : <abd144ac-e219-4ca9-8443-aea408941dd7>Token
	{
		public <e12792f4-589e-46e6-baf2-85761126c7a5>Key()
			: this(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <e12792f4-589e-46e6-baf2-85761126c7a5>Key(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar : <abd144ac-e219-4ca9-8443-aea408941dd7>Token
	{
		public bool IsKey { get; set; }

		public string Value { get; }

		public <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle Style { get; }

		public <d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar(string value)
			: this(value, <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Any)
		{
		}

		public <d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar(string value, <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle style)
			: this(value, style, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <d635eca9-836e-4f74-8d61-47a2e478d4ac>Scalar(string value, <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle style, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
			Value = value ?? throw new ArgumentNullException("value");
			Style = style;
		}
	}
	internal sealed class <d9dfed6c-4441-4064-a28b-ae9e56d8221b>StreamEnd : <abd144ac-e219-4ca9-8443-aea408941dd7>Token
	{
		public <d9dfed6c-4441-4064-a28b-ae9e56d8221b>StreamEnd()
			: this(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <d9dfed6c-4441-4064-a28b-ae9e56d8221b>StreamEnd(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class <9732b3ee-7084-48fe-a728-33d8b4c4576f>StreamStart : <abd144ac-e219-4ca9-8443-aea408941dd7>Token
	{
		public <9732b3ee-7084-48fe-a728-33d8b4c4576f>StreamStart()
			: this(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <9732b3ee-7084-48fe-a728-33d8b4c4576f>StreamStart(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <59c04d0a-eac2-4f44-b453-d7a0ff6f0dd8>Tag : <abd144ac-e219-4ca9-8443-aea408941dd7>Token
	{
		public string Handle { get; }

		public string Suffix { get; }

		public <59c04d0a-eac2-4f44-b453-d7a0ff6f0dd8>Tag(string handle, string suffix)
			: this(handle, suffix, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <59c04d0a-eac2-4f44-b453-d7a0ff6f0dd8>Tag(string handle, string suffix, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
			Handle = handle ?? throw new ArgumentNullException("handle");
			Suffix = suffix ?? throw new ArgumentNullException("suffix");
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal class <58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective : <abd144ac-e219-4ca9-8443-aea408941dd7>Token
	{
		private static readonly Regex TagHandlePattern = new Regex("^!([0-9A-Za-z_\\-]*!)?$", RegexOptions.Compiled);

		public string Handle { get; }

		public string Prefix { get; }

		public <58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective(string handle, string prefix)
			: this(handle, prefix, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective(string handle, string prefix, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
			if (string.IsNullOrEmpty(handle))
			{
				throw new ArgumentNullException("handle", "Tag handle must not be empty.");
			}
			if (!TagHandlePattern.IsMatch(handle))
			{
				throw new ArgumentException("Tag handle must start and end with '!' and contain alphanumerical characters only.", "handle");
			}
			Handle = handle;
			if (string.IsNullOrEmpty(prefix))
			{
				throw new ArgumentNullException("prefix", "Tag prefix must not be empty.");
			}
			Prefix = prefix;
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (obj is <58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective <58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective2 && Handle.Equals(<58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective2.Handle))
			{
				return Prefix.Equals(<58abd5fa-9e18-414c-8a43-c981d0df3154>TagDirective2.Prefix);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Handle.GetHashCode() ^ Prefix.GetHashCode();
		}

		public override string ToString()
		{
			return Handle + " => " + Prefix;
		}
	}
	internal abstract class <abd144ac-e219-4ca9-8443-aea408941dd7>Token
	{
		public <b3f32382-dd1c-454c-b573-36801723d8c1>Mark Start { get; }

		public <b3f32382-dd1c-454c-b573-36801723d8c1>Mark End { get; }

		protected <abd144ac-e219-4ca9-8443-aea408941dd7>Token(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
		{
			Start = start;
			End = end;
		}
	}
	internal sealed class <d1c98b09-9c2f-4ca5-acd9-b7172526c3a0>Value : <abd144ac-e219-4ca9-8443-aea408941dd7>Token
	{
		public <d1c98b09-9c2f-4ca5-acd9-b7172526c3a0>Value()
			: this(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <d1c98b09-9c2f-4ca5-acd9-b7172526c3a0>Value(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective : <abd144ac-e219-4ca9-8443-aea408941dd7>Token
	{
		public <6803d8e0-a57c-4ba7-ada8-bd55856c55ec>Version Version { get; }

		public <af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective(<6803d8e0-a57c-4ba7-ada8-bd55856c55ec>Version version)
			: this(version, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective(<6803d8e0-a57c-4ba7-ada8-bd55856c55ec>Version version, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
			Version = version;
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (obj is <af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective <af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective2)
			{
				return Version.Equals(<af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective2.Version);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Version.GetHashCode();
		}
	}
}
namespace YamlDotNet.Core.Events
{
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias : <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent
	{
		internal override <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType Type => <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.Alias;

		public <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName Value { get; }

		public <4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName value, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
			if (value.IsEmpty)
			{
				throw new <04c2f6b2-d467-42d4-b4ab-71edf4cf5299>YamlException(in start, in end, "Anchor value must not be empty.");
			}
			Value = value;
		}

		public <4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName value)
			: this(value, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Alias [value = {Value}]";
		}

		public override void Accept(<816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <5332d915-103b-4367-bd24-5d21f0bd7d9a>Comment : <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent
	{
		public string Value { get; }

		public bool IsInline { get; }

		internal override <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType Type => <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.Comment;

		public <5332d915-103b-4367-bd24-5d21f0bd7d9a>Comment(string value, bool isInline)
			: this(value, isInline, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <5332d915-103b-4367-bd24-5d21f0bd7d9a>Comment(string value, bool isInline, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
			Value = value;
			IsInline = isInline;
		}

		public override void Accept(<816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override string ToString()
		{
			return (IsInline ? "Inline" : "Block") + " Comment [" + Value + "]";
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <c51742f9-fbb1-469d-bb0b-e52d59018ce6>DocumentEnd : <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType Type => <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.DocumentEnd;

		public bool IsImplicit { get; }

		public <c51742f9-fbb1-469d-bb0b-e52d59018ce6>DocumentEnd(bool isImplicit, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
			IsImplicit = isImplicit;
		}

		public <c51742f9-fbb1-469d-bb0b-e52d59018ce6>DocumentEnd(bool isImplicit)
			: this(isImplicit, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Document end [isImplicit = {IsImplicit}]";
		}

		public override void Accept(<816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(2)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart : <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent
	{
		public override int NestingIncrease => 1;

		internal override <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType Type => <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.DocumentStart;

		public <229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection Tags { get; }

		public <af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective Version { get; }

		public bool IsImplicit { get; }

		public <b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart(<af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective version, <229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection tags, bool isImplicit, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
			Version = version;
			Tags = tags;
			IsImplicit = isImplicit;
		}

		public <b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart(<af2938ec-8142-4bf0-b41b-5489dda03043>VersionDirective version, <229911d9-05f5-4872-8a6d-a793f001d058>TagDirectiveCollection tags, bool isImplicit)
			: this(version, tags, isImplicit, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: this(null, null, isImplicit: true, start, end)
		{
		}

		public <b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart()
			: this(null, null, isImplicit: true, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public override string ToString()
		{
			return $"Document start [isImplicit = {IsImplicit}]";
		}

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public override void Accept(<816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType
	{
		None,
		StreamStart,
		StreamEnd,
		DocumentStart,
		DocumentEnd,
		Alias,
		Scalar,
		SequenceStart,
		SequenceEnd,
		MappingStart,
		MappingEnd,
		Comment
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal interface <816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor
	{
		void Visit(<4a137d3c-94b4-4797-9632-45f2b51012ac>AnchorAlias e);

		void Visit(<b0b23517-beda-496a-8223-4c3554a848bc>StreamStart e);

		void Visit(<639c5f87-0aee-41c1-9e7d-0f8ace8688c9>StreamEnd e);

		void Visit(<b4065c8d-52b6-415d-bd6c-828f89136f2d>DocumentStart e);

		void Visit(<c51742f9-fbb1-469d-bb0b-e52d59018ce6>DocumentEnd e);

		void Visit(<6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar e);

		void Visit(<743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart e);

		void Visit(<7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd e);

		void Visit(<fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart e);

		void Visit(<d66b1b5c-22da-4393-8f8d-68d3635cb59f>MappingEnd e);

		void Visit(<5332d915-103b-4367-bd24-5d21f0bd7d9a>Comment e);
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal class <d66b1b5c-22da-4393-8f8d-68d3635cb59f>MappingEnd : <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType Type => <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.MappingEnd;

		public <d66b1b5c-22da-4393-8f8d-68d3635cb59f>MappingEnd(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
		}

		public <d66b1b5c-22da-4393-8f8d-68d3635cb59f>MappingEnd()
			: this(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public override string ToString()
		{
			return "Mapping end";
		}

		public override void Accept(<816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart : <17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent
	{
		public override int NestingIncrease => 1;

		internal override <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType Type => <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.MappingStart;

		public bool IsImplicit { get; }

		public override bool IsCanonical => !IsImplicit;

		public <5bdd0818-2e61-4148-a2dc-8d667b816026>MappingStyle Style { get; }

		public <fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName anchor, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName tag, bool isImplicit, <5bdd0818-2e61-4148-a2dc-8d667b816026>MappingStyle style, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(anchor, tag, start, end)
		{
			IsImplicit = isImplicit;
			Style = style;
		}

		public <fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName anchor, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName tag, bool isImplicit, <5bdd0818-2e61-4148-a2dc-8d667b816026>MappingStyle style)
			: this(anchor, tag, isImplicit, style, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <fb119ef4-492f-4153-9e2c-355fadf07854>MappingStart()
			: this(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName.Empty, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName.Empty, isImplicit: true, <5bdd0818-2e61-4148-a2dc-8d667b816026>MappingStyle.Any, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Mapping start [anchor = {base.Anchor}, tag = {base.Tag}, isImplicit = {IsImplicit}, style = {Style}]";
		}

		public override void Accept(<816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum <5bdd0818-2e61-4148-a2dc-8d667b816026>MappingStyle
	{
		Any,
		Block,
		Flow
	}
	internal abstract class <17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent : <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent
	{
		public <1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName Anchor { get; }

		public <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName Tag { get; }

		public abstract bool IsCanonical { get; }

		protected <17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName anchor, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName tag, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
			Anchor = anchor;
			Tag = tag;
		}

		protected <17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName anchor, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName tag)
			: this(anchor, tag, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}
	}
	internal abstract class <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent
	{
		public virtual int NestingIncrease => 0;

		internal abstract <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType Type { get; }

		public <b3f32382-dd1c-454c-b573-36801723d8c1>Mark Start { get; }

		public <b3f32382-dd1c-454c-b573-36801723d8c1>Mark End { get; }

		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public abstract void Accept(<816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor visitor);

		internal <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
		{
			Start = start;
			End = end;
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar : <17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent
	{
		internal override <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType Type => <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.Scalar;

		public string Value { get; }

		public <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle Style { get; }

		public bool IsPlainImplicit { get; }

		public bool IsQuotedImplicit { get; }

		public override bool IsCanonical
		{
			get
			{
				if (!IsPlainImplicit)
				{
					return !IsQuotedImplicit;
				}
				return false;
			}
		}

		public bool IsKey { get; }

		public <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName anchor, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName tag, string value, <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle style, bool isPlainImplicit, bool isQuotedImplicit, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end, bool isKey = false)
			: base(anchor, tag, start, end)
		{
			Value = value;
			Style = style;
			IsPlainImplicit = isPlainImplicit;
			IsQuotedImplicit = isQuotedImplicit;
			IsKey = isKey;
		}

		public <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName anchor, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName tag, string value, <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle style, bool isPlainImplicit, bool isQuotedImplicit)
			: this(anchor, tag, value, style, isPlainImplicit, isQuotedImplicit, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar(string value)
			: this(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName.Empty, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName.Empty, value, <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar(<baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName tag, string value)
			: this(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName.Empty, tag, value, <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <6de52a3a-4363-4642-b572-ff69e9dc189e>Scalar(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName anchor, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName tag, string value)
			: this(anchor, tag, value, <04315b26-e1c8-4e5a-93f2-a3194d527695>ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, <b3f32382-dd1c-454c-b573-36801723d8c1>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(<816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd : <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType Type => <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.SequenceEnd;

		public <7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
		}

		public <7f287aeb-12e4-4f76-8c9e-f7622d066f5d>SequenceEnd()
			: this(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public override string ToString()
		{
			return "Sequence end";
		}

		public override void Accept(<816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart : <17b80f1e-db12-4b74-94e4-11fb84cb3a26>NodeEvent
	{
		public override int NestingIncrease => 1;

		internal override <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType Type => <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.SequenceStart;

		public bool IsImplicit { get; }

		public override bool IsCanonical => !IsImplicit;

		public <633aecbb-227c-4a56-bde3-6176f414312f>SequenceStyle Style { get; }

		public <743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName anchor, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName tag, bool isImplicit, <633aecbb-227c-4a56-bde3-6176f414312f>SequenceStyle style, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(anchor, tag, start, end)
		{
			IsImplicit = isImplicit;
			Style = style;
		}

		public <743cb17c-5a90-4a15-87b5-5deb5cee3673>SequenceStart(<1694e2bc-fd5a-4057-8be0-f52199c1f0da>AnchorName anchor, <baffffec-0e3a-40cd-94b0-5056fc2cc14e>TagName tag, bool isImplicit, <633aecbb-227c-4a56-bde3-6176f414312f>SequenceStyle style)
			: this(anchor, tag, isImplicit, style, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Sequence start [anchor = {base.Anchor}, tag = {base.Tag}, isImplicit = {IsImplicit}, style = {Style}]";
		}

		public override void Accept(<816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum <633aecbb-227c-4a56-bde3-6176f414312f>SequenceStyle
	{
		Any,
		Block,
		Flow
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	internal sealed class <639c5f87-0aee-41c1-9e7d-0f8ace8688c9>StreamEnd : <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType Type => <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.StreamEnd;

		public <639c5f87-0aee-41c1-9e7d-0f8ace8688c9>StreamEnd(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
		}

		public <639c5f87-0aee-41c1-9e7d-0f8ace8688c9>StreamEnd()
			: this(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public override string ToString()
		{
			return "Stream end";
		}

		public override void Accept(<816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <b0b23517-beda-496a-8223-4c3554a848bc>StreamStart : <83ef3299-9efa-4d51-b8c1-ad9f887f306d>ParsingEvent
	{
		public override int NestingIncrease => 1;

		internal override <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType Type => <c850f13b-bfcc-4ec7-bc48-2b1259f67d0a>EventType.StreamStart;

		public <b0b23517-beda-496a-8223-4c3554a848bc>StreamStart()
			: this(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark.Empty)
		{
		}

		public <b0b23517-beda-496a-8223-4c3554a848bc>StreamStart(in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark start, in <b3f32382-dd1c-454c-b573-36801723d8c1>Mark end)
			: base(in start, in end)
		{
		}

		public override string ToString()
		{
			return "Stream start";
		}

		public override void Accept(<816de241-b414-4c33-87d6-d9d8074f6bfa>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
}
namespace System.Collections.Generic
{
	internal static class <7b27c832-54d7-4c2e-88c0-afc6f5363ec6>DeconstructionExtensions
	{
		[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
		public static void Deconstruct<[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TKey, [<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(2)] TValue>([<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(new byte[] { 0, 1, 1 })] this KeyValuePair<TKey, TValue> pair, out TKey key, out TValue value)
		{
			key = pair.Key;
			value = pair.Value;
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[DebuggerNonUserCode]
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class <590afc20-c427-4b92-bf6f-e96ab746b8e2>AllowNullAttribute : Attribute
	{
	}
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	internal sealed class <68998b68-eb22-420f-bc5a-a3b824e67485>DisallowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class <1dbddc92-44f3-4cd7-bdc8-4e467bef83c4>DoesNotReturnAttribute : Attribute
	{
	}
	[DebuggerNonUserCode]
	[ExcludeFromCodeCoverage]
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class <e7b48b5d-b9f9-4667-81a5-1dfde9490e91>DoesNotReturnIfAttribute : Attribute
	{
		public bool ParameterValue { get; }

		public <e7b48b5d-b9f9-4667-81a5-1dfde9490e91>DoesNotReturnIfAttribute(bool parameterValue)
		{
			ParameterValue = parameterValue;
		}
	}
	[DebuggerNonUserCode]
	[ExcludeFromCodeCoverage]
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	internal sealed class <5efc7cea-0044-4fef-8184-8756b06de675>MaybeNullAttribute : Attribute
	{
	}
	[DebuggerNonUserCode]
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class <6977aacd-47a7-4a01-9bad-79c003aa1e36>MaybeNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public <6977aacd-47a7-4a01-9bad-79c003aa1e36>MaybeNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class <8eeafec0-c396-460a-ba12-6cf36c540753>NotNullAttribute : Attribute
	{
	}
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
	[<0d606795-0ee1-47ee-aaaa-2df0804da96c>Nullable(0)]
	[<b36caba6-ec7b-49e8-8641-5a4015501a0a>NullableContext(1)]
	internal sealed class <99247fee-aa35-49ed-87c5-b43f4aad50a7>NotNullIfNotNullAttribute : Attribute
	{
		public string ParameterName { get; }

		public <99247fee-aa35-49ed-87c5-b43f4aad50a7>NotNullIfNotNullAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class <4240ea5d-1d18-4a74-bdd9-8446445c7160>NotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public <4240ea5d-1d18-4a74-bdd9-8446445c7160>NotNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<112b52fc-385e-4422-8766-76e3d2c67965>Embedded]
	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)]
	[CompilerGenerated]
	[<112b52fc-385e-4422-8766-76e3d2c67965>Embedded]
	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;
		}
	}
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	[<112b52fc-385e-4422-8766-76e3d2c67965>Embedded]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace LocalizationManager
{
	[<1bfc4759-c5a6-4eb1-bee9-a1d0c5c59449>Nullable(0)]
	[<79594173-e941-4ad9-973e-713c0d41eb0b>NullableContext(1)]
	[PublicAPI]
	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 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 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
{
	[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;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[Microsoft.CodeAnalysis.Embedded]
	[CompilerGenerated]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public 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)]
	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
	{
		public static void Deconstruct<TKey, TValue>(this KeyValuePair<TKey, TValue> pair, out TKey key, out TValue value)
		{
			key = pair.Key;
			value = pair.Value;
		}
	}
}
namespace YamlDotNet
{
	internal sealed class CultureInfoAdapter : CultureInfo
	{
		private readonly IFormatProvider provider;

		public CultureInfoAdapter(CultureInfo baseCulture, IFormatProvider provider)
			: base(baseCulture.LCID)
		{
			this.provider = provider;
		}

		public override object? GetFormat(Type? formatType)
		{
			return provider.GetFormat(formatType);
		}
	}
	internal static class ReflectionExtensions
	{
		private static readonly FieldInfo? RemoteStackTraceField = typeof(Exception).GetField("_remoteStackTraceString", BindingFlags.Instance | BindingFlags.NonPublic);

		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);
		}

		public static PropertyInfo? GetPublicProperty(this Type type, string name)
		{
			return type.GetProperty(name);
		}

		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((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 + "'.");
		}

		public static MethodInfo? GetPublicStaticMethod(this Type type, string name, params Type[] parameterTypes)
		{
			return type.GetMethod(name, BindingFlags.Static | BindingFlags.Public, null, parameterTypes, null);
		}

		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<TAttribute>(this PropertyInfo property)
		{
			return Attribute.GetCustomAttributes(property, typeof(TAttribute));
		}
	}
	internal static class PropertyInfoExtensions
	{
		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
{
	internal abstract class BuilderSkeleton<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<TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
		{
			overrides.Add(propertyAccessor, attribute);
			return Self;
		}

		public TBuilder WithAttributeOverride(Type type, string member, Attribute attribute)
		{
			overrides.Add(type, member, attribute);
			return Self;
		}

		public TBuilder WithTypeConverter(IYamlTypeConverter typeConverter)
		{
			return WithTypeConverter(typeConverter, delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeConverter(IYamlTypeConverter typeConverter, Action<IRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where)
		{
			IYamlTypeConverter typeConverter2 = typeConverter;
			if (typeConverter2 == null)
			{
				throw new ArgumentNullException("typeConverter");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter2.GetType(), (Nothing _) => typeConverter2));
			return Self;
		}

		public TBuilder WithTypeConverter<TYamlTypeConverter>(WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where) where TYamlTypeConverter : IYamlTypeConverter
		{
			WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory2 = typeConverterFactory;
			if (typeConverterFactory2 == null)
			{
				throw new ArgumentNullException("typeConverterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (IYamlTypeConverter wrapped, Nothing _) => typeConverterFactory2(wrapped)));
			return Self;
		}

		public TBuilder WithoutTypeConverter<TYamlTypeConverter>() where TYamlTypeConverter : IYamlTypeConverter
		{
			return WithoutTypeConverter(typeof(TYamlTypeConverter));
		}

		public TBuilder WithoutTypeConverter(Type converterType)
		{
			if (converterType == null)
			{
				throw new ArgumentNullException("converterType");
			}
			typeConverterFactories.Remove(converterType);
			return Self;
		}

		public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : ITypeInspector
		{
			return WithTypeInspector(typeInspectorFactory, delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory, Action<IRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			Func<ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
			if (typeInspectorFactory2 == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector inner) => typeInspectorFactory2(inner)));
			return Self;
		}

		public TBuilder WithTypeInspector<TTypeInspector>(WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
			if (typeInspectorFactory2 == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector wrapped, ITypeInspector inner) => typeInspectorFactory2(wrapped, inner)));
			return Self;
		}

		public TBuilder WithoutTypeInspector<TTypeInspector>() where TTypeInspector : ITypeInspector
		{
			return WithoutTypeInspector(typeof(TTypeInspector));
		}

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

		protected IEnumerable<IYamlTypeConverter> BuildTypeConverters()
		{
			return typeConverterFactories.BuildComponentList();
		}
	}
	internal delegate TComponent WrapperFactory<TComponentBase, TComponent>(TComponentBase wrapped) where TComponent : TComponentBase;
	internal delegate TComponent WrapperFactory<TArgument, TComponentBase, TComponent>(TComponentBase wrapped, TArgument argument) where TComponent : TComponentBase;
	[Flags]
	internal enum DefaultValuesHandling
	{
		Preserve = 0,
		OmitNull = 1,
		OmitDefaults = 2,
		OmitEmptyCollections = 4
	}
	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<T>(string input)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize<T>(input2);
		}

		public T Deserialize<T>(TextReader input)
		{
			return Deserialize<T>(new Parser(input));
		}

		public object? Deserialize(TextReader input)
		{
			return Deserialize(input, typeof(object));
		}

		public object? Deserialize(string input, Type type)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize(input2, type);
		}

		public object? Deserialize(TextReader input, Type type)
		{
			return Deserialize(new Parser(input), type);
		}

		public T Deserialize<T>(IParser parser)
		{
			return (T)Deserialize(parser, typeof(T));
		}

		public object? Deserialize(IParser parser)
		{
			return Deserialize(parser, typeof(object));
		}

		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;
		}
	}
	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)
		{
			IObjectFactory objectFactory2 = objectFactory;
			if (objectFactory2 == null)
			{
				throw new ArgumentNullException("objectFactory");
			}
			this.objectFactory = new Lazy<IObjectFactory>(() => objectFactory2, isThreadSafe: true);
			return this;
		}

		public DeserializerBuilder WithObjectFactory(Func<Type, object> objectFactory)
		{
			if (objectFactory == null)
			{
				throw new ArgumentNullException("objectFactory");
			}
			return WithObjectFactory(new LambdaObjectFactory(objectFactory));
		}

		public DeserializerBuilder WithNodeDeserializer(INodeDeserializer nodeDeserializer)
		{
			return WithNodeDeserializer(nodeDeserializer, delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> w)
			{
				w.OnTop();
			});
		}

		public DeserializerBuilder WithNodeDeserializer(INodeDeserializer nodeDeserializer, Action<IRegistrationLocationSelectionSyntax<INodeDeserializer>> where)
		{
			INodeDeserializer nodeDeserializer2 = nodeDeserializer;
			if (nodeDeserializer2 == null)
			{
				throw new ArgumentNullException("nodeDeserializer");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer2.GetType(), (Nothing _) => nodeDeserializer2));
			return this;
		}

		public DeserializerBuilder WithNodeDeserializer<TNodeDeserializer>(WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeDeserializer>> where) where TNodeDeserializer : INodeDeserializer
		{
			WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory2 = nodeDeserializerFactory;
			if (nodeDeserializerFactory2 == null)
			{
				throw new ArgumentNullException("nodeDeserializerFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (INodeDeserializer wrapped, Nothing _) => nodeDeserializerFactory2(wrapped)));
			return this;
		}

		public DeserializerBuilder WithoutNodeDeserializer<TNodeDeserializer>() where TNodeDeserializer : INodeDeserializer
		{
			return WithoutNodeDeserializer(typeof(TNodeDeserializer));
		}

		public DeserializerBuilder WithoutNodeDeserializer(Type nodeDeserializerType)
		{
			if (nodeDeserializerType == null)
			{
				throw new ArgumentNullException("nodeDeserializerType");
			}
			nodeDeserializerFactories.Remove(nodeDeserializerType);
			return this;
		}

		public DeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver)
		{
			return WithNodeTypeResolver(nodeTypeResolver, delegate(IRegistrationLocationSelectionSyntax<INodeTypeResolver> w)
			{
				w.OnTop();
			});
		}

		public DeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver, Action<IRegistrationLocationSelectionSyntax<INodeTypeResolver>> where)
		{
			INodeTypeResolver nodeTypeResolver2 = nodeTypeResolver;
			if (nodeTypeResolver2 == null)
			{
				throw new ArgumentNullException("nodeTypeResolver");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver2.GetType(), (Nothing _) => nodeTypeResolver2));
			return this;
		}

		public DeserializerBuilder WithNodeTypeResolver<TNodeTypeResolver>(WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeTypeResolver>> where) where TNodeTypeResolver : INodeTypeResolver
		{
			WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory2 = nodeTypeResolverFactory;
			if (nodeTypeResolverFactory2 == null)
			{
				throw new ArgumentNullException("nodeTypeResolverFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (INodeTypeResolver wrapped, Nothing _) => nodeTypeResolverFactory2(wrapped)));
			return this;
		}

		public DeserializerBuilder WithoutNodeTypeResolver<TNodeTypeResolver>() where TNodeTypeResolver : INodeTypeResolver
		{
			return WithoutNodeTypeResolver(typeof(TNodeTypeResolver));
		}

		public DeserializerBuilder WithoutNodeTypeResolver(Type nodeTypeResolverType)
		{
			if (nodeTypeResolverType == null)
			{
				throw new ArgumentNullException("nodeTypeResolverType");
			}
			nodeTypeResolverFactories.Remove(nodeTypeResolverType);
			return this;
		}

		public override DeserializerBuilder WithTagMapping(TagName tag, Type type)
		{
			if (tag.IsEmpty)
			{
				throw new ArgumentException("Non-specific tags cannot be maped");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (tagMappings.TryGetValue(tag, out Type value))
			{
				throw new ArgumentException($"Type already has a registered type '{value.FullName}' for tag '{tag}'", "tag");
			}
			tagMappings.Add(tag, type);
			return this;
		}

		public DeserializerBuilder WithTypeMapping<TInterface, TConcrete>() where TConcrete : TInterface
		{
			Type typeFromHandle = typeof(TInterface);
			Type typeFromHandle2 = typeof(TConcrete);
			if (!typeFromHandle.IsAssignableFrom(typeFromHandle2))
			{
				throw new InvalidOperationException("The type '" + typeFromHandle2.Name + "' does not implement interface '" + typeFromHandle.Name + "'.");
			}
			if (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()));
		}
	}
	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<T>() where T : IObjectGraphVisitor<Nothing>
		{
			return preProcessingPhaseVisitors.OfType<T>().Single();
		}
	}
	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; }

		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; }

		protected ObjectEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	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; }

		public MappingStartEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class MappingEndEventInfo : EventInfo
	{
		public MappingEndEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class SequenceStartEventInfo : ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public SequenceStyle Style { get; set; }

		public SequenceStartEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class SequenceEndEventInfo : EventInfo
	{
		public SequenceEndEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal interface IAliasProvider
	{
		AnchorName GetAlias(object target);
	}
	internal interface IDeserializer
	{
		T Deserialize<T>(string input);

		T Deserialize<T>(TextReader input);

		object? Deserialize(TextReader input);

		object? Deserialize(string input, Type type);

		object? Deserialize(TextReader input, Type type);

		T Deserialize<T>(IParser parser);

		object? Deserialize(IParser parser);

		object? Deserialize(IParser parser, Type type);
	}
	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);
	}
	internal interface INamingConvention
	{
		string Apply(string value);
	}
	internal interface INodeDeserializer
	{
		bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value);
	}
	internal interface INodeTypeResolver
	{
		bool Resolve(NodeEvent? nodeEvent, ref Type currentType);
	}
	internal interface IObjectDescriptor
	{
		object? Value { get; }

		Type Type { get; }

		Type StaticType { get; }

		ScalarStyle ScalarStyle { get; }
	}
	internal static class ObjectDescriptorExtensions
	{
		public static object NonNullValue(this IObjectDescriptor objectDescriptor)
		{
			return objectDescriptor.Value ?? throw new InvalidOperationException("Attempted to use a IObjectDescriptor of type '" + objectDescriptor.Type.FullName + "' whose Value is null at a point whete it is invalid to do so. This may indicate a bug in YamlDotNet.");
		}
	}
	internal interface IObjectFactory
	{
		object Create(Type type);
	}
	internal interface IObjectGraphTraversalStrategy
	{
		void Traverse<TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context);
	}
	internal interface IObjectGraphVisitor<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);
	}
	internal interface IPropertyDescriptor
	{
		string Name { get; }

		bool CanWrite { get; }

		Type Type { get; }

		Type? TypeOverride { get; set; }

		int Order { get; set; }

		ScalarStyle ScalarStyle { get; set; }

		T GetCustomAttribute<T>() where T : Attribute;

		IObjectDescriptor Read(object target);

		void Write(object target, object? value);
	}
	internal interface IRegistrationLocationSelectionSyntax<TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;

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

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

		void OnTop();

		void OnBottom();
	}
	internal interface ITrackingRegistrationLocationSelectionSyntax<TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
	}
	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);
	}
	internal interface ITypeInspector
	{
		IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container);

		IPropertyDescriptor GetProperty(Type type, object? container, string name, [MaybeNullWhen(true)] bool ignoreUnmatched);
	}
	internal interface ITypeResolver
	{
		Type Resolve(Type staticType, object? actualValue);
	}
	internal interface IValueDeserializer
	{
		object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer);
	}
	internal interface IValuePromise
	{
		event Action<object?> ValueAvailable;
	}
	internal interface IValueSerializer
	{
		void SerializeValue(IEmitter emitter, object? value, Type? type);
	}
	internal interface IYamlConvertible
	{
		void Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer);

		void Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer);
	}
	internal delegate object? ObjectDeserializer(Type type);
	internal delegate void ObjectSerializer(object? value, Type? type = null);
	[Obsolete("Please use IYamlConvertible instead")]
	internal interface IYamlSerializable
	{
		void ReadYaml(IParser parser);

		void WriteYaml(IEmitter emitter);
	}
	internal interface IYamlTypeConverter
	{
		bool Accepts(Type type);

		object? ReadYaml(IParser parser, Type type);

		void WriteYaml(IEmitter emitter, object? value, Type type);
	}
	internal sealed class LazyComponentRegistrationList<TArgument, TComponent> : IEnumerable<Func<TArgument, TComponent>>, IEnumerable
	{
		public sealed class LazyComponentRegistration
		{
			public readonly Type ComponentType;

			public readonly Func<TArgument, TComponent> Factory;

			public LazyComponentRegistration(Type componentType, Func<TArgument, TComponent> factory)
			{
				ComponentType = componentType;
				Factory = factory;
			}
		}

		public sealed class TrackingLazyComponentRegistration
		{
			public readonly Type ComponentType;

			public readonly Func<TComponent, TArgument, TComponent> Factory;

			public TrackingLazyComponentRegistration(Type componentType, Func<TComponent, TArgument, TComponent> factory)
			{
				ComponentType = componentType;
				Factory = factory;
			}
		}

		private class RegistrationLocationSelector : IRegistrationLocationSelectionSyntax<TComponent>
		{
			private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;

			private readonly LazyComponentRegistration newRegistration;

			public RegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, LazyComponentRegistration newRegistration)
			{
				this.registrations = registrations;
				this.newRegistration = newRegistration;
			}

			void IRegistrationLocationSelectionSyntax<TComponent>.InsteadOf<TRegistrationType>()
			{
				if (newRegistration.ComponentType != typeof(TRegistrationType))
				{
					registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				}
				int index = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries[index] = newRegistration;
			}

			void IRegistrationLocationSelectionSyntax<TComponent>.After<TRegistrationType>()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				int num = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries.Insert(num + 1, newRegistration);
			}

			void IRegistrationLocationSelectionSyntax<TComponent>.Before<TRegistrationType>()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				int index = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries.Insert(index, newRegistration);
			}

			void IRegistrationLocationSelectionSyntax<TComponent>.OnBottom()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				registrations.entries.Add(newRegistration);
			}

			void IRegistrationLocationSelectionSyntax<TComponent>.OnTop()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				registrations.entries.Insert(0, newRegistration);
			}
		}

		private class TrackingRegistrationLocationSelector : ITrackingRegistrationLocationSelectionSyntax<TComponent>
		{
			private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;

			private readonly TrackingLazyComponentRegistration newRegistration;

			public TrackingRegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, TrackingLazyComponentRegistration newRegistration)
			{
				this.registrations = registrations;
				this.newRegistration = newRegistration;
			}

			void ITrackingRegistrationLocationSelectionSyntax<TComponent>.InsteadOf<TRegistrationType>()
			{
				if (newRegistration.ComponentType != typeof(TRegistrationType))
				{
					registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				}
				int index = registrations.EnsureRegistrationExists<TRegistrationType>();
				Func<TArgument, TComponent> innerComponentFactory = registrations.entries[index].Factory;
				registrations.entries[index] = new LazyComponentRegistration(newRegistration.ComponentType, (TArgument arg) => newRegistration.Factory(innerComponentFactory(arg), arg));
			}
		}

		private readonly List<LazyComponentRegistration> entries = new List<LazyComponentRegistration>();

		public int Count => entries.Count;

		public IEnumerable<Func<TArgument, TComponent>> InReverseOrder
		{
			get
			{
				int i = entries.Count - 1;
				while (i >= 0)
				{
					yield return entries[i].Factory;
					int num = i - 1;
					i = num;
				}
			}
		}

		public LazyComponentRegistrationList<TArgument, TComponent> Clone()
		{
			LazyComponentRegistrationList<TArgument, TComponent> lazyComponentRegistrationList = new LazyComponentRegistrationList<TArgument, TComponent>();
			foreach (LazyComponentRegistration entry in entries)
			{
				lazyComponentRegistrationList.entries.Add(entry);
			}
			return lazyComponentRegistrationList;
		}

		public void Add(Type componentType, Func<TArgument, TComponent> factory)
		{
			entries.Add(new LazyComponentRegistration(componentType, factory));
		}

		public void Remove(Type componentType)
		{
			for (int i = 0; i < entries.Count; i++)
			{
				if (entries[i].ComponentType == componentType)
				{
					entries.RemoveAt(i);
					return;
				}
			}
			throw new KeyNotFoundException("A component registration of type '" + componentType.FullName + "' was not found.");
		}

		public IRegistrationLocationSelectionSyntax<TComponent> CreateRegistrationLocationSelector(Type componentType, Func<TArgument, TComponent> factory)
		{
			return new RegistrationLocationSelector(this, new LazyComponentRegistration(componentType, factory));
		}

		public ITrackingRegistrationLocationSelectionSyntax<TComponent> CreateTrackingRegistrationLocationSelector(Type componentType, Func<TComponent, TArgument, TComponent> factory)
		{
			return new TrackingRegistrationLocationSelector(this, new TrackingLazyComponentRegistration(componentType, factory));
		}

		public IEnumerator<Func<TArgument, TComponent>> GetEnumerator()
		{
			return entries.Select((LazyComponentRegistration e) => e.Factory).GetEnumerator();
		}

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

		private int IndexOfRegistration(Type registrationType)
		{
			for (int i = 0; i < entries.Count; i++)
			{
				if (registrationType == entries[i].ComponentType)
				{
					return i;
				}
			}
			return -1;
		}

		private void EnsureNoDuplicateRegistrationType(Type componentType)
		{
			if (IndexOfRegistration(componentType) != -1)
			{
				throw new InvalidOperationException("A component of type '" + componentType.FullName + "' has already been registered.");
			}
		}

		private int EnsureRegistrationExists<TRegistrationType>()
		{
			int num = IndexOfRegistration(typeof(TRegistrationType));
			if (num == -1)
			{
				throw new InvalidOperationException("A component of type '" + typeof(TRegistrationType).FullName + "' has not been registered.");
			}
			return num;
		}
	}
	internal static class LazyComponentRegistrationListExtensions
	{
		public static TComponent BuildComponentChain<TComponent>(this LazyComponentRegistrationList<TComponent, TComponent> registrations, TComponent innerComponent)
		{
			return registrations.InReverseOrder.Aggregate(innerComponent, (TComponent inner, Func<TComponent, TComponent> factory) => factory(inner));
		}

		public static TComponent BuildComponentChain<TArgument, TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TComponent innerComponent, Func<TComponent, TArgument> argumentBuilder)
		{
			Func<TComponent, TArgument> argumentBuilder2 = argumentBuilder;
			return registrations.InReverseOrder.Aggregate(innerComponent, (TComponent inner, Func<TArgument, TComponent> factory) => factory(argumentBuilder2(inner)));
		}

		public static List<TComponent> BuildComponentList<TComponent>(this LazyComponentRegistrationList<Nothing, TComponent> registrations)
		{
			return registrations.Select((Func<Nothing, TComponent> factory) => factory(default(Nothing))).ToList();
		}

		public static List<TComponent> BuildComponentList<TArgument, TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TArgument argument)
		{
			TArgument argument2 = argument;
			return registrations.Select((Func<TArgument, TComponent> factory) => factory(argument2)).ToList();
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	internal struct Nothing
	{
	}
	internal sealed class ObjectDescriptor : IObjectDescriptor
	{
		public object? Value { get; private set; }

		public Type Type { get; private set; }

		public Type StaticType { get; private set; }

		public ScalarStyle ScalarStyle { get; private set; }

		public ObjectDescriptor(object? value, Type type, Type staticType)
			: this(value, type, staticType, ScalarStyle.Any)
		{
		}

		public ObjectDescriptor(object? value, Type type, Type staticType, ScalarStyle scalarStyle)
		{
			Value = value;
			Type = type ?? throw new ArgumentNullException("type");
			StaticType = staticType ?? throw new ArgumentNullException("staticType");
			ScalarStyle = scalarStyle;
		}
	}
	internal delegate IObjectGraphTraversalStrategy ObjectGraphTraversalStrategyFactory(ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion);
	internal sealed class PropertyDescriptor : IPropertyDescriptor
	{
		private readonly IPropertyDescriptor baseDescriptor;

		public string Name { get; set; }

		public Type Type => baseDescriptor.Type;

		public Type? TypeOverride
		{
			get
			{
				return baseDescriptor.TypeOverride;
			}
			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, object? value)
		{
			baseDescriptor.Write(target, value);
		}

		public T GetCustomAttribute<T>() where T : Attribute
		{
			return baseDescriptor.GetCustomAttribute<T>();
		}

		public IObjectDescriptor Read(object target)
		{
			return baseDescriptor.Read(target);
		}
	}
	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, 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());
		}
	}
	internal sealed class SerializerBuilder : BuilderSkeleton<SerializerBuilder>
	{
		private class ValueSerializer : IValueSerializer
		{
			private readonly IObjectGraphTraversalStrategy traversalStrategy;

			private readonly IEventEmitter eventEmitter;

			private readonly IEnumerable<IYamlTypeConverter> typeConverters;

			private readonly LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

			private readonly LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories;

			public ValueSerializer(IObjectGraphTraversalStrategy traversalStrategy, IEventEmitter eventEmitter, IEnumerable<IYamlTypeConverter> typeConverters, LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories, LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories)
			{
				this.traversalStrategy = traversalStrategy;
				this.eventEmitter = eventEmitter;
				this.typeConverters = typeConverters;
				this.preProcessingPhaseObjectGraphVisitorFactories = preProcessingPhaseObjectGraphVisitorFactories;
				this.emissionPhaseObjectGraphVisitorFactories = emissionPhaseObjectGraphVisitorFactories;
			}

			public void SerializeValue(IEmitter emitter, object? value, Type? type)
			{
				IEmitter emitter2 = emitter;
				Type type2 = type ?? ((value != null) ? value.GetType() : typeof(object));
				Type staticType = type ?? typeof(object);
				ObjectDescriptor graph = new ObjectDescriptor(value, type2, staticType);
				List<IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitors = preProcessingPhaseObjectGraphVisitorFactories.BuildComponentList(typeConverters);
				foreach (IObjectGraphVisitor<Nothing> item in preProcessingPhaseObjectGraphVisitors)
				{
					traversalStrategy.Traverse(graph, item, default(Nothing));
				}
				IObjectGraphVisitor<IEmitter> visitor = emissionPhaseObjectGraphVisitorFactories.BuildComponentChain<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>>(new EmittingObjectGraphVisitor(eventEmitter), (IObjectGraphVisitor<IEmitter> inner) => new EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
				traversalStrategy.Traverse(graph, visitor, emitter2);
				void NestedObjectSerializer(object? v, Type? t)
				{
					SerializeValue(emitter2, v, t);
				}
			}
		}

		private ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory;

		private readonly LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

		private readonly LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories;

		private readonly LazyComponentRegistrationList<IEventEmitter, IEventEmitter> eventEmitterFactories;

		private readonly 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<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			Func<IEventEmitter, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			if (eventEmitterFactory2 == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter inner) => eventEmitterFactory2(inner)));
			return Self;
		}

		public SerializerBuilder WithEventEmitter<TEventEmitter>(WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			if (eventEmitterFactory2 == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateTrackingRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter wrapped, IEventEmitter inner) => eventEmitterFactory2(wrapped, inner)));
			return Self;
		}

		public SerializerBuilder WithoutEventEmitter<TEventEmitter>() where TEventEmitter : IEventEmitter
		{
			return WithoutEventEmitter(typeof(TEventEmitter));
		}

		public SerializerBuilder WithoutEventEmitter(Type eventEmitterType)
		{
			if (eventEmitterType == null)
			{
				throw new ArgumentNullException("eventEmitterType");
			}
			eventEmitterFactories.Remove(eventEmitterType);
			return this;
		}

		public override SerializerBuilder WithTagMapping(TagName tag, Type type)
		{
			if (tag.IsEmpty)
			{
				throw new ArgumentException("Non-specific tags cannot be maped");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (tagMappings.TryGetValue(type, out var value))
			{
				throw new ArgumentException($"Type already has a registered tag '{value}' for type '{type.FullName}'", "type");
			}
			tagMappings.Add(type, tag);
			return this;
		}

		public SerializerBuilder WithoutTagMapping(Type type)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (!tagMappings.Remove(type))
			{
				throw new KeyNotFoundException("Tag for type '" + type.FullName + "' is not registered");
			}
			return this;
		}

		public SerializerBuilder EnsureRoundtrip()
		{
			objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new RoundtripObjectGraphTraversalStrategy(typeConverters, typeInspector, typeResolver, maximumRecursion, namingConvention);
			WithEventEmitter((IEventEmitter inner) => new TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: true, tagMappings), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
			return WithTypeInspector((ITypeInspector inner) => new ReadableAndWritablePropertiesTypeInspector(inner), delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> loc)
			{
				loc.OnBottom();
			});
		}

		public SerializerBuilder DisableAliases()
		{
			preProcessingPhaseObjectGraphVisitorFactories.Remove(typeof(AnchorAssigner));
			emissionPhaseObjectGraphVisitorFactories.Remove(typeof(AnchorAssigningObjectGraphVisitor));
			return this;
		}

		[Obsolete("The default behavior is now to always emit default values, thefore calling this method has no effect. This behavior is now controlled by ConfigureDefaultValuesHandling.", true)]
		public SerializerBuilder EmitDefaults()
		{
			return ConfigureDefaultValuesHandling(DefaultValuesHandling.Preserve);
		}

		public SerializerBuilder ConfigureDefaultValuesHandling(DefaultValuesHandling configuration)
		{
			defaultValuesHandlingConfiguration = configuration;
			return this;
		}

		public SerializerBuilder JsonCompatible()
		{
			emitterSettings = emitterSettings.WithMaxSimpleKeyLength(int.MaxValue).WithoutAnchorName();
			return WithTypeConverter(new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: true), delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.InsteadOf<YamlDotNet.Serialization.Converters.GuidConverter>();
			}).WithEventEmitter((IEventEmitter inner) => new JsonEventEmitter(inner), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			TObjectGraphVisitor objectGraphVisitor2 = objectGraphVisitor;
			if (objectGraphVisitor2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitor");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> _) => objectGraphVisitor2));
			return this;
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> _) => objectGraphVisitorFactory2(wrapped)));
			return this;
		}

		public SerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithoutPreProcessingPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

		public SerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor(Type objectGraphVisitorType)
		{
			if (objectGraphVisitorType == null)
			{
				throw new ArgumentNullException("objectGraphVisitorType");
			}
			preProcessingPhaseObjectGraphVisitorFactories.Remove(objectGraphVisitorType);
			return this;
		}

		public SerializerBuilder WithObjectGraphTraversalStrategyFactory(ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory)
		{
			this.objectGraphTraversalStrategyFactory = objectGraphTraversalStrategyFactory;
			return this;
		}

		public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory2(args)));
			return this;
		}

		public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			WrapperFactory<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<IEmitter> wrapped, EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory2(wrapped, args)));
			return this;
		}

		public SerializerBuilder WithoutEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithoutEmissionPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

		public SerializerBuilder WithoutEmissionPhaseObjectGraphVisitor(Type objectGraphVisitorType)
		{
			if (objectGraphVisitorType == null)
			{
				throw new ArgumentNullException("objectGraphVisitorType");
			}
			emissionPhaseObjectGraphVisitorFactories.Remove(objectGraphVisitorType);
			return this;
		}

		public SerializerBuilder WithIndentedSequences()
		{
			emitterSettings = emitterSettings.WithIndentedSequences();
			return this;
		}

		public ISerializer Build()
		{
			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());
		}
	}
	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);
			}
		}
	}
	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);
		}

		internal Type? GetMapping(string tag)
		{
			if (!mappings.TryGetValue(tag, out Type value))
			{
				return null;
			}
			return value;
		}
	}
	internal sealed class YamlAttributeOverrides
	{
		private struct AttributeKey
		{
			public readonly Type AttributeType;

			public readonly string PropertyName;

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

			public override bool Equals(object? obj)
			{
				if (obj is AttributeKey attributeKey && AttributeType.Equals(attributeKey.AttributeType))
				{
					return PropertyName.Equals(attributeKey.PropertyName);
				}
				return false;
			}

			public override int GetHashCode()
			{
				return YamlDotNet.Core.HashCode.CombineHashCodes(AttributeType.GetHashCode(), PropertyName.GetHashCode());
			}
		}

		private sealed class AttributeMapping
		{
			public readonly Type RegisteredType;

			public readonly Attribute Attribute;

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

			public override bool Equals(object? obj)
			{
				if (obj is AttributeMapping attributeMapping && RegisteredType.Equals(attributeMapping.RegisteredType))
				{
					return Attribute.Equals(attributeMapping.Attribute);
				}
				return false;
			}

			public override int GetHashCode()
			{
				return YamlDotNet.Core.HashCode.CombineHashCodes(RegisteredType.GetHashCode(), Attribute.GetHashCode());
			}

			public int Matches(Type matchType)
			{
				int num = 0;
				Type type = matchType;
				while (type != null)
				{
					num++;
					if (type == RegisteredType)
					{
						return num;
					}
					type = ReflectionExtensions.BaseType(type);
				}
				if (matchType.GetInterfaces().Contains(RegisteredType))
				{
					return num;
				}
				return 0;
			}
		}

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

		public T? GetAttribute<T>(Type type, string member) where T : Attribute
		{
			if (overrides.TryGetValue(new AttributeKey(typeof(T), member), out List<AttributeMapping> value))
			{
				int num = 0;
				AttributeMapping attributeMapping = null;
				foreach (AttributeMapping item in value)
				{
					int num2 = item.Matches(type);
					if (num2 > num)
					{
						num = num2;
						attributeMapping = item;
					}
				}
				if (num > 0)
				{
					return (T)attributeMapping.Attribute;
				}
			}
			return null;
		}

		public void Add(Type type, string member, Attribute attribute)
		{
			AttributeMapping item = new AttributeMapping(type, attribute);
			AttributeKey key = new AttributeKey(attribute.GetType(), member);
			if (!overrides.TryGetValue(key, out List<AttributeMapping> value))
			{
				value = new List<AttributeMapping>();
				overrides.Add(key, value);
			}
			else if (value.Contains(item))
			{
				throw new InvalidOperationException($"Attribute ({attribute}) already set for Type {type.FullName}, Member {member}");
			}
			value.Add(item);
		}

		public YamlAttributeOverrides Clone()
		{
			YamlAttributeOverrides yamlAttributeOverrides = new YamlAttributeOverrides();
			foreach (KeyValuePair<AttributeKey, List<AttributeMapping>> @override in overrides)
			{
				foreach (AttributeMapping item in @override.Value)
				{
					yamlAttributeOverrides.Add(item.RegisteredType, @override.Key.PropertyName, item.Attribute);
				}
			}
			return yamlAttributeOverrides;
		}

		public void Add<TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
		{
			PropertyInfo propertyInfo = ExpressionExtensions.AsProperty(propertyAccessor);
			Add(typeof(TClass), propertyInfo.Name, attribute);
		}
	}
	internal sealed class YamlAttributeOverridesInspector : TypeInspectorSkeleton
	{
		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;

			public Type? TypeOverride
			{
				get
				{
					return baseDescriptor.TypeOverride;
				}
				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, object? value)
			{
				baseDescriptor.Write(target, value);
			}

			public T GetCustomAttribute<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, object? container)
		{
			Type type2 = type;
			IEnumerable<IPropertyDescriptor> enumerable = innerTypeDescriptor.GetProperties(type2, container);
			if (overrides != null)
			{
				enumerable = enumerable.Select((Func<IPropertyDescriptor, IPropertyDescriptor>)((IPropertyDescriptor p) => new OverridePropertyDescriptor(p, overrides, type2)));
			}
			return enumerable;
		}
	}
	internal sealed class YamlAttributesTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

		public YamlAttributesTypeInspector(ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor;
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return from p in (from p in innerTypeDescriptor.GetProperties(type, container)
					where p.GetCustomAttribute<YamlIgnoreAttribute>() == null
					select p).Select((Func<IPropertyDescriptor, IPropertyDescriptor>)delegate(IPropertyDescriptor p)
				{
					PropertyDescriptor propertyDescriptor = new PropertyDescriptor(p);
					YamlMemberAttribute customAttribute = p.GetCustomAttribute<YamlMemberAttribute>();
					if (customAttribute != null)
					{
						if (customAttribute.SerializeAs != null)
						{
							propertyDescriptor.TypeOverride = customAttribute.SerializeAs;
						}
						propertyDescriptor.Order = customAttribute.Order;
						propertyDescriptor.ScalarStyle = customAttribute.ScalarStyle;
						if (customAttribute.Alias != null)
						{
							propertyDescriptor.Name = customAttribute.Alias;
						}
					}
					return propertyDescriptor;
				})
				orderby p.Order
				select p;
		}
	}
	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)]
	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;
		}

		public YamlMemberAttribute(Type serializeAs)
			: this()
		{
			SerializeAs = serializeAs ?? throw new ArgumentNullException("serializeAs");
		}
	}
}
namespace YamlDotNet.Serialization.ValueDeserializers
{
	internal sealed class AliasValueDeserializer : IValueDeserializer
	{
		private sealed class AliasState : Dictionary<AnchorName, ValuePromise>, IPostDeserializationCallback
		{
			public void OnDeserialization()
			{
				foreach (ValuePromise value in base.Values)
				{
					if (!value.HasValue)
					{
						YamlDotNet.Core.Events.AnchorAlias alias = value.Alias;
						throw new AnchorNotFoundException(alias.Start, alias.End, $"Anchor '{alias.Value}' not found");
					}
				}
			}
		}

		private sealed class ValuePromise : IValuePromise
		{
			private object? value;

			public readonly YamlDotNet.Core.Events.AnchorAlias? Alias;

			public bool HasValue { get; private set; }

			public object? Value
			{
				get
				{
					if (!HasValue)
					{
						throw new InvalidOperationException("Value not set");
					}
					return value;
				}
				set
				{
					if (HasValue)
					{
						throw new InvalidOperationException("Value already set");
					}
					HasValue = true;
					this.value = value;
					this.ValueAvailable?.Invoke(value);
				}
			}

			public event Action<object?>? ValueAvailable;

			public ValuePromise(YamlDotNet.Core.Events.AnchorAlias alias)
			{
				Alias = alias;
			}

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

		private readonly IValueDeserializer innerDeserializer;

		public AliasValueDeserializer(IValueDeserializer innerDeserializer)
		{
			this.innerDeserializer = innerDeserializer ?? throw new ArgumentNullException("innerDeserializer");
		}

		public object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
		{
			if (parser.TryConsume<YamlDotNet.Core.Events.AnchorAlias>(out var @event))
			{
				if (!state.Get<AliasState>().TryGetValue(@event.Value, out ValuePromise 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 ValuePromise value2))
				{
					aliasState2.Add(anchorName, new ValuePromise(obj));
				}
				else if (!value2.HasValue)
				{
					value2.Value = obj;
				}
				else
				{
					aliasState2[anchorName] = new ValuePromise(obj);
				}
			}
			return obj;
		}
	}
	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");
		}

		public object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
		{
			IValueDeserializer nestedObjectDeserializer2 = nestedObjectDeserializer;
			SerializerState state2 = state;
			parser.Accept<NodeEvent>(out var @event);
			Type typeFromEvent = GetTypeFromEvent(@event, expectedType);
			try
			{
				foreach (INodeDeserializer deserializer in deserializers)
				{
					if (deserializer.Deserialize(parser, typeFromEvent, (IParser r, Type t) => nestedObjectDeserializer2.DeserializeValue(r, t, state2, nestedObjectDeserializer2), out object 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(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();
	}
	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 object value))
				{
					return value;
				}
				throw new AnchorNotFoundException("The anchor '" + anchor + "' does not exists");
			}
		}

		public void Add(string anchor, object @object)
		{
			objectsByAnchor.Add(anchor, @object);
			if (@object != null)
			{
				anchorsByObject.Add(@object, anchor);
			}
		}

		public bool TryGetAnchor(object @object, [MaybeNullWhen(false)] out string? anchor)
		{
			return anchorsByObject.TryGetValue(@object, out anchor);
		}
	}
	internal static class ReflectionUtility
	{
		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
	{
		private readonly IDictionary<Type, object> items = new Dictionary<Type, object>();

		public T Get<T>() where T : class, new()
		{
			if (!items.TryGetValue(typeof(T), out object value))
			{
				value = new T();
				items.Add(typeof(T), value);
			}
			return (T)value;
		}

		public void OnDeserialization()
		{
			foreach (IPostDeserializationCallback item in items.Values.OfType<IPostDeserializationCallback>())
			{
				item.OnDeserialization();
			}
		}

		public void Dispose()
		{
			foreach (IDisposable item in items.Values.OfType<IDisposable>())
			{
				item.Dispose();
			}
		}
	}
	internal static class StringExtensions
	{
		private static string ToCamelOrPascalCase(string str, Func<char, char> firstLetterTransform)
		{
			string text = Regex.Replace(str, "([_\\-])(?<char>[a-z])", (Match match) => match.Groups["char"].Value.ToUpperInvariant(), RegexOptions.IgnoreCase);
			return firstLetterTransform(text[0]) + text.Substring(1);
		}

		public static string ToCamelCase(this string str)
		{
			return ToCamelOrPascalCase(str, char.ToLowerInvariant);
		}

		public static string ToPascalCase(this string str)
		{
			return ToCamelOrPascalCase(str, char.ToUpperInvariant);
		}

		public static string FromCamelCase(this string str, string separator)
		{
			string separator2 = separator;
			str = char.ToLower(str[0]) + str.Substring(1);
			str = Regex.Replace(ToCamelCase(str), "(?<char>[A-Z])", (Match match) => separator2 + match.Groups["char"].Value.ToLowerInvariant());
			return str;
		}
	}
	internal static class TypeConverter
	{
		public static T ChangeType<T>(object? value)
		{
			return (T)ChangeType(value, typeof(T));
		}

		public static T ChangeType<T>(object? value, IFormatProvider provider)
		{
			return (T)ChangeType(value, typeof(T), provider);
		}

		public static T ChangeType<T>(object? value, CultureInfo culture)
		{
			return (T)ChangeType(value, typeof(T), culture);
		}

		public static object? ChangeType(object? value, Type destinationType)
		{
			return ChangeType(value, destinationType, CultureInfo.InvariantCulture);
		}

		public static object? ChangeType(object? value, Type destinationType, IFormatProvider provider)
		{
			return ChangeType(value, destinationType, new CultureInfoAdapter(CultureInfo.CurrentCulture, provider));
		}

		public static object? ChangeType(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);
		}

		[PermissionSet(SecurityAction.LinkDemand, Name = "FullTrust")]
		public static void RegisterTypeConverter<TConvertible, TConverter>() where TConverter : System.ComponentModel.TypeConverter
		{
			if (!TypeDescriptor.GetAttributes(typeof(TConvertible)).OfType<TypeConverterAttribute>().Any((TypeConverterAttribute a) => a.ConverterTypeName == typeof(TConverter).AssemblyQualifiedName))
			{
				TypeDescriptor.AddAttributes(typeof(TConvertible), new TypeConverterAttribute(typeof(TConverter)));
			}
		}
	}
}
namespace YamlDotNet.Serialization.TypeResolvers
{
	internal sealed class DynamicTypeResolver : ITypeResolver
	{
		public Type Resolve(Type staticType, object? actualValue)
		{
			if (actualValue == null)
			{
				return staticType;
			}
			return actualValue.GetType();
		}
	}
	internal sealed class StaticTypeResolver : ITypeResolver
	{
		public Type Resolve(Type staticType, object? actualValue)
		{
			return staticType;
		}
	}
}
namespace YamlDotNet.Serialization.TypeInspectors
{
	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, object? container)
		{
			object container2 = container;
			return cache.GetOrAdd(type, (Type t) => innerTypeDescriptor.GetProperties(t, container2).ToList());
		}
	}
	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, object? container)
		{
			Type type2 = type;
			object container2 = container;
			return typeInspectors.SelectMany((ITypeInspector i) => i.GetProperties(type2, container2));
		}
	}
	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, object? container)
		{
			return innerTypeDescriptor.GetProperties(type, container).Select(delegate(IPropertyDescriptor p)
			{
				YamlMemberAttribute customAttribute = p.GetCustomAttribute<YamlMemberAttribute>();
				return (customAttribute != null && !customAttribute.ApplyNamingConventions) ? p : new PropertyDescriptor(p)
				{
					Name = namingConvention.Apply(p.Name)
				};
			});
		}
	}
	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, object? container)
		{
			return from p in innerTypeDescriptor.GetProperties(type, container)
				where p.CanWrite
				select p;
		}
	}
	internal sealed class ReadableFieldsTypeInspector : TypeInspectorSkeleton
	{
		private sealed class ReflectionFieldDescriptor : IPropertyDescriptor
		{
			private readonly FieldInfo fieldInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => fieldInfo.Name;

			public Type Type => fieldInfo.FieldType;

			public Type? TypeOverride { get; 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, object? value)
			{
				fieldInfo.SetValue(target, value);
			}

			public T GetCustomAttribute<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, object? container)
		{
			return ReflectionExtensions.GetPublicFields(type).Select((Func<FieldInfo, IPropertyDescriptor>)((FieldInfo p) => new ReflectionFieldDescriptor(p, typeResolver)));
		}
	}
	internal sealed class ReadablePropertiesTypeInspector : TypeInspectorSkeleton
	{
		private sealed class ReflectionPropertyDescriptor : IPropertyDescriptor
		{
			private readonly PropertyInfo propertyInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => propertyInfo.Name;

			public Type Type => propertyInfo.PropertyType;

			public Type? TypeOverride { get; 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, object? value)
			{
				propertyInfo.SetValue(target, value, null);
			}

			public T GetCustomAttribute<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, object? container)
		{
			return ReflectionExtensions.GetProperties(type, includeNonPublicProperties).Where(IsValidProperty).Select((Func<PropertyInfo, IPropertyDescriptor>)((PropertyInfo p) => new ReflectionPropertyDescriptor(p, typeResolver)));
		}
	}
	internal abstract class TypeInspectorSkeleton : ITypeInspector
	{
		public abstract IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container);

		public IPropertyDescriptor GetProperty(Type type, object? container, string name, [MaybeNullWhen(true)] bool ignoreUnmatched)
		{
			string name2 = name;
			IEnumerable<IPropertyDescriptor> enumerable = from p in GetProperties(type, container)
				where p.Name == name2
				select p;
			using IEnumerator<IPropertyDescriptor> enumerator = enumerable.GetEnumerator();
			if (!enumerator.MoveNext())
			{
				if (ignoreUnmatched)
				{
					return null;
				}
				throw new SerializationException("Property '" + name2 + "' not found on type '" + type.FullName + "'.");
			}
			IPropertyDescriptor current = enumerator.Current;
			if (enumerator.MoveNext())
			{
				throw new SerializationException("Multiple properties with the name/alias '" + name2 + "' already exists on type '" + type.FullName + "', maybe you're misusing YamlAlias or maybe you are using the wrong naming convention? The matching properties are: " + string.Join(", ", enumerable.Select((IPropertyDescriptor p) => p.Name).ToArray()));
			}
			return current;
		}
	}
}
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
{
	internal sealed class AnchorAssigner : PreProcessingPhaseObjectGraphVisitorSkeleton, IAliasProvider
	{
		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 AnchorAssignment value2))
			{
				if (value2.Anchor.IsEmpty)
				{
					value2.Anchor = new AnchorName("o" + nextId.ToString(CultureInfo.InvariantCulture));
					nextId++;
				}
				return false;
			}
			return true;
		}

		protected override bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value)
		{
			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 AnchorAssignment value))
			{
				return value.Anchor;
			}
			return AnchorName.Empty;
		}
	}
	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);
		}
	}
	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);
		}
	}
	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);
		}
	}
	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)
		{
			IObjectDescriptor value2 = value;
			IYamlTypeConverter yamlTypeConverter = typeConverters.FirstOrDefault((IYamlTypeConverter t) => t.Accepts(value2.Type));
			if (yamlTypeConverter != null)
			{
				yamlTypeConverter.WriteYaml(context, value2.Value, value2.Type);
				return false;
			}
			if (value2.Value is IYamlConvertible yamlConvertible)
			{
				yamlConvertible.Write(context, nestedObjectSerializer);
				return false;
			}
			if (value2.Value is IYamlSerializable yamlSerializable)
			{
				yamlSerializable.WriteYaml(context);
				return false;
			}
			return base.Enter(value2, context);
		}
	}
	internal sealed class DefaultExclusiveObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		public DefaultExclusiveObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		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;
		}
	}
	internal sealed class DefaultValuesObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		private readonly DefaultValuesHandling handling;

		public DefaultValuesObjectGraphVisitor(DefaultValuesHandling handling, IObjectGraphVisitor<IEmitter> nextVisitor)
			: base(nextVisitor)
		{
			this.handling = handling;
		}

		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);
		}
	}
	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);
		}
	}
	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)
		{
			IObjectDescriptor value2 = value;
			if (typeConverters.FirstOrDefault((IYamlTypeConverter t) => t.Accepts(value2.Type)) != null)
			{
				return false;
			}
			if (value2.Value is IYamlConvertible)
			{
				return false;
			}
			if (value2.Value is IYamlSerializable)
			{
				return false;
			}
			return Enter(value2);
		}

		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
{
	internal class FullObjectGraphTraversalStrategy : IObjectGraphTraversalStrategy
	{
		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<TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context)
		{
			Traverse("<root>", graph, visitor, context, new Stack<ObjectPathSegment>(maxRecursion));
		}

		protected virtual void Traverse<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<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<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<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<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(object? value, Type staticType)
		{
			return new ObjectDescriptor(value, typeResolver.Resolve(staticType, value), staticType);
		}
	}
	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<TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
		{
			IObjectDescriptor value2 = value;
			if (!value2.Type.HasDefaultConstructor() && !converters.Any((IYamlTypeConverter c) => c.Accepts(value2.Type)))
			{
				throw new InvalidOperationException($"Type '{value2.Type}' cannot be deserialized because it does not have a default constructor or a type converter.");
			}
			base.TraverseProperties(value2, visitor, context, path);
		}
	}
}
namespace YamlDotNet.Serialization.ObjectFactories
{
	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 Type 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);
			}
		}
	}
	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
	{
		bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (currentType == typeof(object))
			{
				if (nodeEvent is SequenceStart)
				{
					currentType = typeof(List<object>);
					return true;
				}
				if (nodeEvent is MappingStart)
				{
					currentType = typeof(Dictionary<object, object>);
					return true;
				}
			}
			return false;
		}
	}
	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(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (_mappings.TryGetValue(currentType, out Type value))
			{
				currentType = value;
				return true;
			}
			return false;
		}
	}
	internal class PreventUnknownTagsNodeTypeResolver : INodeTypeResolver
	{
		bool INodeTypeResolver.Resolve(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;
		}
	}
	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(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty && tagMappings.TryGetValue(nodeEvent.Tag, out Type value))
			{
				currentType = value;
				return true;
			}
			return false;
		}
	}
	[Obsolete("The mechanism that this class uses to specify type names is non-standard. Register the tags explicitly instead of using this convention.")]
	internal sealed class TypeNameInTagNodeTypeResolver : INodeTypeResolver
	{
		bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty)
			{
				Type type = Type.GetType(nodeEvent.Tag.Value.Substring(1), throwOnError: false);
				if (type != null)
				{
					currentType = type;
					return true;
				}
			}
			return false;
		}
	}
	internal sealed class YamlConvertibleTypeResolver : INodeTypeResolver
	{
		public bool Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			return typeof(IYamlConvertible).IsAssignableFrom(currentType);
		}
	}
	internal sealed class YamlSerializableTypeResolver : INodeTypeResolver
	{
		public bool Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			return typeof(IYamlSerializable).IsAssignableFrom(currentType);
		}
	}
}
namespace YamlDotNet.Serialization.NodeDeserializers
{
	internal sealed class ArrayNodeDeserializer : INodeDeserializer
	{
		private sealed class ArrayList : IList, ICollection, IEnumerable
		{
			private object?[] data;

			public bool IsFixedSize => false;

			public bool IsReadOnly => false;

			public object? this[int index]
			{
				get
				{
					return data[index];
				}
				set
				{
					data[index] = value;
				}
			}

			public int Count { get; private set; }

			public bool IsSynchronized => false;

			public object SyncRoot => data;

			public ArrayList()
			{
				Clear();
			}

			public int Add(object? value)
			{
				if (Count == data.Length)
				{
					Array.Resize(ref data, data.Length * 2);
				}
				data[Count] = value;
				return Count++;
			}

			public void Clear()
			{
				data = new object[10];
				Count = 0;
			}

			bool IList.Contains(object? value)
			{
				throw new NotSupportedException();
			}

			int IList.IndexOf(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Insert(int index, object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Remove(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.RemoveAt(int index)
			{
				throw new NotSupportedException();
			}

			public void CopyTo(Array array, int index)
			{
				Array.Copy(data, 0, array, index, Count);
			}

			public IEnumerator GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return data[i];
					int num = i + 1;
					i = num;
				}
			}
		}

		bool INodeDeserializer.Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, 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;
		}
	}
	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, Func<IParser, Type, object?> nestedObjectDeserializer, 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, Func<IParser, Type, object?> nestedObjectDeserializer, IList result, bool canUpdate)
		{
			IList result2 = result;
			Type tItem2 = tItem;
			parser.Consume<SequenceStart>();
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem2);
				if (obj is IValuePromise valuePromise)
				{
					if (!canUpdate)
					{
						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 = result2.Add(ReflectionExtensions.IsValueType(tItem2) ? Activator.CreateInstance(tItem2) : null);
					valuePromise.ValueAvailable += delegate(object? v)
					{
						result2[index] = YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(v, tItem2);
					};
				}
				else
				{
					result2.Add(YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(obj, tItem2));
				}
			}
		}
	}
	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, Func<IParser, Type, object?> nestedObjectDeserializer, 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, Func<IParser, Type, object?> nestedObjectDeserializer, IDictionary result)
		{
			IDictionary result2 = 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 += delegate(object? v)
						{
							result2[v] = value;
						};
						continue;
					}
					bool hasFirstPart = false;
					valuePromise2.ValueAvailable += delegate(object? v)
					{
						if (hasFirstPart)
						{
							result2[v] = value;
						}
						else
						{
							key = v;
							hasFirstPart = true;
						}
					};
					valuePromise.ValueAvailable += delegate(object? v)
					{
						if (hasFirstPart)
						{
							result2[key] = v;
						}
						else
						{
							value = v;
							hasFirstPart = true;
						}
					};
				}
				else if (valuePromise == null)
				{
					result2[key] = value;
				}
				else
				{
					valuePromise.ValueAvailable += delegate(object? v)
					{
						result2[key] = v;
					};
				}
			}
		}
	}
	internal sealed class EnumerableNodeDeserializer : INodeDeserializer
	{
		bool INodeDeserializer.Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, 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
	{
		bool INodeDeserializer.Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value)
		{
			value = null;
			if (parser.Accept<NodeEvent>(out var @event) && NodeIsNull(@event))
			{
				parser.SkipThisAndNestedEvents();
				return true;
			}
			return false;
		}

		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;
		}
	}
	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, Func<IParser, Type, object?> nestedObjectDeserializer, 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 += delegate(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;
		}
	}
	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, Func<IParser, Type, object?> nestedObjectDeserializer, 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, 
			});
		}
	}
	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, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value)
		{
			Type expectedType2 = expectedType;
			IYamlTypeConverter yamlTypeConverter = converters.FirstOrDefault((IYamlTypeConverter c) => c.Accepts(expectedType2));
			if (yamlTypeConverter == null)
			{
				value = null;
				return false;
			}
			value = yamlTypeConverter.ReadYaml(parser, expectedType2);
			return true;
		}
	}
	internal sealed class YamlConvertibleNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public YamlConvertibleNodeDeserializer(IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value)
		{
			Func<IParser, Type, object?> nestedObjectDeserializer2 = nestedObjectDeserializer;
			IParser parser2 = parser;
			if (typeof(IYamlConvertible).IsAssignableFrom(expectedType))
			{
				IYamlConvertible yamlConvertible = (IYamlConvertible)objectFactory.Create(expectedType);
				yamlConvertible.Read(parser2, expectedType, (Type type) => nestedObjectDeserializer2(parser2, type));
				value = yamlConvertible;
				return true;
			}
			value = null;
			return false;
		}
	}
	internal sealed class YamlSerializableNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public YamlSerializableNodeDeserializer(IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value)
		{
			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
	{
		public static readonly INamingConvention Instance = new CamelCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public CamelCaseNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return StringExtensions.ToCamelCase(value);
		}
	}
	internal sealed class HyphenatedNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new HyphenatedNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public HyphenatedNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return StringExtensions.FromCamelCase(value, "-");
		}
	}
	internal sealed class LowerCaseNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new LowerCaseNamingConvention();

		private LowerCaseNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return StringExtensions.ToCamelCase(value).ToLower();
		}
	}
	internal sealed class NullNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new NullNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public NullNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value;
		}
	}
	internal sealed class PascalCaseNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new PascalCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public PascalCaseNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return StringExtensions.ToPascalCase(value);
		}
	}
	internal sealed class UnderscoredNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new UnderscoredNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public UnderscoredNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return StringExtensions.FromCamelCase(value, "_");
		}
	}
}
namespace YamlDotNet.Serialization.EventEmitters
{
	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);
		}
	}
	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);
		}
	}
	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 + "));");
			}
		}
	}
	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
{
	internal class DateTimeConverter : IYamlTypeConverter
	{
		private readonly DateTimeKind kind;

		private readonly IFormatProvider provider;

		private readonly string[] formats;

		public DateTimeConverter(DateTimeKind kind = DateTimeKind.Utc, 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, 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;
		}
	}
	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, 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));
		}
	}
	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, 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
{
	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 YamlNode value))
			{
				return value;
			}
			throw new AnchorNotFoundException(start, end, $"The anchor '{anchor}' does not exists");
		}

		public bool TryGetNode(AnchorName anchor, [NotNullWhen(true)] out YamlNode? node)
		{
			return anchors.TryGetValue(anchor, out node);
		}

		public void AddNodeWithUnresolvedAliases(YamlNode node)
		{
			nodesWithUnresolvedAliases.Add(node);
		}

		public void ResolveAliases()
		{
			foreach (YamlNode nodesWithUnresolvedAlias in nodesWithUnresolvedAliases)
			{
				nodesWithUnresolvedAlias.ResolveAliases(this);
			}
		}
	}
	internal class EmitterState
	{
		public HashSet<AnchorName> EmittedAnchors { get; } = new HashSet<AnchorName>();

	}
	internal interface IYamlVisitor
	{
		void Visit(YamlStream stream);

		void Visit(YamlDocument document);

		void Visit(YamlScalarNode scalar);

		void Visit(YamlSequenceNode sequence);

		void Visit(YamlMappingNode mapping);
	}
	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(">");
			}
		}
	}
	internal class YamlAliasNode : YamlNode
	{
		public override YamlNodeType NodeType => YamlNodeType.Alias;

		internal YamlAliasNode(AnchorName anchor)
		{
			base.Anchor = anchor;
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			throw new NotSupportedException("Resolving an alias on an alias node does not make sense");
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			throw new NotSupportedException("A YamlAliasNode is an implementation detail and should never be saved.");
		}

		public override void Accept(IYamlVisitor visitor)
		{
			throw new NotSupportedException("A YamlAliasNode is an implementation detail and should never be visited.");
		}

		public override bool Equals(object? obj)
		{
			if (obj is YamlAliasNode yamlAliasNode && Equals(yamlAliasNode))
			{
				return object.Equals(base.Anchor, yamlAliasNode.Anchor);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		internal override string ToString(RecursionLevel level)
		{
			return "*" + base.Anchor.ToString();
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			yield return this;
		}
	}
	internal class YamlDocument
	{
		private class AnchorAssigningVisitor : YamlVisitorBase
		{
			private readonly HashSet<AnchorName> existingAnchors = new HashSet<AnchorName>();

			private readonly Dictionary<YamlNode, bool> visitedNodes = new Dictionary<YamlNode, bool>();

			public void AssignAnchors(YamlDocument document)
			{
				existingAnchors.Clear();
				visitedNodes.Clear();
				document.Accept(this);
				Random random = new Random();
				foreach (KeyValuePair<YamlNode, bool> visitedNode in visitedNodes)
				{
					if (!visitedNode.Value)
					{
						continue;
					}
					AnchorName anchorName;
					if (!visitedNode.Key.Anchor.IsEmpty && !existingAnchors.Contains(visitedNode.Key.Anchor))
					{
						anchorName = visitedNode.Key.Anchor;
					}
					else
					{
						do
						{
							anchorName = new AnchorName(random.Next().ToString(CultureInfo.InvariantCulture));
						}
						while (existingAnchors.Contains(anchorName));
					}
					existingAnchors.Add(anchorName);
					visitedNode.Key.Anchor = anchorName;
				}
			}

			private bool VisitNodeAndFindDuplicates(YamlNode node)
			{
				if (visitedNodes.TryGetValue(node, out var value))
				{
					if (!value)
					{
						visitedNodes[node] = true;
					}
					return !value;
				}
				visitedNodes.Add(node, value: false);
				return false;
			}

			public override void Visit(YamlScalarNode scalar)
			{
				VisitNodeAndFindDuplicates(scalar);
			}

			public override void Visit(YamlMappingNode mapping)
			{
				if (!VisitNodeAndFindDuplicates(mapping))
				{
					base.Visit(mapping);
				}
			}

			public override void Visit(YamlSequenceNode sequence)
			{
				if (!VisitNodeAndFindDuplicates(sequence))
				{
					base.Visit(sequence);
				}
			}
		}

		public YamlNode RootNode { get; private set; }

		public IEnumerable<YamlNode> AllNodes => RootNode.AllNodes;

		public YamlDocument(YamlNode rootNode)
		{
			RootNode = rootNode;
		}

		public YamlDocument(string rootNode)
		{
			RootNode = new YamlScalarNode(rootNode);
		}

		internal YamlDocument(IParser parser)
		{
			DocumentLoadingState documentLoadingState = new DocumentLoadingState();
			parser.Consume<YamlDotNet.Core.Events.DocumentStart>();
			YamlDotNet.Core.Events.DocumentEnd @event;
			while (!parser.TryConsume<YamlDotNet.Core.Events.DocumentEnd>(out @event))
			{
				RootNode = YamlNode.ParseNode(parser, documentLoadingState);
				if (RootNode is YamlAliasNode)
				{
					throw new YamlException("A document cannot contain only an alias");
				}
			}
			documentLoadingState.ResolveAliases();
			if (RootNode == null)
			{
				throw new ArgumentException("Atempted to parse an empty document");
			}
		}

		private void AssignAnchors()
		{
			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);
		}
	}
	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(params KeyValuePair<YamlNode, YamlNode>[] children)
			: this((IEnumerable<KeyValuePair<YamlNode, YamlNode>>)children)
		{
		}

		public YamlMappingNode(IEnumerable<KeyValuePair<YamlNode, YamlNode>> children)
		{
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				this.children.Add(child);
			}
		}

		public YamlMappingNode(params YamlNode[] children)
			: this((IEnumerable<YamlNode>)children)
		{
		}

		public YamlMappingNode(IEnumerable<YamlNode> children)
		{
			using IEnumerator<YamlNode> enumerator = children.GetEnumerator();
			while (enumerator.MoveNext())
			{
				YamlNode current = enumerator.Current;
				if (!enumerator.MoveNext())
				{
					throw new ArgumentException("When constructing a mapping node with a sequence, the number of elements of the sequence must be even.");
				}
				Add(current, enumerator.Current);
			}
		}

		public void Add(YamlNode key, YamlNode value)
		{
			children.Add(key, value);
		}

		public void Add(string key, YamlNode value)
		{
			children.Add(new YamlScalarNode(key), value);
		}

		public void Add(YamlNode key, string value)
		{
			children.Add(key, new YamlScalarNode(value));
		}

		public void Add(string key, string value)
		{
			children.Add(new YamlScalarNode(key), new YamlScalarNode(value));
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			Dictionary<YamlNode, YamlNode> dictionary = null;
			Dictionary<YamlNode, YamlNode> dictionary2 = null;
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				if (child.Key is YamlAliasNode)
				{
					if (dictionary == null)
					{
						dictionary = new Dictionary<YamlNode, YamlNode>();
					}
					dictionary.Add(child.Key, state.GetNode(child.Key.Anchor, child.Key.Start, child.Key.End));
				}
				if (child.Value is YamlAliasNode)
				{
					if (dictionary2 == null)
					{
						dictionary2 = new Dictionary<YamlNode, YamlNode>();
					}
					dictionary2.Add(child.Key, state.GetNode(child.Value.Anchor, child.Value.Start, child.Value.End));
				}
			}
			if (dictionary2 != null)
			{
				foreach (KeyValuePair<YamlNode, YamlNode> item in dictionary2)
				{
					children[item.Key] = item.Value;
				}
			}
			if (dictionary == null)
			{
				return;
			}
			foreach (KeyValuePair<YamlNode, YamlNode> item2 in dictionary)
			{
				YamlNode value = children[item2.Key];
				children.Remove(item2.Key);
				children.Add(item2.Value, value);
			}
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			emitter.Emit(new MappingStart(base.Anchor, base.Tag, isImplicit: true, Style));
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				child.Key.Save(emitter, state);
				child.Value.Save(emitter, state);
			}
			emitter.Emit(new MappingEnd());
		}

		public override void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override bool Equals(object? obj)
		{
			if (!(obj is YamlMappingNode yamlMappingNode) || !object.Equals(base.Tag, yamlMappingNode.Tag) || children.Count != yamlMappingNode.children.Count)
			{
				return false;
			}
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				if (!yamlMappingNode.children.TryGetValue(child.Key, out YamlNode value) || !object.Equals(child.Value, value))
				{
					return false;
				}
			}
			return true;
		}

		public override int GetHashCode()
		{
			int num = base.GetHashCode();
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				num = YamlDotNet.Core.HashCode.CombineHashCodes(num, child.Key);
				num = 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();
		}

		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;
		}
	}
	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 YamlNode node))
				{
					return new YamlAliasNode(event4.Value);
				}
				return node;
			}
			throw new ArgumentException("The current event is of an unsupported type.", "parser");
		}

		internal abstract void ResolveAliases(DocumentLoadingState state);

		internal void Save(IEmitter emitter, EmitterState state)
		{
			if (!Anchor.IsEmpty && !state.EmittedAnchors.Add(Anchor))
			{
				emitter.Emit(new YamlDotNet.Core.Events.AnchorAlias(Anchor));
			}
			else
			{
				Emit(emitter, state);
			}
		}

		internal abstract void Emit(IEmitter emitter, EmitterState state);

		public abstract void Accept(IYamlVisitor visitor);

		public override string ToString()
		{
			RecursionLevel recursionLevel = new RecursionLevel(1000);
			return ToString(recursionLevel);
		}

		internal abstract string ToString(RecursionLevel level);

		internal abstract IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level);

		public static implicit operator YamlNode(string value)
		{
			return new YamlScalarNode(value);
		}

		public static implicit operator YamlNode(string[] sequence)
		{
			return new YamlSequenceNode(((IEnumerable<string>)sequence).Select((Func<string, YamlNode>)((string i) => i)));
		}

		public static explicit operator string?(YamlNode node)
		{
			if (!(node is YamlScalarNode yamlScalarNode))
			{
				throw new ArgumentException($"Attempted to convert a '{node.NodeType}' to string. This conversion is valid only for Scalars.");
			}
			return yamlScalarNode.Value;
		}
	}
	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
	}
	[DebuggerDisplay("{Value}")]
	internal sealed class YamlScalarNode : YamlNode, IYamlConvertible
	{
		public string? Value { get; 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()
		{
		}

		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);
		}

		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);
		}

		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}")]
	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);
		}

		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());
		}
	}
	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();
		}
	}
	[Obsolete("Use YamlVisitorBase")]
	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);
		}
	}
	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
{
	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;
		}

		private static TMemberInfo? TryGetMemberExpression<TMemberInfo>(LambdaExpression lambdaExpression) where TMemberInfo : MemberInfo
		{
			if (lambdaExpression.Parameters.Count != 1)
			{
				return null;
			}
			Expression expression = lambdaExpression.Body;
			if (expression is UnaryExpression unaryExpression)
			{
				if (unaryExpression.NodeType != ExpressionType.Convert)
				{
					return null;
				}
				expression = unaryExpression.Operand;
			}
			if (expression is MemberExpression memberExpression)
			{
				if (memberExpression.Expression != lambdaExpression.Parameters[0])
				{
					return null;
				}
				return memberExpression.Member as TMemberInfo;
			}
			return null;
		}
	}
	internal sealed class GenericCollectionToNonGenericAdapter<T> : IList, ICollection, IEnumerable
	{
		private readonly ICollection<T> genericCollection;

		public bool IsFixedSize
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsReadOnly
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object? this[int index]
		{
			get
			{
				throw new NotSupportedException();
			}
			set
			{
				((IList<T>)genericCollection)[index] = (T)value;
			}
		}

		public int Count
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsSynchronized
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object SyncRoot
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public GenericCollectionToNonGenericAdapter(ICollection<T> genericCollection)
		{
			this.genericCollection = genericCollection ?? throw new ArgumentNullException("genericCollection");
		}

		public int Add(object? value)
		{
			int count = genericCollection.Count;
			genericCollection.Add((T)value);
			return count;
		}

		public void Clear()
		{
			genericCollection.Clear();
		}

		public bool Contains(object? value)
		{
			throw new NotSupportedException();
		}

		public int IndexOf(object? value)
		{
			throw new NotSupportedException();
		}

		public void Insert(int index, object? value)
		{
			throw new NotSupportedException();
		}

		public void Remove(object? value)
		{
			throw new NotSupportedException();
		}

		public void RemoveAt(int index)
		{
			throw new NotSupportedException();
		}

		public void CopyTo(Array array, int index)
		{
			throw new NotSupportedException();
		}

		public IEnumerator GetEnumerator()
		{
			return genericCollection.GetEnumerator();
		}
	}
	internal sealed class GenericDictionaryToNonGenericAdapter<TKey, TValue> : IDictionary, ICollection, IEnumerable where TKey : notnull
	{
		private class DictionaryEnumerator : IDictionaryEnumerator, IEnumerator
		{
			private readonly IEnumerator<KeyValuePair<TKey, TValue>> enumerator;

			public DictionaryEntry Entry => new DictionaryEntry(Key, Value);

			public object Key => enumerator.Current.Key;

			public object? Value => enumerator.Current.Value;

			public object Current => Entry;

			public DictionaryEnumerator(IEnumerator<KeyValuePair<TKey, TValue>> enumerator)
			{
				this.enumerator = enumerator;
			}

			public bool MoveNext()
			{
				return enumerator.MoveNext();
			}

			public void Reset()
			{
				enumerator.Reset();
			}
		}

		private readonly IDictionary<TKey, TValue> genericDictionary;

		public bool IsFixedSize
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsReadOnly
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public ICollection Keys
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public ICollection Values
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object? this[object key]
		{
			get
			{
				throw new NotSupportedException();
			}
			set
			{
				genericDictionary[(TKey)key] = (TValue)value;
			}
		}

		public int Count
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsSynchronized
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object SyncRoot
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public GenericDictionaryToNonGenericAdapter(IDictionary<TKey, TValue> genericDictionary)
		{
			this.genericDictionary = genericDictionary ?? throw new ArgumentNullException("genericDictionary");
		}

		public void Add(object key, object? value)
		{
			throw new NotSupportedException();
		}

		public void Clear()
		{
			throw new NotSupportedException();
		}

		public bool Contains(object key)
		{
			throw new NotSupportedException();
		}

		public IDictionaryEnumerator GetEnumerator()
		{
			return new DictionaryEnumerator(genericDictionary.GetEnumerator());
		}

		public void Remove(object key)
		{
			throw new NotSupportedException();
		}

		public void CopyTo(Array array, int index)
		{
			throw new NotSupportedException();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	internal interface IOrderedDictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable where TKey : notnull
	{
		KeyValuePair<TKey, TValue> this[int index] { get; set; }

		void Insert(int index, TKey key, TValue value);

		void RemoveAt(int index);
	}
	internal static class NumberExtensions
	{
		public static bool IsPowerOfTwo(this int value)
		{
			return (value & (value - 1)) == 0;
		}
	}
	[Serializable]
	internal class OrderedDictionary<TKey, TValue> : IOrderedDictionary<TKey, TValue>, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable where TKey : notnull
	{
		private class KeyCollection : ICollection<TKey>, IEnumerable<TKey>, IEnumerable
		{
			private readonly OrderedDictionary<TKey, TValue> orderedDictionary;

			public int Count => orderedDictionary.list.Count;

			public bool IsReadOnly => true;

			public void Add(TKey item)
			{
				throw new NotSupportedException();
			}

			public void Clear()
			{
				throw new NotSupportedException();
			}

			public bool Contains(TKey item)
			{
				return orderedDictionary.dictionary.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((KeyValuePair<TKey, TValue> kvp) => kvp.Key).GetEnumerator();
			}

			public bool Remove(TKey item)
			{
				throw new NotSupportedException();
			}

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

		private class ValueCollection : ICollection<TValue>, IEnumerable<TValue>, IEnumerable
		{
			private readonly OrderedDictionary<TKey, TValue> orderedDictionary;

			public int Count => orderedDictionary.list.Count;

			public bool IsReadOnly => true;

			public void Add(TValue item)
			{
				throw new NotSupportedException();
			}

			public void Clear()
			{
				throw new NotSupportedException();
			}

			public bool Contains(TValue item)
			{
				return orderedDictionary.dictionary.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((KeyValuePair<TKey, TValue> kvp) => kvp.Value).GetEnumerator();
			}

			public bool Remove(TValue item)
			{
				throw new NotSupportedException();
			}

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

		[NonSerialized]
		private Dictionary<TKey, TValue> dictionary;

		private readonly List<KeyValuePair<TKey, TValue>> list;

		private readonly IEqualityComparer<TKey> comparer;

		public TValue this[TKey key]
		{
			get
			{
				return dictionary[key];
			}
			set
			{
				TKey key2 = key;
				if (dictionary.ContainsKey(key2))
				{
					int index = list.FindIndex((KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key2));
					dictionary[key2] = value;
					list[index] = new KeyValuePair<TKey, TValue>(key2, value);
				}
				else
				{
					Add(key2, value);
				}
			}
		}

		public ICollection<TKey> Keys => new KeyCollection(this);

		public ICollection<TValue> Values => new ValueCollection(this);

		public int Count => dictionary.Count;

		public bool IsReadOnly => false;

		public KeyValuePair<TKey, TValue> this[int index]
		{
			get
			{
				return list[index];
			}
			set
			{
				list[index] = value;
			}
		}

		public OrderedDictionary()
			: this((IEqualityComparer<TKey>)EqualityComparer<TKey>.Default)
		{
		}

		public OrderedDictionary(IEqualityComparer<TKey> comparer)
		{
			list = new List<KeyValuePair<TKey, TValue>>();
			dictionary = new Dictionary<TKey, TValue>(comparer);
			this.comparer = comparer;
		}

		public void Add(TKey key, TValue value)
		{
			Add(new KeyValuePair<TKey, TValue>(key, value));
		}

		public void Add(KeyValuePair<TKey, TValue> item)
		{
			dictionary.Add(item.Key, item.Value);
			list.Add(item);
		}

		public void Clear()
		{
			dictionary.Clear();
			list.Clear();
		}

		public bool Contains(KeyValuePair<TKey, TValue> item)
		{
			return dictionary.Contains(item);
		}

		public bool ContainsKey(TKey key)
		{
			return dictionary.ContainsKey(key);
		}

		public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			list.CopyTo(array, arrayIndex);
		}

		public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
		{
			return list.GetEnumerator();
		}

		public void Insert(int index, TKey key, TValue value)
		{
			dictionary.Add(key, value);
			list.Insert(index, new KeyValuePair<TKey, TValue>(key, value));
		}

		public bool Remove(TKey key)
		{
			TKey key2 = key;
			if (dictionary.ContainsKey(key2))
			{
				int index = list.FindIndex((KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key2));
				list.RemoveAt(index);
				if (!dictionary.Remove(key2))
				{
					throw new InvalidOperationException();
				}
				return true;
			}
			return false;
		}

		public bool Remove(KeyValuePair<TKey, TValue> item)
		{
			return Remove(item.Key);
		}

		public void RemoveAt(int index)
		{
			TKey key = list[index].Key;
			dictionary.Remove(key);
			list.RemoveAt(index);
		}

		public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
		{
			return dictionary.TryGetValue(key, out value);
		}

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

		[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
	{
		public static Lazy<T> FromValue<T>(T value)
		{
			T value2 = value;
			Lazy<T> lazy = new Lazy<T>(() => value2, isThreadSafe: false);
			_ = lazy.Value;
			return lazy;
		}
	}
	internal static class ReadOnlyCollectionExtensions
	{
		public static IReadOnlyList<T> AsReadonlyList<T>(this List<T> list)
		{
			return list;
		}

		public static IReadOnlyDictionary<TKey, TValue> AsReadonlyDictionary<TKey, TValue>(this Dictionary<TKey, TValue> dictionary) where TKey : notnull
		{
			return dictionary;
		}
	}
}
namespace YamlDotNet.Core
{
	internal struct AnchorName : IEquatable<AnchorName>
	{
		public static readonly AnchorName Empty = default(AnchorName);

		private static readonly Regex AnchorPattern = new Regex("^[^\\[\\]\\{\\},]+$", RegexOptions.Compiled);

		private readonly string? value;

		public string Value => value ?? throw new InvalidOperationException("Cannot read the Value of an empty anchor");

		public bool IsEmpty => value == null;

		public AnchorName(string value)
		{
			this.value = value ?? throw new ArgumentNullException("value");
			if (!AnchorPattern.IsMatch(value))
			{
				throw new ArgumentException("Anchor cannot be empty or contain disallowed characters: []{},\nThe value was '" + value + "'.", "value");
			}
		}

		public override string ToString()
		{
			return value ?? "[empty]";
		}

		public bool Equals(AnchorName other)
		{
			return object.Equals(value, other.value);
		}

		public override bool Equals(object? obj)
		{
			if (obj is AnchorName other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return value?.GetHashCode() ?? 0;
		}

		public static bool operator ==(AnchorName left, AnchorName right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(AnchorName left, AnchorName right)
		{
			return !(left == right);
		}

		public static implicit operator AnchorName(string? value)
		{
			if (value != null)
			{
				return new AnchorName(value);
			}
			return Empty;
		}
	}
	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)
		{
		}
	}
	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
	{
		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;
	}
	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;
			}
		}
	}
	internal class Emitter : IEmitter
	{
		private class AnchorData
		{
			public AnchorName Anchor;

			public bool IsAlias;
		}

		private class TagData
		{
			public string? Handle;

			public string? Suffix;
		}

		private class ScalarData
		{
			public string Value = string.Empty;

			public bool IsMultiline;

			public bool IsFlowPlainAllowed;

			public bool IsBlockPlainAllowed;

			public bool IsSingleQuotedAllowed;

			public bool IsBlockAllowed;

			public bool HasSingleQuotes;

			public ScalarStyle Style;
		}

		private static readonly Regex UriReplacer = new Regex("[^0-9A-Za-z_\\-;?@=$~\\\\\\)\\]/:&+,\\.\\*\\(\\[!]", RegexOptions.Compiled | RegexOptions.Singleline);

		private 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(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;
		}

		private int SafeStringLength(string? value)
		{
			return value?.Length ?? 0;
		}

		private bool CheckEmptySequence()
		{
			return CheckEmptyStructure<SequenceStart, SequenceEnd>();
		}

		private bool CheckEmptyMapping()
		{
			return CheckEmptyStructure<MappingStart, MappingEnd>();
		}

		private bool CheckEmptyStructure<TStart, TEnd>() where TStart : NodeEvent where TEnd : ParsingEvent
		{
			if (events.Count < 2)
			{
				return false;
			}
			using Queue<ParsingEvent>.Enumerator enumerator = events.GetEnumerator();
			return enumerator.MoveNext() && enumerator.Current is TStart && enumerator.MoveNext() && enumerator.Current is TEnd;
		}

		private void WriteBlockScalarHints(string value)
		{
			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, delegate(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;
		}
	}
	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
	}
	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)
		{
		}
	}
	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, 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;
		}
	}
	internal interface IEmitter
	{
		void Emit(ParsingEvent @event);
	}
	internal interface ILookAheadBuffer
	{
		bool EndOfInput { get; }

		char Peek(int offset);

		void Skip(int length);
	}
	internal sealed class InsertionQueue<T> : IEnumerable<T>, IEnumerable
	{
		private const int DefaultInitialCapacity = 128;

		private T[] items;

		private int readPtr;

		private int writePtr;

		private int mask;

		private int count;

		public int Count => count;

		public int Capacity => items.Length;

		public InsertionQueue(int initialCapacity = 128)
		{
			if (initialCapacity <= 0)
			{
				throw new ArgumentOutOfRangeException("initialCapacity", "The initial capacity must be a positive number.");
			}
			if (!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();
		}
	}
	internal interface IParser
	{
		ParsingEvent? Current { get; }

		bool MoveNext();
	}
	internal interface IScanner
	{
		Mark CurrentPosition { get; }

		Token? Current { get; }

		bool MoveNext();

		bool MoveNextWithoutConsuming();

		void ConsumeCurrent();
	}
	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;
		}
	}
	internal sealed class Mark : IEquatable<Mark>, IComparable<Mark>, IComparable
	{
		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;
		}

		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;
		}
	}
	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)
		{
		}
	}
	internal sealed class MergingParser : IParser
	{
		private sealed class ParsingEventCollection : IEnumerable<LinkedListNode<ParsingEvent>>, IEnumerable
		{
			private readonly LinkedList<ParsingEvent> events;

			private readonly HashSet<LinkedListNode<ParsingEvent>> deleted;

			private readonly Dictionary<AnchorName, LinkedListNode<ParsingEvent>> references;

			public ParsingEventCollection()
			{
				events = new LinkedList<ParsingEvent>();
				deleted = new HashSet<LinkedListNode<ParsingEvent>>();
				references = new Dictionary<AnchorName, LinkedListNode<ParsingEvent>>();
			}

			public void AddAfter(LinkedListNode<ParsingEvent> node, IEnumerable<ParsingEvent> items)
			{
				foreach (ParsingEvent item in items)
				{
					node = events.AddAfter(node, item);
				}
			}

			public void Add(ParsingEvent item)
			{
				LinkedListNode<ParsingEvent> node = events.AddLast(item);
				AddReference(item, node);
			}

			public void MarkDeleted(LinkedListNode<ParsingEvent> node)
			{
				deleted.Add(node);
			}

			public 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(LinkedListNode<ParsingEvent>? node)
			{
				while (node != null)
				{
					yield return node;
					node = node.Next;
				}
			}

			private void AddReference(ParsingEvent item, LinkedListNode<ParsingEvent> node)
			{
				if (item is MappingStart mappingStart)
				{
					AnchorName anchor = mappingStart.Anchor;
					if (!anchor.IsEmpty)
					{
						references[anchor] = node;
					}
				}
			}
		}

		private sealed class ParsingEventCloner : IParsingEventVisitor
		{
			private ParsingEvent? clonedEvent;

			public ParsingEvent Clone(ParsingEvent e)
			{
				e.Accept(this);
				if (clonedEvent == null)
				{
					throw new InvalidOperationException($"Could not clone event of type '{e.Type}'");
				}
				return clonedEvent;
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.AnchorAlias e)
			{
				clonedEvent = new YamlDotNet.Core.Events.AnchorAlias(e.Value, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.StreamStart e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.StreamEnd e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.DocumentStart e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.DocumentEnd e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.Scalar e)
			{
				clonedEvent = new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, e.Tag, e.Value, e.Style, e.IsPlainImplicit, e.IsQuotedImplicit, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(SequenceStart e)
			{
				clonedEvent = new SequenceStart(AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(SequenceEnd e)
			{
				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;

		public ParsingEvent? Current => iterator.Current?.Value;

		public MergingParser(IParser innerParser)
		{
			events = new ParsingEventCollection();
			merged = false;
			iterator = events.GetEnumerator();
			this.innerParser = innerParser;
		}

		public bool MoveNext()
		{
			if (!merged)
			{
				Merge();
				events.CleanMarked();
				iterator = events.GetEnumerator();
				merged = true;
			}
			return iterator.MoveNext();
		}

		private void Merge()
		{
			while (innerParser.MoveNext())
			{
				events.Add(innerParser.Current);
			}
			foreach (LinkedListNode<ParsingEvent> @event in events)
			{
				if (IsMergeToken(@event))
				{
					events.MarkDeleted(@event);
					if (!HandleMerge(@event.Next))
					{
						throw new SemanticErrorException(@event.Value.Start, @event.Value.End, "Unrecognized merge key pattern");
					}
				}
			}
		}

		private bool HandleMerge(LinkedListNode<ParsingEvent>? node)
		{
			if (node == null)
			{
				return false;
			}
			if (node.Value is YamlDotNet.Core.Events.AnchorAlias anchorAlias)
			{
				return HandleAnchorAlias(node, node, anchorAlias);
			}
			if (node.Value is SequenceStart)
			{
				return HandleSequence(node);
			}
			return false;
		}

		private bool HandleMergeSequence(LinkedListNode<ParsingEvent> sequenceStart, LinkedListNode<ParsingEvent>? node)
		{
			if (node == null)
			{
				return false;
			}
			if (node.Value is YamlDotNet.Core.Events.AnchorAlias anchorAlias)
			{
				return HandleAnchorAlias(sequenceStart, node, anchorAlias);
			}
			if (node.Value is SequenceStart)
			{
				return HandleSequence(node);
			}
			return false;
		}

		private 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((ParsingEvent e) => (nesting += e.NestingIncrease) >= 0)
				select cloner.Clone(e);
		}
	}
	internal class Parser : IParser
	{
		private class EventQueue
		{
			private readonly Queue<ParsingEvent> highPriorityEvents = new Queue<ParsingEvent>();

			private readonly Queue<ParsingEvent> normalPriorityEvents = new Queue<ParsingEvent>();

			public int Count => highPriorityEvents.Count + normalPriorityEvents.Count;

			public void Enqueue(ParsingEvent @event)
			{
				EventType type = @event.Type;
				if (type == EventType.StreamStart || type == EventType.DocumentStart)
				{
					highPriorityEvents.Enqueue(@event);
				}
				else
				{
					normalPriorityEvents.Enqueue(@event);
				}
			}

			public ParsingEvent Dequeue()
			{
				if (highPriorityEvents.Count <= 0)
				{
					return normalPriorityEvents.Dequeue();
				}
				return highPriorityEvents.Dequeue();
			}
		}

		private readonly Stack<ParserState> states = new Stack<ParserState>();

		private readonly TagDirectiveCollection tagDirectives = new TagDirectiveCollection();

		private ParserState state;

		private readonly IScanner scanner;

		private Token? currentToken;

		private VersionDirective? version;

		private readonly EventQueue pendingEvents = new EventQueue();

		public ParsingEvent? Current { get; private set; }

		private Token? GetCurrentToken()
		{
			if (currentToken == null)
			{
				while (scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (!(currentToken is YamlDotNet.Core.Tokens.Comment comment))
					{
						break;
					}
					pendingEvents.Enqueue(new YamlDotNet.Core.Events.Comment(comment.Value, comment.IsInline, comment.Start, comment.End));
					scanner.ConsumeCurrent();
				}
			}
			return currentToken;
		}

		public Parser(TextReader input)
			: this(new Scanner(input))
		{
		}

		public Parser(IScanner scanner)
		{
			this.scanner = scanner;
		}

		public bool MoveNext()
		{
			if (state == ParserState.StreamEnd)
			{
				Current = null;
				return false;
			}
			if (pendingEvents.Count == 0)
			{
				pendingEvents.Enqueue(StateMachine());
			}
			Current = pendingEvents.Dequeue();
			return true;
		}

		private ParsingEvent StateMachine()
		{
			return state switch
			{
				ParserState.StreamStart => ParseStreamStart(), 
				ParserState.ImplicitDocumentStart => ParseDocumentStart(isImplicit: true), 
				ParserState.DocumentStart => ParseDocumentStart(isImplicit: false), 
				ParserState.DocumentContent => ParseDocumentContent(), 
				ParserState.DocumentEnd => ParseDocumentEnd(), 
				ParserState.BlockNode => ParseNode(isBlock: true, isIndentlessSequence: false), 
				ParserState.BlockNodeOrIndentlessSequence => ParseNode(isBlock: true, isIndentlessSequence: true), 
				ParserState.FlowNode => ParseNode(isBlock: false, isIndentlessSequence: false), 
				ParserState.BlockSequenceFirstEntry => ParseBlockSequenceEntry(isFirst: true), 
				ParserState.BlockSequenceEntry => ParseBlockSequenceEntry(isFirst: false), 
				ParserState.IndentlessSequenceEntry => ParseIndentlessSequenceEntry(), 
				ParserState.BlockMappingFirstKey => ParseBlockMappingKey(isFirst: true), 
				ParserState.BlockMappingKey => ParseBlockMappingKey(isFirst: false), 
				ParserState.BlockMappingValue => ParseBlockMappingValue(), 
				ParserState.FlowSequenceFirstEntry => ParseFlowSequenceEntry(isFirst: true), 
				ParserState.FlowSequenceEntry => ParseFlowSequenceEntry(isFirst: false), 
				ParserState.FlowSequenceEntryMappingKey => ParseFlowSequenceEntryMappingKey(), 
				ParserState.FlowSequenceEntryMappingValue => ParseFlowSequenceEntryMappingValue(), 
				ParserState.FlowSequenceEntryMappingEnd => ParseFlowSequenceEntryMappingEnd(), 
				ParserState.FlowMappingFirstKey => ParseFlowMappingKey(isFirst: true), 
				ParserState.FlowMappingKey => ParseFlowMappingKey(isFirst: false), 
				ParserState.FlowMappingValue => ParseFlowMappingValue(isEmpty: false), 
				ParserState.FlowMappingEmptyValue => ParseFlowMappingValue(isEmpty: true), 
				_ => throw new InvalidOperationException(), 
			};
		}

		private void Skip()
		{
			if (currentToken != null)
			{
				currentToken = null;
				scanner.ConsumeCurrent();
			}
		}

		private 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;
		}

		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);
		}
	}
	internal static class ParserExtensions
	{
		public static T Consume<T>(this IParser parser) where T : ParsingEvent
		{
			T result = parser.Require<T>();
			parser.MoveNext();
			return result;
		}

		public static bool TryConsume<T>(this IParser parser, [MaybeNullWhen(false)] out T @event) where T : ParsingEvent
		{
			if (parser.Accept<T>(out @event))
			{
				parser.MoveNext();
				return true;
			}
			return false;
		}

		public static T Require<T>(this IParser parser) where T : ParsingEvent
		{
			if (!parser.Accept<T>(out var @event))
			{
				ParsingEvent current = parser.Current;
				if (current == null)
				{
					throw new YamlException("Expected '" + typeof(T).Name + "', got nothing.");
				}
				throw new YamlException(current.Start, current.End, $"Expected '{typeof(T).Name}', got '{current.GetType().Name}' (at {current.Start}).");
			}
			return @event;
		}

		public static bool Accept<T>(this IParser parser, [MaybeNullWhen(false)] out T @event) where T : ParsingEvent
		{
			if (parser.Current == null && !parser.MoveNext())
			{
				throw new EndOfStreamException();
			}
			if (parser.Current is T val)
			{
				@event = val;
				return true;
			}
			@event = null;
			return false;
		}

		public static void SkipThisAndNestedEvents(this IParser parser)
		{
			int num = 0;
			do
			{
				ParsingEvent parsingEvent = parser.Consume<ParsingEvent>();
				num += parsingEvent.NestingIncrease;
			}
			while (num > 0);
		}

		[Obsolete("Please use Consume<T>() instead")]
		public static T Expect<T>(this IParser parser) where T : ParsingEvent
		{
			return parser.Consume<T>();
		}

		[Obsolete("Please use TryConsume<T>(out var evt) instead")]
		public static T? Allow<T>(this IParser parser) where T : ParsingEvent
		{
			if (!parser.TryConsume<T>(out var @event))
			{
				return null;
			}
			return @event;
		}

		[Obsolete("Please use Accept<T>(out var evt) instead")]
		public static T? Peek<T>(this IParser parser) where T : ParsingEvent
		{
			if (!parser.Accept<T>(out var @event))
			{
				return null;
			}
			return @event;
		}

		[Obsolete("Please use TryConsume<T>(out var evt) or Accept<T>(out var evt) instead")]
		public static bool Accept<T>(this IParser parser) where T : ParsingEvent
		{
			T @event;
			return parser.Accept<T>(out @event);
		}
	}
	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
	}
	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;

		private Token? previous;

		private Anchor? previousAnchor;

		private static readonly byte[] EmptyBytes = new byte[0];

		public bool SkipComments { get; private set; }

		public Token? Current { get; private set; }

		public Mark CurrentPosition => cursor.Mark();

		private bool IsDocumentStart()
		{
			if (!analyzer.EndOfInput && cursor.LineOffset == 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);
			}
		}

		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(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);
			}
		}
	}
	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)
		{
		}
	}
	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
	{
		private readonly string value;

		public int Position { get; private set; }

		public int Length => value.Length;

		public bool EndOfInput => IsOutside(Position);

		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;
		}
	}
	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)
		{
		}
	}
	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));
		}
	}
	internal struct TagName : IEquatable<TagName>
	{
		public static readonly TagName Empty;

		private readonly string? value;

		public string Value => value ?? throw new InvalidOperationException("Cannot read the Value of a non-specific tag");

		public bool IsEmpty => value == null;

		public bool IsNonSpecific
		{
			get
			{
				if (!IsEmpty)
				{
					if (!(value == "!"))
					{
						return value == "?";
					}
					return true;
				}
				return false;
			}
		}

		public bool IsLocal
		{
			get
			{
				if (!IsEmpty)
				{
					return Value[0] == '!';
				}
				return false;
			}
		}

		public bool IsGlobal
		{
			get
			{
				if (!IsEmpty)
				{
					return !IsLocal;
				}
				return false;
			}
		}

		public TagName(string value)
		{
			this.value = value ?? throw new ArgumentNullException("value");
			if (value.Length == 0)
			{
				throw new ArgumentException("Tag value must not be empty.", "value");
			}
			if (IsGlobal && !Uri.IsWellFormedUriString(value, UriKind.RelativeOrAbsolute))
			{
				throw new ArgumentException("Global tags must be valid URIs.", "value");
			}
		}

		public override string ToString()
		{
			return value ?? "?";
		}

		public bool Equals(TagName other)
		{
			return object.Equals(value, other.value);
		}

		public override bool Equals(object? obj)
		{
			if (obj is TagName other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return value?.GetHashCode() ?? 0;
		}

		public static bool operator ==(TagName left, TagName right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(TagName left, TagName right)
		{
			return !(left == right);
		}

		public static bool operator ==(TagName left, string right)
		{
			return object.Equals(left.value, right);
		}

		public static bool operator !=(TagName left, string right)
		{
			return !(left == right);
		}

		public static implicit operator TagName(string? value)
		{
			if (value != null)
			{
				return new TagName(value);
			}
			return Empty;
		}
	}
	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;
		}

		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());
		}
	}
	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, 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)
		{
		}

		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)
		{
		}

		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)
		{
		}

		public BlockEnd(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class BlockEntry : Token
	{
		public BlockEntry()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		public BlockEntry(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class BlockMappingStart : Token
	{
		public BlockMappingStart()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		public BlockMappingStart(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class BlockSequenceStart : Token
	{
		public BlockSequenceStart()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		public BlockSequenceStart(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	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)
		{
		}

		public DocumentEnd(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class DocumentStart : Token
	{
		public DocumentStart()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		public DocumentStart(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	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)
		{
		}

		public FlowEntry(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class FlowMappingEnd : Token
	{
		public FlowMappingEnd()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		public FlowMappingEnd(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class FlowMappingStart : Token
	{
		public FlowMappingStart()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		public FlowMappingStart(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class FlowSequenceEnd : Token
	{
		public FlowSequenceEnd()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		public FlowSequenceEnd(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class FlowSequenceStart : Token
	{
		public FlowSequenceStart()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		public FlowSequenceStart(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class Key : Token
	{
		public Key()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		public Key(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	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)
		{
		}

		public StreamEnd(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	internal sealed class StreamStart : Token
	{
		public StreamStart()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		public StreamStart(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	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");
		}
	}
	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;
		}

		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;
		}
	}
	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)
		{
		}

		public Value(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
	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;
		}

		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
{
	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);
		}
	}
	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 + "]";
		}
	}
	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);
		}
	}
	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; }

		public DocumentStart(VersionDirective? version, 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)
		{
		}

		public DocumentStart(Mark start, Mark end)
			: this(null, null, isImplicit: true, start, end)
		{
		}

		public DocumentStart()
			: this(null, null, isImplicit: true, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Document start [isImplicit = {IsImplicit}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum EventType
	{
		None,
		StreamStart,
		StreamEnd,
		DocumentStart,
		DocumentEnd,
		Alias,
		Scalar,
		SequenceStart,
		SequenceEnd,
		MappingStart,
		MappingEnd,
		Comment
	}
	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);
	}
	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);
		}
	}
	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; }

		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)
		{
		}
	}
	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");
		}
	}
	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);
		}
	}
	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);
		}
	}
	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
	}
	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);
		}
	}
	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);
		}
	}
}