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.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using APIManager;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Preloader;
using BepInEx.Preloader.Patching;
using HarmonyLib;
using JetBrains.Annotations;
using LocalizationManager;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Collections.Generic;
using ServerSync;
using Splatform;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Core.ObjectPool;
using YamlDotNet.Core.Tokens;
using YamlDotNet.Helpers;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.BufferedDeserialization;
using YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators;
using YamlDotNet.Serialization.Callbacks;
using YamlDotNet.Serialization.Converters;
using YamlDotNet.Serialization.EventEmitters;
using YamlDotNet.Serialization.NamingConventions;
using YamlDotNet.Serialization.NodeDeserializers;
using YamlDotNet.Serialization.NodeTypeResolvers;
using YamlDotNet.Serialization.ObjectFactories;
using YamlDotNet.Serialization.ObjectGraphTraversalStrategies;
using YamlDotNet.Serialization.ObjectGraphVisitors;
using YamlDotNet.Serialization.Schemas;
using YamlDotNet.Serialization.TypeInspectors;
using YamlDotNet.Serialization.TypeResolvers;
using YamlDotNet.Serialization.Utilities;
using YamlDotNet.Serialization.ValueDeserializers;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Guilds")]
[assembly: AssemblyDescription("https://valheim.thunderstore.io/package/Smoothbrain/Guilds")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Guilds")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("4090002D-833C-47D1-B33D-2AD719E969F5")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Guilds
{
	[PublicAPI]
	public static class API
	{
		public delegate void AchievementCompleted(PlayerReference player, string achievment);

		public delegate void GuildJoined(Guild guild, PlayerReference player);

		public delegate void GuildLeft(Guild guild, PlayerReference player);

		public delegate void GuildCreated(Guild guild);

		public delegate void GuildDeleted(Guild guild);

		public static List<GuildJoined> OnGuildJoined = new List<GuildJoined>();

		public static List<GuildLeft> OnGuildLeft = new List<GuildLeft>();

		public static List<GuildCreated> OnGuildCreated = new List<GuildCreated>();

		public static List<GuildDeleted> OnGuildDeleted = new List<GuildDeleted>();

		public static bool IsLoaded()
		{
			return true;
		}

		public static Guild? GetPlayerGuild(PlayerReference player)
		{
			KeyValuePair<string, Guild> keyValuePair = GuildList.guildList.FirstOrDefault<KeyValuePair<string, Guild>>((KeyValuePair<string, Guild> s) => s.Value.Members.ContainsKey(player));
			if (!Utility.IsNullOrWhiteSpace(keyValuePair.Key))
			{
				return keyValuePair.Value;
			}
			return null;
		}

		public static Guild? GetPlayerGuild(Player player)
		{
			return GetPlayerGuild(PlayerReference.fromPlayer(player));
		}

		public static Guild? GetOwnGuild()
		{
			return GetPlayerGuild(PlayerReference.forOwnPlayer());
		}

		public static Guild? GetGuild(string name)
		{
			if (GuildList.guildList.TryGetValue(name, out Guild value))
			{
				return value;
			}
			return null;
		}

		public static Guild? GetGuild(int id)
		{
			if (GuildList.guildsById.TryGetValue(id, out Guild value))
			{
				return value;
			}
			return null;
		}

		public static List<Guild> GetGuilds()
		{
			return GuildList.guildList.Values.ToList();
		}

		public static PlayerReference GetGuildLeader(Guild guild)
		{
			return guild.Members.FirstOrDefault<KeyValuePair<PlayerReference, GuildMember>>((KeyValuePair<PlayerReference, GuildMember> r) => r.Value.rank == Ranks.Leader).Key;
		}

		public static Guild? CreateGuild(string name, PlayerReference leader)
		{
			if (GuildList.guildList.TryGetValue(name, out Guild _))
			{
				return null;
			}
			int id = GuildList.guildsById.Keys.DefaultIfEmpty().Max() + 1;
			Guild guild = new Guild
			{
				General = new GuildGeneral
				{
					id = id
				},
				Name = name
			};
			guild.Members.Add(leader, new GuildMember
			{
				rank = Ranks.Leader
			});
			GuildList.guildList[name] = guild;
			GuildList.updateGuild(name);
			return guild;
		}

		public static bool DeleteGuild(Guild guild)
		{
			if (GuildList.guildList.ContainsKey(guild.Name))
			{
				GuildList.removeGuild(guild.Name);
				return true;
			}
			return false;
		}

		public static bool RenameGuild(Guild guild, string newName)
		{
			if (GuildList.guildList.ContainsKey(newName))
			{
				return false;
			}
			GuildList.guildList[newName] = GuildList.guildList[guild.Name];
			GuildList.guildList.Remove(guild.Name);
			GuildList.renameGuild(guild.Name, newName);
			return true;
		}

		public static bool SaveGuild(Guild guild)
		{
			if (GuildList.guildList.ContainsKey(guild.Name))
			{
				GuildList.guildList[guild.Name] = guild;
				GuildList.updateGuild(guild.Name);
				return true;
			}
			return false;
		}

		public static bool AddPlayerToGuild(PlayerReference player, Guild guild)
		{
			if (GetPlayerGuild(player) == null)
			{
				guild.Members.Add(player, new GuildMember());
				SaveGuild(guild);
				InvokeGuildJoined(guild, player);
				return true;
			}
			return false;
		}

		public static bool RemovePlayerFromGuild(PlayerReference player)
		{
			Guild playerGuild = GetPlayerGuild(player);
			if (playerGuild != null)
			{
				playerGuild.Members.Remove(player);
				SaveGuild(playerGuild);
				InvokeGuildLeft(playerGuild, player);
				return true;
			}
			return false;
		}

		public static Ranks GetPlayerRank(PlayerReference player)
		{
			return GetPlayerGuild(player)?.Members[player].rank ?? Ranks.Leader;
		}

		public static bool UpdatePlayerRank(PlayerReference player, Ranks newRank)
		{
			Guild playerGuild = GetPlayerGuild(player);
			if (playerGuild != null)
			{
				GuildMember guildMember = playerGuild.Members[player];
				guildMember.rank = newRank;
				playerGuild.Members[player] = guildMember;
				SaveGuild(playerGuild);
				return true;
			}
			return false;
		}

		public static IEnumerable<PlayerReference> GetOnlinePlayers(Guild? guild = null)
		{
			HashSet<PlayerReference> hashSet = new HashSet<PlayerReference>(ZNet.instance.m_players.Select(PlayerReference.fromPlayerInfo));
			if (guild != null)
			{
				return guild.Members.Keys.Where(hashSet.Contains);
			}
			foreach (PlayerReference item in GetGuilds().SelectMany((Guild g) => g.Members.Keys))
			{
				hashSet.Remove(item);
			}
			return hashSet;
		}

		public static Guild? GetOwnAppliedGuild()
		{
			return GetPlayerAppliedGuild(PlayerReference.forOwnPlayer());
		}

		public static Guild? GetPlayerAppliedGuild(PlayerReference player)
		{
			return GuildList.guildList.FirstOrDefault<KeyValuePair<string, Guild>>((KeyValuePair<string, Guild> s) => s.Value.Applications.ContainsKey(player)).Value;
		}

		public static bool ApplyToGuild(PlayerReference player, string description, Guild guild)
		{
			RemovePlayerApplication(player);
			guild.Applications[player] = new Application
			{
				description = description
			};
			return SaveGuild(guild);
		}

		public static bool RemovePlayerApplication(PlayerReference player, Guild? guild = null)
		{
			Guild playerAppliedGuild = GetPlayerAppliedGuild(player);
			if (playerAppliedGuild != null && (guild == null || playerAppliedGuild == guild))
			{
				playerAppliedGuild.Applications.Remove(player);
				return SaveGuild(playerAppliedGuild);
			}
			return true;
		}

		public static void RegisterCustomData(Type type)
		{
			CustomDataConverter.RegisteredCustomTypes.Add(type.FullName, type);
		}

		public static T? GetCustomData<T>(Guild guild) where T : class
		{
			guild.customData.data.TryGetValue(typeof(T), out object value);
			return (T)value;
		}

		public static void SetCustomData<T>(Guild guild, T customData) where T : class
		{
			guild.customData.data[typeof(T)] = customData;
		}

		public static void IncreaseAchievementProgress(Guild guild, string achievement, float increment = 1f)
		{
			if (guild.Achievements.TryGetValue(achievement, out AchievementData value))
			{
				float? progress = value.progress;
				if (!progress.HasValue)
				{
					return;
				}
			}
			GuildList.increaseAchievement(guild.General.id, achievement, increment);
		}

		public static void RegisterOnAchievementCompleted(AchievementCompleted callback)
		{
			Achievements.achievementCompletedCallbacks.Add(callback);
		}

		public static void RegisterAchievement(string name, AchievementConfig config)
		{
			Achievements.dynamicAchievementConfigs.Add(name, config);
		}

		internal static AchievementConfig? GetAchievementConfig(string achievement)
		{
			return Achievements.GetAchievementConfig(achievement);
		}

		internal static IEnumerable<KeyValuePair<string, AchievementConfig>> AllAchievementConfigs()
		{
			return Achievements.AllAchievementConfigs();
		}

		public static Sprite? GetGuildIcon(Guild guild)
		{
			if (!Interface.GuildIcons.TryGetValue(guild.General.icon, out Sprite value))
			{
				return Interface.GuildIcons[1];
			}
			return value;
		}

		public static Sprite? GetGuildIconById(int iconId)
		{
			if (!Interface.GuildIcons.TryGetValue(iconId, out Sprite value))
			{
				return Interface.GuildIcons[1];
			}
			return value;
		}

		public static int GetAchievementStage(Guild guild, AchievementConfig achievement)
		{
			if (guild.Achievements.TryGetValue(achievement.name, out AchievementData value))
			{
				return value.completed.Count;
			}
			return 0;
		}

		public static void RegisterOnGuildJoined(GuildJoined callback)
		{
			OnGuildJoined.Add(callback);
		}

		public static void RegisterOnGuildLeft(GuildLeft callback)
		{
			OnGuildLeft.Add(callback);
		}

		public static void RegisterOnGuildCreated(GuildCreated callback)
		{
			OnGuildCreated.Add(callback);
		}

		public static void RegisterOnGuildDeleted(GuildDeleted callback)
		{
			OnGuildDeleted.Add(callback);
		}

		internal static void InvokeGuildJoined(Guild guild, PlayerReference player)
		{
			Guild guild2 = guild;
			OnGuildJoined.ForEach(delegate(GuildJoined cb)
			{
				cb(guild2, player);
			});
		}

		internal static void InvokeGuildLeft(Guild guild, PlayerReference player)
		{
			Guild guild2 = guild;
			OnGuildLeft.ForEach(delegate(GuildLeft cb)
			{
				cb(guild2, player);
			});
		}

		internal static void InvokeGuildCreated(Guild guild)
		{
			Guild guild2 = guild;
			OnGuildCreated.ForEach(delegate(GuildCreated cb)
			{
				cb(guild2);
			});
		}

		internal static void InvokeGuildDeleted(Guild guild)
		{
			Guild guild2 = guild;
			OnGuildDeleted.ForEach(delegate(GuildDeleted cb)
			{
				cb(guild2);
			});
		}
	}
	[PublicAPI]
	public class Guild
	{
		public string Name = "";

		public GuildGeneral General = new GuildGeneral();

		public Dictionary<PlayerReference, GuildMember> Members = new Dictionary<PlayerReference, GuildMember>();

		public Dictionary<PlayerReference, Application> Applications = new Dictionary<PlayerReference, Application>();

		public Dictionary<string, AchievementData> Achievements = new Dictionary<string, AchievementData>();

		public CustomData customData = new CustomData();
	}
	[PublicAPI]
	public class GuildMember
	{
		public Ranks rank = Ranks.Member;

		[<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMember(Alias = "last online", ApplyNamingConventions = false)]
		public DateTime lastOnline = DateTime.Now;

		public Dictionary<int, Dictionary<string, int>> contribution = new Dictionary<int, Dictionary<string, int>>();
	}
	[PublicAPI]
	public class GuildGeneral
	{
		public int id;

		public string description = "";

		[<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMember(Alias = "icon id", ApplyNamingConventions = false)]
		public int icon = 1;

		public int level;

		[<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMember(Alias = "guild color", ApplyNamingConventions = false)]
		public string color = "";
	}
	[PublicAPI]
	public class Application
	{
		public DateTime applied = DateTime.Now;

		public string description = "";
	}
	[PublicAPI]
	public class AchievementData
	{
		public float? progress = 0f;

		public List<DateTime> completed = new List<DateTime>();
	}
	[PublicAPI]
	public class CustomData
	{
		internal Dictionary<Type, object> data = new Dictionary<Type, object>();

		internal Dictionary<string, object> unknown = new Dictionary<string, object>();
	}
	[PublicAPI]
	public class AchievementConfig
	{
		public string name = "";

		public string description = "";

		public List<float> progress = new List<float> { 1f };

		public List<int>? guild;

		public List<int> level = new List<int>();

		public string icon = "";

		public bool first;

		public Dictionary<string, string> config = new Dictionary<string, string>();

		public T getConfigValue<T>(string name, T defaultValue = default(T))
		{
			if (config.TryGetValue(name, out string value))
			{
				if (typeof(T) == typeof(int))
				{
					if (int.TryParse(value, out var result))
					{
						return (T)(object)result;
					}
				}
				else
				{
					if (!(typeof(T) == typeof(float)))
					{
						return (T)(object)value;
					}
					if (float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
					{
						return (T)(object)result2;
					}
				}
			}
			return defaultValue;
		}

		internal int GetLevel(int completed)
		{
			if (completed > level.Count)
			{
				return level.Max();
			}
			return level[completed - 1];
		}

		internal Sprite? GetIcon()
		{
			if (!Interface.AchievementIcons.TryGetValue(icon, out Sprite value))
			{
				return null;
			}
			return value;
		}
	}
	[PublicAPI]
	[TypeConverter(typeof(PlayerReferenceTypeConverter))]
	public struct PlayerReference
	{
		public string id;

		public string name;

		public static PlayerReference fromPlayerInfo(PlayerInfo playerInfo)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			PlayerReference result = default(PlayerReference);
			result.id = ((object)(PlatformUserID)(ref playerInfo.m_userInfo.m_id)).ToString();
			result.name = playerInfo.m_name ?? "";
			return result;
		}

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

		public static PlayerReference forOwnPlayer()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			PlayerReference result = default(PlayerReference);
			IDistributionPlatform distributionPlatform = PlatformManager.DistributionPlatform;
			object obj;
			if (distributionPlatform == null)
			{
				obj = null;
			}
			else
			{
				PlatformUserID platformUserID = ((IUser)distributionPlatform.LocalUser).PlatformUserID;
				obj = ((object)(PlatformUserID)(ref platformUserID)).ToString();
			}
			if (obj == null)
			{
				obj = "";
			}
			result.id = (string)obj;
			result.name = Game.instance.GetPlayerProfile().GetName();
			return result;
		}

		public static PlayerReference fromRPC(ZRpc? rpc)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			ZRpc rpc2 = rpc;
			if (rpc2 != null)
			{
				return fromPlayerInfo(ZNet.instance.m_players.First((PlayerInfo p) => ((object)(PlatformUserID)(ref p.m_userInfo.m_id)).ToString().EndsWith(rpc2.m_socket.GetHostName())));
			}
			return forOwnPlayer();
		}

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

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

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

		public override bool Equals(object? obj)
		{
			if (obj is PlayerReference other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return (id.GetHashCode() * 397) ^ name.GetHashCode();
		}

		public override string ToString()
		{
			return id + ":" + name;
		}

		public static PlayerReference fromString(string str)
		{
			string[] array = str.Split(new char[1] { ':' });
			PlayerReference result = default(PlayerReference);
			result.id = array[0];
			result.name = array[1];
			return result;
		}
	}
	public class PlayerReferenceTypeConverter : System.ComponentModel.TypeConverter
	{
		public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object? value)
		{
			return PlayerReference.fromString(value?.ToString() ?? ":");
		}
	}
	public enum Toggle
	{
		On = 1,
		Off = 0
	}
	public enum Ranks
	{
		Leader,
		Coleader,
		Officer,
		Member
	}
	public class AchievementStorage
	{
		public readonly Dictionary<string, DateTime> lastBossKillTimes = new Dictionary<string, DateTime>();

		public readonly List<string> guildBossKills = new List<string>();

		[<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlIgnore]
		private Guild? guild;

		public static AchievementStorage get(Guild? guild = null)
		{
			if (guild == null)
			{
				guild = API.GetOwnGuild();
			}
			if (guild != null)
			{
				AchievementStorage customData = API.GetCustomData<AchievementStorage>(guild);
				if (customData != null)
				{
					customData.guild = guild;
					return customData;
				}
				customData = new AchievementStorage
				{
					guild = guild
				};
				API.SetCustomData(guild, customData);
				return customData;
			}
			return new AchievementStorage();
		}

		public void Save()
		{
			if (guild != null)
			{
				API.SetCustomData(guild, this);
			}
		}
	}
	public static class Achievements
	{
		[HarmonyPatch(typeof(PlayerProfile), "IncrementStat")]
		private static class IncreaseGuildAchievementProgress
		{
			private static void Postfix(PlayerStatType stat, float amount)
			{
				Guild ownGuild = API.GetOwnGuild();
				if (ownGuild != null)
				{
					API.IncreaseAchievementProgress(ownGuild, ((object)(PlayerStatType)(ref stat)).ToString().ToLowerInvariant(), amount);
				}
			}
		}

		private static readonly CustomSyncedValue<string> achievementConfigData = new CustomSyncedValue<string>(Guilds.configSync, "achievementConfig", "");

		private static Dictionary<string, AchievementConfig> achievementConfigs = new Dictionary<string, AchievementConfig>();

		internal static readonly Dictionary<string, AchievementConfig> dynamicAchievementConfigs = new Dictionary<string, AchievementConfig>();

		private static string achievementConfigPath = null;

		internal static readonly List<API.AchievementCompleted> achievementCompletedCallbacks = new List<API.AchievementCompleted>();

		internal static void Init()
		{
			string? directoryName = Path.GetDirectoryName(((BaseUnityPlugin)Guilds.self).Config.ConfigFilePath);
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			achievementConfigPath = directoryName + directorySeparatorChar + "AchievementConfig.yml";
			achievementConfigData.ValueChanged += ConfigChanged;
			Guilds.guildAchievementConfig.SettingChanged += delegate
			{
				ConfigChanged();
			};
			readAchievementConfigFile();
			Guilds.addFileWatchEvent(new FileSystemWatcher(Path.GetDirectoryName(achievementConfigPath), Path.GetFileName(achievementConfigPath)), delegate
			{
				readAchievementConfigFile();
			});
			API.RegisterOnAchievementCompleted(delegate(PlayerReference player, string achievement)
			{
				AchievementConfig achievementConfig = GetAchievementConfig(achievement);
				if (achievementConfig != null)
				{
					Guild ownGuild = API.GetOwnGuild();
					if (ownGuild != null && ownGuild.Members.ContainsKey(player) && ownGuild.Achievements.TryGetValue(achievement, out AchievementData value))
					{
						AchievementPopup.Queue(player, achievementConfig, value.completed.Count);
					}
				}
			});
			static void ConfigChanged()
			{
				if (Guilds.guildAchievementConfig.Value == Guilds.GuildAchievements.Disabled)
				{
					achievementConfigs = new Dictionary<string, AchievementConfig>();
					return;
				}
				try
				{
					Dictionary<string, AchievementConfig> dictionary = deserializeConfig(achievementConfigData.Value);
					if (Guilds.guildAchievementConfig.Value != Guilds.GuildAchievements.External)
					{
						achievementConfigs = deserializeConfig(Encoding.UTF8.GetString(Tools.ReadEmbeddedFileBytes("AchievementConfig.yml")));
						{
							foreach (KeyValuePair<string, AchievementConfig> item in dictionary)
							{
								achievementConfigs[item.Key] = item.Value;
							}
							return;
						}
					}
					achievementConfigs = dictionary;
				}
				catch (Exception arg)
				{
					Debug.LogError((object)$"Failed to deserialize achievementConfig: {arg}");
				}
			}
		}

		private static Dictionary<string, AchievementConfig> deserializeConfig(string data)
		{
			Dictionary<string, AchievementConfig> dictionary = new Dictionary<string, AchievementConfig>(new <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder().WithNamingConvention(<cba6ec40-2546-4a46-9577-18d27987fd9e>CamelCaseNamingConvention.Instance).Build().Deserialize<Dictionary<string, AchievementConfig>>(data) ?? new Dictionary<string, AchievementConfig>(), StringComparer.InvariantCultureIgnoreCase);
			foreach (AchievementConfig value in dictionary.Values)
			{
				AchievementConfig current;
				AchievementConfig achievementConfig = (current = value);
				if (current.progress == null)
				{
					current.progress = new List<float> { 1f };
				}
				current = achievementConfig;
				if (current.level == null)
				{
					current.level = new List<int>();
				}
				current = achievementConfig;
				if (current.config == null)
				{
					current.config = new Dictionary<string, string>();
				}
			}
			return dictionary;
		}

		internal static AchievementConfig? GetAchievementConfig(string achievement)
		{
			if (!achievementConfigs.TryGetValue(achievement, out AchievementConfig value))
			{
				dynamicAchievementConfigs.TryGetValue(achievement, out value);
			}
			return value;
		}

		internal static IEnumerable<KeyValuePair<string, AchievementConfig>> AllAchievementConfigs()
		{
			return achievementConfigs.Concat(dynamicAchievementConfigs);
		}

		private static void readAchievementConfigFile()
		{
			achievementConfigData.AssignLocalValue(File.Exists(achievementConfigPath) ? File.ReadAllText(achievementConfigPath) : "");
		}
	}
	public static class AchievementTracker
	{
		[HarmonyPatch(typeof(Character), "OnDeath")]
		public static class TrackBossKills
		{
			private static void Prefix(Character __instance)
			{
				Guild ownGuild = API.GetOwnGuild();
				if (ownGuild == null || !bosses.Contains(Utils.GetPrefabName(((Component)__instance).gameObject)))
				{
					return;
				}
				AchievementStorage achievementStorage = AchievementStorage.get(ownGuild);
				if (!achievementStorage.guildBossKills.Contains(Utils.GetPrefabName(((Component)__instance).gameObject)))
				{
					AchievementConfig achievementConfig = API.GetAchievementConfig("Guild Boss Kills");
					if (achievementConfig != null && Tools.GetNearbyGuildMembers(Player.m_localPlayer, 40f, includeSelf: true).Count >= achievementConfig.getConfigValue("required members", 3))
					{
						achievementStorage.guildBossKills.Add(((Object)__instance).name);
						achievementStorage.Save();
						if (achievementStorage.guildBossKills.Count == bosses.Count)
						{
							API.IncreaseAchievementProgress(ownGuild, "Guild Boss Kills");
						}
					}
				}
				AchievementConfig timedKillsConfig = API.GetAchievementConfig("Guild Boss Kills Timed");
				if (timedKillsConfig != null)
				{
					if (achievementStorage.lastBossKillTimes.All<KeyValuePair<string, DateTime>>((KeyValuePair<string, DateTime> k) => k.Value < DateTime.Now.Subtract(new TimeSpan(0, 0, timedKillsConfig.getConfigValue("maximum time between kills", 10)))))
					{
						achievementStorage.lastBossKillTimes.Clear();
					}
					achievementStorage.lastBossKillTimes[((Object)__instance).name] = DateTime.Now;
					if (achievementStorage.lastBossKillTimes.Count == bosses.Count)
					{
						API.IncreaseAchievementProgress(ownGuild, "Guild Boss Kills Timed");
					}
					achievementStorage.Save();
				}
			}
		}

		[HarmonyPatch(typeof(Trader), "Interact")]
		private static class TrackTraderDiscovery
		{
			private static void Postfix(Trader __instance)
			{
				Guild ownGuild = API.GetOwnGuild();
				if (ownGuild != null)
				{
					if (Utils.GetPrefabName(((Component)__instance).gameObject) == "Haldor")
					{
						API.IncreaseAchievementProgress(ownGuild, "Found Haldor");
					}
					if (Utils.GetPrefabName(((Component)__instance).gameObject) == "Hildir")
					{
						API.IncreaseAchievementProgress(ownGuild, "Found Hildir");
					}
				}
			}
		}

		[HarmonyPatch(typeof(Trader), "OnBought")]
		private static class TrackCoinsSpend
		{
			private static void Postfix(TradeItem item)
			{
				Guild ownGuild = API.GetOwnGuild();
				if (ownGuild != null)
				{
					API.IncreaseAchievementProgress(ownGuild, "Spend Coins", item.m_price);
				}
			}
		}

		private static readonly List<string> bosses = new List<string> { "Eikthyr", "gd_king", "Bonemass", "Dragon", "GoblinKing", "SeekerQueen", "Fader" };
	}
	[PublicAPI]
	public class AchievementPopup : MonoBehaviour
	{
		private struct QueuedPopup
		{
			public PlayerReference Player;

			public AchievementConfig Config;

			public int Level;
		}

		[CompilerGenerated]
		private sealed class <<Queue>g__Dequeue|41_0>d : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public AchievementPopup <>4__this;

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

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

			[DebuggerHidden]
			public <<Queue>g__Dequeue|41_0>d(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: Expected O, but got Unknown
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Expected O, but got Unknown
				int num = <>1__state;
				AchievementPopup achievementPopup = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					achievementPopup.Hide();
					<>2__current = (object)new WaitForSeconds(2f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					break;
				}
				if (achievementPopup.queue.Count > 0)
				{
					QueuedPopup queuedPopup = achievementPopup.queue.Dequeue();
					achievementPopup.achievementIconImg.sprite = queuedPopup.Config.GetIcon() ?? achievementPopup.defaultIcon;
					((TMP_Text)achievementPopup.aiDescription).text = queuedPopup.Config.name;
					((TMP_Text)achievementPopup.guildLevelText).text = queuedPopup.Config.GetLevel(queuedPopup.Level).ToString();
					achievementPopup.Show();
					<>2__current = (object)new WaitForSeconds(5f);
					<>1__state = 1;
					return true;
				}
				((Component)achievementPopup).gameObject.SetActive(false);
				return false;
			}

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

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

		[Header("Row Root")]
		public RectTransform rowRootTransform;

		public AchievementPopup rowInstance;

		public GameObject rowRootGameObject;

		public RectTransform back;

		public Image backImage;

		public Image borderImage;

		public GameObject rowNotCompleted;

		[Header("Content Area")]
		public RectTransform contentAreaRectTransform;

		[Header("Left Column")]
		public RectTransform leftColumnRect;

		public HorizontalLayoutGroup leftColumnHLayoutGroup;

		[Header("Left Column - Icon Container")]
		public RectTransform achievementIconContainerRect;

		public Image achievementIconContainerImg;

		public RectTransform achievementIconImgRect;

		public RectTransform achievementIconBorderRect;

		public Image achievementIconBorderImg;

		public Image achievementIconImg;

		[Header("Right Column - Rank Area")]
		public RectTransform rightCol;

		public Image rightColBg;

		public RectTransform rightColIconContainer;

		public Image rightColIconContainerSelectedIcon;

		public Image rightColIconcontainerBorder;

		public RectTransform guildLevelRect;

		public TextMeshProUGUI guildLevelText;

		[Header("Right Column - AchievementInformation")]
		public RectTransform aiRect;

		public RectTransform aiHeader;

		public HorizontalLayoutGroup aiHeaderHLG;

		public TextMeshProUGUI aiHeaderTitle;

		public TextMeshProUGUI aiHeaderDate;

		public TextMeshProUGUI aiDescription;

		public RectTransform progressBar;

		public Image progressBarBg;

		public Image progressBarBgGreen;

		public TextMeshProUGUI progressText;

		[Header("Animator")]
		public Animator animatorComp;

		public Sprite defaultIcon;

		private Queue<QueuedPopup> queue = new Queue<QueuedPopup>();

		public void Awake()
		{
			//IL_0018: 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)
			RectTransform component = ((Component)this).GetComponent<RectTransform>();
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0.5f, 0.25f);
			component.anchorMax = val;
			component.anchorMin = val;
			defaultIcon = achievementIconImg.sprite;
		}

		public void Show()
		{
			animatorComp.SetBool("visible", true);
		}

		public void Hide()
		{
			if (animatorComp.GetBool("visible"))
			{
				animatorComp.SetBool("visible", false);
			}
		}

		public static void Queue(PlayerReference player, AchievementConfig config, int level)
		{
			if (Object.op_Implicit((Object)(object)Interface.AchievementPopup))
			{
				Interface.AchievementPopup.GetComponent<AchievementPopup>().Queue(new QueuedPopup
				{
					Player = player,
					Config = config,
					Level = level
				});
			}
		}

		private void Queue(QueuedPopup popup)
		{
			queue.Enqueue(popup);
			if (!((Component)this).gameObject.activeSelf)
			{
				((Component)this).gameObject.SetActive(true);
				((MonoBehaviour)this).StartCoroutine(Dequeue());
			}
			[IteratorStateMachine(typeof(<<Queue>g__Dequeue|41_0>d))]
			IEnumerator Dequeue()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <<Queue>g__Dequeue|41_0>d(0)
				{
					<>4__this = this
				};
			}
		}
	}
	[PublicAPI]
	public class AchievementUI : MonoBehaviour
	{
		public Canvas canvas;

		public RectTransform root;

		public Image BackgroundBack;

		public Button ButtonClose;

		public Image ButtonCloseImage;

		public TextMeshProUGUI ButtonCloseTMP;

		public Image Background;

		public RectTransform Header;

		public HorizontalLayoutGroup HeaderHLG;

		public Image HeaderImageLeft;

		public Image HeaderImageRight;

		public TextMeshProUGUI HeaderTMP;

		public RectTransform content;

		public ScrollRect contentScrollRect;

		public Image contentScrollRectImage;

		public RectTransform contentList;

		public VerticalLayoutGroup contentListVLG;

		public ContentSizeFitter contentListContentSizeFitter;

		public TextMeshProUGUI guildLevel;

		public TextMeshProUGUI achievementsCompleted;

		[Header("Placeholder")]
		public RectTransform RowPlaceholder;

		public AchievementUIRow PlaceholderInstance;

		public RectTransform PlaceholderBack;

		public RectTransform PlaceholderBackBg;

		public RectTransform PlaceholderBackBgImg;

		public RectTransform PlaceholderBackBorder;

		public RectTransform PlaceholderBackBorderImg;

		public RectTransform PlaceholderContent;

		public RectTransform PlaceholderContentLeftCol;

		public HorizontalLayoutGroup PlaceholderContentLeftColHLG;

		public RectTransform PlaceholderContentLeftColIcon;

		public Image PlaceholderContentLeftColIconImage;

		public Image PlaceholderContentLeftColIconImageSelected;

		public Image PlaceholderContentLeftColIconImageBorder;

		public RectTransform PlaceholderContentRightColIcon;

		public Image PlaceholderContentRightColIconImage;

		public Image PlaceholderContentRightColIconImageSelected;

		public Image PlaceholderContentRightColIconImageBorder;

		public TextMeshProUGUI PlaceholderContentRightColIconGuildLevelTMP;

		public RectTransform PlaceholderContentAchievementInformationRect;

		public RectTransform PlaceholderContentAchievementInformationHeader;

		public HorizontalLayoutGroup PlaceholderContentAchievementInformationHeaderHLG;

		public TextMeshProUGUI PlaceholderContentAchievementInformationHeaderTitle;

		public TextMeshProUGUI PlaceholderContentAchievementInformationHeaderDate;

		public TextMeshProUGUI PlaceholderContentAchievementInformationHeaderDesc;

		public RectTransform PlaceholderContentAchievementInformationProgressBar;

		public Image PlaceholderContentAchievementInformationProgressBarBg;

		public Image PlaceholderContentAchievementInformationProgressBarGreen;

		public TextMeshProUGUI PlaceholderContentAchievementInformationProgressBarText;

		public RectTransform PlaceholderContentRightCol;

		public Image PlaceholderContentRightColBg;

		[Header("Content - Scroll")]
		public Scrollbar contentScrollbar;

		public RectTransform contentScrollbarSlidingArea;

		public Image contentScrollbarImage;

		public RectTransform contentScrollbarHandle;

		public Image contentScrollbarHandleImage;

		private List<AchievementUIRow> _activeRows = new List<AchievementUIRow>();

		private Queue<AchievementUIRow> _pooledRows = new Queue<AchievementUIRow>();

		public void OnEnable()
		{
			UpdateRows();
		}

		public void UpdateRows()
		{
			if (((Component)this).gameObject.activeSelf)
			{
				if (API.GetOwnGuild() == null)
				{
					Interface.SwitchUI(Interface.NoGuildUI);
				}
				else
				{
					PopulateRows(API.GetOwnGuild().Achievements);
				}
			}
		}

		public void PopulateRows(Dictionary<string, AchievementData> achievements)
		{
			int num = 0;
			foreach (AchievementUIRow activeRow in _activeRows)
			{
				((Component)activeRow).gameObject.SetActive(false);
				_pooledRows.Enqueue(activeRow);
			}
			_activeRows.Clear();
			foreach (KeyValuePair<string, AchievementConfig> kv in Achievements.AllAchievementConfigs())
			{
				if (achievements.TryGetValue(kv.Key, out AchievementData value) && value.completed.Count >= kv.Value.progress.Count)
				{
					num++;
				}
				if (!kv.Value.first || (value?.completed.Count ?? 0) >= 1 || !GuildList.guildList.Values.Any((Guild g) => g.Achievements.TryGetValue(kv.Key, out AchievementData value2) && value2.completed.Count > 0))
				{
					AchievementUIRow row = GetRow();
					row.Setup(kv.Value, value);
					_activeRows.Add(row);
				}
			}
			((TMP_Text)guildLevel).text = Localization.instance.Localize("$guilds_guildlevel", new string[1] { API.GetOwnGuild().General.level.ToString() });
			((TMP_Text)achievementsCompleted).text = Localization.instance.Localize("$guilds_achievements_completed", new string[1] { num.ToString() });
		}

		private AchievementUIRow GetRow()
		{
			AchievementUIRow obj = ((_pooledRows.Count > 0) ? _pooledRows.Dequeue() : Object.Instantiate<GameObject>(((Component)RowPlaceholder).gameObject, (Transform)(object)contentList).GetComponent<AchievementUIRow>());
			((Component)obj).gameObject.SetActive(true);
			return obj;
		}

		private void ReturnRowToPool(AchievementUIRow row)
		{
			((Component)row).gameObject.SetActive(false);
			_pooledRows.Enqueue(row);
		}

		public void OnButtonClosed_Clicked()
		{
			Interface.HideUI();
		}

		public void OnButtonGoBack_Clicked()
		{
			Interface.SwitchUI(Interface.GuildManagementUI);
		}
	}
	[PublicAPI]
	public class AchievementUIRow : MonoBehaviour
	{
		[Header("Row Root")]
		public RectTransform rowRootTransform;

		public AchievementUIRow rowInstance;

		public GameObject rowRootGameObject;

		public RectTransform back;

		public Image backImage;

		public Image borderImage;

		public GameObject rowNotCompleted;

		[Header("Content Area")]
		public RectTransform contentAreaRectTransform;

		[Header("Left Column")]
		public RectTransform leftColumnRect;

		public HorizontalLayoutGroup leftColumnHLayoutGroup;

		[Header("Left Column - Icon Container")]
		public RectTransform achievementIconContainerRect;

		public Image achievementIconContainerImg;

		public RectTransform achievementIconImgRect;

		public RectTransform achievementIconBorderRect;

		public Image achievementIconBorderImg;

		public Image achievementIconImg;

		[Header("Right Column - Rank Area")]
		public RectTransform rightCol;

		public Image rightColBg;

		public RectTransform rightColIconContainer;

		public Image rightColIconContainerSelectedIcon;

		public Image rightColIconcontainerBorder;

		public RectTransform guildLevelRect;

		public TextMeshProUGUI guildLevelText;

		[Header("Right Column - AchievementInformation")]
		public RectTransform aiRect;

		public RectTransform aiHeader;

		public HorizontalLayoutGroup aiHeaderHLG;

		public TextMeshProUGUI aiHeaderTitle;

		public TextMeshProUGUI aiHeaderDate;

		public TextMeshProUGUI aiDescription;

		public RectTransform progressBar;

		public Image progressBarBg;

		public Image progressBarBgGreen;

		public TextMeshProUGUI progressText;

		public Sprite defaultIcon;

		public void Awake()
		{
			defaultIcon = achievementIconImg.sprite;
		}

		public void Setup(AchievementConfig config, AchievementData? data)
		{
			if (data == null)
			{
				data = new AchievementData();
			}
			int num = Math.Min(data.completed.Count, config.progress.Count - 1);
			float num2 = config.progress[num];
			((TMP_Text)aiDescription).text = config.config.Aggregate<KeyValuePair<string, string>, string>(Localization.instance.Localize(config.description), (string text, KeyValuePair<string, string> kv) => text.Replace("{" + kv.Key + "}", kv.Value));
			((TMP_Text)aiHeaderTitle).text = config.name;
			achievementIconImg.sprite = config.GetIcon() ?? defaultIcon;
			((TMP_Text)guildLevelText).text = config.GetLevel(num + 1).ToString();
			((Component)progressBar).gameObject.SetActive(num2 > 1f);
			if (config.progress.Count > data.completed.Count)
			{
				float? progress = data.progress;
				if (progress.HasValue)
				{
					progressBarBgGreen.fillAmount = data.progress.Value / num2;
					((TMP_Text)progressText).text = $"{data.progress} / {num2}";
					goto IL_0182;
				}
			}
			float num3 = config.progress.Last();
			progressBarBgGreen.fillAmount = 1f;
			((TMP_Text)progressText).text = $"{num3} / {num3}";
			goto IL_0182;
			IL_0182:
			((TMP_Text)aiHeaderDate).text = ((data.completed.Count > 0) ? data.completed.Last().ToString("yyyy-MM-dd HH:mm") : "");
			rowNotCompleted.SetActive(data.completed.Count == 0);
		}
	}
	[PublicAPI]
	public class ApplicationsUI : MonoBehaviour
	{
		[Header("Placeholder Variables")]
		public ApplicationsUIRow rowPlaceHolderPrefab;

		public Transform rowPlaceHolderParentList;

		public List<ApplicationsUIRow> rowElements;

		[Header("Root UI")]
		public RectTransform rootTransform;

		public Image backgroundBack;

		public Image background;

		[Header("Header UI")]
		public RectTransform headerTransform;

		public HorizontalLayoutGroup headerHlg;

		public Image headerImageLeft;

		public TextMeshProUGUI headerTextTMP;

		public Image headerImageRight;

		[Header("Close Button UI")]
		public Button buttonClose;

		public Image buttonCloseImage;

		public TextMeshProUGUI buttonCloseText;

		[Header("Content UI")]
		public RectTransform contentTransform;

		public ScrollRect contentScrollRect;

		public Image contentScrollRectImage;

		public RectTransform contentList;

		public VerticalLayoutGroup contentListVlg;

		public ContentSizeFitter contentListSizeFitter;

		[Header("Row Placeholder UI")]
		public RectTransform rowTransform;

		public Image rowBackImage;

		public Image rowBorderImage;

		public HorizontalLayoutGroup contentHlg;

		[Header("Row Content UI - Name Area")]
		public RectTransform nameAreaRect;

		public VerticalLayoutGroup nameAreaVlg;

		public TextMeshProUGUI nameAreaNameTextTMP;

		[Header("Row Content UI - WhyMe Area")]
		public RectTransform whyMeArea;

		public VerticalLayoutGroup whyMeAreaVlg;

		public Button whyMeButton;

		public Image whyMeButtonImg;

		public TextMeshProUGUI whyMeAreaText;

		[Header("Row Content UI - Applied Area")]
		public RectTransform appliedAreaRect;

		public VerticalLayoutGroup appliedAreaVlg;

		public TextMeshProUGUI appliedAreaAppliedStatusTextTMP;

		[Header("Row Content UI - Action Area")]
		public RectTransform actionArea;

		public Button actionAreaAcceptMemberButton;

		public Image actionAreaAcceptMemberButtonImage;

		public Image actionAreaAcceptMemberButtonCheckmark;

		public Button actionAreaDenyMemberButton;

		public TextMeshProUGUI actionAreaDenyMemberButtonTextTMP;

		public Image actionAreaDenyMemberButtonImage;

		[Header("Root UI Global Scrollbar")]
		public Scrollbar scrollbar;

		public RectTransform scrollbarRect;

		public RectTransform scrollbarSlidingArea;

		public RectTransform scrollbarHandle;

		public Image scrollbarHandleImage;

		[Header("Back Button")]
		public Button backButton;

		public Image backButtonImage;

		public TextMeshProUGUI backButtonText;

		[Header("Accept Guild Member Button")]
		public Button acceptGuildMemberButton;

		public Image acceptGuildMemberButtonImage;

		public Image acceptGuildMemberButtonCheckmark;

		[Header("Deny Guild Member Button")]
		public Button denyGuildMemberButton;

		public Image denyGuildMemberImage;

		public TextMeshProUGUI denyGuildMemberText;

		[Header("Popup")]
		public RectTransform popupRootRect;

		public RectTransform popupBkgBlocking;

		public Image popupBkgBlockingImg;

		public CanvasGroup popupCanvasGroup;

		public RectTransform popupBkg;

		public Image popupBkgImg;

		public RectTransform popupScrollviewRect;

		public ScrollRect popupScrollview;

		public Image popupScrollviewImage;

		public RectTransform popupViewport;

		public Image popupViewportImage;

		public RectTransform popupViewportContentRect;

		public RectTransform popupViewportContentBodyTextRect;

		public TextMeshProUGUI popupViewportContentBodyText;

		public RectTransform popupScrollbarRect;

		public Scrollbar popupScrollbar;

		public Image popupScrollbarImg;

		public RectTransform popupSlidingAreaRect;

		public RectTransform popupHandleRect;

		public Image popupHandleImg;

		public RectTransform popupHeaderTextRect;

		public TextMeshProUGUI popupHeaderText;

		public RectTransform popupButtonGroupRect;

		public HorizontalLayoutGroup popupButtonGroup;

		public RectTransform popupButtonOkRect;

		public Button popupButtonOk;

		public Image popupButtonOkImg;

		public RectTransform popupButtonOkTextRect;

		public Text popupButtonOkText;

		private List<ApplicationsUIRow> _activeRows = new List<ApplicationsUIRow>();

		private Queue<ApplicationsUIRow> _pooledRows = new Queue<ApplicationsUIRow>();

		public void OnEnable()
		{
			UpdateRows();
		}

		public void UpdateRows()
		{
			if (((Component)this).gameObject.activeSelf)
			{
				if (API.GetOwnGuild() == null)
				{
					Interface.SwitchUI(Interface.NoGuildUI);
				}
				else
				{
					PopulateRows(API.GetOwnGuild().Applications);
				}
			}
		}

		public void PopulateRows(Dictionary<PlayerReference, Application> members)
		{
			foreach (ApplicationsUIRow activeRow in _activeRows)
			{
				((Component)activeRow).gameObject.SetActive(false);
				_pooledRows.Enqueue(activeRow);
			}
			_activeRows.Clear();
			foreach (KeyValuePair<PlayerReference, Application> member in members)
			{
				ApplicationsUIRow row = GetRow();
				row.Setup(this, member.Key, member.Value);
				_activeRows.Add(row);
			}
		}

		private ApplicationsUIRow GetRow()
		{
			ApplicationsUIRow obj = ((_pooledRows.Count > 0) ? _pooledRows.Dequeue() : Object.Instantiate<GameObject>(((Component)rowPlaceHolderPrefab).gameObject, rowPlaceHolderParentList).GetComponent<ApplicationsUIRow>());
			((Component)obj).gameObject.SetActive(true);
			return obj;
		}

		private void ReturnRowToPool(ApplicationsUIRow row)
		{
			((Component)row).gameObject.SetActive(false);
			_pooledRows.Enqueue(row);
		}

		public void whyMeAreaClicked()
		{
		}

		public void OnButtonClosed_Clicked()
		{
			Interface.HideUI();
		}

		public void ButtonBackClicked()
		{
			Interface.SwitchUI(Interface.GuildManagementUI);
		}

		public void ButtonEditGuildClicked()
		{
		}

		public void ButtonApplicationsClicked()
		{
		}
	}
	[PublicAPI]
	public class ApplicationsUIRow : MonoBehaviour
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static PopupButtonCallback <0>__Pop;
		}

		private PlayerReference applicant;

		private Application application;

		private int guildId = -1;

		[Header("Row Root")]
		public RectTransform rowRootTransform;

		public GameObject rowRootGameObject;

		public RectTransform back;

		public Image backImage;

		public Image borderImage;

		[Header("Content Area")]
		public RectTransform contentAreaRectTransform;

		public HorizontalLayoutGroup contentAreaHorizontalLayoutGroup;

		[Header("Name Area")]
		public RectTransform nameAreaTransform;

		public VerticalLayoutGroup nameAreaVerticalLayoutGroup;

		public TextMeshProUGUI nameText;

		[Header("WhyMe Area")]
		public RectTransform whyMeArea;

		public VerticalLayoutGroup whyMeAreaVlg;

		public Button whyMeButton;

		public Image whyMeButtonImg;

		public TextMeshProUGUI whyMeAreaText;

		[Header("Applied Area")]
		public RectTransform appliedAreaTransform;

		public VerticalLayoutGroup appliedAreaLayoutGroup;

		public RectTransform statusTextTransform;

		public TextMeshProUGUI statusText;

		[Header("Action Area")]
		public RectTransform actionAreaTransform;

		public HorizontalLayoutGroup actionAreaLayoutGroup;

		public Button actionAreaAcceptMemberButton;

		public Image actionAreaAcceptMemberButtonImage;

		public Image actionAreaAcceptMemberButtonCheckmark;

		public Button actionAreaDenyMemberButton;

		public Image actionAreaDenyMemberButtonImage;

		public TextMeshProUGUI actionAreaDenyMemberButtonTextTMP;

		public ApplicationsUI applicationsUI;

		public void Setup(ApplicationsUI applicationsUI, PlayerReference applicant, Application application)
		{
			this.applicationsUI = applicationsUI;
			this.applicant = applicant;
			this.application = application;
			((TMP_Text)nameText).text = applicant.name;
			((TMP_Text)whyMeAreaText).text = application.description;
			((TMP_Text)statusText).text = Localization.instance.Localize("$guilds_apply_applied", new string[1] { Tools.GetHumanFriendlyTime((int)(DateTime.Now - application.applied).TotalSeconds) });
			guildId = API.GetOwnGuild().General.id;
		}

		public void OnDenyMember_ButtonClicked()
		{
			Guild guild = API.GetGuild(guildId);
			if (guild != null)
			{
				API.RemovePlayerApplication(applicant, guild);
				Guilds.SendMessageToPlayer(applicant, Localization.instance.Localize("$guilds_application_declined", new string[1] { guild.Name }));
			}
		}

		public void OnAcceptMember_ButtonClicked()
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			Guild guild = API.GetGuild(guildId);
			if (guild == null)
			{
				return;
			}
			if (Guilds.maximumGuildMembers.Value != 0 && guild.Members.Count >= Guilds.maximumGuildMembers.Value)
			{
				object obj = <>O.<0>__Pop;
				if (obj == null)
				{
					PopupButtonCallback val = UnifiedPopup.Pop;
					<>O.<0>__Pop = val;
					obj = (object)val;
				}
				UnifiedPopup.Push((PopupBase)new WarningPopup("$guilds_guild_full", "$guilds_guild_full_details", (PopupButtonCallback)obj, true));
			}
			else
			{
				API.RemovePlayerApplication(applicant, guild);
				guild = API.GetGuild(guildId);
				if (guild != null)
				{
					API.AddPlayerToGuild(applicant, guild);
					Guilds.SendMessageToPlayer(applicant, Localization.instance.Localize("$guilds_application_accepted", new string[1] { guild.Name }));
				}
			}
		}

		public void OnWhyMe_ButtonClicked()
		{
			((Component)applicationsUI.popupRootRect).gameObject.SetActive(true);
			((TMP_Text)applicationsUI.popupHeaderText).text = applicant.name;
			((TMP_Text)applicationsUI.popupViewportContentBodyText).text = application.description;
		}
	}
	[PublicAPI]
	public class ApplyUI : MonoBehaviour
	{
		public Guild guild;

		[Header("Root Objects")]
		public RectTransform root;

		public Image Background;

		public Image BackgroundBack;

		[Header("Close Button")]
		public Image BackgroundBackButtonImage;

		public Button BackgroundBackButton;

		public TextMeshProUGUI BackgroundBackButtonTextMeshProUGui;

		[Header("Header Area")]
		public RectTransform header;

		public HorizontalLayoutGroup headerHLayoutGroup;

		public Image headerLeftImage;

		public Image headerRightImage;

		public TextMeshProUGUI headerTMP;

		[Header("Content Area")]
		public RectTransform content;

		public HorizontalLayoutGroup contentHLayoutGroup;

		[Header("Content - Text Entry Area")]
		public RectTransform textArea;

		public VerticalLayoutGroup textAreaVLayoutGroup;

		public RectTransform textAreaContainerRect;

		public TMP_InputField textAreaInputField;

		public Image textAreaInputFieldBkg;

		public TextMeshProUGUI textareaInputPlaceholderText;

		public TextMeshProUGUI textAreaInputText;

		[Header("Content - Action Area")]
		public RectTransform actionAreaRect;

		public HorizontalLayoutGroup actionAreaHLayoutGroup;

		public Button actionAreaButtonCancel;

		public Image actionAreaButtonCancelImg;

		public TextMeshProUGUI actionAreaButtonCancelText;

		public Button actionAreaButtonApply;

		public Image actionAreaButtonApplyImg;

		public TextMeshProUGUI actionAreaButtonApplyText;

		public void Setup(Guild guild)
		{
			this.guild = guild;
			((TMP_Text)headerTMP).text = Localization.instance.Localize("$guilds_applyguildui_title", new string[1] { guild.Name });
		}

		public void OnButtonClose_Clicked()
		{
			Interface.HideUI();
		}

		public void OnButtonCancel_Clicked()
		{
			Interface.SwitchUI(Interface.SearchGuildUI);
		}

		public void OnButtonApply_Clicked()
		{
			API.ApplyToGuild(PlayerReference.forOwnPlayer(), textAreaInputField.text, guild);
			Interface.HideUI();
		}

		public void OnTextAreaInputField_ValueChanged()
		{
		}

		public void OnTextAreaInputField_EndEdit()
		{
		}

		public void OnTextAreaInputField_Select()
		{
		}

		public void OnTextAreaInputField_Deselect()
		{
		}
	}
	[PublicAPI]
	public class CreateGuildUI : MonoBehaviour
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static PopupButtonCallback <0>__Pop;
		}

		private int guildIconId;

		[Header("Root Objects")]
		public Canvas canvas;

		public RectTransform root;

		public Image Background;

		public Image BackgroundBack;

		[Header("Close Button")]
		public Image BackgroundBackButtonImage;

		public Button BackgroundBackButton;

		public TextMeshProUGUI BackgroundBackButtonTextMeshProUGui;

		[Header("GuildsColorPicker - Instance")]
		public GameObject guildsColorPicker;

		public RectTransform guildsColorPickerRect;

		public GuildColorPicker guildsColorPickerInstance;

		[Header("Header Area")]
		public RectTransform header;

		public HorizontalLayoutGroup headerHLayoutGroup;

		public Image headerLeftImage;

		public Image headerRightImage;

		public TextMeshProUGUI headerTMP;

		[Header("Content Area")]
		public RectTransform content;

		[Header("Column 1")]
		public RectTransform Col1;

		public VerticalLayoutGroup Col1VLayoutGroup;

		public RectTransform Col1IconContainerRect;

		public Image Col1IconContainerIcon;

		public RectTransform Col1IconContainerIconRect;

		public Image Col1IconContainerBorder;

		public RectTransform Col1IconContainerBorderRect;

		public Button Col1ButtonSelect;

		public Image Col1ButtonSelectImage;

		public TextMeshProUGUI Col1ButtonTMP;

		[Header("Column 2")]
		public RectTransform Col2;

		public VerticalLayoutGroup Col2VLG;

		public RectTransform Col2InputFieldGuildNameRect;

		public TMP_InputField Col2InputFieldGuildName;

		public TextMeshProUGUI Col2InputFieldGuildNamePlaceHolder;

		public TextMeshProUGUI Col2InputFieldGuildNameText;

		public TMP_InputField Col2InputFieldGuildDescription;

		public RectTransform Col2InputFieldGuildDescriptionRect;

		public TextMeshProUGUI Col2InputFieldGuildDescriptionPlaceholder;

		public TextMeshProUGUI Col2InputFieldGuildDescriptionText;

		public RectTransform Col2ButtonCreateRect;

		public Image Col2ButtonCreateImg;

		public Button Col2ButtonCreate;

		public TextMeshProUGUI Col2ButtonCreateTMP;

		public RectTransform Col3;

		public Image Col3Icon;

		public TextMeshProUGUI Col3RequirementsText;

		[Header("GuildIconUI - Instance")]
		public GameObject guildIconUI;

		public RectTransform guildIconUIRect;

		public GuildIconUI guildIconUIInstance;

		public Image guildsColorPlaceholderImg;

		public void Awake()
		{
			Col2InputFieldGuildName.characterValidation = (CharacterValidation)8;
			Col2InputFieldGuildName.inputValidator = (TMP_InputValidator)(object)ScriptableObject.CreateInstance<Tools.NameValidator>();
			((Component)Col3RequirementsText).gameObject.SetActive(false);
			guildsColorPickerInstance.chosenColorPreview = guildsColorPlaceholderImg;
		}

		public void OnButtonClosed_Clicked()
		{
			Interface.HideUI();
		}

		public void OnButtonSelectIcon_Clicked()
		{
			guildIconUIInstance.selectedGuildIcon = delegate(int idx)
			{
				guildIconId = idx;
				Col1IconContainerIcon.sprite = Interface.GuildIcons[idx];
			};
		}

		public void OnButtonCreate_Clicked()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Expected O, but got Unknown
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Expected O, but got Unknown
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Expected O, but got Unknown
			if (guildIconId == 0)
			{
				object obj = <>O.<0>__Pop;
				if (obj == null)
				{
					PopupButtonCallback val = UnifiedPopup.Pop;
					<>O.<0>__Pop = val;
					obj = (object)val;
				}
				UnifiedPopup.Push((PopupBase)new WarningPopup("$guilds_no_icon_selected", "$guilds_no_icon_selected_details", (PopupButtonCallback)obj, true));
				return;
			}
			if (Col2InputFieldGuildName.text.Trim().Length > Guilds.maximumGuildNameLength.Value)
			{
				string text = Localization.instance.Localize("$guilds_name_too_long_details", new string[1] { Guilds.maximumGuildNameLength.Value.ToString() });
				object obj2 = <>O.<0>__Pop;
				if (obj2 == null)
				{
					PopupButtonCallback val2 = UnifiedPopup.Pop;
					<>O.<0>__Pop = val2;
					obj2 = (object)val2;
				}
				UnifiedPopup.Push((PopupBase)new WarningPopup("$guilds_name_too_long", text, (PopupButtonCallback)obj2, true));
				return;
			}
			if (Col2InputFieldGuildName.text.Trim().Length < Guilds.minimumGuildNameLength.Value)
			{
				string text2 = Localization.instance.Localize("$guilds_name_too_short_details", new string[1] { Guilds.minimumGuildNameLength.Value.ToString() });
				object obj3 = <>O.<0>__Pop;
				if (obj3 == null)
				{
					PopupButtonCallback val3 = UnifiedPopup.Pop;
					<>O.<0>__Pop = val3;
					obj3 = (object)val3;
				}
				UnifiedPopup.Push((PopupBase)new WarningPopup("$guilds_name_too_short", text2, (PopupButtonCallback)obj3, true));
				return;
			}
			Guild guild = API.CreateGuild(Col2InputFieldGuildName.text.Trim(), PlayerReference.forOwnPlayer());
			if (guild == null)
			{
				object obj4 = <>O.<0>__Pop;
				if (obj4 == null)
				{
					PopupButtonCallback val4 = UnifiedPopup.Pop;
					<>O.<0>__Pop = val4;
					obj4 = (object)val4;
				}
				UnifiedPopup.Push((PopupBase)new WarningPopup("$guilds_name_taken", "$guilds_name_taken_details", (PopupButtonCallback)obj4, true));
			}
			else
			{
				API.RemovePlayerApplication(PlayerReference.forOwnPlayer());
				guild.General.description = Col2InputFieldGuildDescription.text;
				guild.General.icon = guildIconId;
				guild.General.color = guildsColorPickerInstance.chosenColor;
				API.SaveGuild(guild);
				Interface.HideUI();
				Interface.GuildManagementUI.SetActive(true);
			}
		}

		public void OnCol2InputField_GuildName_ValueChanged()
		{
		}

		public void OnCol2InputField_GuildName_EndEdit()
		{
		}

		public void OnCol2InputField_GuildName_Select()
		{
		}

		public void OnCol2InputField_GuildName_Deselect()
		{
		}

		public void OnCol2InputField_GuildDescription_ValueChanged()
		{
		}

		public void OnCol2InputField_GuildDescription_EndEdit()
		{
		}

		public void OnCol2InputField_GuildDescription_Select()
		{
		}

		public void OnCol2InputField_GuildDescription_Deselect()
		{
		}
	}
	[PublicAPI]
	public class EditGuildUI : MonoBehaviour
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static PopupButtonCallback <0>__Pop;
		}

		private int guildIconId;

		[Header("Root Objects")]
		public Canvas canvas;

		public RectTransform root;

		public Image Background;

		public Image BackgroundBack;

		[Header("GuildsColorPicker - Instance")]
		public GameObject guildsColorPicker;

		public RectTransform guildsColorPickerRect;

		public GuildColorPicker guildsColorPickerInstance;

		[Header("Close Button")]
		public Image BackgroundBackButtonImage;

		public Button BackgroundBackButton;

		public TextMeshProUGUI BackgroundBackButtonTextMeshProUGui;

		[Header("Header Area")]
		public RectTransform header;

		public HorizontalLayoutGroup headerHLayoutGroup;

		public Image headerLeftImage;

		public Image headerRightImage;

		public TextMeshProUGUI headerTMP;

		[Header("Content Area")]
		public RectTransform content;

		[Header("Column 1")]
		public RectTransform Col1;

		public VerticalLayoutGroup Col1VLayoutGroup;

		public RectTransform Col1IconContainerRect;

		public Image Col1IconContainerIcon;

		public RectTransform Col1IconContainerIconRect;

		public Image Col1IconContainerBorder;

		public RectTransform Col1IconContainerBorderRect;

		public Button Col1ButtonSelect;

		public Image Col1ButtonSelectImage;

		public TextMeshProUGUI Col1ButtonTMP;

		[Header("Column 2")]
		public RectTransform Col2;

		public VerticalLayoutGroup Col2VLG;

		public RectTransform Col2InputFieldGuildNameRect;

		public TMP_InputField Col2InputFieldGuildName;

		public TextMeshProUGUI Col2InputFieldGuildNamePlaceHolder;

		public TextMeshProUGUI Col2InputFieldGuildNameText;

		public TMP_InputField Col2InputFieldGuildDescription;

		public RectTransform Col2InputFieldGuildDescriptionRect;

		public TextMeshProUGUI Col2InputFieldGuildDescriptionPlaceholder;

		public TextMeshProUGUI Col2InputFieldGuildDescriptionText;

		public RectTransform Col2ButtonEditRect;

		public Image Col2ButtonEditImg;

		public Button Col2ButtonEdit;

		public TextMeshProUGUI Col2ButtonEditTMP;

		public RectTransform Col3;

		public Image Col3Icon;

		public TextMeshProUGUI Col3RequirementsText;

		[Header("GuildIconUI - Instance")]
		public GameObject guildIconUI;

		public RectTransform guildIconUIRect;

		public GuildIconUI guildIconUIInstance;

		public Image guildsColorPlaceholderImg;

		public void Awake()
		{
			Col2InputFieldGuildName.characterValidation = (CharacterValidation)8;
			Col2InputFieldGuildName.inputValidator = (TMP_InputValidator)(object)ScriptableObject.CreateInstance<Tools.NameValidator>();
			((Component)Col3RequirementsText).gameObject.SetActive(false);
			guildsColorPickerInstance.chosenColorPreview = guildsColorPlaceholderImg;
		}

		public void OnEnable()
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			Guild ownGuild = API.GetOwnGuild();
			Col2InputFieldGuildName.text = ownGuild.Name;
			Col2InputFieldGuildDescription.text = ownGuild.General.description;
			Col1IconContainerIcon.sprite = API.GetGuildIcon(ownGuild);
			guildIconId = ownGuild.General.icon;
			guildsColorPickerInstance.chosenColor = ownGuild.General.color;
			Color color = default(Color);
			if (ColorUtility.TryParseHtmlString(guildsColorPickerInstance.chosenColor, ref color))
			{
				((Graphic)guildsColorPlaceholderImg).color = color;
			}
		}

		public void OnButtonClosed_Clicked()
		{
			Interface.HideUI();
		}

		public void OnButtonSelectIcon_Clicked()
		{
			guildIconUIInstance.selectedGuildIcon = delegate(int idx)
			{
				guildIconId = idx;
				Col1IconContainerIcon.sprite = Interface.GuildIcons[idx];
			};
		}

		public void OnButtonEdit_Clicked()
		{
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Expected O, but got Unknown
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Expected O, but got Unknown
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Expected O, but got Unknown
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Expected O, but got Unknown
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Expected O, but got Unknown
			Guild ownGuild = API.GetOwnGuild();
			if (ownGuild.General.description != Col2InputFieldGuildDescription.text)
			{
				ownGuild.General.description = Col2InputFieldGuildDescription.text;
				API.SaveGuild(ownGuild);
			}
			if (ownGuild.General.icon != guildIconId)
			{
				ownGuild.General.icon = guildIconId;
				API.SaveGuild(ownGuild);
			}
			if (ownGuild.General.color != guildsColorPickerInstance.chosenColor)
			{
				ownGuild.General.color = guildsColorPickerInstance.chosenColor;
				API.SaveGuild(ownGuild);
			}
			if (Col2InputFieldGuildName.text.Trim().Length > Guilds.maximumGuildNameLength.Value)
			{
				string text = Localization.instance.Localize("$guilds_name_too_long_details", new string[1] { Guilds.maximumGuildNameLength.Value.ToString() });
				object obj = <>O.<0>__Pop;
				if (obj == null)
				{
					PopupButtonCallback val = UnifiedPopup.Pop;
					<>O.<0>__Pop = val;
					obj = (object)val;
				}
				UnifiedPopup.Push((PopupBase)new WarningPopup("$guilds_name_too_long", text, (PopupButtonCallback)obj, true));
			}
			else if (Col2InputFieldGuildName.text.Trim().Length < Guilds.minimumGuildNameLength.Value)
			{
				string text2 = Localization.instance.Localize("$guilds_name_too_short_details", new string[1] { Guilds.minimumGuildNameLength.Value.ToString() });
				object obj2 = <>O.<0>__Pop;
				if (obj2 == null)
				{
					PopupButtonCallback val2 = UnifiedPopup.Pop;
					<>O.<0>__Pop = val2;
					obj2 = (object)val2;
				}
				UnifiedPopup.Push((PopupBase)new WarningPopup("$guilds_name_too_short", text2, (PopupButtonCallback)obj2, true));
			}
			else if (ownGuild.Name != Col2InputFieldGuildName.text && !API.RenameGuild(ownGuild, Col2InputFieldGuildName.text.Trim()))
			{
				object obj3 = <>O.<0>__Pop;
				if (obj3 == null)
				{
					PopupButtonCallback val3 = UnifiedPopup.Pop;
					<>O.<0>__Pop = val3;
					obj3 = (object)val3;
				}
				UnifiedPopup.Push((PopupBase)new WarningPopup("$guilds_name_taken", "$guilds_name_taken_details", (PopupButtonCallback)obj3, true));
			}
			else
			{
				Interface.SwitchUI(Interface.GuildManagementUI);
			}
		}

		public void OnCol2InputField_GuildName_ValueChanged()
		{
		}

		public void OnCol2InputField_GuildName_EndEdit()
		{
		}

		public void OnCol2InputField_GuildName_Select()
		{
		}

		public void OnCol2InputField_GuildName_Deselect()
		{
		}

		public void OnCol2InputField_GuildDescription_ValueChanged()
		{
		}

		public void OnCol2InputField_GuildDescription_EndEdit()
		{
		}

		public void OnCol2InputField_GuildDescription_Select()
		{
		}

		public void OnCol2InputField_GuildDescription_Deselect()
		{
		}
	}
	public class GuildColorPicker : MonoBehaviour
	{
		private delegate void ColorEvent(Color c);

		private sealed class HSV
		{
			public double H;

			public double S = 1.0;

			public double V = 1.0;

			private const byte A = byte.MaxValue;

			public HSV()
			{
			}

			public HSV(double h, double s, double v)
			{
				H = h;
				S = s;
				V = v;
			}

			public HSV(Color color)
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				float num = Mathf.Max(color.r, Mathf.Max(color.g, color.b));
				float num2 = Mathf.Min(color.r, Mathf.Min(color.g, color.b));
				float num3 = (float)H;
				if (num2 != num)
				{
					num3 = ((num == color.r) ? ((color.g - color.b) / (num - num2)) : ((num != color.g) ? (4f + (color.r - color.g) / (num - num2)) : (2f + (color.b - color.r) / (num - num2)))) * 60f;
					if (num3 < 0f)
					{
						num3 += 360f;
					}
				}
				H = num3;
				S = ((num == 0f) ? 0.0 : (1.0 - (double)num2 / (double)num));
				V = num;
			}

			public Color32 ToColor()
			{
				//IL_00df: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_010c: Unknown result type (might be due to invalid IL or missing references)
				//IL_011b: Unknown result type (might be due to invalid IL or missing references)
				//IL_012a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0132: Unknown result type (might be due to invalid IL or missing references)
				//IL_0138: Unknown result type (might be due to invalid IL or missing references)
				int num = Convert.ToInt32(Math.Floor(H / 60.0)) % 6;
				double num2 = H / 60.0 - Math.Floor(H / 60.0);
				double num3 = V * 255.0;
				byte b = (byte)Convert.ToInt32(num3);
				byte b2 = (byte)Convert.ToInt32(num3 * (1.0 - S));
				byte b3 = (byte)Convert.ToInt32(num3 * (1.0 - num2 * S));
				byte b4 = (byte)Convert.ToInt32(num3 * (1.0 - (1.0 - num2) * S));
				return (Color32)(num switch
				{
					0 => new Color32(b, b4, b2, byte.MaxValue), 
					1 => new Color32(b3, b, b2, byte.MaxValue), 
					2 => new Color32(b2, b, b4, byte.MaxValue), 
					3 => new Color32(b2, b3, b, byte.MaxValue), 
					4 => new Color32(b4, b2, b, byte.MaxValue), 
					5 => new Color32(b, b2, b3, byte.MaxValue), 
					_ => default(Color32), 
				});
			}
		}

		private static GuildColorPicker? self;

		private static bool done = true;

		private static ColorEvent? onCC;

		private static ColorEvent? onCS;

		private static Color32 originalColor;

		private static Color32 modifiedColor;

		private static HSV modifiedHsv = null;

		public string chosenColor = "#000000";

		private bool interact;

		public RectTransform positionIndicator;

		public Slider mainComponent;

		public Slider rComponent;

		public Slider gComponent;

		public Slider bComponent;

		public TMP_InputField hexComponent;

		public RawImage colorComponent;

		public Image chosenColorPreview;

		private void Awake()
		{
			self = this;
		}

		public void OnColorButtonClicked()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			Color original = default(Color);
			ColorUtility.TryParseHtmlString(chosenColor, ref original);
			Create(original, SetColor, ColorFinished);
		}

		private void SetColor(Color currentColor)
		{
		}

		private void ColorFinished(Color finishedColor)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			((Graphic)chosenColorPreview).color = finishedColor;
			chosenColor = "#" + ColorUtility.ToHtmlStringRGBA(finishedColor);
		}

		private static void Create(Color original, ColorEvent onColorChanged, ColorEvent onColorSelected)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (self != null)
			{
				if (done)
				{
					done = false;
					originalColor = Color32.op_Implicit(original);
					modifiedColor = Color32.op_Implicit(original);
					onCC = onColorChanged;
					onCS = onColorSelected;
					((Component)self).gameObject.SetActive(true);
					self.RecalculateMenu(recalculateHSV: true);
					((TMP_Text)((Component)self.hexComponent.placeholder).GetComponent<TextMeshProUGUI>()).text = "RRGGBB";
				}
				else
				{
					Done();
				}
			}
		}

		private void RecalculateMenu(bool recalculateHSV)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			interact = false;
			if (recalculateHSV)
			{
				modifiedHsv = new HSV(Color32.op_Implicit(modifiedColor));
			}
			else
			{
				modifiedColor = modifiedHsv.ToColor();
			}
			rComponent.value = (int)modifiedColor.r;
			((Component)((Component)rComponent).transform.GetChild(3)).GetComponent<TMP_InputField>().text = modifiedColor.r.ToString();
			gComponent.value = (int)modifiedColor.g;
			((Component)((Component)gComponent).transform.GetChild(3)).GetComponent<TMP_InputField>().text = modifiedColor.g.ToString();
			bComponent.value = (int)modifiedColor.b;
			((Component)((Component)bComponent).transform.GetChild(3)).GetComponent<TMP_InputField>().text = modifiedColor.b.ToString();
			mainComponent.value = (float)modifiedHsv.H;
			((Graphic)((Component)((Component)rComponent).transform.GetChild(0)).GetComponent<RawImage>()).color = Color32.op_Implicit(new Color32(byte.MaxValue, modifiedColor.g, modifiedColor.b, byte.MaxValue));
			((Graphic)((Component)((Component)rComponent).transform.GetChild(0).GetChild(0)).GetComponent<RawImage>()).color = Color32.op_Implicit(new Color32((byte)0, modifiedColor.g, modifiedColor.b, byte.MaxValue));
			((Graphic)((Component)((Component)gComponent).transform.GetChild(0)).GetComponent<RawImage>()).color = Color32.op_Implicit(new Color32(modifiedColor.r, byte.MaxValue, modifiedColor.b, byte.MaxValue));
			((Graphic)((Component)((Component)gComponent).transform.GetChild(0).GetChild(0)).GetComponent<RawImage>()).color = Color32.op_Implicit(new Color32(modifiedColor.r, (byte)0, modifiedColor.b, byte.MaxValue));
			((Graphic)((Component)((Component)bComponent).transform.GetChild(0)).GetComponent<RawImage>()).color = Color32.op_Implicit(new Color32(modifiedColor.r, modifiedColor.g, byte.MaxValue, byte.MaxValue));
			((Graphic)((Component)((Component)bComponent).transform.GetChild(0).GetChild(0)).GetComponent<RawImage>()).color = Color32.op_Implicit(new Color32(modifiedColor.r, modifiedColor.g, (byte)0, byte.MaxValue));
			((Graphic)((Component)((Transform)positionIndicator).parent.GetChild(0)).GetComponent<RawImage>()).color = Color32.op_Implicit(new HSV(modifiedHsv.H, 1.0, 1.0).ToColor());
			positionIndicator.anchorMin = new Vector2((float)modifiedHsv.S, (float)modifiedHsv.V);
			positionIndicator.anchorMax = positionIndicator.anchorMin;
			hexComponent.text = ColorUtility.ToHtmlStringRGB(Color32.op_Implicit(modifiedColor));
			((Graphic)colorComponent).color = Color32.op_Implicit(modifiedColor);
			onCC?.Invoke(Color32.op_Implicit(modifiedColor));
			interact = true;
		}

		public void SetChooser()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: 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)
			Transform parent = ((Transform)positionIndicator).parent;
			Vector2 val = default(Vector2);
			RectTransformUtility.ScreenPointToLocalPointInRectangle((RectTransform)(object)((parent is RectTransform) ? parent : null), Vector2.op_Implicit(Input.mousePosition), ((Component)this).GetComponentInParent<Canvas>().worldCamera, ref val);
			val = Rect.PointToNormalized(((RectTransform)((parent is RectTransform) ? parent : null)).rect, val);
			if (positionIndicator.anchorMin != val)
			{
				positionIndicator.anchorMin = val;
				positionIndicator.anchorMax = val;
				modifiedHsv.S = val.x;
				modifiedHsv.V = val.y;
				RecalculateMenu(recalculateHSV: false);
			}
		}

		public void SetMain(float value)
		{
			if (interact)
			{
				modifiedHsv.H = value;
				RecalculateMenu(recalculateHSV: false);
			}
		}

		public void SetR(float value)
		{
			if (interact)
			{
				modifiedColor.r = (byte)value;
				RecalculateMenu(recalculateHSV: true);
			}
		}

		public void SetR(string value)
		{
			if (interact)
			{
				modifiedColor.r = (byte)Mathf.Clamp(int.Parse(value), 0, 255);
				RecalculateMenu(recalculateHSV: true);
			}
		}

		public void SetG(float value)
		{
			if (interact)
			{
				modifiedColor.g = (byte)value;
				RecalculateMenu(recalculateHSV: true);
			}
		}

		public void SetG(string value)
		{
			if (interact)
			{
				modifiedColor.g = (byte)Mathf.Clamp(int.Parse(value), 0, 255);
				RecalculateMenu(recalculateHSV: true);
			}
		}

		public void SetB(float value)
		{
			if (interact)
			{
				modifiedColor.b = (byte)value;
				RecalculateMenu(recalculateHSV: true);
			}
		}

		public void SetB(string value)
		{
			if (interact)
			{
				modifiedColor.b = (byte)Mathf.Clamp(int.Parse(value), 0, 255);
				RecalculateMenu(recalculateHSV: true);
			}
		}

		public void SetHexa(string value)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (interact)
			{
				Color val = default(Color);
				if (ColorUtility.TryParseHtmlString("#" + value, ref val))
				{
					val.a = 1f;
					modifiedColor = Color32.op_Implicit(val);
					RecalculateMenu(recalculateHSV: true);
				}
				else
				{
					hexComponent.text = ColorUtility.ToHtmlStringRGB(Color32.op_Implicit(modifiedColor));
				}
			}
		}

		public void CCancel()
		{
			Cancel();
		}

		private static void Cancel()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			modifiedColor = originalColor;
			Done();
		}

		public void CDone()
		{
			Done();
		}

		private static void Done()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			done = true;
			onCC?.Invoke(Color32.op_Implicit(modifiedColor));
			onCS?.Invoke(Color32.op_Implicit(modifiedColor));
			((Component)((Component)self).transform).gameObject.SetActive(false);
		}
	}
	[PublicAPI]
	public class GuildIconElement : MonoBehaviour
	{
		public Button guildIconButton;

		public RectTransform guildIconButtonRect;

		public Image guildIconBkg;

		public RectTransform guildIconBkgRect;

		public Image guildIcon;

		public RectTransform guildIconRect;

		public GuildIconUI guildIconUI;

		public int guildIconId;

		public void OnGuildIconElement_Clicked()
		{
			guildIconUI.selectedGuildIcon(guildIconId);
			((Component)guildIconUI).gameObject.SetActive(false);
		}
	}
	[PublicAPI]
	public class GuildIconUI : MonoBehaviour
	{
		[Header("Root UI")]
		public RectTransform rootTransform;

		public GameObject rootGameObject;

		public Image backgroundBack;

		public Image background;

		[Header("Header UI")]
		public RectTransform headerTransform;

		public HorizontalLayoutGroup headerHlg;

		public Image headerImageLeft;

		public TextMeshProUGUI headerTextTMP;

		public Image headerImageRight;

		[Header("Close Button UI")]
		public Button buttonClose;

		public Image buttonCloseImage;

		public TextMeshProUGUI buttonCloseText;

		[Header("Content UI")]
		public RectTransform contentTransform;

		public ScrollRect contentScrollRect;

		public Image contentScrollRectImage;

		public Scrollbar guildIconListScroll;

		public Image guildIconListScrollImage;

		public RectTransform guildIconListScrollSlidingArea;

		public RectTransform guildIconListScrollHandle;

		public Image guildIconListScrollHandleImage;

		[Header("Content UI - Guild Icons")]
		public RectTransform guildIconListRoot;

		public GridLayoutGroup guildIconListRootGlg;

		public ContentSizeFitter guildIconListRootSizeFitter;

		[Header("Guild Icon Placeholder")]
		public GameObject guidIconElementPrefab;

		public GuildIconElement guildIconElementPrefabComponent;

		public Button guildIconElementButton;

		public Image guildIconElementButtonImage;

		public Image guildIconElementButtonIconBackground;

		public Image guildIconElementButtonIcon;

		public List<GameObject> guildIconList = new List<GameObject>();

		public Action<int> selectedGuildIcon;

		public void Awake()
		{
			FillTrophyList();
		}

		public void FillTrophyList()
		{
			foreach (KeyValuePair<int, Sprite> guildIcon in Interface.GuildIcons)
			{
				GuildIconElement component = Object.Instantiate<GameObject>(guidIconElementPrefab, (Transform)(object)guildIconListRoot).GetComponent<GuildIconElement>();
				component.guildIcon.sprite = guildIcon.Value;
				((Component)component).gameObject.SetActive(true);
				component.guildIconUI = this;
				component.guildIconId = guildIcon.Key;
			}
		}

		public void OnButtonClosed_Clicked()
		{
			((Component)this).gameObject.SetActive(false);
		}
	}
	[PublicAPI]
	public class GuildManagementUI : MonoBehaviour
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static PopupButtonCallback <0>__Pop;
		}

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

			public static PopupButtonCallback <>9__80_0;

			public static PopupButtonCallback <>9__80_1;

			internal void <ButtonLeaveGuildClicked>b__80_0()
			{
				API.DeleteGuild(API.GetOwnGuild());
				UnifiedPopup.Pop();
			}

			internal void <ButtonLeaveGuildClicked>b__80_1()
			{
				API.RemovePlayerFromGuild(PlayerReference.forOwnPlayer());
				UnifiedPopup.Pop();
			}
		}

		[Header("Placeholder Variables")]
		public GuildManagementUIRow rowPlaceHolderPrefab;

		public Transform rowPlaceHolderParentList;

		public List<GuildManagementUIRow> rowElements;

		[Header("Root UI")]
		public RectTransform rootTransform;

		public Image backgroundBack;

		public Image background;

		[Header("Header UI")]
		public RectTransform headerTransform;

		public HorizontalLayoutGroup headerHlg;

		public Image headerImageLeft;

		public TextMeshProUGUI headerTextTMP;

		public Image headerImageRight;

		[Header("Close Button UI")]
		public Button buttonClose;

		public Image buttonCloseImage;

		public TextMeshProUGUI buttonCloseText;

		[Header("Content UI")]
		public RectTransform contentTransform;

		public ScrollRect contentScrollRect;

		public Image contentScrollRectImage;

		public RectTransform contentList;

		public VerticalLayoutGroup contentListVlg;

		public ContentSizeFitter contentListSizeFitter;

		[Header("Row Placeholder UI")]
		public RectTransform rowTransform;

		public Image rowBackImage;

		public Image rowBorderImage;

		public HorizontalLayoutGroup contentHlg;

		[Header("Row Content UI - Name Area")]
		public RectTransform nameAreaRect;

		public VerticalLayoutGroup nameAreaVlg;

		public TextMeshProUGUI nameAreaNameTextTMP;

		[Header("Row Content UI - Rank Area")]
		public RectTransform rankArea;

		public VerticalLayoutGroup rankAreaVlg;

		public TMP_Dropdown rankAreaDropdown;

		public Image rankAreaDropdownImage;

		public TextMeshProUGUI rankAreaDropdownLabel;

		public Image rankAreaDropdownArrow;

		public RectTransform rankAreaDropdownTemplate;

		public ScrollRect rankAreaDropdownTemplateScrollRect;

		public Image rankAreaDropdownTemplateScrollRectImage;

		public RectTransform rankAreaDropdownTemplateViewport;

		public Image rankAreaDropdownTemplateViewportImage;

		public RectTransform rankAreaDropdownTemplateContent;

		public RectTransform rankAreaDropdownTemplateItem;

		public Image rankAreaDropdownTemplateItemBackgroundImage;

		public Image rankAreaDropdownTemplateItemCheckmarkImage;

		public TextMeshProUGUI rankAreaDropdownTemplateItemLabel;

		public Scrollbar rankAreaDropdownTemplateScrollbar;

		public Image rankAreaDropdownTemplateScrollbarImage;

		public RectTransform rankAreaDropdownTemplateSlidingAreaRect;

		public RectTransform rankAreaDropdownTemplateHandle;

		public Image rankAreaDropdownTemplateHandleImage;

		[Header("Row Content UI - Online Area")]
		public RectTransform onlineAreaRect;

		public VerticalLayoutGroup onlineAreaVlg;

		public TextMeshProUGUI onlineAreaOnlineStatusTextTMP;

		[Header("Row Content UI - Action Area")]
		public RectTransform actionArea;

		public Button actionAreaRemoveMemberButton;

		public TextMeshProUGUI actionAreaRemoveMemberButtonTextTMP;

		public Image actionAreaRemoveMemberButtonImage;

		[Header("Root UI Global Scrollbar")]
		public Scrollbar scrollbar;

		public RectTransform scrollbarRect;

		public RectTransform scrollbarSlidingArea;

		public RectTransform scrollbarHandle;

		public Image scrollbarHandleImage;

		[Header("Leave Guild Button")]
		public Button leaveGuildButton;

		public Image leaveGuildButtonImage;

		public TextMeshProUGUI leaveGuildButtonText;

		[Header("Achievements Button")]
		public Button achievementsButton;

		public Image achievementsButtonImage;

		public TextMeshProUGUI achievementsButtonText;

		[Header("Edit Guild Button")]
		public Button editGuildButton;

		public Image editGuildButtonImage;

		public TextMeshProUGUI editGuildButtonText;

		[Header("Applications Button")]
		public Button applicationsButton;

		public Image applicationsButtonImage;

		public TextMeshProUGUI applicationsButtonText;

		private List<GuildManagementUIRow> _activeRows = new List<GuildManagementUIRow>();

		private Queue<GuildManagementUIRow> _pooledRows = new Queue<GuildManagementUIRow>();

		public void OnEnable()
		{
			UpdateRows();
			((TMP_Text)headerTextTMP).text = API.GetOwnGuild().Name;
		}

		public void Awake()
		{
			((TMP_Text)headerTextTMP).text = "";
			((Component)rowPlaceHolderPrefab).gameObject.SetActive(false);
		}

		public void UpdateRows()
		{
			if (((Component)this).gameObject.activeSelf)
			{
				if (API.GetOwnGuild() == null)
				{
					Interface.SwitchUI(Interface.NoGuildUI);
					return;
				}
				PopulateRows(API.GetOwnGuild().Members);
				GameObject gameObject = ((Component)applicationsButton).gameObject;
				Ranks playerRank = API.GetPlayerRank(PlayerReference.forOwnPlayer());
				bool active = (uint)playerRank <= 2u;
				gameObject.SetActive(active);
				gameObject = ((Component)editGuildButton).gameObject;
				playerRank = API.GetPlayerRank(PlayerReference.forOwnPlayer());
				active = (uint)playerRank <= 1u;
				gameObject.SetActive(active);
			}
		}

		private void PopulateRows(Dictionary<PlayerReference, GuildMember> members)
		{
			foreach (GuildManagementUIRow activeRow in _activeRows)
			{
				((Component)activeRow).gameObject.SetActive(false);
				_pooledRows.Enqueue(activeRow);
			}
			_activeRows.Clear();
			foreach (KeyValuePair<PlayerReference, GuildMember> member in members)
			{
				GuildManagementUIRow row = GetRow();
				row.Setup(member);
				_activeRows.Add(row);
			}
		}

		private GuildManagementUIRow GetRow()
		{
			GuildManagementUIRow obj = ((_pooledRows.Count > 0) ? _pooledRows.Dequeue() : Object.Instantiate<GameObject>(((Component)rowTransform).gameObject, rowPlaceHolderParentList).GetComponent<GuildManagementUIRow>());
			((Component)obj).gameObject.SetActive(true);
			return obj;
		}

		private void ReturnRowToPool(GuildManagementUIRow row)
		{
			((Component)row).gameObject.SetActive(false);
			_pooledRows.Enqueue(row);
		}

		public void ButtonLeaveGuildClicked()
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Expected O, but got Unknown
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			if (API.GetPlayerRank(PlayerReference.forOwnPlayer()) == Ranks.Leader)
			{
				if (API.GetOwnGuild().Members.Count == 1)
				{
					object obj = <>c.<>9__80_0;
					if (obj == null)
					{
						PopupButtonCallback val = delegate
						{
							API.DeleteGuild(API.GetOwnGuild());
							UnifiedPopup.Pop();
						};
						<>c.<>9__80_0 = val;
						obj = (object)val;
					}
					object obj2 = <>O.<0>__Pop;
					if (obj2 == null)
					{
						PopupButtonCallback val2 = UnifiedPopup.Pop;
						<>O.<0>__Pop = val2;
						obj2 = (object)val2;
					}
					UnifiedPopup.Push((PopupBase)new YesNoPopup("$guilds_confirm_deletion", "$guilds_confirm_deletion_details", (PopupButtonCallback)obj, (PopupButtonCallback)obj2, true));
				}
				else
				{
					object obj3 = <>O.<0>__Pop;
					if (obj3 == null)
					{
						PopupButtonCallback val3 = UnifiedPopup.Pop;
						<>O.<0>__Pop = val3;
						obj3 = (object)val3;
					}
					UnifiedPopup.Push((PopupBase)new WarningPopup("$guilds_leader_left", "$guilds_leader_left_details", (PopupButtonCallback)obj3, true));
				}
				return;
			}
			object obj4 = <>c.<>9__80_1;
			if (obj4 == null)
			{
				PopupButtonCallback val4 = delegate
				{
					API.RemovePlayerFromGuild(PlayerReference.forOwnPlayer());
					UnifiedPopup.Pop();
				};
				<>c.<>9__80_1 = val4;
				obj4 = (object)val4;
			}
			object obj5 = <>O.<0>__Pop;
			if (obj5 == null)
			{
				PopupButtonCallback val5 = UnifiedPopup.Pop;
				<>O.<0>__Pop = val5;
				obj5 = (object)val5;
			}
			UnifiedPopup.Push((PopupBase)new YesNoPopup("$guilds_confirm_leave", "$guilds_confirm_leave_details", (PopupButtonCallback)obj4, (PopupButtonCallback)obj5, true));
		}

		public void ButtonEditGuildClicked()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			if (Guilds.allowGuildEdit.Value == Toggle.Off && !Guilds.configSync.IsAdmin)
			{
				object obj = <>O.<0>__Pop;
				if (obj == null)
				{
					PopupButtonCallback val = UnifiedPopup.Pop;
					<>O.<0>__Pop = val;
					obj = (object)val;
				}
				UnifiedPopup.Push((PopupBase)new WarningPopup("$guilds_edit_disabled", "$guilds_edit_disabled_details", (PopupButtonCallback)obj, true));
			}
			else
			{
				Interface.SwitchUI(Interface.EditGuildUI);
			}
		}

		public void ButtonApplicationsClicked()
		{
			Interface.SwitchUI(Interface.ApplicationsUI);
		}

		public void ButtonCloseClicked()
		{
			Interface.HideUI();
		}

		public void ButtonAchievementsClicked()
		{
			Interface.SwitchUI(Interface.AchievementUI);
		}
	}
	[PublicAPI]
	public class GuildManagementUIRow : MonoBehaviour
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static PopupButtonCallback <0>__Pop;
		}

		public PlayerReference player;

		[Header("Row Root")]
		public RectTransform rowRootTransform;

		public GameObject rowRootGameObject;

		public RectTransform back;

		public Image backImage;

		public Image borderImage;

		[Header("Content Area")]
		public RectTransform contentAreaRectTransform;

		public HorizontalLayoutGroup contentAreaHorizontalLayoutGroup;

		[Header("Name Area")]
		public RectTransform nameAreaTransform;

		public VerticalLayoutGroup nameAreaVerticalLayoutGroup;

		public TextMeshProUGUI nameText;

		[Header("Rank Area")]
		public RectTransform rankAreaTransform;

		public VerticalLayoutGroup rankAreaVerticalLayoutGroup;

		public TMP_Dropdown rankDropdown;

		public Image rankDropdownImage;

		public TextMeshProUGUI rankDropdownLabel;

		public Image rankDropdownArrow;

		public RectTransform rankDropdownTemplate;

		public ScrollRect rankDropdownTemplateScrollRect;

		public Image rankDropdownTemplateScrollRectImage;

		public RectTransform rankDropdownTemplateViewport;

		public Image rankDropdownTemplateViewportImage;

		public RectTransform rankDropdownTemplateContent;

		public RectTransform rankDropdownTemplateItem;

		public Image rankDropdownTemplateItemBackgroundImage;

		public Image rankDropdownTemplateItemCheckmarkImage;

		public TextMeshProUGUI rankDropdownTemplateItemLabel;

		[Header("Rank Dropdown Scrollbar")]
		public RectTransform rankScrollbarTransform;

		public Scrollbar rankScrollbar;

		public Image rankScrollbarImage;

		public RectTransform slidingArea;

		public RectTransform handle;

		public Image handleImage;

		[Header("Online Area")]
		public RectTransform onlineAreaTransform;

		public VerticalLayoutGroup onlineAreaLayoutGroup;

		public RectTransform statusTextTransform;

		public TextMeshProUGUI statusText;

		[Header("Action Area")]
		public RectTransform actionAreaTransform;

		public VerticalLayoutGroup actionAreaLayoutGroup;

		public Button removeMemberButton;

		public Image actionAreaButtonImage;

		public TextMeshProUGUI actionAreaButtonText;

		public void Awake()
		{
			rankDropdown.options = ((IEnumerable<Ranks>)(Ranks[])typeof(Ranks).GetEnumValues()).Select((Func<Ranks, OptionData>)((Ranks rank) => new OptionData(Localization.instance.Localize("$guilds_rank_" + rank.ToString().ToLower())))).ToList();
		}

		public void Setup(KeyValuePair<PlayerReference, GuildMember> memberData)
		{
			((TMP_Text)nameText).text = memberData.Key.name;
			rankDropdown.SetValueWithoutNotify((int)memberData.Value.rank);
			((TMP_Text)statusText).text = (ZNet.instance.m_players.Any((PlayerInfo p) => PlayerReference.fromPlayerInfo(p) == memberData.Key) ? Localization.instance.Localize("$guilds_online") : Localization.instance.Localize("$guilds_last_online", new string[1] { Tools.GetHumanFriendlyTime((int)(DateTime.Now - memberData.Value.lastOnline).TotalSeconds) }));
			player = memberData.Key;
			TMP_Dropdown val = rankDropdown;
			Ranks playerRank = API.GetPlayerRank(PlayerReference.forOwnPlayer());
			bool interactable = (uint)playerRank <= 1u;
			((Selectable)val).interactable = interactable;
			GameObject gameObject = ((Component)removeMemberButton).gameObject;
			playerRank = API.GetPlayerRank(PlayerReference.forOwnPlayer());
			interactable = (uint)playerRank <= 2u;
			gameObject.SetActive(interactable);
		}

		public void OnRemoveMember_ButtonClicked()
		{
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_00fe: Expected O, but got Unknown
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			if (player == PlayerReference.forOwnPlayer())
			{
				object obj = <>O.<0>__Pop;
				if (obj == null)
				{
					PopupButtonCallback val = UnifiedPopup.Pop;
					<>O.<0>__Pop = val;
					obj = (object)val;
				}
				UnifiedPopup.Push((PopupBase)new WarningPopup("$guilds_kicked_self", "$guilds_kicked_self_details", (PopupButtonCallback)obj, true));
				return;
			}
			if (API.GetPlayerRank(player) <= API.GetPlayerRank(PlayerReference.forOwnPlayer()))
			{
				string text = Localization.instance.Localize("$guilds_higher_rank_kicked_details", new string[1] { player.name });
				object obj2 = <>O.<0>__Pop;
				if (obj2 == null)
				{
					PopupButtonCallback val2 = UnifiedPopup.Pop;
					<>O.<0>__Pop = val2;
					obj2 = (object)val2;
				}
				UnifiedPopup.Push((PopupBase)new WarningPopup("$guilds_higher_rank_kicked", text, (PopupButtonCallback)obj2, true));
				return;
			}
			string text2 = Localization.instance.Localize("$guilds_confirm_kick_details", new string[1] { player.name });
			PopupButtonCallback val3 = delegate
			{
				API.RemovePlayerFromGuild(player);
				Guilds.SendMessageToPlayer(player, Localization.instance.Localize("$guilds_kicked_out", new string[1] { API.GetOwnGuild().Name }));
				UnifiedPopup.Pop();
			};
			object obj3 = <>O.<0>__Pop;
			if (obj3 == null)
			{
				PopupButtonCallback val4 = UnifiedPopup.Pop;
				<>O.<0>__Pop = val4;
				obj3 = (object)val4;
			}
			UnifiedPopup.Push((PopupBase)new YesNoPopup("$guilds_confirm_kick", text2, val3, (PopupButtonCallback)obj3, true));
		}

		public void OnRankDropdown_ValueChanged(int value)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Expected O, but got Unknown
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Expected O, but got Unknown
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Expected O, but got Unknown
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Expected O, but got Unknown
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Expected O, but got Unknown
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Expected O, but got Unknown
			value = rankDropdown.value;
			if (value == (int)API.GetPlayerRank(player))
			{
				return;
			}
			if (player == PlayerReference.forOwnPlayer())
			{
				object obj = <>O.<0>__Pop;
				if (obj == null)
				{
					PopupButtonCallback val = UnifiedPopup.Pop;
					<>O.<0>__Pop = val;
					obj = (object)val;
				}
				UnifiedPopup.Push((PopupBase)new WarningPopup("$guilds_own_rank_changed", "$guilds_own_rank_changed_details", (PopupButtonCallback)obj, true));
				rankDropdown.value = (int)API.GetPlayerRank(player);
				return;
			}
			if (API.GetPlayerRank(PlayerReference.forOwnPlayer()) == Ranks.Leader)
			{
				if (value == 0)
				{
					rankDropdown.value = (int)API.GetPlayerRank(player);
					string text = Localization.instance.Localize("$guilds_transfer_guild_details", new string[1] { player.name });
					PopupButtonCallback val2 = delegate
					{
						API.UpdatePlayerRank(PlayerReference.forOwnPlayer(), Ranks.Coleader);
						API.UpdatePlayerRank(player, (Ranks)value);
						UnifiedPopup.Pop();
					};
					object obj2 = <>O.<0>__Pop;
					if (obj2 == null)
					{
						PopupButtonCallback val3 = UnifiedPopup.Pop;
						<>O.<0>__Pop = val3;
						obj2 = (object)val3;
					}
					UnifiedPopup.Push((PopupBase)new YesNoPopup("$guilds_transfer_guild", text, val2, (PopupButtonCallback)obj2, true));
				}
				else
				{
					API.UpdatePlayerRank(player, (Ranks)value);
				}
				return;
			}
			Ranks playerRank = API.GetPlayerRank(player);
			if ((uint)playerRank <= 1u)
			{
				object obj3 = <>O.<0>__Pop;
				if (obj3 == null)
				{
					PopupButtonCallback val4 = UnifiedPopup.Pop;
					<>O.<0>__Pop = val4;
					obj3 = (object)val4;
				}
				UnifiedPopup.Push((PopupBase)new WarningPopup("$guilds_higher_rank_changed", "$guilds_higher_rank_changed_details", (PopupButtonCallback)obj3, true));
				rankDropdown.value = (int)API.GetPlayerRank(player);
				return;
			}
			playerRank = (Ranks)value;
			if ((uint)playerRank <= 1u)
			{
				object obj4 = <>O.<0>__Pop;
				if (obj4 == null)
				{
					PopupButtonCallback val5 = UnifiedPopup.Pop;
					<>O.<0>__Pop = val5;
					obj4 = (object)val5;
				}
				UnifiedPopup.Push((PopupBase)new WarningPopup("$guilds_new_rank_too_high", "$guilds_new_rank_too_high_details", (PopupButtonCallback)obj4, true));
				rankDropdown.value = (int)API.GetPlayerRank(player);
			}
			else
			{
				API.UpdatePlayerRank(player, (Ranks)value);
			}
		}
	}
	[PublicAPI]
	public class NoGuildUI : MonoBehaviour
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static PopupButtonCallback <0>__Pop;
		}

		[Header("Root")]
		public RectTransform root;

		public Image Background;

		public Image BackgroundBackImg;

		[Header("Close Button")]
		public Button ButtonClose;

		public Image ButtonCloseImage;

		public RectTransform ButtonCloseRect;

		public TextMeshProUGUI ButtonCloseText;

		[Header("Content")]
		public RectTransform content;

		public VerticalLayoutGroup contentVLG;

		public TextMeshProUGUI contentText;

		[Header("Content Panel")]
		public RectTransform panelRect;

		public HorizontalLayoutGroup panelHLG;

		public Button panelButtonCreate;

		public Image panelButtonCreateImg;

		public TextMeshProUGUI panelButtonCreateText;

		public Button panelButtonConnect;

		public Image panelButtonConnectImg;

		public TextMeshProUGUI panelButtonConnectText;

		public Image Border;

		public void OnEnable()
		{
			Guild ownAppliedGuild = API.GetOwnAppliedGuild();
			if (ownAppliedGuild != null)
			{
				((TMP_Text)contentText).text = Localization.instance.Localize("$guilds_pending_application", new string[1] { ownAppliedGuild.Name });
			}
			else
			{
				((TMP_Text)contentText).text = Localization.instance.Localize("$guilds_noguild_message");
			}
		}

		public void OnButtonClosed_Clicked()
		{
			Interface.HideUI();
		}

		public void OnButtonCreate_Clicked()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			if (Guilds.allowGuildCreation.Value == Toggle.Off && !Guilds.configSync.IsAdmin)
			{
				object obj = <>O.<0>__Pop;
				if (obj == null)
				{
					PopupButtonCallback val = UnifiedPopup.Pop;
					<>O.<0>__Pop = val;
					obj = (object)val;
				}
				UnifiedPopup.Push((PopupBase)new WarningPopup("$guilds_creation_admin_only", "$guilds_creation_admin_only_details", (PopupButtonCallback)obj, true));
			}
			else
			{
				Interface.SwitchUI(Interface.CreateGuildUI);
			}
		}

		public void OnButtonConnect_Clicked()
		{
			Interface.SwitchUI(Interface.SearchGuildUI);
		}
	}
	[PublicAPI]
	public class SearchGuildUI : MonoBehaviour
	{
		public Canvas canvas;

		public RectTransform root;

		public Image BackgroundBack;

		public Button ButtonClose;

		public Image ButtonCloseImage;

		public TextMeshProUGUI ButtonCloseTMP;

		public Image Background;

		public RectTransform Header;

		public HorizontalLayoutGroup HeaderHLG;

		public Image HeaderImageLeft;

		public Image HeaderImageRight;

		public TextMeshProUGUI HeaderTMP;

		public RectTransform content;

		public ScrollRect contentScrollRect;

		public Image contentScrollRectImage;

		public RectTransform contentList;

		public VerticalLayoutGroup contentListVLG;

		public ContentSizeFitter contentListContentSizeFitter;

		public RectTransform GuildRowPlaceholder;

		public RectTransform GuildRowPlaceholderBack;

		public RectTransform GuildRowPlaceholderBackBg;

		public RectTransform GuildRowPlaceholderBackBgImg;

		public RectTransform GuildRowPlaceholderBackBorder;

		public RectTransform GuildRowPlaceholderBackBorderImg;

		public RectTransform GuildRowPlaceholderContent;

		public RectTransform GuildRowPlaceholderContentLeftCol;

		public HorizontalLayoutGroup GuildRowPlaceholderContentLeftColHLG;

		public RectTransform GuildRowPlaceholderContentLeftColIcon;

		public Image GuildRowPlaceholderContentLeftColIconImage;

		public Image GuildRowPlaceholderContentLeftColIconImageSelected;

		public Image GuildRowPlaceholderContentLeftColIconImageBorder;

		public RectTransform GuildRowPlaceholderContentLeftColNaming;

		public VerticalLayoutGroup GuildRowPlaceholderContentLeftColNamingVLG;

		public RectTransform GuildRowPlaceholderContentLeftColNamingLvl;

		public TextMeshProUGUI GuildRowPlaceholderContentLeftColNamingLvlTMP;

		public RectTransform GuildRowPlaceholderContentLeftColNamingName;

		public TextMeshProUGUI GuildRowPlaceholderContentLeftColNamingNameTMP;

		public RectTransform GuildRowPlaceholderContentLeftColNamingLeader;

		public TextMeshProUGUI GuildRowPlaceholderContentLeftColNamingLeaderTMP;

		public RectTransform GuildRowPlaceholderContentRightCol;

		public Image GuildRowPlaceholderContentRightColBg;

		public TMP_InputField GuildRowPlaceholderContentRightColInputField;

		public Scrollbar contentScrollbar;

		public RectTransform contentScrollbarSlidingArea;

		public Image contentScrollbarImage;

		public RectTransform contentScrollbarHandle;

		public Image contentScrollbarHandleImage;

		private ApplyUI applyUI;

		private List<SearchGuildUIRow> _activeRows = new List<SearchGuildUIRow>();

		private Queue<SearchGuildUIRow> _pooledRows = new Queue<SearchGuildUIRow>();

		public void Awake()
		{
			((Component)GuildRowPlaceholder).gameObject.SetActive(false);
			applyUI = ((Component)((Component)this).transform.Find("ApplyUI")).GetComponent<ApplyUI>();
		}

		public void OnEnable()
		{
			UpdateRows();
		}

		public void UpdateRows()
		{
			if (((Component)this).gameObject.activeSelf)
			{
				if (API.GetOwnGuild() != null)
				{
					((Component)this).gameObject.SetActive(false);
					Interface.GuildManagementUI.SetActive(true);
				}
				else
				{
					PopulateRows(API.GetGuilds());
				}
			}
		}

		private void PopulateRows(List<Guild> guilds)
		{
			foreach (SearchGuildUIRow activeRow in _activeRows)
			{
				((Component)activeRow).gameObject.SetActive(false);
				_pooledRows.Enqueue(activeRow);
			}
			_activeRows.Clear();
			foreach (Guild guild in guilds)
			{
				SearchGuildUIRow row = GetRow();
				row.Setup(guild, applyUI);
				_activeRows.Add(row);
			}
		}

		private SearchGuildUIRow GetRow()
		{
			SearchGuildUIRow obj = ((_pooledRows.Count > 0) ? _pooledRows.Dequeue() : Object.Instantiate<GameObject>(((Component)GuildRowPlaceholder).gameObject, (Transform)(object)contentList).GetComponent<SearchGuildUIRow>());
			((Component)obj).gameObject.SetActive(true);
			return obj;
		}

		private void ReturnRowToPool(SearchGuildUIRow row)
		{
			((Component)row).gameObject.SetActive(false);
			_pooledRows.Enqueue(row);
		}

		public void OnButtonClosed_Clicked()
		{
			Interface.HideUI();
		}

		public void GuildRowPlaceholderContentRightColInputFieldOnValueChanged()
		{
		}

		public void GuildRowPlaceholderContentRightColInputFieldOnEndEdit()
		{
		}

		public void GuildRowPlaceholderContentRightColInputFieldOnSelect()
		{
		}

		public void GuildRowPlaceholderContentRightColInputFieldOnDeselect()
		{
		}
	}
	[PublicAPI]
	public class SearchGuildUIRow : MonoBehaviour
	{
		private Guild guild;

		private ApplyUI applyUI;

		[Header("Row Root")]
		public RectTransform rowRootTransform;

		public GameObject rowRootGameObject;

		public RectTransform back;

		public Image backImage;

		public Image borderImage;

		[Header("Content Area")]
		public RectTransform contentAreaRectTransform;

		[Header("Left Column")]
		public RectTransform leftColumnRect;

		public HorizontalLayoutGroup leftColumnHLayoutGroup;

		[Header("Left Column - Icon Container")]
		public RectTransform iconContainerRect;

		public Image iconContainerImg;

		public RectTransform guildIconImgRect;

		public RectTransform guildIconBorderRect;

		public Image guildIconBorderImg;

		public Image guildIconImg;

		public Button guildIconButton;

		[Header("Left Column - Naming Area")]
		public RectTransform namingAreaRect;

		public VerticalLayoutGroup namingAreaVLayoutGroup;

		public RectTransform levelTextRect;

		public TextMeshProUGUI levelText;

		public RectTransform nameTextRect;

		public TextMeshProUGUI nameText;

		public RectTransform leaderTextRect;

		public TextMeshProUGUI leaderText;

		[Header("Right Column")]
		public RectTransform rightColumnRect;

		public Image rightColumnBkg;

		public RectTransform rightColumnInputFieldRect;

		public TMP_InputField rightColumnInputField;

		public TextMeshProUGUI rightColumnInputFieldPlaceholderText;

		public TextMeshProUGUI rightColumnInputFieldText;

		public void Setup(Guild guild, ApplyUI applyUI)
		{
			this.guild = guild;
			this.applyUI = applyUI;
			((TMP_Text)leaderText).text = Localization.instance.Localize("$guilds_rank_leader: ") + API.GetGuildLeader(guild).name;
			((TMP_Text)nameText).text = guild.Name;
			guildIconImg.sprite = API.GetGuildIcon(guild);
			((TMP_Text)levelText).text = Localization.instance.Localize("$guilds_level ") + guild.General.level;
			rightColumnInputField.text = guild.General.description;
		}

		public void OnGuildIconButton_Clicked()
		{
			applyUI.Setup(guild);
		}
	}
	public static class GuildChat
	{
		[HarmonyPatch(typeof(Terminal), "InitTerminal")]
		public class AddChatCommands
		{
			[Serializable]
			[CompilerGenerated]
			private sealed class <>c
			{
				public static readonly <>c <>9 = new <>c();

				public static ConsoleEvent <>9__0_0;

				internal void <Postfix>b__0_0(ConsoleEventArgs args)
				{
					//IL_005a: Unknown result type (might be due to invalid IL or missing references)
					//IL_005f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0060: Unknown result type (might be due to invalid IL or missing references)
					//IL_0061: Unknown result type (might be due to invalid IL or missing references)
					//IL_0066: Unknown result type (might be due to invalid IL or missing references)
					//IL_0077: Unknown result type (might be due to invalid IL or missing references)
					//IL_0089: Unknown result type (might be due to invalid IL or missing references)
					//IL_008a: Unknown result type (might be due to invalid IL or missing references)
					//IL_008f: Unknown result type (might be due to invalid IL or missing references)
					if ((Object)(object)Chat.instance == (Object)null)
					{
						return;
					}
					Guild ownGuild = API.GetOwnGuild();
					if (ownGuild == null)
					{
						args.Context.AddString("You are not in a guild.");
						return;
					}
					if (args.FullLine.Length > 2)
					{
						string text = args.FullLine.Substring(2);
						{
							foreach (PlayerInfo player in ZNet.instance.m_players)
							{
								ZDOID characterID = player.m_characterID;
								if (((ZDOID)(ref characterID)).UserID != 0L && ownGuild.Members.ContainsKey(PlayerReference.fromPlayerInfo(player)))
								{
									ZRoutedRpc instance = ZRoutedRpc.instance;
									characterID = player.m_characterID;
									instance.InvokeRoutedRPC(((ZDOID)(ref characterID)).UserID, "Guilds ChatMessage", new object[2]
									{
										UserInfo.GetLocalUser(),
										text
									});
								}
							}
							return;
						}
					}
					ToggleGuildsChat(!guildChatActive);
				}
			}

			private static void Postfix()
			{
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Expected O, but got Unknown
				guildChatPlaceholder = Localization.instance.Localize("$guilds_guild_chat_placeholder");
				object obj = <>c.<>9__0_0;
				if (obj == null)
				{
					ConsoleEvent val = delegate(ConsoleEventArgs args)
					{
						//IL_005a: Unknown result type (might be due to invalid IL or missing references)
						//IL_005f: Unknown result type (might be due to invalid IL or missing references)
						//IL_0060: Unknown result type (might be due to invalid IL or missing references)
						//IL_0061: Unknown result type (might be due to invalid IL or missing references)
						//IL_0066: Unknown result type (might be due to invalid IL or missing references)
						//IL_0077: Unknown result type (might be due to invalid IL or missing references)
						//IL_0089: Unknown result type (might be due to invalid IL or missing references)
						//IL_008a: Unknown result type (might be due to invalid IL or missing references)
						//IL_008f: Unknown result type (might be due to invalid IL or missing references)
						if (!((Object)(object)Chat.instance == (Object)null))
						{
							Guild ownGuild = API.GetOwnGuild();
							if (ownGuild == null)
							{
								args.Context.AddString("You are not in a guild.");
							}
							else
							{
								if (args.FullLine.Length > 2)
								{
									string text = args.FullLine.Substring(2);
									{
										foreach (PlayerInfo player in ZNet.instance.m_players)
										{
											ZDOID characterID = player.m_characterID;
											if (((ZDOID)(ref characterID)).UserID != 0L && ownGuild.Members.ContainsKey(PlayerReference.fromPlayerInfo(player)))
											{
												ZRoutedRpc instance = ZRoutedRpc.instance;
												characterID = player.m_characterID;
												instance.InvokeRoutedRPC(((ZDOID)(ref characterID)).UserID, "Guilds ChatMessage", new object[2]
												{
													UserInfo.GetLocalUser(),
													text
												});
											}
										}
										return;
									}
								}
								ToggleGuildsChat(!guildChatActive);
							}
						}
					};
					<>c.<>9__0_0 = val;
					obj = (object)val;
				}
				new ConsoleCommand("g", "toggles the guild chat on", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			}
		}

		[HarmonyPatch(typeof(Chat), "Awake")]
		public class AddGuildChat
		{
			private static void Postfix(Chat __instance)
			{
				int index = Math.Max(0, ((Terminal)__instance).m_chatBuffer.Count - 5);
				((Terminal)__instance).m_chatBuffer.Insert(index, "/g [text] Guild chat");
				((Terminal)__instance).m_chatBuffer.Insert(index, "/g Toggle guild chat");
				((Terminal)__instance).UpdateChat();
			}
		}

		[HarmonyPatch(typeof(Chat), "InputText")]
		public class SendMessageToGuild
		{
			private static void Prefix(Chat __instance)
			{
				if (((TMP_InputField)((Terminal)__instance).m_input).text.Length != 0 && guildChatActive && ((TMP_InputField)((Terminal)__instance).m_input).text[0] != '/')
				{
					((TMP_InputField)((Terminal)__instance).m_input).text = "/g " + ((TMP_InputField)((Terminal)__instance).m_input).text;
				}
			}
		}

		[HarmonyPatch(typeof(Game), "Start")]
		private static class AddRPCs
		{
			private static void Postfix()
			{
				ZRoutedRpc.instance.Register<UserInfo, string>("Guilds ChatMessage", (Action<long, UserInfo, string>)onChatMessageReceived);
				ZRoutedRpc.instance.Register<Vector3, int, UserInfo, string>("Guilds MapPing", (Method<Vector3, int, UserInfo, string>)Map.onMapPing);
				ZRoutedRpc.instance.Register<Vector3>("Guilds UpdatePosition", (Action<long, Vector3>)Map.onUpdatePosition);
			}
		}

		private static string guildChatPlaceholder;

		private static bool guildChatActive
		{
			get
			{
				if (Object.op_Implicit((Object)(object)Chat.instance))
				{
					return ((TMP_Text)((Component)((Component)((Terminal)Chat.instance).m_input).transform.Find("Text Area/Placeholder")).GetComponent<TextMeshProUGUI>()).text == guildChatPlaceholder;
				}
				return false;
			}
		}

		public static void ToggleGuildsChat(bool active)
		{
			if (Object.op_Implicit((Object)(object)Chat.instance))
			{
				TextMeshProUGUI component = ((Component)((Component)((Terminal)Chat.instance).m_input).transform.Find("Text Area/Placeholder")).GetComponent<TextMeshProUGUI>();
				if (active)
				{
					((TMP_Text)component).text = guildChatPlaceholder;
					Localization.instance.textMeshStrings[(TMP_Text)(object)component] = guildChatPlaceholder;
				}
				else if (((TMP_Text)component).text == guildChatPlaceholder)
				{
					((TMP_Text)component).text = Localization.instance.Localize("$chat_entertext");
					Localization.instance.textMeshStrings[(TMP_Text)(object)component] = "$chat_entertext";
				}
			}
		}

		private static void onChatMessageReceived(long senderId, UserInfo name, string message)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			string text = ((Guilds.guildColors.Value == Toggle.Off) ? ("#" + ColorUtility.ToHtmlStringRGBA(Guilds.guildChatColor.Value)) : API.GetOwnGuild().General.color);
			((Terminal)Chat.instance).AddString("<color=orange>" + name.Name + "</color>: <color=" + text + ">" + message + "</color>");
			Chat.instance.m_hideTimer = 0f;
			ZDOID characterID = ((IEnumerable<PlayerInfo>)ZNet.instance.m_players).FirstOrDefault((Func<PlayerInfo, bool>)((PlayerInfo p) => ((ZDOID)(ref p.m_characterID)).UserID == senderId)).m_characterID;
			if (!(characterID != ZDOID.None))
			{
				return;
			}
			GameObject val = ZNetScene.instance.FindInstance(characterID);
			if (val != null)
			{
				Player component = val.GetComponent<Player>();
				if (component != null && (!Object.op_Implicit((Object)(object)Minimap.instance) || !Object.op_Implicit((Object)(object)Player.m_localPlayer) || (int)Minimap.instance.m_mode != 0 || !(Vector3.Distance(((Component)Player.m_localPlayer).transform.position, ((Character)component).GetHeadPoint()) > Minimap.instance.m_nomapPingDistance)))
				{
					Chat.instance.AddInworldText(val, senderId, ((Character)component).GetHeadPoint(), (Type)1, name, "<color=" + text + ">" + message + "</color>");
				}
			}
		}
	}
	public static class Map
	{
		[HarmonyPatch(typeof(Game), "RequestRespawn")]
		private static class UpdateGuildIcon
		{
			private static void Postfix()
			{
				UpdateMapPinColor();
			}
		}

		[HarmonyPatch(typeof(Chat), "SendPing")]
		private static class RestrictPingsToGuildOnModifierHeld
		{
			[UsedImplicitly]
			private static bool RestrictBroadcast(ZRoutedRpc instance, long targetPeerId, string methodName, params object[] parameters)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: 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_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				Guild ownGuild = API.GetOwnGuild();
				if (ownGuild != null && targetPeerId == ZRoutedRpc.Everybody)
				{
					KeyboardShortcut value = Guilds.guildPingHotkey.Value;
					if (((KeyboardShortcut)(ref value)).IsPressed())
					{
						foreach (PlayerInfo player in ZNet.instance.m_players)
						{
							if (ownGuild.Members.ContainsKey(PlayerReference.fromPlayerInfo(player)))
							{
								ZDOID characterID = player.m_characterID;
								instance.InvokeRoutedRPC(((ZDOID)(ref characterID)).UserID, "Guilds MapPing", parameters);
							}
						}
						return true;
					}
				}
				return false;
			}

			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructionsEnumerable, ILGenerator ilg)
			{
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Expected O, but got Unknown
				//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0101: Expected O, but got Unknown
				MethodInfo routedRPC = AccessTools.DeclaredMethod(typeof(ZRoutedRpc), "InvokeRoutedRPC", new Type[3]
				{
					typeof(long),
					typeof(string),
					typeof(object[])
				}, (Type[])null);
				MethodInfo routedRPCInstance = AccessTools.DeclaredPropertyGetter(typeof(ZRoutedRpc), "instance");
				List<CodeInstruction> list = instructionsEnumerable.ToList();
				int num = list.FindIndex((CodeInstruction i) => CodeInstructionExtensions.Calls(i, routedRPC));
				int num2 = list.FindLastIndex(num, (CodeInstruction i) => CodeInstructionExtensions.Calls(i, routedRPCInstance));
				Label label = ilg.DefineLabel();
				list[num + 1].labels.Add(label);
				list.InsertRange(num2, list.Skip(num2).Take(num - num2).Concat((IEnumerable<CodeInstruction>)(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(RestrictPingsToGuildOnModifierHeld), "RestrictBroadcast", (Type[])null, (Type[])null)),
					new CodeInstruction(OpCodes.Brtrue, (object)label)
				})
					.ToArray());
				return list;
			}
		}

		[HarmonyPatch(typeof(Chat), "RPC_ChatMessage")]
		private class ClearGuildPing
		{
			public static void Prefix(Chat __instance, long sender)
			{
				WorldTextInstance val = __instance.FindExistingWorldText(sender);
				if (val == null || !guildPingTexts.Remove(val) || !Object.op_Implicit((Object)(object)Minimap.instance))
				{
					return;
				}
				for (int i = 0; i < Minimap.instance.m_tempShouts.Count; i++)
				{
					PinData val2 = Minimap.instance.m_pingPins[i];
					if (Minimap.instance.m_tempShouts[i] == val)
					{
						val2.m_icon = Minimap.instance.GetSprite((PinType)12);
						if (Object.op_Implicit((Object)(object)val2.m_iconElement))
						{
							val2.m_iconElement.sprite = val2.m_icon;
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(Minimap), "UpdatePlayerPins")]
		private class ChangeGuildMemberPin
		{
			[HarmonyPriority(500)]
			private static void Postfix(Minimap __instance)
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				for (int i = 0; i < __instance.m_tempPlayerInfo.Count; i++)
				{
					PinData val = __instance.m_playerPins[i];
					PlayerInfo val2 = __instance.m_tempPlayerInfo[i];
					if (val.m_name == val2.m_name)
					{
						bool flag = false;
						Guild? ownGuild = API.GetOwnGuild();
						if (ownGuild != null && ownGuild.Members.ContainsKey(PlayerReference.fromPlayerInfo(val2)))
						{
							val.m_icon = guildMapPlayerIcon;
							flag = true;
						}
						else if ((Object)(object)val.m_icon == (Object)(object)guildMapPlayerIcon)
						{
							val.m_icon = __instance.GetSprite((PinType)10);
							flag = true;
						}
						if (flag && Object.op_Implicit((Object)(object)val.m_iconElement))
						{
							val.m_iconElement.sprite = val.m_icon;
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(Minimap), "UpdatePingPins")]
		private class ChangeGuildMemberPing
		{
			private static void Postfix(Minimap __instance)
			{
				for (int i = 0; i < __instance.m_tempShouts.Count; i++)
				{
					PinData val = __instance.m_pingPins[i];
					WorldTextInstance key = __instance.m_tempShouts[i];
					if (guildPingTexts.TryGetValue(key, out object _))
					{
						val.m_icon = guildMapPingIcon;
						if (Object.op_Implicit((Object)(object)val.m_iconElement))
						{
							val.m_iconElement.sprite = val.m_icon;
						}
					}
				}
			}
		}

		[HarmonyPatch]
		private class PreservePlayerPosition
		{
			private static IEnumerable<MethodInfo> TargetMethods()
			{
				return new MethodInfo[2]
				{
					AccessTools.DeclaredMethod(typeof(ZNet), "RPC_PlayerList", (Type[])null, (Type[])null),
					AccessTools.DeclaredMethod(typeof(ZNet), "UpdatePlayerList", (Type[])null, (Type[])null)
				};
			}

			private static void Prefix(ZNet __instance, out Dictionary<long, Vector3> __state)
			{
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				__state = new Dictionary<long, Vector3>();
				Guild guild = API.GetOwnGuild();
				if (guild == null)
				{
					return;
				}
				foreach (PlayerInfo item in __instance.m_players.Where((PlayerInfo p) => guild.Members.ContainsKey(PlayerReference.fromPlayerInfo(p))))
				{
					Dictionary<long, Vector3> obj = __state;
					ZDOID characterID = item.m_characterID;
					obj[((ZDOID)(ref characterID)).UserID] = item.m_position;
				}
			}

			private static void Postfix(ZNet __instance, Dictionary<long, Vector3> __state)
			{
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				Guild ownGuild = API.GetOwnGuild();
				if (ownGuild == null)
				{
					return;
				}
				List<PlayerInfo> list = new List<PlayerInfo>();
				foreach (PlayerInfo player in __instance.m_players)
				{
					PlayerInfo val = player;
					if (ownGuild.Members.ContainsKey(PlayerReference.fromPlayerInfo(val)))
					{
						ZDOID characterID = val.m_characterID;
						Player localPlayer = Player.m_localPlayer;
						ZDOID? val2 = ((localPlayer != null) ? new ZDOID?(((Character)localPlayer).GetZDOID()) : null);
						if (!val2.HasValue || characterID != val2.GetValueOrDefault())
						{
							characterID = player.m_characterID;
							if (__state.TryGetValue(((ZDOID)(ref characterID)).UserID, out var value) && !player.m_publicPosition)
							{
								val.m_position = value;
							}
							val.m_publicPosition = true;
						}
					}
					list.Add(val);
				}
				__instance.m_players = list;
			}
		}

		private static Sprite guildMapPlayerIcon = null;

		private static Sprite guildMapPingIcon = null;

		private static readonly ConditionalWeakTable<WorldTextInstance, object> guildPingTexts = new ConditionalWeakTable<WorldTextInstance, object>();

		private static readonly Color defaultColor = new Color(1f, 61f / 85f, 49f / 136f);

		public static void Init()
		{
			guildMapPlayerIcon = Tools.loadSprite("guildPlayerIcon.png", 64, 64);
			guildMapPingIcon = Tools.loadSprite("guildMapPingIcon.png", 64, 64);
		}

		public static void onMapPing(long senderId, Vector3 position, int type, UserInfo name, string text)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			Guild ownGuild = API.GetOwnGuild();
			if (ownGuild != null)
			{
				Color color = default(Color);
				ColorUtility.TryParseHtmlString(ownGuild.General.color, ref color);
				Chat.instance.RPC_ChatMessage(senderId, position, type, name, text);
				WorldTextInstance val = Chat.instance.FindExistingWorldText(senderId);
				((Graphic)val.m_textMeshField).color = color;
				guildPingTexts.Add(val, Array.Empty<object>());
			}
		}

		internal static void UpdateMapPinColor()
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			Guild ownGuild = API.GetOwnGuild();
			if (ownGuild == null)
			{
				return;
			}
			Color val = default(Color);
			ColorUtility.TryParseHtmlString(ownGuild.General.color, ref val);
			Color[] pixels = Tools.loadTexture("guildPlayerIcon.png").GetPixels();
			for (int i = 0; i < pixels.Length; i++)
			{
				if ((double)pixels[i].r > 0.5 && (double)pixels[i].b < 0.5 && (double)pixels[i].g < 0.5)
				{
					pixels[i] = val;
				}
			}
			guildMapPlayerIcon.texture.SetPixels(pixels);
			guildMapPlayerIcon.texture.Apply();
			pixels = Tools.loadTexture("guildMapPingIcon.png").GetPixels();
			for (int j = 0; j < pixels.Length; j++)
			{
				if ((double)pixels[j].r > 0.5 && (double)pixels[j].b < 0.5 && (double)pixels[j].g < 0.5)
				{
					pixels[j].b = val.b;
					pixels[j].g = val.g;
					pixels[j].r = val.r;
				}
			}
			guildMapPingIcon.texture.SetPixels(pixels);
			guildMapPingIcon.texture.Apply();
		}

		internal static void onUpdatePosition(long senderId, Vector3 position)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			List<PlayerInfo> list = new List<PlayerInfo>();
			foreach (PlayerInfo player in ZNet.instance.m_players)
			{
				PlayerInfo current = player;
				if (((ZDOID)(ref current.m_characterID)).UserID == senderId)
				{
					current.m_position = position;
				}
				list.Add(current);
			}
			ZNet.instance.m_players = list;
		}
	}
	[BepInPlugin("org.bepinex.plugins.guilds", "Guilds", "1.1.13")]
	[BepInIncompatibility("org.bepinex.plugins.valheim_plus")]
	public class Guilds : BaseUnityPlugin
	{
		internal enum GuildAchievements
		{
			Disabled,
			Default,
			External
		}

		[HarmonyPatch(typeof(FejdStartup), "Awake")]
		private static class ReadGuildList
		{
			private static bool first = true;

			private static void Postfix()
			{
				if (first)
				{
					first = false;
					string saveDataPath = Utils.GetSaveDataPath((FileSource)1);
					char directorySeparatorChar = Path.DirectorySeparatorChar;
					GuildsPath = saveDataPath + directorySeparatorChar + "Guilds";
					GuildList.Init();
					GuildList.readGuildFiles();
					addFileWatchEvent(new FileSystemWatcher(GuildsPath, "*.yml"), delegate
					{
						GuildList.readGuildFiles();
					});
				}
			}
		}

		[HarmonyPatch(typeof(Game), "Start")]
		private class ShowPlayerMessage
		{
			private static void Postfix()
			{
				ZRoutedRpc.instance.Register<string>("Guilds PlayerMessage", (Action<long, string>)delegate(long _, string message)
				{
					MessageHud.instance.ShowMessage((MessageType)2, message, 0, (Sprite)null, false);
				});
			}
		}

		private const string ModName = "Guilds";

		private const string ModVersion = "1.1.13";

		private const string ModGUID = "org.bepinex.plugins.guilds";

		public static readonly ConfigSync configSync = new ConfigSync("Guilds")
		{
			DisplayName = "Guilds",
			CurrentVersion = "1.1.13",
			MinimumRequiredVersion = "1.1.13"
		};

		internal static Guilds self = null;

		public static string GuildsPath = null;

		private static ConfigEntry<Toggle> serverConfigLocked = null;

		internal static ConfigEntry<Toggle> friendlyFire = null;

		internal static ConfigEntry<KeyboardShortcut> guildInterfaceKey = null;

		internal static ConfigEntry<Toggle> displayGuildLevel = null;

		internal static ConfigEntry<Toggle> guildColors = null;

		internal static ConfigEntry<Color> guildChatColor = null;

		internal static ConfigEntry<int> minimumGuildNameLength = null;

		internal static ConfigEntry<int> maximumGuildNameLength = null;

		internal static ConfigEntry<uint> maximumGuildMembers = null;

		internal static ConfigEntry<Toggle> allowGuildCreation = null;

		internal static ConfigEntry<Toggle> allowGuildEdit = null;

		internal static ConfigEntry<KeyboardShortcut> guildPingHotkey = null;

		internal static ConfigEntry<GuildAchievements> guildAchievementConfig = null;

		private ConfigEntry<T> config<T>(string group, string name, T value, ConfigDescription description, bool synchronizedSetting = true)
		{
			ConfigEntry<T> val = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, description);
			configSync.AddConfigEntry<T>(val).SynchronizedConfig = synchronizedSetting;
			return val;
		}

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

		public void Awake()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Expected O, but got Unknown
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Expected O, but got Unknown
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Expected O, but got Unknown
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Expected O, but got Unknown
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Expected O, but got Unknown
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Expected O, but got Unknown
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Expected O, but got Unknown
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Expected O, but got Unknown
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			self = this;
			Patcher.Patch();
			Localizer.Load();
			serverConfigLocked = config("1 - General", "Lock Configuration", Toggle.Off, new ConfigDescription("Locks the config and enforces the servers configuration.", (AcceptableValueBase)null, Array.Empty<object>()));
			configSync.AddLockingConfigEntry<Toggle>(serverConfigLocked);
			guildInterfaceKey = config<KeyboardShortcut>("1 - General", "Guild Interface Key", new KeyboardShortcut((KeyCode)111, Array.Empty<KeyCode>()), new ConfigDescription("Keyboard shortcut to press in order to display the guild interface.", (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting: false);
			friendlyFire = config("1 - General", "Friendly fire in guilds", Toggle.Off, new ConfigDescription("If members from the same guild can damage each other in PvP.", (AcceptableValueBase)null, Array.Empty<object>()));
			displayGuildLevel = config("1 - General", "Display guild level on nameplate", Toggle.Off, new ConfigDescription("Displays the level of the guild after its name on nameplates.", (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting: false);
			guildColors = config("1 - General", "Guild Colors", Toggle.On, new ConfigDescription("If off, the guild colors will be replaced with Valheims default colors instead.", (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting: false);
			guildChatColor = config<Color>("1 - General", "Guild Chat Color", new Color(1f, 61f / 85f, 49f / 136f), new ConfigDescription("The color for messages in the guild chat.", (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting: false);
			minimumGuildNameLength = config("1 - General", "Minimum Name Length", 2, new ConfigDescription("The minimum length of guild names as the number of characters.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 16), Array.Empty<object>()));
			minimumGuildNameLength.SettingChanged += delegate
			{
				if (minimumGuildNameLength.Value > maximumGuildNameLength.Value)
				{
					minimumGuildNameLength.Value = maximumGuildNameLength.Value;
				}
			};
			maximumGuildNameLength = config("1 - General", "Maximum Name Length", 32, new ConfigDescription("The maximum length of guild names as the number of characters.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(2, 64), Array.Empty<object>()));
			maximumGuildNameLength.SettingChanged += delegate
			{
				if (maximumGuildNameLength.Value < minimumGuildNameLength.Value)
				{
					maximumGuildNameLength.Value = minimumGuildNameLength.Value;
				}
			};
			allowGuildCreation = config("1 - General", "Allow Guild Creation", Toggle.On, new ConfigDescription("If off, only admins can create new guilds.", (AcceptableValueBase)null, Array.Empty<object>()));
			allowGuildEdit = config("1 - General", "Allow Guild Edit", Toggle.On, new ConfigDescription("If off, only admins can edit guilds.", (AcceptableValueBase)null, Array.Empty<object>()));
			guildPingHotkey = config<KeyboardShortcut>("1 - General", "Guild Ping Modifier Key", new KeyboardShortcut((KeyCode)304, Array.Empty<KeyCode>()), new ConfigDescription("Modifier key that has to be pressed while pinging the map, to make the map ping visible to guild members only.", (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting: false);
			maximumGuildMembers = config("1 - General", "Maximum Guild Members", 0u, new ConfigDescription("Maximum number of guild members per guild. Set to 0 for no maximum.", (AcceptableValueBase)null, Array.Empty<object>()));
			guildAchievementConfig = config("2 - Achievements", "Ignore Internal Achievement Config", GuildAchievements.Default, new ConfigDescription("Disabled: Guild achievements are disabled and not available on your server.\nDefault: The internal guild achievement config is enabled and can be adjusted via an optional external AchievementConfig.yml file.\nExternal: The internal guild achievement configs are ignored and guild achievements are parsed from an external AchievementConfig.yml file only. This means that you have to keep track of newly added achievements yourself and add them to your config file, if you want to have them on your server.", (AcceptableValueBase)null, Array.Empty<object>()));
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			new Harmony("org.bepinex.plugins.guilds").PatchAll(executingAssembly);
			Interface.LoadAssets();
			Map.Init();
			Achievements.Init();
			((MonoBehaviour)this).InvokeRepeating("updatePositon", 0f, 2f);
		}

		public void Update()
		{
			Interface.Update();
		}

		internal static void addFileWatchEvent(FileSystemWatcher watcher, Action<object, EventArgs> handler)
		{
			watcher.Created += handler.Invoke;
			watcher.Changed += handler.Invoke;
			watcher.Renamed += handler.Invoke;
			watcher.Deleted += handler.Invoke;
			watcher.IncludeSubdirectories = true;
			watcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			watcher.EnableRaisingEvents = true;
		}

		public static void SendMessageToPlayer(PlayerReference player, string message)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			PlayerInfo val = ((IEnumerable<PlayerInfo>)ZNet.instance.m_players).FirstOrDefault((Func<PlayerInfo, bool>)((PlayerInfo p) => PlayerReference.fromPlayerInfo(p) == player));
			ZDOID characterID = val.m_characterID;
			if (((ZDOID)(ref characterID)).UserID != 0L)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(((ZDOID)(ref val.m_characterID)).UserID, "Guilds PlayerMessage", new object[1] { message });
			}
		}

		public static void SendMessageToAllPlayers(string message)
		{
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "Guilds PlayerMessage", new object[1] { message });
		}

		private void updatePositon()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer == null)
			{
				return;
			}
			Guild ownGuild = API.GetOwnGuild();
			if (ownGuild == null || ZNet.instance.m_publicReferencePosition)
			{
				return;
			}
			foreach (PlayerInfo player in ZNet.instance.m_players)
			{
				if (ownGuild.Members.ContainsKey(PlayerReference.fromPlayerInfo(player)) && player.m_characterID != ((Character)localPlayer).GetZDOID())
				{
					ZRoutedRpc instance = ZRoutedRpc.instance;
					ZDOID characterID = player.m_characterID;
					instance.InvokeRoutedRPC(((ZDOID)(ref characterID)).UserID, "Guilds UpdatePosition", new object[1] { ((Component)localPlayer).transform.position });
				}
			}
		}
	}
	[PublicAPI]
	public class GuildConfigSerialized
	{
		public GuildGeneral general = new GuildGeneral();

		public List<GuildMemberClass> members = new List<GuildMemberClass>();

		public List<ApplicationClass> applications = new List<ApplicationClass>();

		public Dictionary<string, AchievementData> achievements = new Dictionary<string, AchievementData>();

		[<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMember(Alias = "custom data", ApplyNamingConventions = false)]
		public CustomData customData = new CustomData();

		public Guild toGuild(string name)
		{
			return new Guild
			{
				Name = name,
				Members = new Dictionary<PlayerReference, GuildMember>(members.ToDictionary((GuildMemberClass m) => m.player, (GuildMemberClass m) => new GuildMember
				{
					rank = m.rank,
					lastOnline = m.lastOnline
				})),
				General = general,
				Applications = new Dictionary<PlayerReference, Application>(applications.ToDictionary((ApplicationClass a) => a.player, (ApplicationClass a) => new Application
				{
					applied = a.applied,
					description = a.description
				})),
				Achievements = achievements,
				customData = customData
			};
		}

		public static GuildConfigSerialized fromGuildConfig(Guild from)
		{
			return new GuildConfigSerialized
			{
				members = from.Members.Select<KeyValuePair<PlayerReference, GuildMember>, GuildMemberClass>((KeyValuePair<PlayerReference, GuildMember> kv) => new GuildMemberClass
				{
					player = kv.Key,
					rank = kv.Value.rank,
					lastOnline = kv.Value.lastOnline
				}).ToList(),
				applications = from.Applications.Select<KeyValuePair<PlayerReference, Application>, ApplicationClass>((KeyValuePair<PlayerReference, Application> kv) => new ApplicationClass
				{
					player = kv.Key,
					applied = kv.Value.applied,
					description = kv.Value.description
				}).ToList(),
				general = from.General,
				customData = from.customData,
				achievements = from.Achievements
			};
		}
	}
	[PublicAPI]
	public class GuildMemberClass
	{
		public PlayerReference player;

		public Ranks rank;

		[<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMember(Alias = "last online", ApplyNamingConventions = false)]
		public DateTime lastOnline;
	}
	[PublicAPI]
	public class ApplicationClass
	{
		public PlayerReference player;

		public DateTime applied = DateTime.Now;

		public string description = "";
	}
	public class CustomDataConverter : <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter
	{
		[CompilerGenerated]
		private <cba6ec40-2546-4a46-9577-18d27987fd9e>IValueDeserializer <valueDeserializer>P;

		[CompilerGenerated]
		private <cba6ec40-2546-4a46-9577-18d27987fd9e>IValueSerializer <valueSerializer>P;

		public static readonly Dictionary<string, Type> RegisteredCustomTypes = new Dictionary<string, Type>();

		public CustomDataConverter(<cba6ec40-2546-4a46-9577-18d27987fd9e>IValueDeserializer valueDeserializer, <cba6ec40-2546-4a46-9577-18d27987fd9e>IValueSerializer valueSerializer)
		{
			<valueDeserializer>P = valueDeserializer;
			<valueSerializer>P = valueSerializer;
			base..ctor();
		}

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

		public object ReadYaml(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type _, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer)
		{
			parser.Consume<<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart>();
			CustomData customData = new CustomData();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEnd @event;
			while (!parser.TryConsume<<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEnd>(out @event))
			{
				string key = (string)<valueDeserializer>P.DeserializeValue(parser, typeof(string), new <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerState(), <valueDeserializer>P);
				if (RegisteredCustomTypes.TryGetValue(key, out Type value))
				{
					object obj = <valueDeserializer>P.DeserializeValue(parser, value, new <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerState(), <valueDeserializer>P);
					if (obj != null)
					{
						customData.data.Add(value, obj);
					}
				}
				else
				{
					object obj2 = <valueDeserializer>P.DeserializeValue(parser, typeof(object), new <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerState(), <valueDeserializer>P);
					if (obj2 != null)
					{
						customData.unknown.Add(key, obj2);
					}
				}
			}
			return customData;
		}

		public void WriteYaml(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, object? value, Type type, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			if (value == null)
			{
				return;
			}
			CustomData customData = (CustomData)value;
			emitter.Emit(new <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart());
			foreach (KeyValuePair<Type, object> datum in customData.data)
			{
				<valueSerializer>P.SerializeValue(emitter, datum.Key.FullName, typeof(string));
				<valueSerializer>P.SerializeValue(emitter, datum.Value, datum.Key);
			}
			foreach (KeyValuePair<string, object> item in customData.unknown)
			{
				<valueSerializer>P.SerializeValue(emitter, item.Key, typeof(string));
				<valueSerializer>P.SerializeValue(emitter, item.Value, typeof(object));
			}
			emitter.Emit(new <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEnd());
		}
	}
	public static class GuildSerialization
	{
		private static readonly CustomDataConverter customDataConverter = new CustomDataConverter(new <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder().WithTypeConverter(new ZDOIDYamlConverter()).BuildValueDeserializer(), new <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder().WithTypeConverter(new ZDOIDYamlConverter()).BuildValueSerializer());

		private static readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IDeserializer Deserializer = new <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder().WithNamingConvention(<cba6ec40-2546-4a46-9577-18d27987fd9e>CamelCaseNamingConvention.Instance).WithTypeConverter(new ZDOIDYamlConverter()).WithTypeConverter(customDataConverter)
			.Build();

		private static readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ISerializer Serializer = new <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder().WithNamingConvention(<cba6ec40-2546-4a46-9577-18d27987fd9e>CamelCaseNamingConvention.Instance).WithTypeConverter(new ZDOIDYamlConverter()).WithTypeConverter(customDataConverter)
			.Build();

		public static T Deserialize<T>(string yaml)
		{
			return Deserializer.Deserialize<T>(yaml);
		}

		public static object? Deserialize(string yaml, Type type)
		{
			return Deserializer.Deserialize(yaml, type);
		}

		public static string Serialize<T>(T guild) where T : notnull
		{
			return Serializer.Serialize(guild);
		}
	}
	internal static class GuildList
	{
		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class GuildListManipulationListener
		{
			[UsedImplicitly]
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				if (__instance.IsServer())
				{
					peer.m_rpc.Register<ZPackage>("Guild Create Guild", (Action<ZRpc, ZPackage>)AddGuild);
					peer.m_rpc.Register<ZPackage>("Guild Update Guild", (Action<ZRpc, ZPackage>)UpdateGuild);
					peer.m_rpc.Register<ZPackage>("Guild Remove Guild", (Action<ZRpc, ZPackage>)RemoveGuild);
					peer.m_rpc.Register<ZPackage>("Guild Rename Guild", (Action<ZRpc, ZPackage>)RenameGuild);
					peer.m_rpc.Register<ZPackage>("Guild Increase Achievement", (Action<ZRpc, ZPackage>)IncreaseAchievement);
				}
				else
				{
					peer.m_rpc.Register<int>("Guild Update Ack", (Action<ZRpc, int>)AckUpdate);
					peer.m_rpc.Register<string, string, string>("Guild Achievement Completed", (Action<ZRpc, string, string, string>)CompletedAchievement);
				}
			}

			private static void AckUpdate(ZRpc rpc, int id)
			{
				unappliedChanges.Remove(id);
			}

			public static void UpdateGuild(ZRpc? rpc, ZPackage zpkg)
			{
				int num = zpkg.ReadInt();
				string text = zpkg.ReadString();
				Dictionary<string[], object> dictionary = new Dictionary<string[], object>();
				int num2 = zpkg.ReadInt();
				for (int i = 0; i < num2; i++)
				{
					string[] array = new string[zpkg.ReadInt()];
					for (int j = 0; j < array.Length; j++)
					{
						array[j] = zpkg.ReadString();
					}
					object value = null;
					string text2 = zpkg.ReadString();
					if (text2 != "")
					{
						Type type = Type.GetType(text2);
						if ((object)type != null)
						{
							value = GuildSerialization.Deserialize(zpkg.ReadString(), type);
						}
					}
					dictionary.Add(array, value);
				}
				Guild baseTarget = guildList[text];
				HashSet<PlayerReference> hashSet = new HashSet<PlayerReference>(baseTarget.Members.Keys);
				ObjectDiff.ApplyDiff(ref baseTarget, dictionary);
				guildList[text] = baseTarget;
				foreach (PlayerReference item in baseTarget.Members.Keys.Except(hashSet))
				{
					API.InvokeGuildJoined(baseTarget, item);
				}
				foreach (PlayerReference item2 in hashSet.Except(baseTarget.Members.Keys))
				{
					API.InvokeGuildLeft(baseTarget, item2);
				}
				WriteGuild(text);
				if (rpc != null)
				{
					rpc.Invoke("Guild Update Ack", new object[1] { num });
				}
			}

			public static void AddGuild(ZRpc? rpc, ZPackage zpkg)
			{
				Guild guild = GuildSerialization.Deserialize<Guild>(zpkg.ReadString());
				if (!guildList.ContainsKey(guild.Name))
				{
					guildList[guild.Name] = guild;
				}
				WriteGuild(guild.Name);
			}

			public static void RemoveGuild(ZRpc? rpc, ZPackage zpkg)
			{
				string key = zpkg.ReadString();
				guildEntries.Value.Remove(key);
				guildEntries.Value = guildEntries.Value;
			}

			public static void RenameGuild(ZRpc? rpc, ZPackage zpkg)
			{
				string key = zpkg.ReadString();
				string key2 = zpkg.ReadString();
				if (guildEntries.Value.TryGetValue(key, out string value))
				{
					guildEntries.Value[key2] = value;
					guildEntries.Value.Remove(key);
					guildEntries.Value = guildEntries.Value;
				}
			}

			public static void IncreaseAchievement(ZRpc? rpc, ZPackage package)
			{
				int num = package.ReadInt();
				string achievement = package.ReadString();
				float num2 = package.ReadSingle();
				if (!guildsById.TryGetValue(num, out Guild value))
				{
					return;
				}
				AchievementConfig achievementConfig = Achievements.GetAchievementConfig(achievement);
				if (achievementConfig == null)
				{
					return;
				}
				if (!value.Achievements.TryGetValue(achievement, out AchievementData value2))
				{
					value2 = (value.Achievements[achievement] = new AchievementData());
					if (achievementConfig.first && API.GetGuilds().Any(delegate(Guild g)
					{
						if (g.Achievements.TryGetValue(achievement, out AchievementData value4))
						{
							float? progress2 = value4.progress;
							return !progress2.HasValue;
						}
						return false;
					}))
					{
						value2.progress = null;
					}
				}
				float? progress = value2.progress;
				if (!progress.HasValue || value2.completed.Count >= achievementConfig.progress.Count)
				{
					return;
				}
				value2.progress += num2;
				if (value2.progress >= achievementConfig.progress[value2.completed.Count])
				{
					if (achievementConfig.first)
					{
						foreach (Guild guild in API.GetGuilds())
						{
							if (guild.Achievements.TryGetValue(achievement, out AchievementData value3))
							{
								value3.progress = null;
							}
						}
					}
					value2.completed.Add(DateTime.Now);
					value.General.level += achievementConfig.GetLevel(value2.completed.Count);
					WriteGuild(num);
					PlayerReference playerReference = PlayerReference.fromRPC(rpc);
					foreach (ZNetPeer connectedPeer in ZNet.instance.GetConnectedPeers())
					{
						connectedPeer.m_rpc.Invoke("Guild Achievement Completed", new object[3] { playerReference.name, playerReference.id, achievement });
					}
					CompletedAchievement(null, playerReference.name, playerReference.id, achievement);
				}
				else
				{
					DelayedGuildUpdate(num);
				}
			}

			private static void CompletedAchievement(ZRpc? rpc, string name, string id, string achievement)
			{
				PlayerReference playerReference = default(PlayerReference);
				playerReference.id = id;
				playerReference.name = name;
				PlayerReference player = playerReference;
				foreach (API.AchievementCompleted achievementCompletedCallback in Achievements.achievementCompletedCallbacks)
				{
					achievementCompletedCallback(player, achievement);
				}
			}
		}

		[CompilerGenerated]
		private sealed class <<DelayedGuildUpdate>g__NotifyPendingChanges|11_0>d : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

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

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

			[DebuggerHidden]
			public <<DelayedGuildUpdate>g__NotifyPendingChanges|11_0>d(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					HashSet<int> guildsWithPendingChanges = GuildList.guildsWithPendingChanges;
					GuildList.guildsWithPendingChanges = new HashSet<int>();
					foreach (int item in guildsWithPendingChanges)
					{
						WriteGuild(item);
					}
					return false;
				}
				}
			}

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

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

		private static readonly CustomSyncedValue<Dictionary<string, string>> guildEntries = new CustomSyncedValue<Dictionary<string, string>>(Guilds.configSync, "guildEntries");

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

		private static readonly SortedDictionary<int, KeyValuePair<string, Dictionary<string[], object?>>> unappliedChanges = new SortedDictionary<int, KeyValuePair<string, Dictionary<string[], object>>>();

		private static int changeCount = 0;

		private static bool GuildIOActive = false;

		public static readonly Dictionary<string, Guild> guildList = new Dictionary<string, Guild>();

		public static Dictionary<int, Guild> guildsById = new Dictionary<int, Guild>();

		private static readonly Dictionary<string, Guild> guildBackup = new Dictionary<string, Guild>();

		private static HashSet<int> guildsWithPendingChanges = new HashSet<int>();

		private static bool truthSource = false;

		public static void Init()
		{
			guildEntries.ValueChanged += delegate
			{
				bool flag = truthSource == Guilds.configSync.IsSourceOfTruth;
				truthSource = Guilds.configSync.IsSourceOfTruth;
				HashSet<string> hashSet = new HashSet<string>();
				bool guildIOActive = GuildIOActive;
				GuildIOActive = true;
				if (Guilds.configSync.IsSourceOfTruth && !guildIOActive)
				{
					foreach (KeyValuePair<string, string> item in guildEntries.Value.Where<KeyValuePair<string, string>>((KeyValuePair<string, string> kv) => !oldEntries.ContainsKey(kv.Key) || oldEntries[kv.Key] != kv.Value))
					{
						hashSet.Add(item.Key);
					}
					foreach (string item2 in oldEntries.Keys.Except(guildEntries.Value.Keys))
					{
						string guildsPath = Guilds.GuildsPath;
						char directorySeparatorChar = Path.DirectorySeparatorChar;
						File.Delete(guildsPath + directorySeparatorChar + item2 + ".yml");
					}
					oldEntries = guildEntries.Value.ToDictionary<KeyValuePair<string, string>, string, string>((KeyValuePair<string, string> kv) => kv.Key, (KeyValuePair<string, string> kv) => kv.Value);
				}
				Dictionary<int, Guild> dictionary = guildsById;
				guildsById = new Dictionary<int, Guild>();
				guildList.Clear();
				guildBackup.Clear();
				foreach (KeyValuePair<string, string> syncedEntry in guildEntries.Value)
				{
					try
					{
						string key = syncedEntry.Key;
						foreach (char c in key)
						{
							if (!Tools.ValidateChar(c))
							{
								throw new InvalidDataException($"Invalid character {(int)c} in guild name");
							}
						}
						Guild baseTarget = GuildSerialization.Deserialize<Guild>(syncedEntry.Value);
						if (baseTarget != null)
						{
							Guild baseTarget2 = GuildSerialization.Deserialize<Guild>(syncedEntry.Value);
							foreach (Dictionary<string[], object> item3 in from kv in unappliedChanges.Values
								where kv.Key == syncedEntry.Key
								select kv.Value)
							{
								ObjectDiff.ApplyDiff(ref baseTarget, item3);
								ObjectDiff.ApplyDiff(ref baseTarget2, item3);
							}
							guildsById.Add(baseTarget.General.id, baseTarget);
							guildList.Add(syncedEntry.Key, baseTarget);
							guildBackup.Add(syncedEntry.Key, baseTarget2);
							if (flag)
							{
								if (!dictionary.TryGetValue(baseTarget.General.id, out var value))
								{
									API.InvokeGuildCreated(baseTarget);
								}
								IEnumerable<PlayerReference> enumerable = value?.Members.Keys;
								HashSet<PlayerReference> hashSet2 = new HashSet<PlayerReference>(enumerable ?? Enumerable.Empty<PlayerReference>());
								foreach (PlayerReference item4 in baseTarget.Members.Keys.Except(hashSet2))
								{
									API.InvokeGuildJoined(baseTarget, item4);
								}
								foreach (PlayerReference item5 in hashSet2.Except(baseTarget.Members.Keys))
								{
									API.InvokeGuildLeft(baseTarget, item5);
								}
							}
							if (!guildIOActive && hashSet.Contains(syncedEntry.Key))
							{
								string guildsPath2 = Guilds.GuildsPath;
								char directorySeparatorChar = Path.DirectorySeparatorChar;
								File.WriteAllText(guildsPath2 + directorySeparatorChar + syncedEntry.Key + ".yml", GuildSerialization.Serialize(GuildConfigSerialized.fromGuildConfig(baseTarget)));
							}
						}
					}
					catch (Exception arg)
					{
						Debug.LogError((object)$"Failed to deserialize internally transferred guild file {syncedEntry.Key}: {arg}");
					}
				}
				if (flag)
				{
					foreach (KeyValuePair<int, Guild> item6 in dictionary)
					{
						if (!guildsById.ContainsKey(item6.Key))
						{
							foreach (PlayerReference key2 in item6.Value.Members.Keys)
							{
								API.InvokeGuildLeft(item6.Value, key2);
							}
							API.InvokeGuildDeleted(item6.Value);
						}
					}
				}
				GuildIOActive = guildIOActive;
				if (Object.op_Implicit((Object)(object)Interface.GuildManagementUI))
				{
					Interface.GuildManagementUI.GetComponent<GuildManagementUI>().UpdateRows();
					Interface.ApplicationsUI.GetComponent<ApplicationsUI>().UpdateRows();
					Interface.SearchGuildUI.GetComponent<SearchGuildUI>().UpdateRows();
					if (API.GetOwnGuild() != null)
					{
						if (Interface.NoGuildUI.activeSelf || Interface.CreateGuildUI.activeSelf)
						{
							Interface.SwitchUI(Interface.GuildManagementUI);
						}
						Map.UpdateMapPinColor();
					}
					else
					{
						GuildChat.ToggleGuildsChat(active: false);
					}
				}
			};
		}

		private static void DelayedGuildUpdate(int guild)
		{
			if (guildsWithPendingChanges.Count == 0)
			{
				((MonoBehaviour)Guilds.self).StartCoroutine(NotifyPendingChanges());
			}
			guildsWithPendingChanges.Add(guild);
			[IteratorStateMachine(typeof(<<DelayedGuildUpdate>g__NotifyPendingChanges|11_0>d))]
			static IEnumerator NotifyPendingChanges()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <<DelayedGuildUpdate>g__NotifyPendingChanges|11_0>d(0);
			}
		}

		public static void readGuildFiles()
		{
			if (GuildIOActive)
			{
				return;
			}
			GuildIOActive = true;
			Directory.CreateDirectory(Guilds.GuildsPath);
			oldEntries.Clear();
			foreach (FileInfo item in from s in Directory.GetFiles(Guilds.GuildsPath)
				select new FileInfo(s) into file
				where file.Name.EndsWith(".yml", StringComparison.Ordinal)
				select file)
			{
				try
				{
					string text = item.Name.Replace(".yml", "");
					GuildConfigSerialized guildConfigSerialized = GuildSerialization.Deserialize<GuildConfigSerialized>(File.ReadAllText(item.FullName));
					if (guildConfigSerialized != null)
					{
						GuildConfigSerialized guildConfigSerialized2 = guildConfigSerialized;
						if (guildConfigSerialized2.members == null)
						{
							guildConfigSerialized2.members = new List<GuildMemberClass>();
						}
						guildConfigSerialized2 = guildConfigSerialized;
						if (guildConfigSerialized2.general == null)
						{
							guildConfigSerialized2.general = new GuildGeneral();
						}
						guildConfigSerialized2 = guildConfigSerialized;
						if (guildConfigSerialized2.applications == null)
						{
							guildConfigSerialized2.applications = new List<ApplicationClass>();
						}
						guildConfigSerialized2 = guildConfigSerialized;
						if (guildConfigSerialized2.customData == null)
						{
							guildConfigSerialized2.customData = new CustomData();
						}
						Guild guild = guildConfigSerialized.toGuild(text);
						oldEntries.Add(text, GuildSerialization.Serialize(guild));
					}
				}
				catch (Exception arg)
				{
					Debug.LogError((object)$"Failed to deserialize guild file {item.Name}: {arg}");
				}
			}
			guildEntries.AssignLocalValue(oldEntries.ToDictionary<KeyValuePair<string, string>, string, string>((KeyValuePair<string, string> kv) => kv.Key, (KeyValuePair<string, string> kv) => kv.Value));
			GuildIOActive = false;
		}

		private static void WriteGuild(string guildName)
		{
			guildsWithPendingChanges.Remove(guildList[guildName].General.id);
			guildEntries.Value[guildName] = GuildSerialization.Serialize(guildList[guildName]);
			guildEntries.Value = guildEntries.Value;
		}

		private static void WriteGuild(int guildId)
		{
			if (guildsById.TryGetValue(guildId, out Guild value))
			{
				WriteGuild(value.Name);
			}
		}

		public static void removeGuild(string guildName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(guildName);
			guildBackup.Remove(guildName);
			ZRpc serverRPC = ZNet.m_instance.GetServerRPC();
			if (serverRPC != null)
			{
				serverRPC.Invoke("Guild Remove Guild", new object[1] { val });
			}
			else
			{
				val.SetPos(0);
				GuildListManipulationListener.RemoveGuild(null, val);
			}
		}

		public static void renameGuild(string oldName, string newName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(oldName);
			val.Write(newName);
			guildBackup[newName] = guildBackup[oldName];
			guildBackup.Remove(oldName);
			ZRpc serverRPC = ZNet.m_instance.GetServerRPC();
			if (serverRPC != null)
			{
				serverRPC.Invoke("Guild Rename Guild", new object[1] { val });
			}
			else
			{
				val.SetPos(0);
				GuildListManipulationListener.RenameGuild(null, val);
			}
		}

		public static void updateGuild(string guildName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			if (guildBackup.ContainsKey(guildName))
			{
				val.Write(++changeCount);
				val.Write(guildName);
				Dictionary<string[], object> dictionary = ObjectDiff.diff(guildBackup[guildName], guildList[guildName]);
				val.Write(dictionary.Count);
				foreach (KeyValuePair<string[], object> item in dictionary)
				{
					val.Write(item.Key.Length);
					string[] key = item.Key;
					foreach (string text in key)
					{
						val.Write(text);
					}
					if (item.Value == null)
					{
						val.Write("");
						continue;
					}
					val.Write(item.Value.GetType().AssemblyQualifiedName);
					string text2 = GuildSerialization.Serialize(item.Value);
					val.Write(text2);
					Guild baseTarget = guildBackup[guildName];
					ObjectDiff.ApplyDiff(ref baseTarget, new Dictionary<string[], object> { 
					{
						item.Key,
						GuildSerialization.Deserialize(text2, item.Value.GetType())
					} });
					guildBackup[guildName] = baseTarget;
				}
				ZRpc serverRPC = ZNet.m_instance.GetServerRPC();
				if (serverRPC != null)
				{
					unappliedChanges.Add(changeCount, new KeyValuePair<string, Dictionary<string[], object>>(guildName, dictionary));
					serverRPC.Invoke("Guild Update Guild", new object[1] { val });
				}
				else
				{
					val.SetPos(0);
					GuildListManipulationListener.UpdateGuild(null, val);
				}
			}
			else
			{
				string text3 = GuildSerialization.Serialize(guildList[guildName]);
				val.Write(text3);
				guildBackup[guildName] = GuildSerialization.Deserialize<Guild>(text3);
				ZRpc serverRPC2 = ZNet.m_instance.GetServerRPC();
				if (serverRPC2 != null)
				{
					serverRPC2.Invoke("Guild Create Guild", new object[1] { val });
				}
				else
				{
					val.SetPos(0);
					GuildListManipulationListener.AddGuild(null, val);
				}
			}
		}

		public static void increaseAchievement(int guildId, string achievement, float increment)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			AchievementConfig achievementConfig = Achievements.GetAchievementConfig(achievement);
			if (achievementConfig == null)
			{
				return;
			}
			List<int> guild = achievementConfig.guild;
			if (guild == null || guild.Contains(guildId))
			{
				ZPackage val = new ZPackage();
				val.Write(guildId);
				val.Write(achievement);
				val.Write(increment);
				ZRpc serverRPC = ZNet.instance.GetServerRPC();
				if (serverRPC != null)
				{
					serverRPC.Invoke("Guild Increase Achievement", new object[1] { val });
				}
				else
				{
					val.SetPos(0);
					GuildListManipulationListener.IncreaseAchievement(null, val);
				}
			}
		}
	}
	public static class ObjectDiff
	{
		private static readonly MethodInfo hashSetDiff = AccessTools.DeclaredMethod(typeof(ObjectDiff), "diffHashSets", (Type[])null, (Type[])null);

		public static Dictionary<string[], object?> diff<T>(T old, T cur) where T : notnull
		{
			Dictionary<string[], object> dictionary = new Dictionary<string[], object>();
			diff(old, cur, typeof(T), new List<string>(), dictionary);
			return dictionary;
		}

		private static void diffHashSets<T>(List<string> path, Dictionary<string[], object?> differences, HashSet<T> a, HashSet<T> b) where T : struct
		{
			HashSet<T> b2 = b;
			HashSet<T> a2 = a;
			foreach (T item in a2.Where((T v) => !b2.Contains(v)))
			{
				path.Add(item.ToString());
				path.Add("0");
				differences.Add(path.ToArray(), item);
				path.RemoveAt(path.Count - 1);
				path.RemoveAt(path.Count - 1);
			}
			foreach (T item2 in b2.Where((T v) => !a2.Contains(v)))
			{
				path.Add(item2.ToString());
				path.Add("1");
				differences.Add(path.ToArray(), item2);
				path.RemoveAt(path.Count - 1);
				path.RemoveAt(path.Count - 1);
			}
		}

		private static void diff(object old, object cur, Type t, List<string> path, Dictionary<string[], object?> differences)
		{
			FieldInfo[] fields = t.GetFields(BindingFlags.Instance | BindingFlags.Public);
			foreach (FieldInfo fieldInfo in fields)
			{
				object value = fieldInfo.GetValue(old);
				object value2 = fieldInfo.GetValue(cur);
				if (fieldInfo.FieldType == typeof(string) || fieldInfo.FieldType.IsPrimitive || fieldInfo.FieldType.IsEnum)
				{
					if (!value.Equals(value2))
					{
						path.Add(fieldInfo.Name);
						differences.Add(path.ToArray(), value2);
						path.RemoveAt(path.Count - 1);
					}
				}
				else if (fieldInfo.FieldType.IsGenericType && typeof(HashSet<>) == fieldInfo.FieldType.GetGenericTypeDefinition())
				{
					Type type = fieldInfo.FieldType.GetGenericArguments()[0];
					path.Add(fieldInfo.Name);
					hashSetDiff.MakeGenericMethod(type).Invoke(null, new object[4] { path, differences, value, value2 });
					path.RemoveAt(path.Count - 1);
				}
				else if (typeof(IDictionary).IsAssignableFrom(fieldInfo.FieldType))
				{
					Type t2 = fieldInfo.FieldType.GetGenericArguments()[1];
					path.Add(fieldInfo.Name);
					foreach (object item in ((IDictionary)value).Keys.Cast<object>().Except(((IDictionary)value2).Keys.Cast<object>()))
					{
						path.Add(item.ToString());
						differences.Add(path.ToArray(), null);
						path.RemoveAt(path.Count - 1);
					}
					foreach (object key in ((IDictionary)value2).Keys)
					{
						path.Add(key.ToString());
						if (((IDictionary)value).Contains(key))
						{
							diff(((IDictionary)value)[key], ((IDictionary)value2)[key], t2, path, differences);
						}
						else
						{
							differences.Add(path.ToArray(), ((IDictionary)value2)[key]);
						}
						path.RemoveAt(path.Count - 1);
					}
					path.RemoveAt(path.Count - 1);
				}
				else
				{
					path.Add(fieldInfo.Name);
					diff(value, value2, fieldInfo.FieldType, path, differences);
					path.RemoveAt(path.Count - 1);
				}
			}
		}

		public static void ApplyDiff<T>(ref T baseTarget, Dictionary<string[], object?> differences) where T : notnull
		{
			foreach (KeyValuePair<string[], object> difference in differences)
			{
				List<FieldInfo> list = new List<FieldInfo>();
				Type type = typeof(T);
				object obj = baseTarget;
				object obj2 = null;
				object key = null;
				for (int i = 0; i < difference.Key.Length; i++)
				{
					FieldInfo field = type.GetField(difference.Key[i]);
					if (i == difference.Key.Length - 1)
					{
						if (list.Count == 0)
						{
							field.SetValue(obj, difference.Value);
							break;
						}
						TypedReference obj3 = TypedReference.MakeTypedReference(obj, list.ToArray());
						field.SetValueDirect(obj3, difference.Value);
						break;
					}
					if (field.FieldType.IsGenericType && typeof(HashSet<>) == field.FieldType.GetGenericTypeDefinition())
					{
						Type type2 = field.FieldType.GetGenericArguments()[0];
						string text = difference.Key[i + 2];
						typeof(HashSet<>).MakeGenericType(type2).GetMethod((text == "1") ? "Add" : "Remove").Invoke(field.GetValue(obj), new object[1] { difference.Value });
						break;
					}
					if (typeof(IDictionary).IsAssignableFrom(field.FieldType))
					{
						Type type3 = field.FieldType.GetGenericArguments()[0];
						object obj4 = difference.Key[++i];
						if (type3 != typeof(string))
						{
							obj4 = TypeDescriptor.GetConverter(type3).ConvertFromString((string)obj4) ?? "";
						}
						IDictionary dictionary;
						if (list.Count == 0)
						{
							dictionary = (IDictionary)field.GetValue(obj);
						}
						else
						{
							TypedReference obj5 = TypedReference.MakeTypedReference(obj, list.ToArray());
							dictionary = (IDictionary)field.GetValueDirect(obj5);
						}
						if (difference.Key.Length == i + 1)
						{
							if (difference.Value == null)
							{
								dictionary.Remove(obj4);
							}
							else
							{
								dictionary[obj4] = difference.Value;
							}
							continue;
						}
						if (!dictionary.Contains(obj4))
						{
							break;
						}
						obj = dictionary[obj4];
						key = obj4;
						obj2 = dictionary;
						type = field.FieldType.GetGenericArguments()[1];
						list.Clear();
					}
					else if (field.FieldType.IsValueType)
					{
						list.Add(field);
						type = field.FieldType;
					}
					else
					{
						if (list.Count == 0)
						{
							obj = field.GetValue(obj);
						}
						else
						{
							TypedReference obj6 = TypedReference.MakeTypedReference(obj, list.ToArray());
							obj = field.GetValueDirect(obj6);
						}
						type = field.FieldType;
						list.Clear();
						obj2 = obj;
					}
				}
				if (obj2 == null)
				{
					baseTarget = (T)obj;
				}
				else if (obj2 is IDictionary dictionary2)
				{
					dictionary2[key] = obj;
				}
			}
		}
	}
	public static class Interface
	{
		internal static GameObject NoGuildUIPrefab = null;

		internal static GameObject SearchGuildUIPrefab = null;

		internal static GameObject CreateGuildUIPrefab = null;

		internal static GameObject GuildManagementUIPrefab = null;

		internal static GameObject ApplicationsUIPrefab = null;

		internal static GameObject EditGuildUIPrefab = null;

		internal static GameObject AchievementUIPrefab = null;

		internal static GameObject AchievementPopupPrefab = null;

		internal static GameObject NoGuildUI = null;

		internal static GameObject SearchGuildUI = null;

		internal static GameObject CreateGuildUI = null;

		internal static GameObject GuildManagementUI = null;

		internal static GameObject ApplicationsUI = null;

		internal static GameObject EditGuildUI = null;

		internal static GameObject AchievementUI = null;

		internal static GameObject AchievementPopup = null;

		internal static readonly Dictionary<int, Sprite> GuildIcons = new Dictionary<int, Sprite>();

		internal static readonly Dictionary<string, Sprite> AchievementIcons = new Dictionary<string, Sprite>();

		internal static void LoadAssets()
		{
			AssetBundle obj = Tools.LoadAssetBundle("guildsbundle");
			NoGuildUIPrefab = obj.LoadAsset<GameObject>("NoGuild");
			CreateGuildUIPrefab = obj.LoadAsset<GameObject>("CreateGuild");
			SearchGuildUIPrefab = obj.LoadAsset<GameObject>("SearchGuild");
			GuildManagementUIPrefab = obj.LoadAsset<GameObject>("GuildManagementUI");
			ApplicationsUIPrefab = obj.LoadAsset<GameObject>("ApplicationsUI");
			EditGuildUIPrefab = obj.LoadAsset<GameObject>("EditGuild");
			AchievementUIPrefab = obj.LoadAsset<GameObject>("AchievementUI");
			AchievementPopupPrefab = obj.LoadAsset<GameObject>("AchievementPopup");
			obj.Unload(false);
			string[] manifestResourceNames = Assembly.GetExecutingAssembly().GetManifestResourceNames();
			foreach (string text in manifestResourceNames)
			{
				if (text.StartsWith("Guilds.Icons.Badges", StringComparison.Ordinal))
				{
					string[] array = text.Split(new char[1] { '.' });
					GuildIcons.Add(int.Parse(array[^2]), Tools.loadSprite(text.Replace("Guilds.Icons.", ""), 128, 128));
				}
				else if (text.StartsWith("Guilds.Icons.Achievements", StringComparison.Ordinal))
				{
					AchievementIcons[text.Replace("Guilds.Icons.Achievements.", "")] = Tools.loadSprite(text.Replace("Guilds.Icons.", ""), 128, 128);
				}
			}
		}

		private static AssetBundle LoadAssetBundle(string bundleName)
		{
			string bundleName2 = bundleName;
			string name = typeof(Guilds).Assembly.GetManifestResourceNames().Single((string s) => s.EndsWith(bundleName2));
			return AssetBundle.LoadFromStream(typeof(Guilds).Assembly.GetManifestResourceStream(name));
		}

		internal static void Update()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			Patches.PreventMainMenu.AllowMainMenu = true;
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer == null)
			{
				return;
			}
			if (((Character)localPlayer).TakeInput())
			{
				KeyboardShortcut value = Guilds.guildInterfaceKey.Value;
				if (((KeyboardShortcut)(ref value)).IsDown())
				{
					if (API.GetOwnGuild() == null)
					{
						NoGuildUI.SetActive(true);
					}
					else
					{
						GuildManagementUI.SetActive(true);
					}
				}
			}
			if (UIIsActive() && Input.GetKey((KeyCode)27))
			{
				HideUI();
				Patches.PreventMainMenu.AllowMainMenu = false;
			}
		}

		internal static bool UIIsActive()
		{
			if ((!Object.op_Implicit((Object)(object)NoGuildUI) || !NoGuildUI.activeSelf) && (!Object.op_Implicit((Object)(object)CreateGuildUI) || !CreateGuildUI.activeSelf) && (!Object.op_Implicit((Object)(object)SearchGuildUI) || !SearchGuildUI.activeSelf) && (!Object.op_Implicit((Object)(object)GuildManagementUI) || !GuildManagementUI.activeSelf) && (!Object.op_Implicit((Object)(object)ApplicationsUI) || !ApplicationsUI.activeSelf) && (!Object.op_Implicit((Object)(object)EditGuildUI) || !EditGuildUI.activeSelf))
			{
				if (Object.op_Implicit((Object)(object)AchievementUI))
				{
					return AchievementUI.activeSelf;
				}
				return false;
			}
			return true;
		}

		internal static void HideUI()
		{
			NoGuildUI.SetActive(false);
			SearchGuildUI.SetActive(false);
			CreateGuildUI.SetActive(false);
			GuildManagementUI.SetActive(false);
			ApplicationsUI.SetActive(false);
			EditGuildUI.SetActive(false);
			AchievementUI.SetActive(false);
		}

		internal static void SwitchUI(GameObject newUI, bool hideOld = true)
		{
			if (hideOld)
			{
				HideUI();
			}
			newUI.SetActive(true);
		}
	}
	public class ZDOIDYamlConverter : <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter
	{
		public bool Accepts(Type type)
		{
			return type == typeof(ZDOID);
		}

		public object ReadYaml(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type type, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			string[] array = ((YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar)parser.Current).Value.Split(new char[1] { ':' });
			ZDOID val = new ZDOID(long.Parse(array[0]), uint.Parse(array[1]));
			parser.MoveNext();
			return (object)val;
		}

		public void WriteYaml(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, object? value, Type type, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			ZDOID val = (ZDOID)value;
			emitter.Emit(new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar($"{((ZDOID)(ref val)).UserID}:{((ZDOID)(ref val)).ID}"));
		}
	}
	public static class Patches
	{
		[HarmonyPatch(typeof(Aoe), "OnHit")]
		private static class TagFriendlyFireAoe
		{
			[CompilerGenerated]
			private sealed class <Transpiler>d__3 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private CodeInstruction <>2__current;

				private int <>l__initialThreadId;

				private IEnumerable<CodeInstruction> instructions;

				public IEnumerable<CodeInstruction> <>3__instructions;

				private bool <preDamage>5__2;

				private IEnumerator<CodeInstruction> <>7__wrap2;

				private CodeInstruction <instruction>5__4;

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

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

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

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

				private bool MoveNext()
				{
					//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
					//IL_00cf: Expected O, but got Unknown
					//IL_0089: Unknown result type (might be due to invalid IL or missing references)
					//IL_0093: Expected O, but got Unknown
					try
					{
						switch (<>1__state)
						{
						default:
							return false;
						case 0:
							<>1__state = -1;
							<preDamage>5__2 = false;
							<>7__wrap2 = instructions.GetEnumerator();
							<>1__state = -3;
							goto IL_0123;
						case 1:
							<>1__state = -3;
							<>2__current = new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(TagFriendlyFireAoe), "CheckAndTag", (Type[])null, (Type[])null));
							<>1__state = 2;
							return true;
						case 2:
							<>1__state = -3;
							goto IL_00fd;
						case 3:
							{
								<>1__state = -3;
								<instruction>5__4 = null;
								goto IL_0123;
							}
							IL_0123:
							if (<>7__wrap2.MoveNext())
							{
								<instruction>5__4 = <>7__wrap2.Current;
								if (<preDamage>5__2 && CodeInstructionExtensions.Calls(<instruction>5__4, Damage))
								{
									<preDamage>5__2 = false;
									<>2__current = new CodeInstruction(OpCodes.Ldarg_0, (object)null);
									<>1__state = 1;
									return true;
								}
								if (CodeInstructionExtensions.Calls(<instruction>5__4, ModifyHit))
								{
									<preDamage>5__2 = true;
								}
								goto IL_00fd;
							}
							<>m__Finally1();
							<>7__wrap2 = null;
							return false;
							IL_00fd:
							<>2__current = <instruction>5__4;
							<>1__state = 3;
							return true;
						}
					}
					catch
					{
						//try-fault
						((IDisposable)this).Dispose();
						throw;
					}
				}

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

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

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

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

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

			private static readonly MethodInfo ModifyHit = AccessTools.DeclaredMethod(typeof(DamageTypes), "Modify", new Type[1] { typeof(float) }, (Type[])null);

			private static readonly MethodInfo Damage = AccessTools.DeclaredMethod(typeof(IDestructible), "Damage", (Type[])null, (Type[])null);

			private static HitData CheckAndTag(HitData hit, Aoe aoe)
			{
				if (aoe.m_hitFriendly && Object.op_Implicit((Object)(object)Projectile.FindHitObject(hit.m_hitCollider).GetComponent<Player>()))
				{
					hit.m_weakSpot = -23749;
				}
				return hit;
			}

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

		[HarmonyPatch(typeof(Character), "RPC_Damage")]
		public class FriendlyFirePatch
		{
			private static bool Prefix(Character __instance, HitData hit)
			{
				if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer)
				{
					Character attacker = hit.GetAttacker();
					Player val = (Player)(object)((attacker is Player) ? attacker : null);
					if (val != null && hit.m_weakSpot != -23749)
					{
						Guild ownGuild = API.GetOwnGuild();
						if (ownGuild != null && ownGuild.Name == API.GetPlayerGuild(val)?.Name && Guilds.friendlyFire.Value == Toggle.Off)
						{
							return false;
						}
					}
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Character), "Damage")]
		private static class PreventFriendlyFireMarkerOverwrite
		{
			[CompilerGenerated]
			private sealed class <Transpiler>d__2 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private CodeInstruction <>2__current;

				private int <>l__initialThreadId;

				private IEnumerable<CodeInstruction> instructions;

				public IEnumerable<CodeInstruction> <>3__instructions;

				private IEnumerator<CodeInstruction> <>7__wrap1;

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

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

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

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

				private bool MoveNext()
				{
					//IL_0077: Unknown result type (might be due to invalid IL or missing references)
					//IL_0081: Expected O, but got Unknown
					try
					{
						switch (<>1__state)
						{
						default:
							return false;
						case 0:
							<>1__state = -1;
							<>7__wrap1 = instructions.GetEnumerator();
							<>1__state = -3;
							break;
						case 1:
							<>1__state = -3;
							break;
						case 2:
							<>1__state = -3;
							break;
						}
						if (<>7__wrap1.MoveNext())
						{
							CodeInstruction current = <>7__wrap1.Current;
							if (CodeInstructionExtensions.StoresField(current, weakSpotField))
							{
								<>2__current = new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(PreventFriendlyFireMarkerOverwrite), "WriteWeakSpot", (Type[])null, (Type[])null));
								<>1__state = 1;
								return true;
							}
							<>2__current = current;
							<>1__state = 2;
							return true;
						}
						<>m__Finally1();
						<>7__wrap1 = null;
						return false;
					}
					catch
					{
						//try-fault
						((IDisposable)this).Dispose();
						throw;
					}
				}

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

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

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

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

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

			private static readonly FieldInfo weakSpotField = AccessTools.DeclaredField(typeof(HitData), "m_weakSpot");

			private static void WriteWeakSpot(HitData hit, short index)
			{
				if (hit.m_weakSpot >= -1)
				{
					hit.m_weakSpot = index;
				}
			}

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

		[HarmonyPatch(typeof(EnemyHud), "ShowHud")]
		public class DisplayGuildNameAbovePlayer
		{
			private static void Postfix(EnemyHud __instance, Character c, Dictionary<Character, HudData> ___m_huds)
			{
				//IL_010f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0114: Unknown result type (might be due to invalid IL or missing references)
				//IL_011d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0122: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Expected O, but got Unknown
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
				Player val = (Player)(object)((c is Player) ? c : null);
				if (val != null)
				{
					GameObject gui = ___m_huds[c].m_gui;
					TextMeshProUGUI component = ((Component)gui.transform.Find("Name")).GetComponent<TextMeshProUGUI>();
					Transform obj = gui.transform.Find("guildname");
					GameObject val2 = ((obj != null) ? ((Component)obj).gameObject : null);
					if (val2 == null)
					{
						val2 = new GameObject("guildname", new Type[1] { typeof(RectTransform) });
						val2.transform.SetParent(gui.transform, false);
						((RectTransform)val2.transform).sizeDelta = new Vector2(300f, 12f);
						TextMeshProUGUI obj2 = val2.AddComponent<TextMeshProUGUI>();
						((TMP_Text)obj2).font = ((TMP_Text)component).font;
						((TMP_Text)obj2).fontSize = 14f;
						((TMP_Text)obj2).alignment = ((TMP_Text)component).alignment;
						Outline obj3 = val2.AddComponent<Outline>();
						((Shadow)obj3).effectColor = Color.black;
						((Shadow)obj3).effectDistance = new Vector2(1f, -1f);
					}
					TextMeshProUGUI component2 = val2.GetComponent<TextMeshProUGUI>();
					Color color = ((Graphic)((Component)__instance.m_baseHudPlayer.transform.Find("Name")).GetComponent<TextMeshProUGUI>()).color;
					RectTransform component3 = ((Component)component).GetComponent<RectTransform>();
					Vector2 pivot = component3.pivot;
					Guild playerGuild = API.GetPlayerGuild(val);
					if (playerGuild != null)
					{
						Color val3 = default(Color);
						ColorUtility.TryParseHtmlString(playerGuild.General.color, ref val3);
						pivot.y = 0.2f;
						((TMP_Text)component2).text = "<" + playerGuild.Name + ((Guilds.displayGuildLevel.Value == Toggle.On) ? $" ({playerGuild.General.level})" : "") + ">";
						((Graphic)component2).color = ((Guilds.guildColors.Value == Toggle.On) ? val3 : color);
					}
					else
					{
						pivot.y = 0.5f;
						((TMP_Text)val2.GetComponent<TextMeshProUGUI>()).text = "";
					}
					component3.pivot = pivot;
				}
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "Awake")]
		public static class FejdStartupFixMaterial
		{
			public static Material? originalMaterial;

			private static void Postfix()
			{
				AssetBundle[] array = Resources.FindObjectsOfTypeAll<AssetBundle>();
				foreach (AssetBundle val in array)
				{
					IEnumerable<Material> enumerable3;
					try
					{
						IEnumerable<Material> enumerable2;
						if (!val.isStreamedSceneAssetBundle)
						{
							IEnumerable<Material> enumerable = val.LoadAllAssets<Material>();
							enumerable2 = enumerable;
						}
						else
						{
							enumerable2 = from shader in ((IEnumerable<string>)val.GetAllAssetNames()).Select((Func<string, Material>)val.LoadAsset<Material>)
								where (Object)(object)shader != (Object)null
								select shader;
						}
						enumerable3 = enumerable2;
					}
					catch (Exception)
					{
						continue;
					}
					if (enumerable3 == null)
					{
						continue;
					}
					foreach (Material item in enumerable3)
					{
						if (Object.op_Implicit((Object)(object)item) && ((Object)item).name == "litpanel")
						{
							originalMaterial = item;
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(Hud), "Awake")]
		public static class AffixGuildMenu
		{
			private static void Prefix(Hud __instance)
			{
				Transform transform = __instance.m_rootObject.transform;
				Interface.NoGuildUIPrefab.SetActive(false);
				Interface.SearchGuildUIPrefab.SetActive(false);
				Interface.CreateGuildUIPrefab.SetActive(false);
				Interface.GuildManagementUIPrefab.SetActive(false);
				Interface.ApplicationsUIPrefab.SetActive(false);
				Interface.EditGuildUIPrefab.SetActive(false);
				Interface.AchievementUIPrefab.SetActive(false);
				Interface.AchievementPopupPrefab.SetActive(false);
				Interface.NoGuildUI = Object.Instantiate<GameObject>(Interface.NoGuildUIPrefab, transform, false);
				Interface.SearchGuildUI = Object.Instantiate<GameObject>(Interface.SearchGuildUIPrefab, transform, false);
				Interface.CreateGuildUI = Object.Instantiate<GameObject>(Interface.CreateGuildUIPrefab, transform, false);
				Interface.GuildManagementUI = Object.Instantiate<GameObject>(Interface.GuildManagementUIPrefab, transform, false);
				Interface.ApplicationsUI = Object.Instantiate<GameObject>(Interface.ApplicationsUIPrefab, transform, false);
				Interface.EditGuildUI = Object.Instantiate<GameObject>(Interface.EditGuildUIPrefab, transform, false);
				Interface.AchievementUI = Object.Instantiate<GameObject>(Interface.AchievementUIPrefab, transform, false);
				Interface.AchievementPopup = Object.Instantiate<GameObject>(Interface.AchievementPopupPrefab, transform, false);
				FixBkgMaterial(Interface.NoGuildUI);
				FixBkgMaterial(Interface.SearchGuildUI);
				FixBkgMaterial(Interface.CreateGuildUI);
				FixBkgMaterial(Interface.GuildManagementUI);
				FixBkgMaterial(Interface.ApplicationsUI);
				FixBkgMaterial(Interface.EditGuildUI);
				FixBkgMaterial(Interface.AchievementUI);
				FixBkgMaterial(Interface.AchievementPopup);
				((Component)UnifiedPopup.instance).transform.SetAsLastSibling();
			}

			private static void FixBkgMaterial(GameObject ui)
			{
				if (!((Object)(object)FejdStartupFixMaterial.originalMaterial == (Object)null))
				{
					Transform val = Utils.FindChild(ui.transform, "Background", (IterativeSearchType)0);
					if (val != null)
					{
						((Graphic)((Component)val).GetComponent<Image>()).material = FejdStartupFixMaterial.originalMaterial;
					}
					Transform val2 = Utils.FindChild(ui.transform, "BackgroundBack", (IterativeSearchType)0);
					if (val2 != null)
					{
						((Graphic)((Component)val2).GetComponent<Image>()).material = FejdStartupFixMaterial.originalMaterial;
					}
				}
			}
		}

		[HarmonyPatch]
		private class DisablePlayerInputInGuildMenu
		{
			private static IEnumerable<MethodInfo> TargetMethods()
			{
				return new MethodInfo[2]
				{
					AccessTools.DeclaredMethod(typeof(StoreGui), "IsVisible", (Type[])null, (Type[])null),
					AccessTools.DeclaredMethod(typeof(TextInput), "IsVisible", (Type[])null, (Type[])null)
				};
			}

			private static void Postfix(ref bool __result)
			{
				if (Interface.UIIsActive())
				{
					__result = true;
				}
			}
		}

		[HarmonyPatch(typeof(Menu), "Update")]
		internal class PreventMainMenu
		{
			public static bool AllowMainMenu = true;

			private static bool Prefix()
			{
				if (!Interface.UIIsActive())
				{
					return AllowMainMenu;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(ZNet), "Disconnect")]
		private static class UpdateLastOnline
		{
			private static void Prefix(ZNet __instance, ZNetPeer peer)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				ZNetPeer peer2 = peer;
				if (!__instance.IsServer())
				{
					return;
				}
				PlayerInfo val = ((IEnumerable<PlayerInfo>)__instance.m_players).FirstOrDefault((Func<PlayerInfo, bool>)((PlayerInfo p) => p.m_characterID == peer2.m_characterID));
				if (val.m_characterID != ZDOID.None)
				{
					PlayerReference playerReference = PlayerReference.fromPlayerInfo(val);
					Guild playerGuild = API.GetPlayerGuild(playerReference);
					if (playerGuild != null)
					{
						playerGuild.Members[playerReference].lastOnline = DateTime.Now;
						API.SaveGuild(playerGuild);
					}
				}
			}
		}

		private const short IsFriendlyAoe = -23749;
	}
	public static class Tools
	{
		internal class NameValidator : TMP_InputValidator
		{
			public override char Validate(ref string text, ref int pos, char ch)
			{
				if (ValidateChar(ch))
				{
					text = text.Insert(pos++, ch.ToString());
					return ch;
				}
				return '\0';
			}
		}

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

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

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

		internal static AssetBundle LoadAssetBundle(string bundleName)
		{
			string bundleName2 = bundleName;
			string name = typeof(Guilds).Assembly.GetManifestResourceNames().Single((string s) => s.EndsWith(bundleName2));
			return AssetBundle.LoadFromStream(typeof(Guilds).Assembly.GetManifestResourceStream(name));
		}

		internal static Sprite LoadNewSprite(string FilePath, float PixelsPerUnit = 100f, SpriteMeshType spriteType = 1)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = LoadTexture(FilePath);
			return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0f, 0f), PixelsPerUnit, 0u, spriteType);
		}

		internal static Sprite ConvertTextureToSprite(Texture2D texture, float PixelsPerUnit = 100f, SpriteMeshType spriteType = 1)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			return Sprite.Create(texture, new Rect(0f, 0f, (float)((Texture)texture).width, (float)((Texture)texture).height), new Vector2(0f, 0f), PixelsPerUnit, 0u, spriteType);
		}

		private static Texture2D? LoadTexture(string FilePath)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			if (File.Exists(FilePath))
			{
				byte[] array = File.ReadAllBytes(FilePath);
				Texture2D val = new Texture2D(2, 2);
				if (ImageConversion.LoadImage(val, array))
				{
					return val;
				}
			}
			return null;
		}

		internal static string GetHumanFriendlyTime(int seconds)
		{
			TimeSpan timeSpan = TimeSpan.FromSeconds(seconds);
			if (timeSpan.TotalSeconds < 60.0)
			{
				return Localization.instance.Localize("$guilds_less_than_minute");
			}
			string text = Localization.instance.Localize((timeSpan.Days >= 2) ? "$guilds_day_plural" : "$guilds_day_singular", new string[1] { ((int)timeSpan.TotalDays).ToString() });
			if (timeSpan.TotalDays >= 30.0)
			{
				return text;
			}
			string text2 = Localization.instance.Localize((timeSpan.Hours >= 2) ? "$guilds_hour_plural" : "$guilds_hour_singular", new string[1] { timeSpan.Hours.ToString() });
			if (timeSpan.TotalDays >= 1.0)
			{
				if (timeSpan.Hours != 0)
				{
					return Localization.instance.Localize("$guilds_bind_day_hour", new string[2] { text, text2 });
				}
				return text;
			}
			string text3 = Localization.instance.Localize((timeSpan.Minutes >= 2) ? "$guilds_minute_plural" : "$guilds_minute_singular", new string[1] { timeSpan.Minutes.ToString() });
			if (!(timeSpan.TotalHours >= 1.0))
			{
				return text3;
			}
			if (timeSpan.Minutes != 0)
			{
				return Localization.instance.Localize("$guilds_bind_hour_minute", new string[2] { text2, text3 });
			}
			return text2;
		}

		internal static bool ValidateChar(char ch)
		{
			if (!char.IsLetterOrDigit(ch))
			{
				return "@!#$%&'*+-=?^_{|}~ ".IndexOf(ch) != -1;
			}
			return true;
		}

		public static List<Player> GetNearbyGuildMembers(Player player, float range, bool includeSelf = false)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			Player player2 = player;
			Guild playerGuild = API.GetPlayerGuild(player2);
			if (playerGuild == null)
			{
				return new List<Player>();
			}
			List<PlayerReference> guildPlayers = API.GetOnlinePlayers(playerGuild).ToList();
			List<Player> list = new List<Player>();
			Player.GetPlayersInRange(((Component)player2).transform.position, range, list);
			list.RemoveAll((Player p) => !guildPlayers.Contains(PlayerReference.fromPlayer(p)) || (!includeSelf && (Object)(object)p == (Object)(object)player2));
			return list;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
}
namespace YamlDotNet
{
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>CultureInfoAdapter : CultureInfo
	{
		private readonly IFormatProvider provider;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>CultureInfoAdapter(CultureInfo baseCulture, IFormatProvider provider)
			: base(baseCulture.Name)
		{
			this.provider = provider;
		}

		public override object? GetFormat(Type formatType)
		{
			return provider.GetFormat(formatType);
		}
	}
	internal static class Polyfills
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool Contains(this string source, char c)
		{
			return source.IndexOf(c) != -1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool EndsWith(this string source, char c)
		{
			if (source.Length > 0)
			{
				return source[source.Length - 1] == c;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool StartsWith(this string source, char c)
		{
			if (source.Length > 0)
			{
				return source[0] == c;
			}
			return false;
		}
	}
	internal static class <cba6ec40-2546-4a46-9577-18d27987fd9e>PropertyInfoExtensions
	{
		public static object? ReadValue(this PropertyInfo property, object target)
		{
			return property.GetValue(target, null);
		}
	}
	internal static class <cba6ec40-2546-4a46-9577-18d27987fd9e>ReflectionExtensions
	{
		private static readonly Func<PropertyInfo, bool> IsInstance = (PropertyInfo property) => !(property.GetMethod ?? property.SetMethod).IsStatic;

		private static readonly Func<PropertyInfo, bool> IsInstancePublic = (PropertyInfo property) => IsInstance(property) && (property.GetMethod ?? property.SetMethod).IsPublic;

		public static Type? BaseType(this Type type)
		{
			return type.GetTypeInfo().BaseType;
		}

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

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

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

		public static Type? GetImplementationOfOpenGenericInterface(this Type type, Type openGenericType)
		{
			if (!openGenericType.IsGenericType || !openGenericType.IsInterface)
			{
				throw new ArgumentException("The type must be a generic type definition and an interface", "openGenericType");
			}
			if (IsGenericDefinitionOfType(type, openGenericType))
			{
				return type;
			}
			return type.FindInterfaces((Type t, object context) => IsGenericDefinitionOfType(t, context), openGenericType).FirstOrDefault();
			static bool IsGenericDefinitionOfType(Type t, object? context)
			{
				if (t.IsGenericType)
				{
					return t.GetGenericTypeDefinition() == (Type)context;
				}
				return false;
			}
		}

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

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

		public static bool IsRequired(this MemberInfo member)
		{
			return member.GetCustomAttributes(inherit: true).Any((object x) => x.GetType().FullName == "System.Runtime.CompilerServices.RequiredMemberAttribute");
		}

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

		public static bool IsAssignableFrom(this Type type, Type source)
		{
			return type.IsAssignableFrom(source.GetTypeInfo());
		}

		public static bool IsAssignableFrom(this Type type, TypeInfo source)
		{
			return type.GetTypeInfo().IsAssignableFrom(source);
		}

		public static TypeCode GetTypeCode(this Type type)
		{
			if (IsEnum(type))
			{
				type = Enum.GetUnderlyingType(type);
			}
			if (type == typeof(bool))
			{
				return TypeCode.Boolean;
			}
			if (type == typeof(char))
			{
				return TypeCode.Char;
			}
			if (type == typeof(sbyte))
			{
				return TypeCode.SByte;
			}
			if (type == typeof(byte))
			{
				return TypeCode.Byte;
			}
			if (type == typeof(short))
			{
				return TypeCode.Int16;
			}
			if (type == typeof(ushort))
			{
				return TypeCode.UInt16;
			}
			if (type == typeof(int))
			{
				return TypeCode.Int32;
			}
			if (type == typeof(uint))
			{
				return TypeCode.UInt32;
			}
			if (type == typeof(long))
			{
				return TypeCode.Int64;
			}
			if (type == typeof(ulong))
			{
				return TypeCode.UInt64;
			}
			if (type == typeof(float))
			{
				return TypeCode.Single;
			}
			if (type == typeof(double))
			{
				return TypeCode.Double;
			}
			if (type == typeof(decimal))
			{
				return TypeCode.Decimal;
			}
			if (type == typeof(DateTime))
			{
				return TypeCode.DateTime;
			}
			if (type == typeof(string))
			{
				return TypeCode.String;
			}
			return TypeCode.Object;
		}

		public static bool IsDbNull(this object value)
		{
			return value?.GetType()?.FullName == "System.DBNull";
		}

		public static Type[] GetGenericArguments(this Type type)
		{
			return type.GetTypeInfo().GenericTypeArguments;
		}

		public static PropertyInfo? GetPublicProperty(this Type type, string name)
		{
			string name2 = name;
			return type.GetProperties(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public).FirstOrDefault((PropertyInfo p) => p.Name == name2);
		}

		public static FieldInfo? GetPublicStaticField(this Type type, string name)
		{
			return type.GetRuntimeField(name);
		}

		public static IEnumerable<PropertyInfo> GetProperties(this Type type, bool includeNonPublic)
		{
			Func<PropertyInfo, bool> predicate = (includeNonPublic ? IsInstance : IsInstancePublic);
			if (!IsInterface(type))
			{
				return type.GetRuntimeProperties().Where(predicate);
			}
			return new Type[1] { type }.Concat(type.GetInterfaces()).SelectMany((Type i) => i.GetRuntimeProperties().Where(predicate));
		}

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

		public static IEnumerable<FieldInfo> GetPublicFields(this Type type)
		{
			return from f in type.GetRuntimeFields()
				where !f.IsStatic && f.IsPublic
				select f;
		}

		public static IEnumerable<MethodInfo> GetPublicStaticMethods(this Type type)
		{
			return from m in type.GetRuntimeMethods()
				where m.IsPublic && m.IsStatic
				select m;
		}

		public static MethodInfo GetPrivateStaticMethod(this Type type, string name)
		{
			string name2 = name;
			return type.GetRuntimeMethods().FirstOrDefault((MethodInfo m) => !m.IsPublic && m.IsStatic && m.Name.Equals(name2)) ?? throw new MissingMethodException("Expected to find a method named '" + name2 + "' in '" + type.FullName + "'.");
		}

		public static MethodInfo? GetPublicStaticMethod(this Type type, string name, params Type[] parameterTypes)
		{
			string name2 = name;
			Type[] parameterTypes2 = parameterTypes;
			return type.GetRuntimeMethods().FirstOrDefault(delegate(MethodInfo m)
			{
				if (m.IsPublic && m.IsStatic && m.Name.Equals(name2))
				{
					ParameterInfo[] parameters = m.GetParameters();
					if (parameters.Length == parameterTypes2.Length)
					{
						return parameters.Zip(parameterTypes2, (ParameterInfo pi, Type pt) => pi.ParameterType == pt).All((bool r) => r);
					}
					return false;
				}
				return false;
			});
		}

		public static MethodInfo? GetPublicInstanceMethod(this Type type, string name)
		{
			string name2 = name;
			return type.GetRuntimeMethods().FirstOrDefault((MethodInfo m) => m.IsPublic && !m.IsStatic && m.Name.Equals(name2));
		}

		public static MethodInfo? GetGetMethod(this PropertyInfo property, bool nonPublic)
		{
			MethodInfo methodInfo = property.GetMethod;
			if (!nonPublic && !methodInfo.IsPublic)
			{
				methodInfo = null;
			}
			return methodInfo;
		}

		public static MethodInfo? GetSetMethod(this PropertyInfo property)
		{
			return property.SetMethod;
		}

		public static IEnumerable<Type> GetInterfaces(this Type type)
		{
			return type.GetTypeInfo().ImplementedInterfaces;
		}

		public static bool IsInstanceOf(this Type type, object o)
		{
			if (!(o.GetType() == type))
			{
				return o.GetType().GetTypeInfo().IsSubclassOf(type);
			}
			return true;
		}

		public static Attribute[] GetAllCustomAttributes<TAttribute>(this PropertyInfo member)
		{
			return Attribute.GetCustomAttributes(member, typeof(TAttribute), inherit: true);
		}

		public static bool AcceptsNull(this MemberInfo member)
		{
			object[] customAttributes = member.DeclaringType.GetCustomAttributes(inherit: true);
			object obj = customAttributes.FirstOrDefault((object x) => x.GetType().FullName == "System.Runtime.CompilerServices.NullableContextAttribute");
			int num = 0;
			if (obj != null)
			{
				Type type = obj.GetType();
				PropertyInfo property = type.GetProperty("Flag");
				num = (byte)property.GetValue(obj);
			}
			object[] customAttributes2 = member.GetCustomAttributes(inherit: true);
			object obj2 = customAttributes2.FirstOrDefault((object x) => x.GetType().FullName == "System.Runtime.CompilerServices.NullableAttribute");
			PropertyInfo propertyInfo = (obj2?.GetType())?.GetProperty("NullableFlags");
			byte[] source = (byte[])propertyInfo.GetValue(obj2);
			return source.Any((byte x) => x == 2) || num == 2;
		}
	}
	internal static class <cba6ec40-2546-4a46-9577-18d27987fd9e>StandardRegexOptions
	{
		public const RegexOptions Compiled = RegexOptions.Compiled;
	}
}
namespace YamlDotNet.Serialization
{
	internal abstract class <cba6ec40-2546-4a46-9577-18d27987fd9e>BuilderSkeleton<TBuilder> where TBuilder : <cba6ec40-2546-4a46-9577-18d27987fd9e>BuilderSkeleton<TBuilder>
	{
		internal <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention namingConvention = <cba6ec40-2546-4a46-9577-18d27987fd9e>NullNamingConvention.Instance;

		internal <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention = <cba6ec40-2546-4a46-9577-18d27987fd9e>NullNamingConvention.Instance;

		internal <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver;

		internal readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributeOverrides overrides;

		internal readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing, <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverterFactories;

		internal readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector> typeInspectorFactories;

		internal bool ignoreFields;

		internal bool includeNonPublicProperties;

		internal Settings settings;

		internal <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlFormatter yamlFormatter = <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlFormatter.Default;

		protected abstract TBuilder Self { get; }

		internal <cba6ec40-2546-4a46-9577-18d27987fd9e>BuilderSkeleton(<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver)
		{
			overrides = new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributeOverrides();
			typeConverterFactories = new <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing, <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>
			{
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>GuidConverter),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>GuidConverter(jsonCompatible: false)
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>SystemTypeConverter),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>SystemTypeConverter()
				}
			};
			typeInspectorFactories = new <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, <cba6ec40-2546-4a46-9577-18d27987fd9e>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(<cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention namingConvention)
		{
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
			return Self;
		}

		public TBuilder WithEnumNamingConvention(<cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention)
		{
			this.enumNamingConvention = enumNamingConvention;
			return Self;
		}

		public TBuilder WithTypeResolver(<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			return Self;
		}

		public abstract TBuilder WithTagMapping(<cba6ec40-2546-4a46-9577-18d27987fd9e>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(<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter typeConverter)
		{
			return WithTypeConverter(typeConverter, delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeConverter(<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter typeConverter, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>> where)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter typeConverter2 = typeConverter;
			if (typeConverter2 == null)
			{
				throw new ArgumentNullException("typeConverter");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter2.GetType(), (<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => typeConverter2));
			return Self;
		}

		public TBuilder WithTypeConverter<TYamlTypeConverter>(<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter, <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverterFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITrackingRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>> where) where TYamlTypeConverter : <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter, <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverterFactory2 = typeConverterFactory;
			if (typeConverterFactory2 == null)
			{
				throw new ArgumentNullException("typeConverterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter wrapped, <cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => typeConverterFactory2(wrapped)));
			return Self;
		}

		public TBuilder WithoutTypeConverter<TYamlTypeConverter>() where TYamlTypeConverter : <cba6ec40-2546-4a46-9577-18d27987fd9e>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<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector
		{
			return WithTypeInspector(typeInspectorFactory, delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeInspector<TTypeInspector>(Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, TTypeInspector> typeInspectorFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector>> where) where TTypeInspector : <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector
		{
			Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
			if (typeInspectorFactory2 == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector inner) => typeInspectorFactory2(inner)));
			return Self;
		}

		public TBuilder WithTypeInspector<TTypeInspector>(<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, TTypeInspector> typeInspectorFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITrackingRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector>> where) where TTypeInspector : <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
			if (typeInspectorFactory2 == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector wrapped, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector inner) => typeInspectorFactory2(wrapped, inner)));
			return Self;
		}

		public TBuilder WithoutTypeInspector<TTypeInspector>() where TTypeInspector : <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector
		{
			return WithoutTypeInspector(typeof(TTypeInspector));
		}

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

		public TBuilder WithYamlFormatter(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlFormatter formatter)
		{
			yamlFormatter = formatter ?? throw new ArgumentNullException("formatter");
			return Self;
		}

		protected IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> BuildTypeConverters()
		{
			return typeConverterFactories.BuildComponentList();
		}
	}
	internal delegate TComponent <cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<TComponentBase, TComponent>(TComponentBase wrapped) where TComponent : TComponentBase;
	internal delegate TComponent <cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<TArgument, TComponentBase, TComponent>(TComponentBase wrapped, TArgument argument) where TComponent : TComponentBase;
	[Flags]
	internal enum <cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultValuesHandling
	{
		Preserve = 0,
		OmitNull = 1,
		OmitDefaults = 2,
		OmitEmptyCollections = 4
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>Deserializer : <cba6ec40-2546-4a46-9577-18d27987fd9e>IDeserializer
	{
		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IValueDeserializer valueDeserializer;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Deserializer()
			: this(new <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder().BuildValueDeserializer())
		{
		}

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>Deserializer(<cba6ec40-2546-4a46-9577-18d27987fd9e>IValueDeserializer valueDeserializer)
		{
			this.valueDeserializer = valueDeserializer ?? throw new ArgumentNullException("valueDeserializer");
		}

		public static <cba6ec40-2546-4a46-9577-18d27987fd9e>Deserializer FromValueDeserializer(<cba6ec40-2546-4a46-9577-18d27987fd9e>IValueDeserializer valueDeserializer)
		{
			return new <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>Parser(input));
		}

		public T Deserialize<T>(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser)
		{
			return (T)Deserialize(parser, typeof(T));
		}

		public object? Deserialize(string input)
		{
			return Deserialize<object>(input);
		}

		public object? Deserialize(TextReader input)
		{
			return Deserialize<object>(input);
		}

		public object? Deserialize(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser)
		{
			return Deserialize<object>(parser);
		}

		public object? Deserialize(string input, Type type)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize(input2, type);
		}

		public object? Deserialize(TextReader input, Type type)
		{
			return Deserialize(new <cba6ec40-2546-4a46-9577-18d27987fd9e>Parser(input), type);
		}

		public object? Deserialize(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type type)
		{
			if (parser == null)
			{
				throw new ArgumentNullException("parser");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamStart @event;
			bool flag = parser.TryConsume<YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamStart>(out @event);
			YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart event2;
			bool flag2 = parser.TryConsume<YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart>(out event2);
			object result = null;
			if (!parser.Accept<YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd>(out var _) && !parser.Accept<YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamEnd>(out var _))
			{
				using <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerState <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerState = new <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerState();
				result = valueDeserializer.DeserializeValue(parser, type, <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerState, valueDeserializer);
				<cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerState.OnDeserialization();
			}
			if (flag2)
			{
				parser.Consume<YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd>();
			}
			if (flag)
			{
				parser.Consume<YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamEnd>();
			}
			return result;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder : <cba6ec40-2546-4a46-9577-18d27987fd9e>BuilderSkeleton<<cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder>
	{
		private Lazy<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory> objectFactory;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing, <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer> nodeDeserializerFactories;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing, <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver> nodeTypeResolverFactories;

		private readonly Dictionary<<cba6ec40-2546-4a46-9577-18d27987fd9e>TagName, Type> tagMappings;

		private readonly Dictionary<Type, Type> typeMappings;

		private readonly ITypeConverter typeConverter;

		private bool ignoreUnmatched;

		private bool duplicateKeyChecking;

		private bool attemptUnknownTypeDeserialization;

		private bool enforceNullability;

		private bool caseInsensitivePropertyMatching;

		private bool enforceRequiredProperties;

		protected override <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder Self => this;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder()
			: base((<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver)new <cba6ec40-2546-4a46-9577-18d27987fd9e>StaticTypeResolver())
		{
			typeMappings = new Dictionary<Type, Type>();
			objectFactory = new Lazy<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory>(() => new <cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultObjectFactory(typeMappings, settings), isThreadSafe: true);
			tagMappings = new Dictionary<<cba6ec40-2546-4a46-9577-18d27987fd9e>TagName, Type>
			{
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>FailsafeSchema.Tags.Map,
					typeof(Dictionary<object, object>)
				},
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>FailsafeSchema.Tags.Str,
					typeof(string)
				},
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>JsonSchema.Tags.Bool,
					typeof(bool)
				},
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>JsonSchema.Tags.Float,
					typeof(double)
				},
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>JsonSchema.Tags.Int,
					typeof(int)
				},
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultSchema.Tags.Timestamp,
					typeof(DateTime)
				}
			};
			typeInspectorFactories.Add(typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>CachedTypeInspector), (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector inner) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>NamingConventionTypeInspector), (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector inner) => (!(namingConvention is <cba6ec40-2546-4a46-9577-18d27987fd9e>NullNamingConvention)) ? new <cba6ec40-2546-4a46-9577-18d27987fd9e>NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributesTypeInspector), (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector inner) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributesTypeInspector(inner));
			typeInspectorFactories.Add(typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributeOverridesInspector), (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector inner) => (overrides == null) ? inner : new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributeOverridesInspector(inner, overrides.Clone()));
			typeInspectorFactories.Add(typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>ReadableAndWritablePropertiesTypeInspector), (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector inner) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>ReadableAndWritablePropertiesTypeInspector(inner));
			nodeDeserializerFactories = new <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing, <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer>
			{
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlConvertibleNodeDeserializer),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlConvertibleNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSerializableNodeDeserializer),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSerializableNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>TypeConverterNodeDeserializer),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>TypeConverterNodeDeserializer(BuildTypeConverters())
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>NullNodeDeserializer),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>NullNodeDeserializer()
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarNodeDeserializer),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarNodeDeserializer(attemptUnknownTypeDeserialization, typeConverter, BuildTypeInspector(), yamlFormatter, enumNamingConvention)
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>ArrayNodeDeserializer),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>ArrayNodeDeserializer(enumNamingConvention, BuildTypeInspector())
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>DictionaryNodeDeserializer),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>DictionaryNodeDeserializer(objectFactory.Value, duplicateKeyChecking)
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>CollectionNodeDeserializer),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>CollectionNodeDeserializer(objectFactory.Value, enumNamingConvention, BuildTypeInspector())
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>EnumerableNodeDeserializer),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>EnumerableNodeDeserializer()
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectNodeDeserializer),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectNodeDeserializer(objectFactory.Value, BuildTypeInspector(), ignoreUnmatched, duplicateKeyChecking, typeConverter, enumNamingConvention, enforceNullability, caseInsensitivePropertyMatching, enforceRequiredProperties, BuildTypeConverters())
				},
				{
					typeof(FsharpListNodeDeserializer),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new FsharpListNodeDeserializer(BuildTypeInspector(), enumNamingConvention)
				}
			};
			nodeTypeResolverFactories = new <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing, <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver>
			{
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingNodeTypeResolver),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingNodeTypeResolver(typeMappings)
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlConvertibleTypeResolver),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlConvertibleTypeResolver()
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSerializableTypeResolver),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSerializableTypeResolver()
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>TagNodeTypeResolver),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>TagNodeTypeResolver(tagMappings)
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>PreventUnknownTagsNodeTypeResolver),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>PreventUnknownTagsNodeTypeResolver()
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultContainersNodeTypeResolver),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultContainersNodeTypeResolver()
				}
			};
			typeConverter = new ReflectionTypeConverter();
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector BuildTypeInspector()
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector2 = new WritablePropertiesTypeInspector(typeResolver, includeNonPublicProperties);
			if (!ignoreFields)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector2 = new <cba6ec40-2546-4a46-9577-18d27987fd9e>CompositeTypeInspector(new <cba6ec40-2546-4a46-9577-18d27987fd9e>ReadableFieldsTypeInspector(typeResolver), <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector2);
			}
			return typeInspectorFactories.BuildComponentChain(<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector2);
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder WithAttemptingUnquotedStringTypeDeserialization()
		{
			attemptUnknownTypeDeserialization = true;
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder WithObjectFactory(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory objectFactory)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory objectFactory2 = objectFactory;
			if (objectFactory2 == null)
			{
				throw new ArgumentNullException("objectFactory");
			}
			this.objectFactory = new Lazy<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory>(() => objectFactory2, isThreadSafe: true);
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder WithObjectFactory(Func<Type, object> objectFactory)
		{
			if (objectFactory == null)
			{
				throw new ArgumentNullException("objectFactory");
			}
			return WithObjectFactory(new <cba6ec40-2546-4a46-9577-18d27987fd9e>LambdaObjectFactory(objectFactory));
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder WithNodeDeserializer(<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer nodeDeserializer)
		{
			return WithNodeDeserializer(nodeDeserializer, delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer> w)
			{
				w.OnTop();
			});
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder WithNodeDeserializer(<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer nodeDeserializer, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer>> where)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer nodeDeserializer2 = nodeDeserializer;
			if (nodeDeserializer2 == null)
			{
				throw new ArgumentNullException("nodeDeserializer");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer2.GetType(), (<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => nodeDeserializer2));
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder WithNodeDeserializer<TNodeDeserializer>(<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITrackingRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer>> where) where TNodeDeserializer : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory2 = nodeDeserializerFactory;
			if (nodeDeserializerFactory2 == null)
			{
				throw new ArgumentNullException("nodeDeserializerFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer wrapped, <cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => nodeDeserializerFactory2(wrapped)));
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder WithoutNodeDeserializer<TNodeDeserializer>() where TNodeDeserializer : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer
		{
			return WithoutNodeDeserializer(typeof(TNodeDeserializer));
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder WithoutNodeDeserializer(Type nodeDeserializerType)
		{
			if (nodeDeserializerType == null)
			{
				throw new ArgumentNullException("nodeDeserializerType");
			}
			nodeDeserializerFactories.Remove(nodeDeserializerType);
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>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(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer> s)
			{
				s.Before<<cba6ec40-2546-4a46-9577-18d27987fd9e>DictionaryNodeDeserializer>();
			});
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder WithNodeTypeResolver(<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver nodeTypeResolver)
		{
			return WithNodeTypeResolver(nodeTypeResolver, delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver> w)
			{
				w.OnTop();
			});
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder WithNodeTypeResolver(<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver nodeTypeResolver, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver>> where)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver nodeTypeResolver2 = nodeTypeResolver;
			if (nodeTypeResolver2 == null)
			{
				throw new ArgumentNullException("nodeTypeResolver");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver2.GetType(), (<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => nodeTypeResolver2));
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder WithNodeTypeResolver<TNodeTypeResolver>(<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITrackingRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver>> where) where TNodeTypeResolver : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory2 = nodeTypeResolverFactory;
			if (nodeTypeResolverFactory2 == null)
			{
				throw new ArgumentNullException("nodeTypeResolverFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver wrapped, <cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => nodeTypeResolverFactory2(wrapped)));
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder WithCaseInsensitivePropertyMatching()
		{
			caseInsensitivePropertyMatching = true;
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder WithEnforceNullability()
		{
			enforceNullability = true;
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder WithEnforceRequiredMembers()
		{
			enforceRequiredProperties = true;
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder WithoutNodeTypeResolver<TNodeTypeResolver>() where TNodeTypeResolver : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver
		{
			return WithoutNodeTypeResolver(typeof(TNodeTypeResolver));
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder WithoutNodeTypeResolver(Type nodeTypeResolverType)
		{
			if (nodeTypeResolverType == null)
			{
				throw new ArgumentNullException("nodeTypeResolverType");
			}
			nodeTypeResolverFactories.Remove(nodeTypeResolverType);
			return this;
		}

		public override <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder WithTagMapping(<cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder WithTypeMapping<TInterface, TConcrete>() where TConcrete : TInterface
		{
			Type typeFromHandle = typeof(TInterface);
			Type typeFromHandle2 = typeof(TConcrete);
			if (!typeFromHandle.IsAssignableFrom(typeFromHandle2))
			{
				throw new InvalidOperationException("The type '" + typeFromHandle2.Name + "' does not implement interface '" + typeFromHandle.Name + "'.");
			}
			if (!DictionaryExtensions.TryAdd(typeMappings, typeFromHandle, typeFromHandle2))
			{
				typeMappings[typeFromHandle] = typeFromHandle2;
			}
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder WithoutTagMapping(<cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder IgnoreUnmatchedProperties()
		{
			ignoreUnmatched = true;
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DeserializerBuilder WithDuplicateKeyChecking()
		{
			duplicateKeyChecking = true;
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>IDeserializer Build()
		{
			if (FsharpHelper.Instance == null)
			{
				FsharpHelper.Instance = new DefaultFsharpHelper();
			}
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>Deserializer.FromValueDeserializer(BuildValueDeserializer());
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>IValueDeserializer BuildValueDeserializer()
		{
			return new <cba6ec40-2546-4a46-9577-18d27987fd9e>AliasValueDeserializer(new <cba6ec40-2546-4a46-9577-18d27987fd9e>NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList(), typeConverter, enumNamingConvention, BuildTypeInspector()));
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs
	{
		private readonly IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>> preProcessingPhaseVisitors;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter> InnerVisitor { get; private set; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter EventEmitter { get; private set; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer NestedObjectSerializer { get; private set; }

		public IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> TypeConverters { get; private set; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter> innerVisitor, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter eventEmitter, IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>> preProcessingPhaseVisitors, IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverters, <cba6ec40-2546-4a46-9577-18d27987fd9e>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 : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>
		{
			return preProcessingPhaseVisitors.OfType<T>().Single();
		}
	}
	internal abstract class <cba6ec40-2546-4a46-9577-18d27987fd9e>EventInfo
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor Source { get; }

		protected <cba6ec40-2546-4a46-9577-18d27987fd9e>EventInfo(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor source)
		{
			Source = source ?? throw new ArgumentNullException("source");
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>AliasEventInfo : <cba6ec40-2546-4a46-9577-18d27987fd9e>EventInfo
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName Alias { get; }

		public bool NeedsExpansion { get; set; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>AliasEventInfo(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor source, <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName alias)
			: base(source)
		{
			if (alias.IsEmpty)
			{
				throw new ArgumentNullException("alias");
			}
			Alias = alias;
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectEventInfo : <cba6ec40-2546-4a46-9577-18d27987fd9e>EventInfo
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName Anchor { get; set; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName Tag { get; set; }

		protected <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectEventInfo(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarEventInfo : <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectEventInfo
	{
		public string RenderedValue { get; set; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle Style { get; set; }

		public bool IsPlainImplicit { get; set; }

		public bool IsQuotedImplicit { get; set; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarEventInfo(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor source)
			: base(source)
		{
			Style = source.ScalarStyle;
			RenderedValue = string.Empty;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStartEventInfo : <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStyle Style { get; set; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStartEventInfo(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEndEventInfo : <cba6ec40-2546-4a46-9577-18d27987fd9e>EventInfo
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEndEventInfo(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStartEventInfo : <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStyle Style { get; set; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStartEventInfo(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEndEventInfo : <cba6ec40-2546-4a46-9577-18d27987fd9e>EventInfo
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEndEventInfo(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal interface <cba6ec40-2546-4a46-9577-18d27987fd9e>IAliasProvider
	{
		<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName GetAlias(object target);
	}
	internal interface <cba6ec40-2546-4a46-9577-18d27987fd9e>IDeserializer
	{
		T Deserialize<T>(string input);

		T Deserialize<T>(TextReader input);

		T Deserialize<T>(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser);

		object? Deserialize(string input);

		object? Deserialize(TextReader input);

		object? Deserialize(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser);

		object? Deserialize(string input, Type type);

		object? Deserialize(TextReader input, Type type);

		object? Deserialize(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type type);
	}
	internal interface <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter
	{
		void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>AliasEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter);

		void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter);

		void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStartEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter);

		void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEndEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter);

		void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStartEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter);

		void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEndEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter);
	}
	internal interface <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention
	{
		string Apply(string value);

		string Reverse(string value);
	}
	internal interface <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer
	{
		bool Deserialize(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser reader, Type expectedType, Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser, Type, object?> nestedObjectDeserializer, out object? value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer);
	}
	internal interface <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver
	{
		bool Resolve(<cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent? nodeEvent, ref Type currentType);
	}
	internal interface IObjectAccessor
	{
		void Set(string name, object target, object value);

		object? Read(string name, object target);
	}
	internal interface <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor
	{
		object? Value { get; }

		Type Type { get; }

		Type StaticType { get; }

		<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle ScalarStyle { get; }
	}
	internal static class <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDescriptorExtensions
	{
		public static object NonNullValue(this <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory
	{
		object Create(Type type);

		object? CreatePrimitive(Type type);

		bool GetDictionary(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor descriptor, out IDictionary? dictionary, out Type[]? genericArguments);

		Type GetValueType(Type type);

		void ExecuteOnDeserializing(object value);

		void ExecuteOnDeserialized(object value);

		void ExecuteOnSerializing(object value);

		void ExecuteOnSerialized(object value);
	}
	internal interface <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphTraversalStrategy
	{
		void Traverse<TContext>(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor graph, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<TContext> visitor, TContext context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer);
	}
	internal interface <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<TContext>
	{
		bool Enter(<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor? propertyDescriptor, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, TContext context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer);

		bool EnterMapping(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor key, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, TContext context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer);

		bool EnterMapping(<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor key, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, TContext context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer);

		void VisitScalar(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor scalar, TContext context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer);

		void VisitMappingStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor mapping, Type keyType, Type valueType, TContext context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer);

		void VisitMappingEnd(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor mapping, TContext context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer);

		void VisitSequenceStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor sequence, Type elementType, TContext context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer);

		void VisitSequenceEnd(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor sequence, TContext context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer);
	}
	internal interface <cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor
	{
		string Name { get; }

		bool AllowNulls { get; }

		bool CanWrite { get; }

		Type Type { get; }

		Type? TypeOverride { get; set; }

		int Order { get; set; }

		<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle ScalarStyle { get; set; }

		bool Required { get; }

		Type? ConverterType { get; }

		T? GetCustomAttribute<T>() where T : Attribute;

		<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor Read(object target);

		void Write(object target, object? value);
	}
	internal interface <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>ITrackingRegistrationLocationSelectionSyntax<TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
	}
	internal interface <cba6ec40-2546-4a46-9577-18d27987fd9e>ISerializer
	{
		string Serialize(object? graph);

		string Serialize(object? graph, Type type);

		void Serialize(TextWriter writer, object? graph);

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

		void Serialize(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, object? graph);

		void Serialize(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, object? graph, Type type);
	}
	internal interface <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector
	{
		IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor> GetProperties(Type type, object? container);

		<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor GetProperty(Type type, object? container, string name, [<cba6ec40-2546-4a46-9577-18d27987fd9e>MaybeNullWhen(true)] bool ignoreUnmatched, bool caseInsensitivePropertyMatching);

		string GetEnumName(Type enumType, string name);

		string GetEnumValue(object enumValue);
	}
	internal interface <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver
	{
		Type Resolve(Type staticType, object? actualValue);
	}
	public interface <cba6ec40-2546-4a46-9577-18d27987fd9e>IValueDeserializer
	{
		object? DeserializeValue(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type expectedType, <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerState state, <cba6ec40-2546-4a46-9577-18d27987fd9e>IValueDeserializer nestedObjectDeserializer);
	}
	internal interface <cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise
	{
		event Action<object?> ValueAvailable;
	}
	public interface <cba6ec40-2546-4a46-9577-18d27987fd9e>IValueSerializer
	{
		void SerializeValue(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, object? value, Type? type);
	}
	internal interface <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlConvertible
	{
		void Read(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type expectedType, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer nestedObjectDeserializer);

		void Write(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer nestedObjectSerializer);
	}
	public delegate object? <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer(Type type);
	public delegate void <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer(object? value, Type? type = null);
	[Obsolete("Please use IYamlConvertible instead")]
	internal interface <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlSerializable
	{
		void ReadYaml(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser);

		void WriteYaml(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter);
	}
	internal interface <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter
	{
		bool Accepts(Type type);

		object? ReadYaml(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type type, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer);

		void WriteYaml(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, object? value, Type type, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer);
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>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 : <cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<TComponent>
		{
			private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<TArgument, TComponent> registrations;

			private readonly LazyComponentRegistration newRegistration;

			public RegistrationLocationSelector(<cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<TArgument, TComponent> registrations, LazyComponentRegistration newRegistration)
			{
				this.registrations = registrations;
				this.newRegistration = newRegistration;
			}

			void <cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<TComponent>.InsteadOf<TRegistrationType>()
			{
				if (newRegistration.ComponentType != typeof(TRegistrationType))
				{
					registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				}
				int index = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries[index] = newRegistration;
			}

			void <cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<TComponent>.After<TRegistrationType>()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				int num = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries.Insert(num + 1, newRegistration);
			}

			void <cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<TComponent>.Before<TRegistrationType>()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				int index = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries.Insert(index, newRegistration);
			}

			void <cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<TComponent>.OnBottom()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				registrations.entries.Add(newRegistration);
			}

			void <cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<TComponent>.OnTop()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				registrations.entries.Insert(0, newRegistration);
			}
		}

		private class TrackingRegistrationLocationSelector : <cba6ec40-2546-4a46-9577-18d27987fd9e>ITrackingRegistrationLocationSelectionSyntax<TComponent>
		{
			private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<TArgument, TComponent> registrations;

			private readonly TrackingLazyComponentRegistration newRegistration;

			public TrackingRegistrationLocationSelector(<cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<TArgument, TComponent> registrations, TrackingLazyComponentRegistration newRegistration)
			{
				this.registrations = registrations;
				this.newRegistration = newRegistration;
			}

			void <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<TArgument, TComponent> Clone()
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<TArgument, TComponent> <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList2 = new <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<TArgument, TComponent>();
			foreach (LazyComponentRegistration entry in entries)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList2.entries.Add(entry);
			}
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<TComponent> CreateRegistrationLocationSelector(Type componentType, Func<TArgument, TComponent> factory)
		{
			return new RegistrationLocationSelector(this, new LazyComponentRegistration(componentType, factory));
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationListExtensions
	{
		public static TComponent BuildComponentChain<TComponent>(this <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing, TComponent> registrations)
		{
			return registrations.Select((Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing, TComponent> factory) => factory(default(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing))).ToList();
		}

		public static List<TComponent> BuildComponentList<TArgument, TComponent>(this <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing
	{
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDescriptor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor
	{
		public object? Value { get; private set; }

		public Type Type { get; private set; }

		public Type StaticType { get; private set; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle ScalarStyle { get; private set; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDescriptor(object? value, Type type, Type staticType)
			: this(value, type, staticType, <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Any)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDescriptor(object? value, Type type, Type staticType, <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle scalarStyle)
		{
			Value = value;
			Type = type ?? throw new ArgumentNullException("type");
			StaticType = staticType ?? throw new ArgumentNullException("staticType");
			ScalarStyle = scalarStyle;
		}
	}
	internal delegate <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphTraversalStrategy <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectGraphTraversalStrategyFactory(<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver, IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverters, int maximumRecursion);
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>PropertyDescriptor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor
	{
		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor baseDescriptor;

		public bool AllowNulls => baseDescriptor.AllowNulls;

		public string Name { get; set; }

		public bool Required => baseDescriptor.Required;

		public Type Type => baseDescriptor.Type;

		public Type? TypeOverride
		{
			get
			{
				return baseDescriptor.TypeOverride;
			}
			set
			{
				baseDescriptor.TypeOverride = value;
			}
		}

		public Type? ConverterType => baseDescriptor.ConverterType;

		public int Order { get; set; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle ScalarStyle
		{
			get
			{
				return baseDescriptor.ScalarStyle;
			}
			set
			{
				baseDescriptor.ScalarStyle = value;
			}
		}

		public bool CanWrite => baseDescriptor.CanWrite;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>PropertyDescriptor(<cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor Read(object target)
		{
			return baseDescriptor.Read(target);
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>Serializer : <cba6ec40-2546-4a46-9577-18d27987fd9e>ISerializer
	{
		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IValueSerializer valueSerializer;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings emitterSettings;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Serializer()
			: this(new <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder().BuildValueSerializer(), <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings.Default)
		{
		}

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>Serializer(<cba6ec40-2546-4a46-9577-18d27987fd9e>IValueSerializer valueSerializer, <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings emitterSettings)
		{
			this.valueSerializer = valueSerializer ?? throw new ArgumentNullException("valueSerializer");
			this.emitterSettings = emitterSettings ?? throw new ArgumentNullException("emitterSettings");
		}

		public static <cba6ec40-2546-4a46-9577-18d27987fd9e>Serializer FromValueSerializer(<cba6ec40-2546-4a46-9577-18d27987fd9e>IValueSerializer valueSerializer, <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings emitterSettings)
		{
			return new <cba6ec40-2546-4a46-9577-18d27987fd9e>Serializer(valueSerializer, emitterSettings);
		}

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

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

		public void Serialize(TextWriter writer, object? graph)
		{
			Serialize(new <cba6ec40-2546-4a46-9577-18d27987fd9e>Emitter(writer, emitterSettings), graph);
		}

		public void Serialize(TextWriter writer, object? graph, Type type)
		{
			Serialize(new <cba6ec40-2546-4a46-9577-18d27987fd9e>Emitter(writer, emitterSettings), graph, type);
		}

		public void Serialize(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, object? graph)
		{
			if (emitter == null)
			{
				throw new ArgumentNullException("emitter");
			}
			EmitDocument(emitter, graph, null);
		}

		public void Serialize(<cba6ec40-2546-4a46-9577-18d27987fd9e>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(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, object? graph, Type? type)
		{
			emitter.Emit(new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamStart());
			emitter.Emit(new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart());
			valueSerializer.SerializeValue(emitter, graph, type);
			emitter.Emit(new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd(isImplicit: true));
			emitter.Emit(new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamEnd());
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder : <cba6ec40-2546-4a46-9577-18d27987fd9e>BuilderSkeleton<<cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder>
	{
		private class ValueSerializer : <cba6ec40-2546-4a46-9577-18d27987fd9e>IValueSerializer
		{
			private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphTraversalStrategy traversalStrategy;

			private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter eventEmitter;

			private readonly IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverters;

			private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

			private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>> emissionPhaseObjectGraphVisitorFactories;

			public ValueSerializer(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphTraversalStrategy traversalStrategy, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter eventEmitter, IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverters, <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>> preProcessingPhaseObjectGraphVisitorFactories, <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>> emissionPhaseObjectGraphVisitorFactories)
			{
				this.traversalStrategy = traversalStrategy;
				this.eventEmitter = eventEmitter;
				this.typeConverters = typeConverters;
				this.preProcessingPhaseObjectGraphVisitorFactories = preProcessingPhaseObjectGraphVisitorFactories;
				this.emissionPhaseObjectGraphVisitorFactories = emissionPhaseObjectGraphVisitorFactories;
			}

			public void SerializeValue(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, object? value, Type? type)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter2 = emitter;
				Type type2 = type ?? ((value != null) ? value.GetType() : typeof(object));
				Type staticType = type ?? typeof(object);
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDescriptor graph = new <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDescriptor(value, type2, staticType);
				List<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>> preProcessingPhaseObjectGraphVisitors = preProcessingPhaseObjectGraphVisitorFactories.BuildComponentList(typeConverters);
				<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter> visitor = emissionPhaseObjectGraphVisitorFactories.BuildComponentChain<<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>>(new <cba6ec40-2546-4a46-9577-18d27987fd9e>EmittingObjectGraphVisitor(eventEmitter), (<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter> inner) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
				foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing> item in preProcessingPhaseObjectGraphVisitors)
				{
					traversalStrategy.Traverse(graph, item, default(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing), NestedObjectSerializer);
				}
				traversalStrategy.Traverse(graph, visitor, emitter2, NestedObjectSerializer);
				void NestedObjectSerializer(object? v, Type? t)
				{
					SerializeValue(emitter2, v, t);
				}
			}
		}

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>> emissionPhaseObjectGraphVisitorFactories;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter> eventEmitterFactories;

		private readonly Dictionary<Type, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName> tagMappings = new Dictionary<Type, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName>();

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory objectFactory;

		private int maximumRecursion = 50;

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings emitterSettings = <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings.Default;

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultValuesHandling defaultValuesHandlingConfiguration;

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle defaultScalarStyle;

		private bool quoteNecessaryStrings;

		private bool quoteYaml1_1Strings;

		protected override <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder Self => this;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder()
			: base((<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver)new <cba6ec40-2546-4a46-9577-18d27987fd9e>DynamicTypeResolver())
		{
			typeInspectorFactories.Add(typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>CachedTypeInspector), (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector inner) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>NamingConventionTypeInspector), (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector inner) => (!(namingConvention is <cba6ec40-2546-4a46-9577-18d27987fd9e>NullNamingConvention)) ? new <cba6ec40-2546-4a46-9577-18d27987fd9e>NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributesTypeInspector), (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector inner) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributesTypeInspector(inner));
			typeInspectorFactories.Add(typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributeOverridesInspector), (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector inner) => (overrides == null) ? inner : new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributeOverridesInspector(inner, overrides.Clone()));
			preProcessingPhaseObjectGraphVisitorFactories = new <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>> { 
			{
				typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAssigner),
				(IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverters) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAssigner(typeConverters)
			} };
			emissionPhaseObjectGraphVisitorFactories = new <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>>
			{
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>CustomSerializationObjectGraphVisitor),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs args) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>CustomSerializationObjectGraphVisitor(args.InnerVisitor, args.TypeConverters, args.NestedObjectSerializer)
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAssigningObjectGraphVisitor),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs args) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAssigningObjectGraphVisitor(args.InnerVisitor, args.EventEmitter, args.GetPreProcessingPhaseObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAssigner>())
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultValuesObjectGraphVisitor),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs args) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultValuesObjectGraphVisitor(defaultValuesHandlingConfiguration, args.InnerVisitor, new <cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultObjectFactory())
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>CommentsObjectGraphVisitor),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs args) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>CommentsObjectGraphVisitor(args.InnerVisitor)
				}
			};
			eventEmitterFactories = new <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter> { 
			{
				typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>TypeAssigningEventEmitter),
				(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter inner) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>TypeAssigningEventEmitter(inner, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings, defaultScalarStyle, yamlFormatter, enumNamingConvention, BuildTypeInspector())
			} };
			objectFactory = new <cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultObjectFactory();
			objectGraphTraversalStrategyFactory = (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver, IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverters, int maximumRecursion) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>FullObjectGraphTraversalStrategy(typeInspector, typeResolver, maximumRecursion, namingConvention, objectFactory);
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithQuotingNecessaryStrings(bool quoteYaml1_1Strings = false)
		{
			quoteNecessaryStrings = true;
			this.quoteYaml1_1Strings = quoteYaml1_1Strings;
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithDefaultScalarStyle(<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle style)
		{
			defaultScalarStyle = style;
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithEventEmitter<TEventEmitter>(Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithEventEmitter<TEventEmitter>(Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, TEventEmitter> eventEmitterFactory) where TEventEmitter : <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithEventEmitter<TEventEmitter>(Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter, TEventEmitter> eventEmitterFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter>> where) where TEventEmitter : <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter
		{
			Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			return WithEventEmitter((<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter e, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector _) => eventEmitterFactory2(e), where);
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithEventEmitter<TEventEmitter>(Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, TEventEmitter> eventEmitterFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter>> where) where TEventEmitter : <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter
		{
			Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			if (eventEmitterFactory2 == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateRegistrationLocationSelector(typeof(TEventEmitter), (<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter inner) => eventEmitterFactory2(inner, BuildTypeInspector())));
			return Self;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithEventEmitter<TEventEmitter>(<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter, TEventEmitter> eventEmitterFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITrackingRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter>> where) where TEventEmitter : <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			if (eventEmitterFactory2 == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateTrackingRegistrationLocationSelector(typeof(TEventEmitter), (<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter wrapped, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter inner) => eventEmitterFactory2(wrapped, inner)));
			return Self;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithoutEventEmitter<TEventEmitter>() where TEventEmitter : <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter
		{
			return WithoutEventEmitter(typeof(TEventEmitter));
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithoutEventEmitter(Type eventEmitterType)
		{
			if (eventEmitterType == null)
			{
				throw new ArgumentNullException("eventEmitterType");
			}
			eventEmitterFactories.Remove(eventEmitterType);
			return this;
		}

		public override <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithTagMapping(<cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder EnsureRoundtrip()
		{
			objectGraphTraversalStrategyFactory = (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver, IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverters, int maximumRecursion) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>RoundtripObjectGraphTraversalStrategy(typeConverters, typeInspector, typeResolver, maximumRecursion, namingConvention, settings, objectFactory);
			WithEventEmitter((<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter inner) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>TypeAssigningEventEmitter(inner, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings, defaultScalarStyle, yamlFormatter, enumNamingConvention, BuildTypeInspector()), delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter> loc)
			{
				loc.InsteadOf<<cba6ec40-2546-4a46-9577-18d27987fd9e>TypeAssigningEventEmitter>();
			});
			return WithTypeInspector((<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector inner) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>ReadableAndWritablePropertiesTypeInspector(inner), delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector> loc)
			{
				loc.OnBottom();
			});
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder DisableAliases()
		{
			preProcessingPhaseObjectGraphVisitorFactories.Remove(typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAssigner));
			emissionPhaseObjectGraphVisitorFactories.Remove(typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder EmitDefaults()
		{
			return ConfigureDefaultValuesHandling(<cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultValuesHandling.Preserve);
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder ConfigureDefaultValuesHandling(<cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultValuesHandling configuration)
		{
			defaultValuesHandlingConfiguration = configuration;
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder JsonCompatible()
		{
			emitterSettings = emitterSettings.WithMaxSimpleKeyLength(int.MaxValue).WithoutAnchorName().WithUtf16SurrogatePairs();
			return WithTypeConverter(new <cba6ec40-2546-4a46-9577-18d27987fd9e>GuidConverter(jsonCompatible: true), delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> w)
			{
				w.InsteadOf<<cba6ec40-2546-4a46-9577-18d27987fd9e>GuidConverter>();
			}).WithTypeConverter(new DateTime8601Converter(<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.DoubleQuoted)).WithEventEmitter((<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter inner) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>JsonEventEmitter(inner, yamlFormatter, enumNamingConvention, BuildTypeInspector()), delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter> loc)
			{
				loc.InsteadOf<<cba6ec40-2546-4a46-9577-18d27987fd9e>TypeAssigningEventEmitter>();
			});
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithNewLine(string newLine)
		{
			emitterSettings = emitterSettings.WithNewLine(newLine);
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>> w)
			{
				w.OnTop();
			});
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>> w)
			{
				w.OnTop();
			});
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>>> where) where TObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>
		{
			TObjectGraphVisitor objectGraphVisitor2 = objectGraphVisitor;
			if (objectGraphVisitor2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitor");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> _) => objectGraphVisitor2));
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>>> where) where TObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>
		{
			Func<IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory2(typeConverters)));
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITrackingRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>>> where) where TObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing> wrapped, IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> _) => objectGraphVisitorFactory2(wrapped)));
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITrackingRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>>> where) where TObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing> wrapped, IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory2(wrapped, typeConverters)));
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>
		{
			return WithoutPreProcessingPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor(Type objectGraphVisitorType)
		{
			if (objectGraphVisitorType == null)
			{
				throw new ArgumentNullException("objectGraphVisitorType");
			}
			preProcessingPhaseObjectGraphVisitorFactories.Remove(objectGraphVisitorType);
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithObjectGraphTraversalStrategyFactory(<cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory)
		{
			this.objectGraphTraversalStrategyFactory = objectGraphTraversalStrategyFactory;
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>
		{
			return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>> w)
			{
				w.OnTop();
			});
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>>> where) where TObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>
		{
			Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory2(args)));
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITrackingRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>>> where) where TObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter> wrapped, <cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory2(wrapped, args)));
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithoutEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>
		{
			return WithoutEmissionPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithoutEmissionPhaseObjectGraphVisitor(Type objectGraphVisitorType)
		{
			if (objectGraphVisitorType == null)
			{
				throw new ArgumentNullException("objectGraphVisitorType");
			}
			emissionPhaseObjectGraphVisitorFactories.Remove(objectGraphVisitorType);
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerBuilder WithIndentedSequences()
		{
			emitterSettings = emitterSettings.WithIndentedSequences();
			return this;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ISerializer Build()
		{
			if (FsharpHelper.Instance == null)
			{
				FsharpHelper.Instance = new DefaultFsharpHelper();
			}
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>Serializer.FromValueSerializer(BuildValueSerializer(), emitterSettings);
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>IValueSerializer BuildValueSerializer()
		{
			IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverters = BuildTypeConverters();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector = BuildTypeInspector();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphTraversalStrategy traversalStrategy = objectGraphTraversalStrategyFactory(typeInspector, typeResolver, typeConverters, maximumRecursion);
			<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter eventEmitter = eventEmitterFactories.BuildComponentChain(new <cba6ec40-2546-4a46-9577-18d27987fd9e>WriterEventEmitter());
			return new ValueSerializer(traversalStrategy, eventEmitter, typeConverters, preProcessingPhaseObjectGraphVisitorFactories.Clone(), emissionPhaseObjectGraphVisitorFactories.Clone());
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector BuildTypeInspector()
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector2 = new <cba6ec40-2546-4a46-9577-18d27987fd9e>ReadablePropertiesTypeInspector(typeResolver, includeNonPublicProperties);
			if (!ignoreFields)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector2 = new <cba6ec40-2546-4a46-9577-18d27987fd9e>CompositeTypeInspector(new <cba6ec40-2546-4a46-9577-18d27987fd9e>ReadableFieldsTypeInspector(typeResolver), <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector2);
			}
			return typeInspectorFactories.BuildComponentChain(<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector2);
		}
	}
	internal class Settings
	{
		public bool AllowPrivateConstructors { get; set; }
	}
	internal abstract class StaticBuilderSkeleton<TBuilder> where TBuilder : StaticBuilderSkeleton<TBuilder>
	{
		internal <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention namingConvention = <cba6ec40-2546-4a46-9577-18d27987fd9e>NullNamingConvention.Instance;

		internal <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention = <cba6ec40-2546-4a46-9577-18d27987fd9e>NullNamingConvention.Instance;

		internal <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver;

		internal readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing, <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverterFactories;

		internal readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector> typeInspectorFactories;

		internal bool includeNonPublicProperties;

		internal Settings settings;

		internal <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlFormatter yamlFormatter = <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlFormatter.Default;

		protected abstract TBuilder Self { get; }

		internal StaticBuilderSkeleton(<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver)
		{
			typeConverterFactories = new <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing, <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> { 
			{
				typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>GuidConverter),
				(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>GuidConverter(jsonCompatible: false)
			} };
			typeInspectorFactories = new <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector>();
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			settings = new Settings();
		}

		public TBuilder WithNamingConvention(<cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention namingConvention)
		{
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
			return Self;
		}

		public TBuilder WithEnumNamingConvention(<cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention)
		{
			this.enumNamingConvention = enumNamingConvention ?? throw new ArgumentNullException("enumNamingConvention");
			return Self;
		}

		public TBuilder WithTypeResolver(<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			return Self;
		}

		public abstract TBuilder WithTagMapping(<cba6ec40-2546-4a46-9577-18d27987fd9e>TagName tag, Type type);

		public TBuilder WithTypeConverter(<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter typeConverter)
		{
			return WithTypeConverter(typeConverter, delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeConverter(<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter typeConverter, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>> where)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter typeConverter2 = typeConverter;
			if (typeConverter2 == null)
			{
				throw new ArgumentNullException("typeConverter");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter2.GetType(), (<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => typeConverter2));
			return Self;
		}

		public TBuilder WithTypeConverter<TYamlTypeConverter>(<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter, <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverterFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITrackingRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>> where) where TYamlTypeConverter : <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter, <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverterFactory2 = typeConverterFactory;
			if (typeConverterFactory2 == null)
			{
				throw new ArgumentNullException("typeConverterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter wrapped, <cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => typeConverterFactory2(wrapped)));
			return Self;
		}

		public TBuilder WithoutTypeConverter<TYamlTypeConverter>() where TYamlTypeConverter : <cba6ec40-2546-4a46-9577-18d27987fd9e>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<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector
		{
			return WithTypeInspector(typeInspectorFactory, delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeInspector<TTypeInspector>(Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, TTypeInspector> typeInspectorFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector>> where) where TTypeInspector : <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector
		{
			Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
			if (typeInspectorFactory2 == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector inner) => typeInspectorFactory2(inner)));
			return Self;
		}

		public TBuilder WithTypeInspector<TTypeInspector>(<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, TTypeInspector> typeInspectorFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITrackingRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector>> where) where TTypeInspector : <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, TTypeInspector> typeInspectorFactory2 = typeInspectorFactory;
			if (typeInspectorFactory2 == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector wrapped, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector inner) => typeInspectorFactory2(wrapped, inner)));
			return Self;
		}

		public TBuilder WithoutTypeInspector<TTypeInspector>() where TTypeInspector : <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector
		{
			return WithoutTypeInspector(typeof(TTypeInspector));
		}

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

		public TBuilder WithYamlFormatter(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlFormatter formatter)
		{
			yamlFormatter = formatter ?? throw new ArgumentNullException("formatter");
			return Self;
		}

		protected IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> BuildTypeConverters()
		{
			return typeConverterFactories.BuildComponentList();
		}
	}
	internal abstract class StaticContext
	{
		public virtual bool IsKnownType(Type type)
		{
			throw new NotImplementedException();
		}

		public virtual <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver GetTypeResolver()
		{
			throw new NotImplementedException();
		}

		public virtual StaticObjectFactory GetFactory()
		{
			throw new NotImplementedException();
		}

		public virtual <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector GetTypeInspector()
		{
			throw new NotImplementedException();
		}
	}
	internal sealed class StaticDeserializerBuilder : StaticBuilderSkeleton<StaticDeserializerBuilder>
	{
		private readonly StaticContext context;

		private readonly StaticObjectFactory factory;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing, <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer> nodeDeserializerFactories;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing, <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver> nodeTypeResolverFactories;

		private readonly Dictionary<<cba6ec40-2546-4a46-9577-18d27987fd9e>TagName, Type> tagMappings;

		private readonly ITypeConverter typeConverter;

		private readonly Dictionary<Type, Type> typeMappings;

		private bool ignoreUnmatched;

		private bool duplicateKeyChecking;

		private bool attemptUnknownTypeDeserialization;

		private bool enforceNullability;

		private bool caseInsensitivePropertyMatching;

		protected override StaticDeserializerBuilder Self => this;

		public StaticDeserializerBuilder(StaticContext context)
			: base(context.GetTypeResolver())
		{
			this.context = context;
			factory = context.GetFactory();
			typeMappings = new Dictionary<Type, Type>();
			tagMappings = new Dictionary<<cba6ec40-2546-4a46-9577-18d27987fd9e>TagName, Type>
			{
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>FailsafeSchema.Tags.Map,
					typeof(Dictionary<object, object>)
				},
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>FailsafeSchema.Tags.Str,
					typeof(string)
				},
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>JsonSchema.Tags.Bool,
					typeof(bool)
				},
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>JsonSchema.Tags.Float,
					typeof(double)
				},
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>JsonSchema.Tags.Int,
					typeof(int)
				},
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultSchema.Tags.Timestamp,
					typeof(DateTime)
				}
			};
			typeInspectorFactories.Add(typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>CachedTypeInspector), (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector inner) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>NamingConventionTypeInspector), (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector inner) => (!(namingConvention is <cba6ec40-2546-4a46-9577-18d27987fd9e>NullNamingConvention)) ? new <cba6ec40-2546-4a46-9577-18d27987fd9e>NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributesTypeInspector), (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector inner) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributesTypeInspector(inner));
			nodeDeserializerFactories = new <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing, <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer>
			{
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlConvertibleNodeDeserializer),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlConvertibleNodeDeserializer(factory)
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSerializableNodeDeserializer),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSerializableNodeDeserializer(factory)
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>TypeConverterNodeDeserializer),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>TypeConverterNodeDeserializer(BuildTypeConverters())
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>NullNodeDeserializer),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>NullNodeDeserializer()
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarNodeDeserializer),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarNodeDeserializer(attemptUnknownTypeDeserialization, typeConverter, BuildTypeInspector(), yamlFormatter, enumNamingConvention)
				},
				{
					typeof(StaticArrayNodeDeserializer),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new StaticArrayNodeDeserializer(factory)
				},
				{
					typeof(StaticDictionaryNodeDeserializer),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new StaticDictionaryNodeDeserializer(factory, duplicateKeyChecking)
				},
				{
					typeof(StaticCollectionNodeDeserializer),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new StaticCollectionNodeDeserializer(factory)
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectNodeDeserializer),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectNodeDeserializer(factory, BuildTypeInspector(), ignoreUnmatched, duplicateKeyChecking, typeConverter, enumNamingConvention, enforceNullability, caseInsensitivePropertyMatching, enforceRequiredProperties: false, BuildTypeConverters())
				}
			};
			nodeTypeResolverFactories = new <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing, <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver>
			{
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingNodeTypeResolver),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingNodeTypeResolver(typeMappings)
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlConvertibleTypeResolver),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlConvertibleTypeResolver()
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSerializableTypeResolver),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSerializableTypeResolver()
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>TagNodeTypeResolver),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>TagNodeTypeResolver(tagMappings)
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>PreventUnknownTagsNodeTypeResolver),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>PreventUnknownTagsNodeTypeResolver()
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultContainersNodeTypeResolver),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultContainersNodeTypeResolver()
				}
			};
			typeConverter = new NullTypeConverter();
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector BuildTypeInspector()
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector = context.GetTypeInspector();
			return typeInspectorFactories.BuildComponentChain(typeInspector);
		}

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

		public StaticDeserializerBuilder WithNodeDeserializer(<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer nodeDeserializer)
		{
			return WithNodeDeserializer(nodeDeserializer, delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer> w)
			{
				w.OnTop();
			});
		}

		public StaticDeserializerBuilder WithNodeDeserializer(<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer nodeDeserializer, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer>> where)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer nodeDeserializer2 = nodeDeserializer;
			if (nodeDeserializer2 == null)
			{
				throw new ArgumentNullException("nodeDeserializer");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer2.GetType(), (<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => nodeDeserializer2));
			return this;
		}

		public StaticDeserializerBuilder WithNodeDeserializer<TNodeDeserializer>(<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITrackingRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer>> where) where TNodeDeserializer : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory2 = nodeDeserializerFactory;
			if (nodeDeserializerFactory2 == null)
			{
				throw new ArgumentNullException("nodeDeserializerFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer wrapped, <cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => nodeDeserializerFactory2(wrapped)));
			return this;
		}

		public StaticDeserializerBuilder WithCaseInsensitivePropertyMatching()
		{
			caseInsensitivePropertyMatching = true;
			return this;
		}

		public StaticDeserializerBuilder WithEnforceNullability()
		{
			enforceNullability = true;
			return this;
		}

		public StaticDeserializerBuilder WithoutNodeDeserializer<TNodeDeserializer>() where TNodeDeserializer : <cba6ec40-2546-4a46-9577-18d27987fd9e>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(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer> s)
			{
				s.Before<<cba6ec40-2546-4a46-9577-18d27987fd9e>DictionaryNodeDeserializer>();
			});
		}

		public StaticDeserializerBuilder WithNodeTypeResolver(<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver nodeTypeResolver)
		{
			return WithNodeTypeResolver(nodeTypeResolver, delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver> w)
			{
				w.OnTop();
			});
		}

		public StaticDeserializerBuilder WithNodeTypeResolver(<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver nodeTypeResolver, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver>> where)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver nodeTypeResolver2 = nodeTypeResolver;
			if (nodeTypeResolver2 == null)
			{
				throw new ArgumentNullException("nodeTypeResolver");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver2.GetType(), (<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => nodeTypeResolver2));
			return this;
		}

		public StaticDeserializerBuilder WithNodeTypeResolver<TNodeTypeResolver>(<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITrackingRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver>> where) where TNodeTypeResolver : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory2 = nodeTypeResolverFactory;
			if (nodeTypeResolverFactory2 == null)
			{
				throw new ArgumentNullException("nodeTypeResolverFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver wrapped, <cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing _) => nodeTypeResolverFactory2(wrapped)));
			return this;
		}

		public StaticDeserializerBuilder WithoutNodeTypeResolver<TNodeTypeResolver>() where TNodeTypeResolver : <cba6ec40-2546-4a46-9577-18d27987fd9e>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(<cba6ec40-2546-4a46-9577-18d27987fd9e>TagName tag, Type type)
		{
			if (tag.IsEmpty)
			{
				throw new ArgumentException("Non-specific tags cannot be maped");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (tagMappings.TryGetValue(tag, out Type value))
			{
				throw new ArgumentException($"Type already has a registered type '{value.FullName}' for tag '{tag}'", "tag");
			}
			tagMappings.Add(tag, type);
			return this;
		}

		public StaticDeserializerBuilder WithTypeMapping<TInterface, TConcrete>() where TConcrete : TInterface
		{
			Type typeFromHandle = typeof(TInterface);
			Type typeFromHandle2 = typeof(TConcrete);
			if (!typeFromHandle.IsAssignableFrom(typeFromHandle2))
			{
				throw new InvalidOperationException("The type '" + typeFromHandle2.Name + "' does not implement interface '" + typeFromHandle.Name + "'.");
			}
			typeMappings[typeFromHandle] = typeFromHandle2;
			return this;
		}

		public StaticDeserializerBuilder WithoutTagMapping(<cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>IDeserializer Build()
		{
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>Deserializer.FromValueDeserializer(BuildValueDeserializer());
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>IValueDeserializer BuildValueDeserializer()
		{
			return new <cba6ec40-2546-4a46-9577-18d27987fd9e>AliasValueDeserializer(new <cba6ec40-2546-4a46-9577-18d27987fd9e>NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList(), typeConverter, enumNamingConvention, BuildTypeInspector()));
		}
	}
	internal sealed class StaticSerializerBuilder : StaticBuilderSkeleton<StaticSerializerBuilder>
	{
		private class ValueSerializer : <cba6ec40-2546-4a46-9577-18d27987fd9e>IValueSerializer
		{
			private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphTraversalStrategy traversalStrategy;

			private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter eventEmitter;

			private readonly IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverters;

			private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

			private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>> emissionPhaseObjectGraphVisitorFactories;

			public ValueSerializer(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphTraversalStrategy traversalStrategy, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter eventEmitter, IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverters, <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>> preProcessingPhaseObjectGraphVisitorFactories, <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>> emissionPhaseObjectGraphVisitorFactories)
			{
				this.traversalStrategy = traversalStrategy;
				this.eventEmitter = eventEmitter;
				this.typeConverters = typeConverters;
				this.preProcessingPhaseObjectGraphVisitorFactories = preProcessingPhaseObjectGraphVisitorFactories;
				this.emissionPhaseObjectGraphVisitorFactories = emissionPhaseObjectGraphVisitorFactories;
			}

			public void SerializeValue(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, object? value, Type? type)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter2 = emitter;
				Type type2 = type ?? ((value != null) ? value.GetType() : typeof(object));
				Type staticType = type ?? typeof(object);
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDescriptor graph = new <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDescriptor(value, type2, staticType);
				List<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>> preProcessingPhaseObjectGraphVisitors = preProcessingPhaseObjectGraphVisitorFactories.BuildComponentList(typeConverters);
				foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing> item in preProcessingPhaseObjectGraphVisitors)
				{
					traversalStrategy.Traverse(graph, item, default(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing), NestedObjectSerializer);
				}
				<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter> visitor = emissionPhaseObjectGraphVisitorFactories.BuildComponentChain<<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>>(new <cba6ec40-2546-4a46-9577-18d27987fd9e>EmittingObjectGraphVisitor(eventEmitter), (<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter> inner) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
				traversalStrategy.Traverse(graph, visitor, emitter2, NestedObjectSerializer);
				void NestedObjectSerializer(object? v, Type? t)
				{
					SerializeValue(emitter2, v, t);
				}
			}
		}

		private readonly StaticContext context;

		private readonly StaticObjectFactory factory;

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>> emissionPhaseObjectGraphVisitorFactories;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter> eventEmitterFactories;

		private readonly Dictionary<Type, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName> tagMappings = new Dictionary<Type, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName>();

		private int maximumRecursion = 50;

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings emitterSettings = <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings.Default;

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultValuesHandling defaultValuesHandlingConfiguration;

		private bool quoteNecessaryStrings;

		private bool quoteYaml1_1Strings;

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle defaultScalarStyle;

		protected override StaticSerializerBuilder Self => this;

		public StaticSerializerBuilder(StaticContext context)
			: base((<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver)new <cba6ec40-2546-4a46-9577-18d27987fd9e>DynamicTypeResolver())
		{
			this.context = context;
			factory = context.GetFactory();
			typeInspectorFactories.Add(typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>CachedTypeInspector), (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector inner) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>NamingConventionTypeInspector), (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector inner) => (!(namingConvention is <cba6ec40-2546-4a46-9577-18d27987fd9e>NullNamingConvention)) ? new <cba6ec40-2546-4a46-9577-18d27987fd9e>NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributesTypeInspector), (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector inner) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributesTypeInspector(inner));
			preProcessingPhaseObjectGraphVisitorFactories = new <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>> { 
			{
				typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAssigner),
				(IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverters) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAssigner(typeConverters)
			} };
			emissionPhaseObjectGraphVisitorFactories = new <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>>
			{
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>CustomSerializationObjectGraphVisitor),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs args) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>CustomSerializationObjectGraphVisitor(args.InnerVisitor, args.TypeConverters, args.NestedObjectSerializer)
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAssigningObjectGraphVisitor),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs args) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAssigningObjectGraphVisitor(args.InnerVisitor, args.EventEmitter, args.GetPreProcessingPhaseObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAssigner>())
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultValuesObjectGraphVisitor),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs args) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultValuesObjectGraphVisitor(defaultValuesHandlingConfiguration, args.InnerVisitor, factory)
				},
				{
					typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>CommentsObjectGraphVisitor),
					(<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs args) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>CommentsObjectGraphVisitor(args.InnerVisitor)
				}
			};
			eventEmitterFactories = new <cba6ec40-2546-4a46-9577-18d27987fd9e>LazyComponentRegistrationList<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter> { 
			{
				typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>TypeAssigningEventEmitter),
				(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter inner) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>TypeAssigningEventEmitter(inner, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings, defaultScalarStyle, yamlFormatter, enumNamingConvention, BuildTypeInspector())
			} };
			objectGraphTraversalStrategyFactory = (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver, IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverters, int maximumRecursion) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>FullObjectGraphTraversalStrategy(typeInspector, typeResolver, maximumRecursion, namingConvention, factory);
		}

		public StaticSerializerBuilder WithQuotingNecessaryStrings(bool quoteYaml1_1Strings = false)
		{
			quoteNecessaryStrings = true;
			this.quoteYaml1_1Strings = quoteYaml1_1Strings;
			return this;
		}

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

		public StaticSerializerBuilder WithDefaultScalarStyle(<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle style)
		{
			defaultScalarStyle = style;
			return this;
		}

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

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, TEventEmitter> eventEmitterFactory) where TEventEmitter : <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter, TEventEmitter> eventEmitterFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter>> where) where TEventEmitter : <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter
		{
			Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			return WithEventEmitter((<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter e, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector _) => eventEmitterFactory2(e), where);
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, TEventEmitter> eventEmitterFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter>> where) where TEventEmitter : <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter
		{
			Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			if (eventEmitterFactory2 == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateRegistrationLocationSelector(typeof(TEventEmitter), (<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter inner) => eventEmitterFactory2(inner, BuildTypeInspector())));
			return Self;
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter, TEventEmitter> eventEmitterFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITrackingRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter>> where) where TEventEmitter : <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter, TEventEmitter> eventEmitterFactory2 = eventEmitterFactory;
			if (eventEmitterFactory2 == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateTrackingRegistrationLocationSelector(typeof(TEventEmitter), (<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter wrapped, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter inner) => eventEmitterFactory2(wrapped, inner)));
			return Self;
		}

		public StaticSerializerBuilder WithoutEventEmitter<TEventEmitter>() where TEventEmitter : <cba6ec40-2546-4a46-9577-18d27987fd9e>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(<cba6ec40-2546-4a46-9577-18d27987fd9e>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 = (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver, IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverters, int maximumRecursion) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>RoundtripObjectGraphTraversalStrategy(typeConverters, typeInspector, typeResolver, maximumRecursion, namingConvention, settings, factory);
			WithEventEmitter((<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter inner) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>TypeAssigningEventEmitter(inner, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings: false, <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Plain, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlFormatter.Default, enumNamingConvention, BuildTypeInspector()), delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter> loc)
			{
				loc.InsteadOf<<cba6ec40-2546-4a46-9577-18d27987fd9e>TypeAssigningEventEmitter>();
			});
			return WithTypeInspector((<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector inner) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>ReadableAndWritablePropertiesTypeInspector(inner), delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector> loc)
			{
				loc.OnBottom();
			});
		}

		public StaticSerializerBuilder DisableAliases()
		{
			preProcessingPhaseObjectGraphVisitorFactories.Remove(typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAssigner));
			emissionPhaseObjectGraphVisitorFactories.Remove(typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>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(<cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultValuesHandling.Preserve);
		}

		public StaticSerializerBuilder ConfigureDefaultValuesHandling(<cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultValuesHandling configuration)
		{
			defaultValuesHandlingConfiguration = configuration;
			return this;
		}

		public StaticSerializerBuilder JsonCompatible()
		{
			emitterSettings = emitterSettings.WithMaxSimpleKeyLength(int.MaxValue).WithoutAnchorName().WithUtf16SurrogatePairs();
			return WithTypeConverter(new <cba6ec40-2546-4a46-9577-18d27987fd9e>GuidConverter(jsonCompatible: true), delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> w)
			{
				w.InsteadOf<<cba6ec40-2546-4a46-9577-18d27987fd9e>GuidConverter>();
			}).WithTypeConverter(new DateTime8601Converter(<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.DoubleQuoted)).WithEventEmitter((<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter inner) => new <cba6ec40-2546-4a46-9577-18d27987fd9e>JsonEventEmitter(inner, yamlFormatter, enumNamingConvention, BuildTypeInspector()), delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter> loc)
			{
				loc.InsteadOf<<cba6ec40-2546-4a46-9577-18d27987fd9e>TypeAssigningEventEmitter>();
			});
		}

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

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>>> where) where TObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>
		{
			TObjectGraphVisitor objectGraphVisitor2 = objectGraphVisitor;
			if (objectGraphVisitor2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitor");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> _) => objectGraphVisitor2));
			return this;
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>>> where) where TObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>
		{
			Func<IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory2(typeConverters)));
			return this;
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITrackingRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>>> where) where TObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing> wrapped, IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> _) => objectGraphVisitorFactory2(wrapped)));
			return this;
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITrackingRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>>> where) where TObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing> wrapped, IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory2(wrapped, typeConverters)));
			return this;
		}

		public StaticSerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>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(<cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory)
		{
			this.objectGraphTraversalStrategyFactory = objectGraphTraversalStrategyFactory;
			return this;
		}

		public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>
		{
			return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>IRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>>> where) where TObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>
		{
			Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory2(args)));
			return this;
		}

		public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITrackingRegistrationLocationSelectionSyntax<<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>>> where) where TObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>WrapperFactory<<cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory2 = objectGraphVisitorFactory;
			if (objectGraphVisitorFactory2 == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter> wrapped, <cba6ec40-2546-4a46-9577-18d27987fd9e>EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory2(wrapped, args)));
			return this;
		}

		public StaticSerializerBuilder WithoutEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>ISerializer Build()
		{
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>Serializer.FromValueSerializer(BuildValueSerializer(), emitterSettings);
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>IValueSerializer BuildValueSerializer()
		{
			IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverters = BuildTypeConverters();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector = BuildTypeInspector();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphTraversalStrategy traversalStrategy = objectGraphTraversalStrategyFactory(typeInspector, typeResolver, typeConverters, maximumRecursion);
			<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter eventEmitter = eventEmitterFactories.BuildComponentChain(new <cba6ec40-2546-4a46-9577-18d27987fd9e>WriterEventEmitter());
			return new ValueSerializer(traversalStrategy, eventEmitter, typeConverters, preProcessingPhaseObjectGraphVisitorFactories.Clone(), emissionPhaseObjectGraphVisitorFactories.Clone());
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector BuildTypeInspector()
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector = context.GetTypeInspector();
			return typeInspectorFactories.BuildComponentChain(typeInspector);
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>StreamFragment : <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlConvertible
	{
		private readonly List<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> events = new List<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent>();

		public IList<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> Events => events;

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlConvertible.Read(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type expectedType, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer nestedObjectDeserializer)
		{
			events.Clear();
			int num = 0;
			do
			{
				if (!parser.MoveNext())
				{
					throw new InvalidOperationException("The parser has reached the end before deserialization completed.");
				}
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent current = parser.Current;
				events.Add(current);
				num += current.NestingIncrease;
			}
			while (num > 0);
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlConvertible.Write(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer nestedObjectSerializer)
		{
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent @event in events)
			{
				emitter.Emit(@event);
			}
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>TagMappings
	{
		private readonly Dictionary<string, Type> mappings;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>TagMappings()
		{
			mappings = new Dictionary<string, Type>();
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributeOverrides
	{
		private readonly struct AttributeKey
		{
			public readonly Type AttributeType;

			public readonly string PropertyName;

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

			public override bool Equals(object? obj)
			{
				if (obj is AttributeKey attributeKey && AttributeType.Equals(attributeKey.AttributeType))
				{
					return PropertyName.Equals(attributeKey.PropertyName);
				}
				return false;
			}

			public override int GetHashCode()
			{
				return <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>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 = <cba6ec40-2546-4a46-9577-18d27987fd9e>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: <cba6ec40-2546-4a46-9577-18d27987fd9e>MaybeNull]
		public T GetAttribute<T>(Type type, string member) where T : Attribute
		{
			if (overrides.TryGetValue(new AttributeKey(typeof(T), member), out List<AttributeMapping> value))
			{
				int num = 0;
				AttributeMapping attributeMapping = null;
				foreach (AttributeMapping item in value)
				{
					int num2 = item.Matches(type);
					if (num2 > num)
					{
						num = num2;
						attributeMapping = item;
					}
				}
				if (num > 0)
				{
					return (T)attributeMapping.Attribute;
				}
			}
			return null;
		}

		public void Add(Type type, string member, Attribute attribute)
		{
			AttributeMapping item = new AttributeMapping(type, attribute);
			AttributeKey key = new AttributeKey(attribute.GetType(), member);
			if (!overrides.TryGetValue(key, out List<AttributeMapping> value))
			{
				value = new List<AttributeMapping>();
				overrides.Add(key, value);
			}
			else if (value.Contains(item))
			{
				throw new InvalidOperationException($"Attribute ({attribute}) already set for Type {type.FullName}, Member {member}");
			}
			value.Add(item);
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributeOverrides Clone()
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributeOverrides <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributeOverrides2 = new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributeOverrides();
			foreach (KeyValuePair<AttributeKey, List<AttributeMapping>> @override in overrides)
			{
				foreach (AttributeMapping item in @override.Value)
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributeOverrides2.Add(item.RegisteredType, @override.Key.PropertyName, item.Attribute);
				}
			}
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributeOverrides2;
		}

		public void Add<TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
		{
			PropertyInfo propertyInfo = <cba6ec40-2546-4a46-9577-18d27987fd9e>ExpressionExtensions.AsProperty(propertyAccessor);
			Add(typeof(TClass), propertyInfo.Name, attribute);
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributeOverridesInspector : ReflectionTypeInspector
	{
		public sealed class OverridePropertyDescriptor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor
		{
			private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor baseDescriptor;

			private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributeOverrides overrides;

			private readonly Type classType;

			public string Name => baseDescriptor.Name;

			public bool Required => baseDescriptor.Required;

			public bool AllowNulls => baseDescriptor.AllowNulls;

			public bool CanWrite => baseDescriptor.CanWrite;

			public Type Type => baseDescriptor.Type;

			public Type? TypeOverride
			{
				get
				{
					return baseDescriptor.TypeOverride;
				}
				set
				{
					baseDescriptor.TypeOverride = value;
				}
			}

			public Type? ConverterType => GetCustomAttribute<YamlConverterAttribute>()?.ConverterType ?? baseDescriptor.ConverterType;

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

			public <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle ScalarStyle
			{
				get
				{
					return baseDescriptor.ScalarStyle;
				}
				set
				{
					baseDescriptor.ScalarStyle = value;
				}
			}

			public OverridePropertyDescriptor(<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor baseDescriptor, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributeOverrides overrides, Type classType)
			{
				this.baseDescriptor = baseDescriptor;
				this.overrides = overrides;
				this.classType = classType;
			}

			public void Write(object target, object? value)
			{
				baseDescriptor.Write(target, value);
			}

			public T? GetCustomAttribute<T>() where T : Attribute
			{
				T attribute = overrides.GetAttribute<T>(classType, Name);
				return attribute ?? baseDescriptor.GetCustomAttribute<T>();
			}

			public <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor Read(object target)
			{
				return baseDescriptor.Read(target);
			}
		}

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector innerTypeDescriptor;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributeOverrides overrides;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributeOverridesInspector(<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector innerTypeDescriptor, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributeOverrides overrides)
		{
			this.innerTypeDescriptor = innerTypeDescriptor;
			this.overrides = overrides;
		}

		public override IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			Type type2 = type;
			IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor> enumerable = innerTypeDescriptor.GetProperties(type2, container);
			if (overrides != null)
			{
				enumerable = enumerable.Select((Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor, <cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor>)((<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor p) => new OverridePropertyDescriptor(p, overrides, type2)));
			}
			return enumerable;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributesTypeInspector : <cba6ec40-2546-4a46-9577-18d27987fd9e>TypeInspectorSkeleton
	{
		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector innerTypeDescriptor;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAttributesTypeInspector(<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor;
		}

		public override string GetEnumName(Type enumType, string name)
		{
			return innerTypeDescriptor.GetEnumName(enumType, name);
		}

		public override string GetEnumValue(object enumValue)
		{
			return innerTypeDescriptor.GetEnumValue(enumValue);
		}

		public override IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return from p in (from p in innerTypeDescriptor.GetProperties(type, container)
					where p.GetCustomAttribute<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlIgnoreAttribute>() == null
					select p).Select((Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor, <cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor>)delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor p)
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>PropertyDescriptor <cba6ec40-2546-4a46-9577-18d27987fd9e>PropertyDescriptor2 = new <cba6ec40-2546-4a46-9577-18d27987fd9e>PropertyDescriptor(p);
					<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMemberAttribute customAttribute = p.GetCustomAttribute<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMemberAttribute>();
					if (customAttribute != null)
					{
						if (customAttribute.SerializeAs != null)
						{
							<cba6ec40-2546-4a46-9577-18d27987fd9e>PropertyDescriptor2.TypeOverride = customAttribute.SerializeAs;
						}
						<cba6ec40-2546-4a46-9577-18d27987fd9e>PropertyDescriptor2.Order = customAttribute.Order;
						<cba6ec40-2546-4a46-9577-18d27987fd9e>PropertyDescriptor2.ScalarStyle = customAttribute.ScalarStyle;
						if (customAttribute.Alias != null)
						{
							<cba6ec40-2546-4a46-9577-18d27987fd9e>PropertyDescriptor2.Name = customAttribute.Alias;
						}
					}
					return <cba6ec40-2546-4a46-9577-18d27987fd9e>PropertyDescriptor2;
				})
				orderby p.Order
				select p;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
	internal sealed class YamlConverterAttribute : Attribute
	{
		public Type ConverterType { get; }

		public YamlConverterAttribute(Type converterType)
		{
			ConverterType = converterType;
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlFormatter
	{
		public static <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlFormatter Default { get; } = new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlFormatter();


		public NumberFormatInfo NumberFormat { get; set; } = new NumberFormatInfo
		{
			CurrencyDecimalSeparator = ".",
			CurrencyGroupSeparator = "_",
			CurrencyGroupSizes = new int[1] { 3 },
			CurrencySymbol = string.Empty,
			CurrencyDecimalDigits = 99,
			NumberDecimalSeparator = ".",
			NumberGroupSeparator = "_",
			NumberGroupSizes = new int[1] { 3 },
			NumberDecimalDigits = 99,
			NaNSymbol = ".nan",
			PositiveInfinitySymbol = ".inf",
			NegativeInfinitySymbol = "-.inf"
		};


		public virtual Func<object, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector, <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention, string> FormatEnum { get; set; } = delegate(object value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector, <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention)
		{
			string empty = string.Empty;
			empty = ((value != null) ? typeInspector.GetEnumValue(value) : string.Empty);
			return enumNamingConvention.Apply(empty);
		};


		public virtual Func<object, bool> PotentiallyQuoteEnums { get; set; } = (object _) => true;


		public string FormatNumber(object number)
		{
			return Convert.ToString(number, NumberFormat);
		}

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

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

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

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

		public string FormatTimeSpan(object timeSpan)
		{
			return ((TimeSpan)timeSpan).ToString();
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlIgnoreAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMemberAttribute : Attribute
	{
		private <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle ScalarStyle { get; set; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultValuesHandling DefaultValuesHandling
		{
			get
			{
				return defaultValuesHandling.GetValueOrDefault();
			}
			set
			{
				defaultValuesHandling = value;
			}
		}

		public bool IsDefaultValuesHandlingSpecified => defaultValuesHandling.HasValue;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMemberAttribute()
		{
			ScalarStyle = <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Any;
			ApplyNamingConventions = true;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMemberAttribute(Type serializeAs)
			: this()
		{
			SerializeAs = serializeAs ?? throw new ArgumentNullException("serializeAs");
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum, Inherited = false, AllowMultiple = true)]
	internal sealed class YamlSerializableAttribute : Attribute
	{
		public YamlSerializableAttribute()
		{
		}

		public YamlSerializableAttribute(Type serializableType)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	internal sealed class YamlStaticContextAttribute : Attribute
	{
	}
}
namespace YamlDotNet.Serialization.ValueDeserializers
{
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>AliasValueDeserializer : <cba6ec40-2546-4a46-9577-18d27987fd9e>IValueDeserializer
	{
		private sealed class AliasState : Dictionary<<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName, ValuePromise>, <cba6ec40-2546-4a46-9577-18d27987fd9e>IPostDeserializationCallback
		{
			public void OnDeserialization()
			{
				foreach (ValuePromise value in base.Values)
				{
					if (!value.HasValue)
					{
						YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias alias = value.Alias;
						<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = alias.Start;
						<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = alias.End;
						throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorNotFoundException(in start, in end, $"Anchor '{alias.Value}' not found");
					}
				}
			}
		}

		private sealed class ValuePromise : <cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise
		{
			private object? value;

			public readonly YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>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.<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias alias)
			{
				Alias = alias;
			}

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

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IValueDeserializer innerDeserializer;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>AliasValueDeserializer(<cba6ec40-2546-4a46-9577-18d27987fd9e>IValueDeserializer innerDeserializer)
		{
			this.innerDeserializer = innerDeserializer ?? throw new ArgumentNullException("innerDeserializer");
		}

		public object? DeserializeValue(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type expectedType, <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerState state, <cba6ec40-2546-4a46-9577-18d27987fd9e>IValueDeserializer nestedObjectDeserializer)
		{
			if (parser.TryConsume<YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias>(out var @event))
			{
				AliasState aliasState = state.Get<AliasState>();
				if (!aliasState.TryGetValue(@event.Value, out ValuePromise value))
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = @event.Start;
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = @event.End;
					throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorNotFoundException(in start, in end, $"Alias ${@event.Value} cannot precede anchor declaration");
				}
				if (!value.HasValue)
				{
					return value;
				}
				return value.Value;
			}
			<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName = <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName.Empty;
			if (parser.Accept<<cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent>(out var event2) && !event2.Anchor.IsEmpty)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName = event2.Anchor;
				AliasState aliasState2 = state.Get<AliasState>();
				if (!aliasState2.ContainsKey(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName))
				{
					aliasState2[<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName] = new ValuePromise(new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName));
				}
			}
			object obj = innerDeserializer.DeserializeValue(parser, expectedType, state, nestedObjectDeserializer);
			if (!<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName.IsEmpty)
			{
				AliasState aliasState3 = state.Get<AliasState>();
				if (!aliasState3.TryGetValue(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName, out ValuePromise value2))
				{
					aliasState3.Add(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName, new ValuePromise(obj));
				}
				else if (!value2.HasValue)
				{
					value2.Value = obj;
				}
				else
				{
					aliasState3[<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName] = new ValuePromise(obj);
				}
			}
			return obj;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>NodeValueDeserializer : <cba6ec40-2546-4a46-9577-18d27987fd9e>IValueDeserializer
	{
		private readonly IList<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer> deserializers;

		private readonly IList<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver> typeResolvers;

		private readonly ITypeConverter typeConverter;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>NodeValueDeserializer(IList<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer> deserializers, IList<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver> typeResolvers, ITypeConverter typeConverter, <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector)
		{
			this.deserializers = deserializers ?? throw new ArgumentNullException("deserializers");
			this.typeResolvers = typeResolvers ?? throw new ArgumentNullException("typeResolvers");
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
			this.enumNamingConvention = enumNamingConvention ?? throw new ArgumentNullException("enumNamingConvention");
			this.typeInspector = typeInspector;
		}

		public object? DeserializeValue(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type expectedType, <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerState state, <cba6ec40-2546-4a46-9577-18d27987fd9e>IValueDeserializer nestedObjectDeserializer)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser2 = parser;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerState state2 = state;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>IValueDeserializer nestedObjectDeserializer2 = nestedObjectDeserializer;
			parser2.Accept<<cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent>(out var @event);
			Type typeFromEvent = GetTypeFromEvent(@event, expectedType);
			<cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer = (Type x) => DeserializeValue(parser2, x, state2, nestedObjectDeserializer2);
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end;
			try
			{
				foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer deserializer in deserializers)
				{
					if (deserializer.Deserialize(parser2, typeFromEvent, (<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser r, Type t) => nestedObjectDeserializer2.DeserializeValue(r, t, state2, nestedObjectDeserializer2), out object value, rootDeserializer))
					{
						return typeConverter.ChangeType(value, expectedType, enumNamingConvention, typeInspector);
					}
				}
			}
			catch (<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException)
			{
				throw;
			}
			catch (Exception innerException)
			{
				start = @event?.Start ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
				end = @event?.End ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException(in start, in end, "Exception during deserialization", innerException);
			}
			start = @event?.Start ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
			end = @event?.End ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
			throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException(in start, in end, "No node deserializer was able to deserialize the node into type " + expectedType.AssemblyQualifiedName);
		}

		private Type GetTypeFromEvent(<cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent? nodeEvent, Type currentType)
		{
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver typeResolver in typeResolvers)
			{
				if (typeResolver.Resolve(nodeEvent, ref currentType))
				{
					break;
				}
			}
			return currentType;
		}
	}
}
namespace YamlDotNet.Serialization.Utilities
{
	internal interface <cba6ec40-2546-4a46-9577-18d27987fd9e>IPostDeserializationCallback
	{
		void OnDeserialization();
	}
	internal interface ITypeConverter
	{
		object? ChangeType(object? value, Type expectedType, <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector);
	}
	internal class NullTypeConverter : ITypeConverter
	{
		public object? ChangeType(object? value, Type expectedType, <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector)
		{
			return value;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectAnchorCollection
	{
		private readonly Dictionary<string, object> objectsByAnchor = new Dictionary<string, object>();

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

		public object this[string anchor]
		{
			get
			{
				if (objectsByAnchor.TryGetValue(anchor, out object value))
				{
					return value;
				}
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>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, [<cba6ec40-2546-4a46-9577-18d27987fd9e>MaybeNullWhen(false)] out string? anchor)
		{
			return anchorsByObject.TryGetValue(@object, out anchor);
		}
	}
	internal class ReflectionTypeConverter : ITypeConverter
	{
		public object? ChangeType(object? value, Type expectedType, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector)
		{
			return ChangeType(value, expectedType, <cba6ec40-2546-4a46-9577-18d27987fd9e>NullNamingConvention.Instance, typeInspector);
		}

		public object? ChangeType(object? value, Type expectedType, <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector)
		{
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>TypeConverter.ChangeType(value, expectedType, enumNamingConvention, typeInspector);
		}
	}
	public sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>SerializerState : IDisposable
	{
		private readonly Dictionary<Type, object> items = new Dictionary<Type, object>();

		public T Get<T>() where T : class, new()
		{
			if (!items.TryGetValue(typeof(T), out object value))
			{
				value = new T();
				items.Add(typeof(T), value);
			}
			return (T)value;
		}

		public void OnDeserialization()
		{
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>IPostDeserializationCallback item in items.Values.OfType<<cba6ec40-2546-4a46-9577-18d27987fd9e>IPostDeserializationCallback>())
			{
				item.OnDeserialization();
			}
		}

		public void Dispose()
		{
			foreach (IDisposable item in items.Values.OfType<IDisposable>())
			{
				item.Dispose();
			}
		}
	}
	internal static class <cba6ec40-2546-4a46-9577-18d27987fd9e>StringExtensions
	{
		private static string ToCamelOrPascalCase(string str, Func<char, char> firstLetterTransform)
		{
			string text = Regex.Replace(str, "([_\\-])(?<char>[a-z])", (Match match) => match.Groups["char"].Value.ToUpperInvariant(), RegexOptions.IgnoreCase);
			return firstLetterTransform(text[0]) + text.Substring(1);
		}

		public static string ToCamelCase(this string str)
		{
			return ToCamelOrPascalCase(str, char.ToLowerInvariant);
		}

		public static string ToPascalCase(this string str)
		{
			return ToCamelOrPascalCase(str, char.ToUpperInvariant);
		}

		public static string FromCamelCase(this string str, string separator)
		{
			string separator2 = separator;
			str = char.ToLower(str[0], CultureInfo.InvariantCulture) + str.Substring(1);
			str = Regex.Replace(ToCamelCase(str), "(?<char>[A-Z])", (Match match) => separator2 + match.Groups["char"].Value.ToLowerInvariant());
			return str;
		}
	}
	internal static class <cba6ec40-2546-4a46-9577-18d27987fd9e>TypeConverter
	{
		public static T ChangeType<T>(object? value, <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector)
		{
			return (T)ChangeType(value, typeof(T), enumNamingConvention, typeInspector);
		}

		public static object? ChangeType(object? value, Type destinationType, <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector)
		{
			return ChangeType(value, destinationType, CultureInfo.InvariantCulture, enumNamingConvention, typeInspector);
		}

		public static object? ChangeType(object? value, Type destinationType, IFormatProvider provider, <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector)
		{
			return ChangeType(value, destinationType, new <cba6ec40-2546-4a46-9577-18d27987fd9e>CultureInfoAdapter(CultureInfo.CurrentCulture, provider), enumNamingConvention, typeInspector);
		}

		public static object? ChangeType(object? value, Type destinationType, CultureInfo culture, <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector)
		{
			if (value == null || <cba6ec40-2546-4a46-9577-18d27987fd9e>ReflectionExtensions.IsDbNull(value))
			{
				if (!<cba6ec40-2546-4a46-9577-18d27987fd9e>ReflectionExtensions.IsValueType(destinationType))
				{
					return null;
				}
				return Activator.CreateInstance(destinationType);
			}
			Type type = value.GetType();
			if (destinationType == type || destinationType.IsAssignableFrom(type))
			{
				return value;
			}
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>ReflectionExtensions.IsGenericType(destinationType))
			{
				Type genericTypeDefinition = destinationType.GetGenericTypeDefinition();
				if (genericTypeDefinition == typeof(Nullable<>) || FsharpHelper.IsOptionType(genericTypeDefinition))
				{
					Type destinationType2 = destinationType.GetGenericArguments()[0];
					object obj = ChangeType(value, destinationType2, culture, enumNamingConvention, typeInspector);
					return Activator.CreateInstance(destinationType, obj);
				}
			}
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>ReflectionExtensions.IsEnum(destinationType))
			{
				object result = value;
				if (value is string value2)
				{
					string name = enumNamingConvention.Reverse(value2);
					name = typeInspector.GetEnumName(destinationType, name);
					result = Enum.Parse(destinationType, name, ignoreCase: true);
				}
				return result;
			}
			if (destinationType == typeof(bool))
			{
				if ("0".Equals(value))
				{
					return false;
				}
				if ("1".Equals(value))
				{
					return true;
				}
			}
			System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(type);
			if (converter != null && converter.CanConvertTo(destinationType))
			{
				return converter.ConvertTo(null, culture, value, destinationType);
			}
			System.ComponentModel.TypeConverter converter2 = TypeDescriptor.GetConverter(destinationType);
			if (converter2 != null && converter2.CanConvertFrom(type))
			{
				return converter2.ConvertFrom(null, culture, value);
			}
			Type[] array = new Type[2] { type, destinationType };
			foreach (Type type2 in array)
			{
				foreach (MethodInfo publicStaticMethod2 in <cba6ec40-2546-4a46-9577-18d27987fd9e>ReflectionExtensions.GetPublicStaticMethods(type2))
				{
					if (!publicStaticMethod2.IsSpecialName || (!(publicStaticMethod2.Name == "op_Implicit") && !(publicStaticMethod2.Name == "op_Explicit")) || !destinationType.IsAssignableFrom(publicStaticMethod2.ReturnParameter.ParameterType))
					{
						continue;
					}
					ParameterInfo[] parameters = publicStaticMethod2.GetParameters();
					if (parameters.Length == 1 && parameters[0].ParameterType.IsAssignableFrom(type))
					{
						try
						{
							return publicStaticMethod2.Invoke(null, new object[1] { value });
						}
						catch (TargetInvocationException ex)
						{
							throw ex.InnerException;
						}
					}
				}
			}
			if (type == typeof(string))
			{
				try
				{
					MethodInfo publicStaticMethod = <cba6ec40-2546-4a46-9577-18d27987fd9e>ReflectionExtensions.GetPublicStaticMethod(destinationType, "Parse", typeof(string), typeof(IFormatProvider));
					if (publicStaticMethod != null)
					{
						return publicStaticMethod.Invoke(null, new object[2] { value, culture });
					}
					publicStaticMethod = <cba6ec40-2546-4a46-9577-18d27987fd9e>ReflectionExtensions.GetPublicStaticMethod(destinationType, "Parse", typeof(string));
					if (publicStaticMethod != null)
					{
						return publicStaticMethod.Invoke(null, new object[1] { value });
					}
				}
				catch (TargetInvocationException ex2)
				{
					throw ex2.InnerException;
				}
			}
			if (destinationType == typeof(TimeSpan))
			{
				return TimeSpan.Parse((string)ChangeType(value, typeof(string), CultureInfo.InvariantCulture, enumNamingConvention, typeInspector), CultureInfo.InvariantCulture);
			}
			return Convert.ChangeType(value, destinationType, CultureInfo.InvariantCulture);
		}

		public static void RegisterTypeConverter<TConvertible, TConverter>() where TConverter : System.ComponentModel.TypeConverter
		{
			if (!TypeDescriptor.GetAttributes(typeof(TConvertible)).OfType<TypeConverterAttribute>().Any((TypeConverterAttribute a) => a.ConverterTypeName == typeof(TConverter).AssemblyQualifiedName))
			{
				TypeDescriptor.AddAttributes(typeof(TConvertible), new TypeConverterAttribute(typeof(TConverter)));
			}
		}
	}
	internal sealed class TypeConverterCache
	{
		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter[] typeConverters;

		private readonly ConcurrentDictionary<Type, (bool HasMatch, <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter? TypeConverter)> cache = new ConcurrentDictionary<Type, (bool, <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter)>();

		public TypeConverterCache(IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>? typeConverters)
			: this(typeConverters?.ToArray() ?? Array.Empty<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>())
		{
		}

		public TypeConverterCache(<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter[] typeConverters)
		{
			this.typeConverters = typeConverters;
		}

		public bool TryGetConverterForType(Type type, [<cba6ec40-2546-4a46-9577-18d27987fd9e>NotNullWhen(true)] out <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter? typeConverter)
		{
			(bool, <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter) orAdd = DictionaryExtensions.GetOrAdd(cache, type, (Type t, <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter[] tc) => LookupTypeConverter(t, tc), typeConverters);
			typeConverter = orAdd.Item2;
			return orAdd.Item1;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter GetConverterByType(Type converter)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter[] array = typeConverters;
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter in array)
			{
				if (<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter.GetType() == converter)
				{
					return <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter;
				}
			}
			throw new ArgumentException("IYamlTypeConverter of type " + converter.FullName + " not found", "converter");
		}

		private static (bool HasMatch, <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter? TypeConverter) LookupTypeConverter(Type type, <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter[] typeConverters)
		{
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter in typeConverters)
			{
				if (<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter.Accepts(type))
				{
					return (true, <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter);
				}
			}
			return (false, null);
		}
	}
}
namespace YamlDotNet.Serialization.TypeResolvers
{
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>DynamicTypeResolver : <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver
	{
		public Type Resolve(Type staticType, object? actualValue)
		{
			if (actualValue == null)
			{
				return staticType;
			}
			return actualValue.GetType();
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>StaticTypeResolver : <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver
	{
		public virtual Type Resolve(Type staticType, object? actualValue)
		{
			if (actualValue != null)
			{
				if (actualValue.GetType().IsEnum)
				{
					return staticType;
				}
				switch (<cba6ec40-2546-4a46-9577-18d27987fd9e>ReflectionExtensions.GetTypeCode(actualValue.GetType()))
				{
				case TypeCode.Boolean:
					return typeof(bool);
				case TypeCode.Char:
					return typeof(char);
				case TypeCode.SByte:
					return typeof(sbyte);
				case TypeCode.Byte:
					return typeof(byte);
				case TypeCode.Int16:
					return typeof(short);
				case TypeCode.UInt16:
					return typeof(ushort);
				case TypeCode.Int32:
					return typeof(int);
				case TypeCode.UInt32:
					return typeof(uint);
				case TypeCode.Int64:
					return typeof(long);
				case TypeCode.UInt64:
					return typeof(ulong);
				case TypeCode.Single:
					return typeof(float);
				case TypeCode.Double:
					return typeof(double);
				case TypeCode.Decimal:
					return typeof(decimal);
				case TypeCode.String:
					return typeof(string);
				case TypeCode.DateTime:
					return typeof(DateTime);
				}
			}
			return staticType;
		}
	}
}
namespace YamlDotNet.Serialization.TypeInspectors
{
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>CachedTypeInspector : <cba6ec40-2546-4a46-9577-18d27987fd9e>TypeInspectorSkeleton
	{
		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector innerTypeDescriptor;

		private readonly ConcurrentDictionary<Type, List<<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor>> cache = new ConcurrentDictionary<Type, List<<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor>>();

		private readonly ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> enumNameCache = new ConcurrentDictionary<Type, ConcurrentDictionary<string, string>>();

		private readonly ConcurrentDictionary<object, string> enumValueCache = new ConcurrentDictionary<object, string>();

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>CachedTypeInspector(<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
		}

		public override string GetEnumName(Type enumType, string name)
		{
			ConcurrentDictionary<string, string> orAdd = enumNameCache.GetOrAdd(enumType, (Type _) => new ConcurrentDictionary<string, string>());
			return DictionaryExtensions.GetOrAdd(orAdd, name, delegate(string n, (Type enumType, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector innerTypeDescriptor) context)
			{
				var (enumType2, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector) = context;
				return <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector.GetEnumName(enumType2, n);
			}, (enumType, innerTypeDescriptor));
		}

		public override string GetEnumValue(object enumValue)
		{
			return DictionaryExtensions.GetOrAdd(enumValueCache, enumValue, delegate(object _, (object enumValue, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector innerTypeDescriptor) context)
			{
				var (enumValue2, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector) = context;
				return <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector.GetEnumValue(enumValue2);
			}, (enumValue, innerTypeDescriptor));
		}

		public override IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return DictionaryExtensions.GetOrAdd(cache, type, delegate(Type t, (object container, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector innerTypeDescriptor) context)
			{
				var (container2, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector) = context;
				return <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector.GetProperties(t, container2).ToList();
			}, (container, innerTypeDescriptor));
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>CompositeTypeInspector : <cba6ec40-2546-4a46-9577-18d27987fd9e>TypeInspectorSkeleton
	{
		private readonly IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector> typeInspectors;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>CompositeTypeInspector(params <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector[] typeInspectors)
			: this((IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector>)typeInspectors)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>CompositeTypeInspector(IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector> typeInspectors)
		{
			this.typeInspectors = typeInspectors?.ToList() ?? throw new ArgumentNullException("typeInspectors");
		}

		public override string GetEnumName(Type enumType, string name)
		{
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector in typeInspectors)
			{
				try
				{
					return typeInspector.GetEnumName(enumType, name);
				}
				catch
				{
				}
			}
			throw new ArgumentOutOfRangeException("enumType,name", "Name not found on enum type");
		}

		public override string GetEnumValue(object enumValue)
		{
			if (enumValue == null)
			{
				throw new ArgumentNullException("enumValue");
			}
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector in typeInspectors)
			{
				try
				{
					return typeInspector.GetEnumValue(enumValue);
				}
				catch
				{
				}
			}
			throw new ArgumentOutOfRangeException("enumValue", $"Value not found for ({enumValue})");
		}

		public override IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			Type type2 = type;
			object container2 = container;
			return typeInspectors.SelectMany((<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector i) => i.GetProperties(type2, container2));
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>NamingConventionTypeInspector : <cba6ec40-2546-4a46-9577-18d27987fd9e>TypeInspectorSkeleton
	{
		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector innerTypeDescriptor;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention namingConvention;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>NamingConventionTypeInspector(<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector innerTypeDescriptor, <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention namingConvention)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
		}

		public override string GetEnumName(Type enumType, string name)
		{
			return innerTypeDescriptor.GetEnumName(enumType, name);
		}

		public override string GetEnumValue(object enumValue)
		{
			return innerTypeDescriptor.GetEnumValue(enumValue);
		}

		public override IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return innerTypeDescriptor.GetProperties(type, container).Select(delegate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor p)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMemberAttribute customAttribute = p.GetCustomAttribute<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMemberAttribute>();
				return (customAttribute != null && !customAttribute.ApplyNamingConventions) ? p : new <cba6ec40-2546-4a46-9577-18d27987fd9e>PropertyDescriptor(p)
				{
					Name = namingConvention.Apply(p.Name)
				};
			});
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>ReadableAndWritablePropertiesTypeInspector : <cba6ec40-2546-4a46-9577-18d27987fd9e>TypeInspectorSkeleton
	{
		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector innerTypeDescriptor;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ReadableAndWritablePropertiesTypeInspector(<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
		}

		public override string GetEnumName(Type enumType, string name)
		{
			return innerTypeDescriptor.GetEnumName(enumType, name);
		}

		public override string GetEnumValue(object enumValue)
		{
			return innerTypeDescriptor.GetEnumValue(enumValue);
		}

		public override IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return from p in innerTypeDescriptor.GetProperties(type, container)
				where p.CanWrite
				select p;
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>ReadableFieldsTypeInspector : ReflectionTypeInspector
	{
		protected class ReflectionFieldDescriptor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor
		{
			private readonly FieldInfo fieldInfo;

			private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver;

			public string Name => fieldInfo.Name;

			public bool Required => fieldInfo.IsRequired();

			public Type Type => fieldInfo.FieldType;

			public Type? ConverterType { get; }

			public Type? TypeOverride { get; set; }

			public bool AllowNulls => fieldInfo.AcceptsNull();

			public int Order { get; set; }

			public bool CanWrite => !fieldInfo.IsInitOnly;

			public <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle ScalarStyle { get; set; }

			public ReflectionFieldDescriptor(FieldInfo fieldInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver)
			{
				this.fieldInfo = fieldInfo;
				this.typeResolver = typeResolver;
				YamlConverterAttribute customAttribute = fieldInfo.GetCustomAttribute<YamlConverterAttribute>();
				if (customAttribute != null)
				{
					ConverterType = customAttribute.ConverterType;
				}
				ScalarStyle = <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Any;
			}

			public void Write(object target, object? value)
			{
				fieldInfo.SetValue(target, value);
			}

			public T? GetCustomAttribute<T>() where T : Attribute
			{
				object[] customAttributes = fieldInfo.GetCustomAttributes(typeof(T), inherit: true);
				return (T)customAttributes.FirstOrDefault();
			}

			public <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor Read(object target)
			{
				object value = fieldInfo.GetValue(target);
				Type type = TypeOverride ?? typeResolver.Resolve(Type, value);
				return new <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDescriptor(value, type, Type, ScalarStyle);
			}
		}

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ReadableFieldsTypeInspector(<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
		}

		public override IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>ReflectionExtensions.GetPublicFields(type).Select((Func<FieldInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor>)((FieldInfo p) => new ReflectionFieldDescriptor(p, typeResolver)));
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>ReadablePropertiesTypeInspector : ReflectionTypeInspector
	{
		protected class ReflectionPropertyDescriptor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor
		{
			private readonly PropertyInfo propertyInfo;

			private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver;

			public string Name => propertyInfo.Name;

			public bool Required => propertyInfo.IsRequired();

			public Type Type => propertyInfo.PropertyType;

			public Type? TypeOverride { get; set; }

			public Type? ConverterType { get; set; }

			public bool AllowNulls => propertyInfo.AcceptsNull();

			public int Order { get; set; }

			public bool CanWrite => propertyInfo.CanWrite;

			public <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle ScalarStyle { get; set; }

			public ReflectionPropertyDescriptor(PropertyInfo propertyInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver)
			{
				this.propertyInfo = propertyInfo ?? throw new ArgumentNullException("propertyInfo");
				this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
				ScalarStyle = <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Any;
				YamlConverterAttribute customAttribute = propertyInfo.GetCustomAttribute<YamlConverterAttribute>();
				if (customAttribute != null)
				{
					ConverterType = customAttribute.ConverterType;
				}
			}

			public void Write(object target, object? value)
			{
				propertyInfo.SetValue(target, value, null);
			}

			public T? GetCustomAttribute<T>() where T : Attribute
			{
				Attribute[] allCustomAttributes = <cba6ec40-2546-4a46-9577-18d27987fd9e>ReflectionExtensions.GetAllCustomAttributes<T>(propertyInfo);
				return (T)allCustomAttributes.FirstOrDefault();
			}

			public <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor Read(object target)
			{
				object obj = <cba6ec40-2546-4a46-9577-18d27987fd9e>PropertyInfoExtensions.ReadValue(propertyInfo, target);
				Type type = TypeOverride ?? typeResolver.Resolve(Type, obj);
				return new <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDescriptor(obj, type, Type, ScalarStyle);
			}
		}

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver;

		private readonly bool includeNonPublicProperties;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ReadablePropertiesTypeInspector(<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver)
			: this(typeResolver, includeNonPublicProperties: false)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ReadablePropertiesTypeInspector(<cba6ec40-2546-4a46-9577-18d27987fd9e>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<<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>ReflectionExtensions.GetProperties(type, includeNonPublicProperties).Where(IsValidProperty).Select((Func<PropertyInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor>)((PropertyInfo p) => new ReflectionPropertyDescriptor(p, typeResolver)));
		}
	}
	internal abstract class ReflectionTypeInspector : <cba6ec40-2546-4a46-9577-18d27987fd9e>TypeInspectorSkeleton
	{
		public override string GetEnumName(Type enumType, string name)
		{
			return name;
		}

		public override string GetEnumValue(object enumValue)
		{
			if (enumValue == null)
			{
				return string.Empty;
			}
			return enumValue.ToString();
		}
	}
	internal abstract class <cba6ec40-2546-4a46-9577-18d27987fd9e>TypeInspectorSkeleton : <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector
	{
		public abstract string GetEnumName(Type enumType, string name);

		public abstract string GetEnumValue(object enumValue);

		public abstract IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor> GetProperties(Type type, object? container);

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor GetProperty(Type type, object? container, string name, [<cba6ec40-2546-4a46-9577-18d27987fd9e>MaybeNullWhen(true)] bool ignoreUnmatched, bool caseInsensitivePropertyMatching)
		{
			string name2 = name;
			IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor> enumerable = ((!caseInsensitivePropertyMatching) ? (from p in GetProperties(type, container)
				where p.Name == name2
				select p) : (from p in GetProperties(type, container)
				where p.Name.Equals(name2, StringComparison.OrdinalIgnoreCase)
				select p));
			using IEnumerator<<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor> enumerator = enumerable.GetEnumerator();
			if (!enumerator.MoveNext())
			{
				if (ignoreUnmatched)
				{
					return null;
				}
				throw new SerializationException("Property '" + name2 + "' not found on type '" + type.FullName + "'.");
			}
			<cba6ec40-2546-4a46-9577-18d27987fd9e>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((<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor p) => p.Name).ToArray()));
			}
			return current;
		}
	}
	internal class WritablePropertiesTypeInspector : ReflectionTypeInspector
	{
		protected class ReflectionPropertyDescriptor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor
		{
			private readonly PropertyInfo propertyInfo;

			private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver;

			public string Name => propertyInfo.Name;

			public bool Required => propertyInfo.IsRequired();

			public Type Type => propertyInfo.PropertyType;

			public Type? TypeOverride { get; set; }

			public Type? ConverterType { get; set; }

			public bool AllowNulls => propertyInfo.AcceptsNull();

			public int Order { get; set; }

			public bool CanWrite => propertyInfo.CanWrite;

			public <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle ScalarStyle { get; set; }

			public ReflectionPropertyDescriptor(PropertyInfo propertyInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver)
			{
				this.propertyInfo = propertyInfo ?? throw new ArgumentNullException("propertyInfo");
				this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
				ScalarStyle = <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Any;
				YamlConverterAttribute customAttribute = propertyInfo.GetCustomAttribute<YamlConverterAttribute>();
				if (customAttribute != null)
				{
					ConverterType = customAttribute.ConverterType;
				}
			}

			public void Write(object target, object? value)
			{
				propertyInfo.SetValue(target, value, null);
			}

			public T? GetCustomAttribute<T>() where T : Attribute
			{
				Attribute[] allCustomAttributes = <cba6ec40-2546-4a46-9577-18d27987fd9e>ReflectionExtensions.GetAllCustomAttributes<T>(propertyInfo);
				return (T)allCustomAttributes.FirstOrDefault();
			}

			public <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor Read(object target)
			{
				object obj = <cba6ec40-2546-4a46-9577-18d27987fd9e>PropertyInfoExtensions.ReadValue(propertyInfo, target);
				Type type = TypeOverride ?? typeResolver.Resolve(Type, obj);
				return new <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDescriptor(obj, type, Type, ScalarStyle);
			}
		}

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver;

		private readonly bool includeNonPublicProperties;

		public WritablePropertiesTypeInspector(<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver)
			: this(typeResolver, includeNonPublicProperties: false)
		{
		}

		public WritablePropertiesTypeInspector(<cba6ec40-2546-4a46-9577-18d27987fd9e>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<<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>ReflectionExtensions.GetProperties(type, includeNonPublicProperties).Where(IsValidProperty).Select((Func<PropertyInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor>)((PropertyInfo p) => new ReflectionPropertyDescriptor(p, typeResolver)))
				.ToArray();
		}
	}
}
namespace YamlDotNet.Serialization.Schemas
{
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>FailsafeSchema
	{
		public static class Tags
		{
			public static readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName Map = new <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName("tag:yaml.org,2002:map");

			public static readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName Seq = new <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName("tag:yaml.org,2002:seq");

			public static readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName Str = new <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName("tag:yaml.org,2002:str");
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>JsonSchema
	{
		public static class Tags
		{
			public static readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName Null = new <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName("tag:yaml.org,2002:null");

			public static readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName Bool = new <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName("tag:yaml.org,2002:bool");

			public static readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName Int = new <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName("tag:yaml.org,2002:int");

			public static readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName Float = new <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName("tag:yaml.org,2002:float");
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>CoreSchema
	{
		public static class Tags
		{
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultSchema
	{
		public static class Tags
		{
			public static readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName Timestamp = new <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName("tag:yaml.org,2002:timestamp");
		}
	}
}
namespace YamlDotNet.Serialization.ObjectGraphVisitors
{
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAssigner : <cba6ec40-2546-4a46-9577-18d27987fd9e>PreProcessingPhaseObjectGraphVisitorSkeleton, <cba6ec40-2546-4a46-9577-18d27987fd9e>IAliasProvider
	{
		private class AnchorAssignment
		{
			public <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName Anchor;
		}

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

		private uint nextId;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAssigner(IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverters)
			: base(typeConverters)
		{
		}

		protected override bool Enter(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			if (value.Value != null && assignments.TryGetValue(value.Value, out AnchorAssignment value2))
			{
				if (value2.Anchor.IsEmpty)
				{
					value2.Anchor = new <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName("o" + nextId.ToString(CultureInfo.InvariantCulture));
					nextId++;
				}
				return false;
			}
			return true;
		}

		protected override bool EnterMapping(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor key, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			return true;
		}

		protected override bool EnterMapping(<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor key, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			return true;
		}

		protected override void VisitScalar(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor scalar, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
		}

		protected override void VisitMappingStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor mapping, Type keyType, Type valueType, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			VisitObject(mapping);
		}

		protected override void VisitMappingEnd(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor mapping, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
		}

		protected override void VisitSequenceStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor sequence, Type elementType, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			VisitObject(sequence);
		}

		protected override void VisitSequenceEnd(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor sequence, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
		}

		private void VisitObject(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value)
		{
			if (value.Value != null)
			{
				assignments.Add(value.Value, new AnchorAssignment());
			}
		}

		<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName <cba6ec40-2546-4a46-9577-18d27987fd9e>IAliasProvider.GetAlias(object target)
		{
			if (target != null && assignments.TryGetValue(target, out AnchorAssignment value))
			{
				return value.Anchor;
			}
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName.Empty;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAssigningObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>ChainedObjectGraphVisitor
	{
		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter eventEmitter;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IAliasProvider aliasProvider;

		private readonly HashSet<<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName> emittedAliases = new HashSet<<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName>();

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAssigningObjectGraphVisitor(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter> nextVisitor, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter eventEmitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>IAliasProvider aliasProvider)
			: base(nextVisitor)
		{
			this.eventEmitter = eventEmitter;
			this.aliasProvider = aliasProvider;
		}

		public override bool Enter(<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor? propertyDescriptor, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			if (value.Value != null)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName alias = aliasProvider.GetAlias(value.Value);
				if (!alias.IsEmpty && !emittedAliases.Add(alias))
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>AliasEventInfo <cba6ec40-2546-4a46-9577-18d27987fd9e>AliasEventInfo = new <cba6ec40-2546-4a46-9577-18d27987fd9e>AliasEventInfo(value, alias);
					eventEmitter.Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>AliasEventInfo, context);
					return <cba6ec40-2546-4a46-9577-18d27987fd9e>AliasEventInfo.NeedsExpansion;
				}
			}
			return base.Enter(propertyDescriptor, value, context, serializer);
		}

		public override void VisitMappingStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor mapping, Type keyType, Type valueType, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName alias = aliasProvider.GetAlias(mapping.NonNullValue());
			eventEmitter.Emit(new <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStartEventInfo(mapping)
			{
				Anchor = alias
			}, context);
		}

		public override void VisitSequenceStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor sequence, Type elementType, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName alias = aliasProvider.GetAlias(sequence.NonNullValue());
			eventEmitter.Emit(new <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStartEventInfo(sequence)
			{
				Anchor = alias
			}, context);
		}

		public override void VisitScalar(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor scalar, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarEventInfo <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarEventInfo = new <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarEventInfo(scalar);
			if (scalar.Value != null)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarEventInfo.Anchor = aliasProvider.GetAlias(scalar.Value);
			}
			eventEmitter.Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarEventInfo, context);
		}
	}
	internal abstract class <cba6ec40-2546-4a46-9577-18d27987fd9e>ChainedObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>
	{
		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter> nextVisitor;

		protected <cba6ec40-2546-4a46-9577-18d27987fd9e>ChainedObjectGraphVisitor(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter> nextVisitor)
		{
			this.nextVisitor = nextVisitor;
		}

		public virtual bool Enter(<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor? propertyDescriptor, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			return nextVisitor.Enter(propertyDescriptor, value, context, serializer);
		}

		public virtual bool EnterMapping(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor key, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			return nextVisitor.EnterMapping(key, value, context, serializer);
		}

		public virtual bool EnterMapping(<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor key, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			return nextVisitor.EnterMapping(key, value, context, serializer);
		}

		public virtual void VisitScalar(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor scalar, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			nextVisitor.VisitScalar(scalar, context, serializer);
		}

		public virtual void VisitMappingStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor mapping, Type keyType, Type valueType, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			nextVisitor.VisitMappingStart(mapping, keyType, valueType, context, serializer);
		}

		public virtual void VisitMappingEnd(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor mapping, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			nextVisitor.VisitMappingEnd(mapping, context, serializer);
		}

		public virtual void VisitSequenceStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor sequence, Type elementType, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			nextVisitor.VisitSequenceStart(sequence, elementType, context, serializer);
		}

		public virtual void VisitSequenceEnd(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor sequence, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			nextVisitor.VisitSequenceEnd(sequence, context, serializer);
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>CommentsObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>ChainedObjectGraphVisitor
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>CommentsObjectGraphVisitor(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		public override bool EnterMapping(<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor key, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMemberAttribute customAttribute = key.GetCustomAttribute<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMemberAttribute>();
			if (customAttribute != null && customAttribute.Description != null)
			{
				context.Emit(new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Comment(customAttribute.Description, isInline: false));
			}
			return base.EnterMapping(key, value, context, serializer);
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>CustomSerializationObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>ChainedObjectGraphVisitor
	{
		private readonly TypeConverterCache typeConverters;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer nestedObjectSerializer;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>CustomSerializationObjectGraphVisitor(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter> nextVisitor, IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverters, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer nestedObjectSerializer)
			: base(nextVisitor)
		{
			this.typeConverters = new TypeConverterCache(typeConverters);
			this.nestedObjectSerializer = nestedObjectSerializer;
		}

		public override bool Enter(<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor? propertyDescriptor, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			if (propertyDescriptor?.ConverterType != null)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter converterByType = typeConverters.GetConverterByType(propertyDescriptor.ConverterType);
				converterByType.WriteYaml(context, value.Value, value.Type, serializer);
				return false;
			}
			if (typeConverters.TryGetConverterForType(value.Type, out <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter typeConverter))
			{
				typeConverter.WriteYaml(context, value.Value, value.Type, serializer);
				return false;
			}
			if (value.Value is <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlConvertible <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlConvertible)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlConvertible.Write(context, nestedObjectSerializer);
				return false;
			}
			if (value.Value is <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlSerializable <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlSerializable)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlSerializable.WriteYaml(context);
				return false;
			}
			return base.Enter(propertyDescriptor, value, context, serializer);
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultExclusiveObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>ChainedObjectGraphVisitor
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultExclusiveObjectGraphVisitor(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		private static object? GetDefault(Type type)
		{
			if (!<cba6ec40-2546-4a46-9577-18d27987fd9e>ReflectionExtensions.IsValueType(type))
			{
				return null;
			}
			return Activator.CreateInstance(type);
		}

		public override bool EnterMapping(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor key, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			if (!object.Equals(value.Value, GetDefault(value.Type)))
			{
				return base.EnterMapping(key, value, context, serializer);
			}
			return false;
		}

		public override bool EnterMapping(<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor key, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			DefaultValueAttribute customAttribute = key.GetCustomAttribute<DefaultValueAttribute>();
			object objB = ((customAttribute != null) ? customAttribute.Value : GetDefault(key.Type));
			if (!object.Equals(value.Value, objB))
			{
				return base.EnterMapping(key, value, context, serializer);
			}
			return false;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultValuesObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>ChainedObjectGraphVisitor
	{
		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultValuesHandling handling;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory factory;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultValuesObjectGraphVisitor(<cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultValuesHandling handling, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter> nextVisitor, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory factory)
			: base(nextVisitor)
		{
			this.handling = handling;
			this.factory = factory;
		}

		private object? GetDefault(Type type)
		{
			return factory.CreatePrimitive(type);
		}

		public override bool EnterMapping(<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor key, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultValuesHandling defaultValuesHandling = handling;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMemberAttribute customAttribute = key.GetCustomAttribute<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMemberAttribute>();
			if (customAttribute != null && customAttribute.IsDefaultValuesHandlingSpecified)
			{
				defaultValuesHandling = customAttribute.DefaultValuesHandling;
			}
			if ((defaultValuesHandling & <cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultValuesHandling.OmitNull) != 0 && value.Value == null)
			{
				return false;
			}
			if ((defaultValuesHandling & <cba6ec40-2546-4a46-9577-18d27987fd9e>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 & <cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultValuesHandling.OmitDefaults) != 0)
			{
				object objB = key.GetCustomAttribute<DefaultValueAttribute>()?.Value ?? GetDefault(key.Type);
				if (object.Equals(value.Value, objB))
				{
					return false;
				}
			}
			return base.EnterMapping(key, value, context, serializer);
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>EmittingObjectGraphVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>
	{
		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter eventEmitter;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>EmittingObjectGraphVisitor(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter eventEmitter)
		{
			this.eventEmitter = eventEmitter;
		}

		bool <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>.Enter(<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor? propertyDescriptor, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			return true;
		}

		bool <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>.EnterMapping(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor key, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			return true;
		}

		bool <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>.EnterMapping(<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor key, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			return true;
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>.VisitScalar(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor scalar, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			eventEmitter.Emit(new <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarEventInfo(scalar), context);
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>.VisitMappingStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor mapping, Type keyType, Type valueType, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			eventEmitter.Emit(new <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStartEventInfo(mapping), context);
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>.VisitMappingEnd(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor mapping, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			eventEmitter.Emit(new <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEndEventInfo(mapping), context);
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>.VisitSequenceStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor sequence, Type elementType, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			eventEmitter.Emit(new <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStartEventInfo(sequence), context);
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter>.VisitSequenceEnd(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor sequence, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			eventEmitter.Emit(new <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEndEventInfo(sequence), context);
		}
	}
	internal abstract class <cba6ec40-2546-4a46-9577-18d27987fd9e>PreProcessingPhaseObjectGraphVisitorSkeleton : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>
	{
		protected readonly IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverters;

		private readonly TypeConverterCache typeConverterCache;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>PreProcessingPhaseObjectGraphVisitorSkeleton(IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverters)
		{
			typeConverterCache = new TypeConverterCache((<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter[])(this.typeConverters = typeConverters?.ToArray() ?? Array.Empty<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter>()));
		}

		bool <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>.Enter(<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor? propertyDescriptor, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			if (typeConverterCache.TryGetConverterForType(value.Type, out <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter _))
			{
				return false;
			}
			if (value.Value is <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlConvertible)
			{
				return false;
			}
			if (value.Value is <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlSerializable)
			{
				return false;
			}
			return Enter(value, serializer);
		}

		bool <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>.EnterMapping(<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor key, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			return EnterMapping(key, value, serializer);
		}

		bool <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>.EnterMapping(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor key, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			return EnterMapping(key, value, serializer);
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>.VisitMappingEnd(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor mapping, <cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			VisitMappingEnd(mapping, serializer);
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>.VisitMappingStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor mapping, Type keyType, Type valueType, <cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			VisitMappingStart(mapping, keyType, valueType, serializer);
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>.VisitScalar(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor scalar, <cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			VisitScalar(scalar, serializer);
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>.VisitSequenceEnd(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor sequence, <cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			VisitSequenceEnd(sequence, serializer);
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing>.VisitSequenceStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor sequence, Type elementType, <cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			VisitSequenceStart(sequence, elementType, serializer);
		}

		protected abstract bool Enter(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer);

		protected abstract bool EnterMapping(<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor key, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer);

		protected abstract bool EnterMapping(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor key, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer);

		protected abstract void VisitMappingEnd(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor mapping, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer);

		protected abstract void VisitMappingStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor mapping, Type keyType, Type valueType, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer);

		protected abstract void VisitScalar(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor scalar, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer);

		protected abstract void VisitSequenceEnd(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor sequence, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer);

		protected abstract void VisitSequenceStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor sequence, Type elementType, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer);
	}
}
namespace YamlDotNet.Serialization.ObjectGraphTraversalStrategies
{
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>FullObjectGraphTraversalStrategy : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphTraversalStrategy
	{
		protected readonly struct ObjectPathSegment
		{
			public readonly object Name;

			public readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor Value;

			public ObjectPathSegment(object name, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value)
			{
				Name = name;
				Value = value;
			}
		}

		private readonly int maxRecursion;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeDescriptor;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention namingConvention;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory objectFactory;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>FullObjectGraphTraversalStrategy(<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeDescriptor, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver, int maxRecursion, <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention namingConvention, <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphTraversalStrategy.Traverse<TContext>(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor graph, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<TContext> visitor, TContext context, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			Traverse(null, "<root>", graph, visitor, context, new Stack<ObjectPathSegment>(maxRecursion), serializer);
		}

		protected virtual void Traverse<TContext>(<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor? propertyDescriptor, object name, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			if (path.Count >= maxRecursion)
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("Too much recursion when traversing the object graph.");
				stringBuilder.AppendLine("The path to reach this recursion was:");
				Stack<KeyValuePair<string, string>> stack = new Stack<KeyValuePair<string, string>>(path.Count);
				int num = 0;
				foreach (ObjectPathSegment item in path)
				{
					string text = item.Name?.ToString() ?? string.Empty;
					num = Math.Max(num, text.Length);
					stack.Push(new KeyValuePair<string, string>(text, item.Value.Type.FullName));
				}
				foreach (KeyValuePair<string, string> item2 in stack)
				{
					stringBuilder.Append(" -> ").Append(item2.Key.PadRight(num)).Append("  [")
						.Append(item2.Value)
						.AppendLine("]");
				}
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>MaximumRecursionLevelReachedException(stringBuilder.ToString());
			}
			if (!visitor.Enter(propertyDescriptor, value, context, serializer))
			{
				return;
			}
			path.Push(new ObjectPathSegment(name, value));
			try
			{
				TypeCode typeCode = <cba6ec40-2546-4a46-9577-18d27987fd9e>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, serializer);
					return;
				case TypeCode.Empty:
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
				if (<cba6ec40-2546-4a46-9577-18d27987fd9e>ReflectionExtensions.IsDbNull(value))
				{
					visitor.VisitScalar(new <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDescriptor(null, typeof(object), typeof(object)), context, serializer);
				}
				if (value.Value == null || value.Type == typeof(TimeSpan))
				{
					visitor.VisitScalar(value, context, serializer);
					return;
				}
				Type underlyingType = Nullable.GetUnderlyingType(value.Type);
				Type type = underlyingType ?? FsharpHelper.GetOptionUnderlyingType(value.Type);
				object obj = ((type != null) ? FsharpHelper.GetValue(value) : null);
				if (underlyingType != null)
				{
					Traverse(propertyDescriptor, "Value", new <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDescriptor(value.Value, underlyingType, value.Type, value.ScalarStyle), visitor, context, path, serializer);
				}
				else if (type != null && obj != null)
				{
					Traverse(propertyDescriptor, "Value", new <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDescriptor(FsharpHelper.GetValue(value), type, value.Type, value.ScalarStyle), visitor, context, path, serializer);
				}
				else
				{
					TraverseObject(propertyDescriptor, value, visitor, context, path, serializer);
				}
			}
			finally
			{
				path.Pop();
			}
		}

		protected virtual void TraverseObject<TContext>(<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor? propertyDescriptor, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			IDictionary dictionary;
			Type[] genericArguments;
			if (typeof(IDictionary).IsAssignableFrom(value.Type))
			{
				TraverseDictionary(propertyDescriptor, value, visitor, typeof(object), typeof(object), context, path, serializer);
			}
			else if (objectFactory.GetDictionary(value, out dictionary, out genericArguments))
			{
				TraverseDictionary(propertyDescriptor, new <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDescriptor(dictionary, value.Type, value.StaticType, value.ScalarStyle), visitor, genericArguments[0], genericArguments[1], context, path, serializer);
			}
			else if (typeof(IEnumerable).IsAssignableFrom(value.Type))
			{
				TraverseList(propertyDescriptor, value, visitor, context, path, serializer);
			}
			else
			{
				TraverseProperties(value, visitor, context, path, serializer);
			}
		}

		protected virtual void TraverseDictionary<TContext>(<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor? propertyDescriptor, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor dictionary, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<TContext> visitor, Type keyType, Type valueType, TContext context, Stack<ObjectPathSegment> path, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			visitor.VisitMappingStart(dictionary, keyType, valueType, context, serializer);
			bool flag = dictionary.Type.FullName.Equals("System.Dynamic.ExpandoObject");
			foreach (DictionaryEntry? item in (IDictionary)dictionary.NonNullValue())
			{
				DictionaryEntry value = item.Value;
				object obj = (flag ? namingConvention.Apply(value.Key.ToString()) : value.Key);
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDescriptor objectDescriptor = GetObjectDescriptor(obj, keyType);
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDescriptor objectDescriptor2 = GetObjectDescriptor(value.Value, valueType);
				if (visitor.EnterMapping(objectDescriptor, objectDescriptor2, context, serializer))
				{
					Traverse(propertyDescriptor, obj, objectDescriptor, visitor, context, path, serializer);
					Traverse(propertyDescriptor, obj, objectDescriptor2, visitor, context, path, serializer);
				}
			}
			visitor.VisitMappingEnd(dictionary, context, serializer);
		}

		private void TraverseList<TContext>(<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor propertyDescriptor, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			Type valueType = objectFactory.GetValueType(value.Type);
			visitor.VisitSequenceStart(value, valueType, context, serializer);
			int num = 0;
			foreach (object item in (IEnumerable)value.NonNullValue())
			{
				Traverse(propertyDescriptor, num, GetObjectDescriptor(item, valueType), visitor, context, path, serializer);
				num++;
			}
			visitor.VisitSequenceEnd(value, context, serializer);
		}

		protected virtual void TraverseProperties<TContext>(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			if (context.GetType() != typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing))
			{
				objectFactory.ExecuteOnSerializing(value.Value);
			}
			visitor.VisitMappingStart(value, typeof(string), typeof(object), context, serializer);
			object obj = value.NonNullValue();
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor property in typeDescriptor.GetProperties(value.Type, obj))
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value2 = property.Read(obj);
				if (visitor.EnterMapping(property, value2, context, serializer))
				{
					Traverse(null, property.Name, new <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDescriptor(property.Name, typeof(string), typeof(string), <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Plain), visitor, context, path, serializer);
					Traverse(property, property.Name, value2, visitor, context, path, serializer);
				}
			}
			visitor.VisitMappingEnd(value, context, serializer);
			if (context.GetType() != typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>Nothing))
			{
				objectFactory.ExecuteOnSerialized(value.Value);
			}
		}

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDescriptor GetObjectDescriptor(object? value, Type staticType)
		{
			return new <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDescriptor(value, typeResolver.Resolve(staticType, value), staticType);
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>RoundtripObjectGraphTraversalStrategy : <cba6ec40-2546-4a46-9577-18d27987fd9e>FullObjectGraphTraversalStrategy
	{
		private readonly TypeConverterCache converters;

		private readonly Settings settings;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>RoundtripObjectGraphTraversalStrategy(IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> converters, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeDescriptor, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeResolver typeResolver, int maxRecursion, <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention namingConvention, Settings settings, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory factory)
			: base(typeDescriptor, typeResolver, maxRecursion, namingConvention, factory)
		{
			this.converters = new TypeConverterCache(converters);
			this.settings = settings;
		}

		protected override void TraverseProperties<TContext>(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor value, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			if (!value.Type.HasDefaultConstructor(settings.AllowPrivateConstructors) && !converters.TryGetConverterForType(value.Type, out <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter _))
			{
				throw new InvalidOperationException($"Type '{value.Type}' cannot be deserialized because it does not have a default constructor or a type converter.");
			}
			base.TraverseProperties(value, visitor, context, path, serializer);
		}
	}
}
namespace YamlDotNet.Serialization.ObjectFactories
{
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultObjectFactory : ObjectFactoryBase
	{
		private readonly Dictionary<Type, ConcurrentDictionary<Type, MethodInfo[]>> stateMethods = new Dictionary<Type, ConcurrentDictionary<Type, MethodInfo[]>>
		{
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnDeserializedAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			},
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnDeserializingAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			},
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnSerializedAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			},
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnSerializingAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			}
		};

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

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

		private readonly Settings settings;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultObjectFactory()
			: this(new Dictionary<Type, Type>(), new Settings())
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultObjectFactory(IDictionary<Type, Type> mappings)
			: this(mappings, new Settings())
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>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 (<cba6ec40-2546-4a46-9577-18d27987fd9e>ReflectionExtensions.IsInterface(type))
			{
				Type value2;
				if (<cba6ec40-2546-4a46-9577-18d27987fd9e>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, settings.AllowPrivateConstructors);
			}
			catch (Exception innerException)
			{
				string message = "Failed to create an instance of type '" + type.FullName + "'.";
				throw new InvalidOperationException(message, innerException);
			}
		}

		public override void ExecuteOnDeserialized(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnDeserializedAttribute), value);
		}

		public override void ExecuteOnDeserializing(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnDeserializingAttribute), value);
		}

		public override void ExecuteOnSerialized(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnSerializedAttribute), value);
		}

		public override void ExecuteOnSerializing(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnSerializingAttribute), value);
		}

		private void ExecuteState(Type attributeType, object value)
		{
			if (value != null)
			{
				Type type = value.GetType();
				MethodInfo[] array = GetStateMethods(attributeType, type);
				MethodInfo[] array2 = array;
				foreach (MethodInfo methodInfo in array2)
				{
					methodInfo.Invoke(value, null);
				}
			}
		}

		private MethodInfo[] GetStateMethods(Type attributeType, Type valueType)
		{
			Type attributeType2 = attributeType;
			ConcurrentDictionary<Type, MethodInfo[]> concurrentDictionary = stateMethods[attributeType2];
			return concurrentDictionary.GetOrAdd(valueType, delegate(Type type)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				return methods.Where((MethodInfo x) => x.GetCustomAttributes(attributeType2, inherit: true).Length != 0).ToArray();
			});
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>LambdaObjectFactory : ObjectFactoryBase
	{
		private readonly Func<Type, object> factory;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>LambdaObjectFactory(Func<Type, object> factory)
		{
			this.factory = factory ?? throw new ArgumentNullException("factory");
		}

		public override object Create(Type type)
		{
			return factory(type);
		}
	}
	internal abstract class ObjectFactoryBase : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory
	{
		public abstract object Create(Type type);

		public virtual object? CreatePrimitive(Type type)
		{
			if (!<cba6ec40-2546-4a46-9577-18d27987fd9e>ReflectionExtensions.IsValueType(type))
			{
				return null;
			}
			return Activator.CreateInstance(type);
		}

		public virtual void ExecuteOnDeserialized(object value)
		{
		}

		public virtual void ExecuteOnDeserializing(object value)
		{
		}

		public virtual void ExecuteOnSerialized(object value)
		{
		}

		public virtual void ExecuteOnSerializing(object value)
		{
		}

		public virtual bool GetDictionary(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor descriptor, out IDictionary? dictionary, out Type[]? genericArguments)
		{
			Type implementationOfOpenGenericInterface = descriptor.Type.GetImplementationOfOpenGenericInterface(typeof(IDictionary<, >));
			if (implementationOfOpenGenericInterface != null)
			{
				genericArguments = implementationOfOpenGenericInterface.GetGenericArguments();
				object obj = Activator.CreateInstance(typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>GenericDictionaryToNonGenericAdapter<, >).MakeGenericType(genericArguments), descriptor.Value);
				dictionary = obj as IDictionary;
				return true;
			}
			genericArguments = null;
			dictionary = null;
			return false;
		}

		public virtual Type GetValueType(Type type)
		{
			Type implementationOfOpenGenericInterface = type.GetImplementationOfOpenGenericInterface(typeof(IEnumerable<>));
			return (implementationOfOpenGenericInterface != null) ? implementationOfOpenGenericInterface.GetGenericArguments()[0] : typeof(object);
		}
	}
	internal abstract class StaticObjectFactory : <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory
	{
		public abstract object Create(Type type);

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

		public abstract bool IsDictionary(Type type);

		public abstract bool IsArray(Type type);

		public abstract bool IsList(Type type);

		public abstract Type GetKeyType(Type type);

		public abstract Type GetValueType(Type type);

		public virtual object? CreatePrimitive(Type type)
		{
			return Type.GetTypeCode(type) switch
			{
				TypeCode.Boolean => false, 
				TypeCode.Byte => (byte)0, 
				TypeCode.Int16 => (short)0, 
				TypeCode.Int32 => 0, 
				TypeCode.Int64 => 0L, 
				TypeCode.SByte => (sbyte)0, 
				TypeCode.UInt16 => (ushort)0, 
				TypeCode.UInt32 => 0u, 
				TypeCode.UInt64 => 0uL, 
				TypeCode.Single => 0f, 
				TypeCode.Double => 0.0, 
				TypeCode.Decimal => 0m, 
				TypeCode.Char => '\0', 
				TypeCode.DateTime => default(DateTime), 
				_ => null, 
			};
		}

		public bool GetDictionary(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor descriptor, out IDictionary? dictionary, out Type[]? genericArguments)
		{
			dictionary = null;
			genericArguments = null;
			return false;
		}

		public abstract void ExecuteOnDeserializing(object value);

		public abstract void ExecuteOnDeserialized(object value);

		public abstract void ExecuteOnSerializing(object value);

		public abstract void ExecuteOnSerialized(object value);
	}
}
namespace YamlDotNet.Serialization.NodeTypeResolvers
{
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultContainersNodeTypeResolver : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver
	{
		bool <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver.Resolve(<cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent? nodeEvent, ref Type currentType)
		{
			if (currentType == typeof(object))
			{
				if (nodeEvent is <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart)
				{
					currentType = typeof(List<object>);
					return true;
				}
				if (nodeEvent is <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart)
				{
					currentType = typeof(Dictionary<object, object>);
					return true;
				}
			}
			return false;
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingNodeTypeResolver : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver
	{
		private readonly IDictionary<Type, Type> mappings;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingNodeTypeResolver(IDictionary<Type, Type> mappings)
		{
			if (mappings == null)
			{
				throw new ArgumentNullException("mappings");
			}
			foreach (KeyValuePair<Type, Type> mapping in mappings)
			{
				if (!mapping.Key.IsAssignableFrom(mapping.Value))
				{
					throw new InvalidOperationException($"Type '{mapping.Value}' does not implement type '{mapping.Key}'.");
				}
			}
			this.mappings = mappings;
		}

		public bool Resolve(<cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent? nodeEvent, ref Type currentType)
		{
			if (mappings.TryGetValue(currentType, out Type value))
			{
				currentType = value;
				return true;
			}
			return false;
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>PreventUnknownTagsNodeTypeResolver : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver
	{
		bool <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver.Resolve(<cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent? nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = nodeEvent.Start;
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = nodeEvent.End;
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException(in start, in end, $"Encountered an unresolved tag '{nodeEvent.Tag}'");
			}
			return false;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>TagNodeTypeResolver : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver
	{
		private readonly IDictionary<<cba6ec40-2546-4a46-9577-18d27987fd9e>TagName, Type> tagMappings;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>TagNodeTypeResolver(IDictionary<<cba6ec40-2546-4a46-9577-18d27987fd9e>TagName, Type> tagMappings)
		{
			this.tagMappings = tagMappings ?? throw new ArgumentNullException("tagMappings");
		}

		bool <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver.Resolve(<cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>TypeNameInTagNodeTypeResolver : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver
	{
		bool <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver.Resolve(<cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlConvertibleTypeResolver : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver
	{
		public bool Resolve(<cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent? nodeEvent, ref Type currentType)
		{
			return typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlConvertible).IsAssignableFrom(currentType);
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSerializableTypeResolver : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeTypeResolver
	{
		public bool Resolve(<cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent? nodeEvent, ref Type currentType)
		{
			return typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlSerializable).IsAssignableFrom(currentType);
		}
	}
}
namespace YamlDotNet.Serialization.NodeDeserializers
{
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>ArrayNodeDeserializer : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer
	{
		private sealed class ArrayList : IList, ICollection, IEnumerable
		{
			private object?[] data;

			public bool IsFixedSize => false;

			public bool IsReadOnly => false;

			public object? this[int index]
			{
				get
				{
					return data[index];
				}
				set
				{
					data[index] = value;
				}
			}

			public int Count { get; private set; }

			public bool IsSynchronized => false;

			public object SyncRoot => data;

			public ArrayList()
			{
				Clear();
			}

			public int Add(object? value)
			{
				if (Count == data.Length)
				{
					Array.Resize(ref data, data.Length * 2);
				}
				data[Count] = value;
				return Count++;
			}

			public void Clear()
			{
				data = new object[10];
				Count = 0;
			}

			bool IList.Contains(object? value)
			{
				throw new NotSupportedException();
			}

			int IList.IndexOf(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Insert(int index, object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Remove(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.RemoveAt(int index)
			{
				throw new NotSupportedException();
			}

			public void CopyTo(Array array, int index)
			{
				Array.Copy(data, 0, array, index, Count);
			}

			public IEnumerator GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return data[i];
					int num = i + 1;
					i = num;
				}
			}
		}

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ArrayNodeDeserializer(<cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector)
		{
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public bool Deserialize(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type expectedType, Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser, Type, object?> nestedObjectDeserializer, out object? value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer)
		{
			if (!expectedType.IsArray)
			{
				value = false;
				return false;
			}
			Type itemType = expectedType.GetElementType();
			ArrayList arrayList = new ArrayList();
			Array array = null;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>CollectionNodeDeserializer.DeserializeHelper(itemType, parser, nestedObjectDeserializer, arrayList, canUpdate: true, enumNamingConvention, typeInspector, PromiseResolvedHandler);
			array = Array.CreateInstance(itemType, arrayList.Count);
			arrayList.CopyTo(array, 0);
			value = array;
			return true;
			void PromiseResolvedHandler(int index, object? value)
			{
				if (array == null)
				{
					throw new InvalidOperationException("Destination array is still null");
				}
				array.SetValue(<cba6ec40-2546-4a46-9577-18d27987fd9e>TypeConverter.ChangeType(value, itemType, enumNamingConvention, typeInspector), index);
			}
		}
	}
	internal abstract class CollectionDeserializer
	{
		protected static void DeserializeHelper(Type tItem, <cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser, Type, object?> nestedObjectDeserializer, IList result, bool canUpdate, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory objectFactory)
		{
			IList result2 = result;
			parser.Consume<<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart>();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEnd @event;
			while (!parser.TryConsume<<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEnd>(out @event))
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem);
				if (obj is <cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise <cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise)
				{
					if (!canUpdate)
					{
						<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = current?.Start ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
						<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = current?.End ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
						throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>ForwardAnchorNotSupportedException(in start, in end, "Forward alias references are not allowed because this type does not implement IList<>");
					}
					int index = result2.Add(objectFactory.CreatePrimitive(tItem));
					<cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise.ValueAvailable += delegate(object? v)
					{
						result2[index] = v;
					};
				}
				else
				{
					result2.Add(obj);
				}
			}
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>CollectionNodeDeserializer : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer
	{
		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory objectFactory;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>CollectionNodeDeserializer(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory objectFactory, <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public bool Deserialize(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type expectedType, Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser, Type, object?> nestedObjectDeserializer, out object? value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer)
		{
			bool canUpdate = true;
			Type implementationOfOpenGenericInterface = expectedType.GetImplementationOfOpenGenericInterface(typeof(ICollection<>));
			Type type;
			IList list;
			if (implementationOfOpenGenericInterface != null)
			{
				Type[] genericArguments = implementationOfOpenGenericInterface.GetGenericArguments();
				type = genericArguments[0];
				value = objectFactory.Create(expectedType);
				list = value as IList;
				if (list == null)
				{
					Type implementationOfOpenGenericInterface2 = expectedType.GetImplementationOfOpenGenericInterface(typeof(IList<>));
					canUpdate = implementationOfOpenGenericInterface2 != null;
					list = (IList)Activator.CreateInstance(typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>GenericCollectionToNonGenericAdapter<>).MakeGenericType(type), value);
				}
			}
			else
			{
				if (!typeof(IList).IsAssignableFrom(expectedType))
				{
					value = null;
					return false;
				}
				type = typeof(object);
				value = objectFactory.Create(expectedType);
				list = (IList)value;
			}
			DeserializeHelper(type, parser, nestedObjectDeserializer, list, canUpdate, enumNamingConvention, typeInspector);
			return true;
		}

		internal static void DeserializeHelper(Type tItem, <cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser, Type, object?> nestedObjectDeserializer, IList result, bool canUpdate, <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector, Action<int, object?>? promiseResolvedHandler = null)
		{
			Action<int, object?> promiseResolvedHandler2 = promiseResolvedHandler;
			IList result2 = result;
			Type tItem2 = tItem;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention2 = enumNamingConvention;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector2 = typeInspector;
			parser.Consume<<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart>();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEnd @event;
			while (!parser.TryConsume<<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEnd>(out @event))
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem2);
				if (obj is <cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise <cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise)
				{
					if (!canUpdate)
					{
						<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = current?.Start ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
						<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = current?.End ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
						throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>ForwardAnchorNotSupportedException(in start, in end, "Forward alias references are not allowed because this type does not implement IList<>");
					}
					int index = result2.Add(<cba6ec40-2546-4a46-9577-18d27987fd9e>ReflectionExtensions.IsValueType(tItem2) ? Activator.CreateInstance(tItem2) : null);
					if (promiseResolvedHandler2 != null)
					{
						<cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise.ValueAvailable += delegate(object? v)
						{
							promiseResolvedHandler2(index, v);
						};
					}
					else
					{
						<cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise.ValueAvailable += delegate(object? v)
						{
							result2[index] = <cba6ec40-2546-4a46-9577-18d27987fd9e>TypeConverter.ChangeType(v, tItem2, enumNamingConvention2, typeInspector2);
						};
					}
				}
				else
				{
					result2.Add(<cba6ec40-2546-4a46-9577-18d27987fd9e>TypeConverter.ChangeType(obj, tItem2, enumNamingConvention2, typeInspector2));
				}
			}
		}
	}
	internal abstract class DictionaryDeserializer
	{
		private readonly bool duplicateKeyChecking;

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

		private void TryAssign(IDictionary result, object key, object value, <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart propertyName)
		{
			if (duplicateKeyChecking && result.Contains(key))
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = propertyName.Start;
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = propertyName.End;
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException(in start, in end, $"Encountered duplicate key {key}");
			}
			result[key] = value;
		}

		protected virtual void Deserialize(Type tKey, Type tValue, <cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser, Type, object?> nestedObjectDeserializer, IDictionary result, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer)
		{
			IDictionary result2 = result;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart property = parser.Consume<<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart>();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEnd @event;
			while (!parser.TryConsume<<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEnd>(out @event))
			{
				object key = nestedObjectDeserializer(parser, tKey);
				object value = nestedObjectDeserializer(parser, tValue);
				<cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise <cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise = value as <cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise;
				if (key is <cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise <cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise2)
				{
					if (<cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise == null)
					{
						<cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise2.ValueAvailable += delegate(object? v)
						{
							result2[v] = value;
						};
						continue;
					}
					bool hasFirstPart = false;
					<cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise2.ValueAvailable += delegate(object? v)
					{
						if (hasFirstPart)
						{
							TryAssign(result2, v, value, property);
						}
						else
						{
							key = v;
							hasFirstPart = true;
						}
					};
					<cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise.ValueAvailable += delegate(object? v)
					{
						if (hasFirstPart)
						{
							TryAssign(result2, key, v, property);
						}
						else
						{
							value = v;
							hasFirstPart = true;
						}
					};
					continue;
				}
				if (key == null)
				{
					throw new ArgumentException("Empty key names are not supported yet.", "tKey");
				}
				if (<cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise == null)
				{
					TryAssign(result2, key, value, property);
					continue;
				}
				<cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise.ValueAvailable += delegate(object? v)
				{
					result2[key] = v;
				};
			}
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>DictionaryNodeDeserializer : DictionaryDeserializer, <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer
	{
		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory objectFactory;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DictionaryNodeDeserializer(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory objectFactory, bool duplicateKeyChecking)
			: base(duplicateKeyChecking)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		public bool Deserialize(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type expectedType, Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser, Type, object?> nestedObjectDeserializer, out object? value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer)
		{
			Type implementationOfOpenGenericInterface = expectedType.GetImplementationOfOpenGenericInterface(typeof(IDictionary<, >));
			Type type;
			Type type2;
			IDictionary dictionary;
			if (implementationOfOpenGenericInterface != null)
			{
				Type[] genericArguments = implementationOfOpenGenericInterface.GetGenericArguments();
				type = genericArguments[0];
				type2 = genericArguments[1];
				value = objectFactory.Create(expectedType);
				dictionary = value as IDictionary;
				if (dictionary == null)
				{
					dictionary = (IDictionary)Activator.CreateInstance(typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>GenericDictionaryToNonGenericAdapter<, >).MakeGenericType(type, type2), value);
				}
			}
			else
			{
				if (!typeof(IDictionary).IsAssignableFrom(expectedType))
				{
					value = null;
					return false;
				}
				type = typeof(object);
				type2 = typeof(object);
				value = objectFactory.Create(expectedType);
				dictionary = (IDictionary)value;
			}
			Deserialize(type, type2, parser, nestedObjectDeserializer, dictionary, rootDeserializer);
			return true;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>EnumerableNodeDeserializer : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer
	{
		public bool Deserialize(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type expectedType, Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser, Type, object?> nestedObjectDeserializer, out object? value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer)
		{
			Type type;
			if (expectedType == typeof(IEnumerable))
			{
				type = typeof(object);
			}
			else
			{
				Type implementationOfOpenGenericInterface = expectedType.GetImplementationOfOpenGenericInterface(typeof(IEnumerable<>));
				if (implementationOfOpenGenericInterface != expectedType)
				{
					value = null;
					return false;
				}
				type = implementationOfOpenGenericInterface.GetGenericArguments()[0];
			}
			Type arg = typeof(List<>).MakeGenericType(type);
			value = nestedObjectDeserializer(parser, arg);
			return true;
		}
	}
	internal sealed class FsharpListNodeDeserializer : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer
	{
		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention;

		public FsharpListNodeDeserializer(<cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector, <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention)
		{
			this.typeInspector = typeInspector;
			this.enumNamingConvention = enumNamingConvention;
		}

		public bool Deserialize(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type expectedType, Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser, Type, object?> nestedObjectDeserializer, out object? value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer)
		{
			if (!FsharpHelper.IsFsharpListType(expectedType))
			{
				value = false;
				return false;
			}
			Type type = expectedType.GetGenericArguments()[0];
			Type t = expectedType.GetGenericTypeDefinition().MakeGenericType(type);
			ArrayList arrayList = new ArrayList();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>CollectionNodeDeserializer.DeserializeHelper(type, parser, nestedObjectDeserializer, arrayList, canUpdate: true, enumNamingConvention, typeInspector);
			Array array = Array.CreateInstance(type, arrayList.Count);
			arrayList.CopyTo(array, 0);
			object obj = FsharpHelper.CreateFsharpListFromArray(t, type, array);
			value = obj;
			return true;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>NullNodeDeserializer : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer
	{
		public bool Deserialize(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type expectedType, Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser, Type, object?> nestedObjectDeserializer, out object? value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer)
		{
			value = null;
			if (parser.Accept<<cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent>(out var @event) && NodeIsNull(@event))
			{
				parser.SkipThisAndNestedEvents();
				return true;
			}
			return false;
		}

		private static bool NodeIsNull(<cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent nodeEvent)
		{
			if (nodeEvent.Tag == "tag:yaml.org,2002:null")
			{
				return true;
			}
			if (nodeEvent is YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar && <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar.Style == <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Plain && !<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar.IsKey)
			{
				string value = <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar.Value;
				switch (value)
				{
				default:
					return value == "NULL";
				case "":
				case "~":
				case "null":
				case "Null":
					return true;
				}
			}
			return false;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectNodeDeserializer : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer
	{
		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory objectFactory;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector;

		private readonly bool ignoreUnmatched;

		private readonly bool duplicateKeyChecking;

		private readonly ITypeConverter typeConverter;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention;

		private readonly bool enforceNullability;

		private readonly bool caseInsensitivePropertyMatching;

		private readonly bool enforceRequiredProperties;

		private readonly TypeConverterCache typeConverters;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectNodeDeserializer(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory objectFactory, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector, bool ignoreUnmatched, bool duplicateKeyChecking, ITypeConverter typeConverter, <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention, bool enforceNullability, bool caseInsensitivePropertyMatching, bool enforceRequiredProperties, IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> typeConverters)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
			this.typeInspector = typeInspector ?? throw new ArgumentNullException("typeInspector");
			this.ignoreUnmatched = ignoreUnmatched;
			this.duplicateKeyChecking = duplicateKeyChecking;
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
			this.enumNamingConvention = enumNamingConvention ?? throw new ArgumentNullException("enumNamingConvention");
			this.enforceNullability = enforceNullability;
			this.caseInsensitivePropertyMatching = caseInsensitivePropertyMatching;
			this.enforceRequiredProperties = enforceRequiredProperties;
			this.typeConverters = new TypeConverterCache(typeConverters);
		}

		public bool Deserialize(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type expectedType, Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser, Type, object?> nestedObjectDeserializer, out object? value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer)
		{
			if (!parser.TryConsume<<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart>(out var _))
			{
				value = null;
				return false;
			}
			Type type = Nullable.GetUnderlyingType(expectedType) ?? FsharpHelper.GetOptionUnderlyingType(expectedType) ?? expectedType;
			value = objectFactory.Create(type);
			objectFactory.ExecuteOnDeserializing(value);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEnd event2;
			while (!parser.TryConsume<<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEnd>(out event2))
			{
				YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar propertyName = parser.Consume<YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar>();
				if (duplicateKeyChecking && !hashSet.Add(propertyName.Value))
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start2 = propertyName.Start;
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = propertyName.End;
					throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException(in start2, in end, "Encountered duplicate key " + propertyName.Value);
				}
				try
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor property = typeInspector.GetProperty(type, null, propertyName.Value, ignoreUnmatched, caseInsensitivePropertyMatching);
					if (property == null)
					{
						parser.SkipThisAndNestedEvents();
						continue;
					}
					hashSet2.Add(property.Name);
					object obj;
					if (property.ConverterType != null)
					{
						<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter converterByType = typeConverters.GetConverterByType(property.ConverterType);
						obj = converterByType.ReadYaml(parser, property.Type, rootDeserializer);
					}
					else
					{
						obj = nestedObjectDeserializer(parser, property.Type);
					}
					if (obj is <cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise <cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise)
					{
						object valueRef = value;
						<cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise.ValueAvailable += delegate(object? v)
						{
							object value3 = typeConverter.ChangeType(v, property.Type, enumNamingConvention, typeInspector);
							NullCheck(value3, property, propertyName);
							property.Write(valueRef, value3);
						};
					}
					else
					{
						object value2 = typeConverter.ChangeType(obj, property.Type, enumNamingConvention, typeInspector);
						NullCheck(value2, property, propertyName);
						property.Write(value, value2);
					}
					goto IL_0267;
				}
				catch (SerializationException ex)
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start2 = propertyName.Start;
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = propertyName.End;
					throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException(in start2, in end, ex.Message);
				}
				catch (<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException)
				{
					throw;
				}
				catch (Exception innerException)
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start2 = propertyName.Start;
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = propertyName.End;
					throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException(in start2, in end, "Exception during deserialization", innerException);
				}
				IL_0267:
				start = propertyName.End;
			}
			if (enforceRequiredProperties)
			{
				IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor> properties = typeInspector.GetProperties(type, value);
				List<string> list = new List<string>();
				foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor item in properties)
				{
					if (item.Required && !hashSet2.Contains(item.Name))
					{
						list.Add(item.Name);
					}
				}
				if (list.Count > 0)
				{
					string text = string.Join(",", list);
					throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException(in start, in start, "Missing properties, '" + text + "' in source yaml.");
				}
			}
			objectFactory.ExecuteOnDeserialized(value);
			return true;
		}

		public void NullCheck(object value, <cba6ec40-2546-4a46-9577-18d27987fd9e>IPropertyDescriptor property, YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar propertyName)
		{
			if (enforceNullability && value == null && !property.AllowNulls)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = propertyName.Start;
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = propertyName.End;
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException(in start, in end, "Strict nullability enforcement error.", new NullReferenceException("Yaml value is null when target property requires non null values."));
			}
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarNodeDeserializer : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer
	{
		private const string BooleanTruePattern = "^(true|y|yes|on)$";

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

		private readonly bool attemptUnknownTypeDeserialization;

		private readonly ITypeConverter typeConverter;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlFormatter formatter;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarNodeDeserializer(bool attemptUnknownTypeDeserialization, ITypeConverter typeConverter, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlFormatter formatter, <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention)
		{
			this.attemptUnknownTypeDeserialization = attemptUnknownTypeDeserialization;
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
			this.typeInspector = typeInspector;
			this.formatter = formatter;
			this.enumNamingConvention = enumNamingConvention;
		}

		public bool Deserialize(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type expectedType, Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser, Type, object?> nestedObjectDeserializer, out object? value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer)
		{
			if (!parser.TryConsume<YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar>(out var @event))
			{
				value = null;
				return false;
			}
			Type type = Nullable.GetUnderlyingType(expectedType) ?? FsharpHelper.GetOptionUnderlyingType(expectedType) ?? expectedType;
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>ReflectionExtensions.IsEnum(type))
			{
				string name = enumNamingConvention.Reverse(@event.Value);
				name = typeInspector.GetEnumName(type, name);
				value = Enum.Parse(type, name, ignoreCase: true);
				return true;
			}
			TypeCode typeCode = <cba6ec40-2546-4a46-9577-18d27987fd9e>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, formatter.NumberFormat);
				break;
			case TypeCode.Double:
				value = double.Parse(@event.Value, formatter.NumberFormat);
				break;
			case TypeCode.Decimal:
				value = decimal.Parse(@event.Value, formatter.NumberFormat);
				break;
			case TypeCode.String:
				value = @event.Value;
				break;
			case TypeCode.Char:
				value = @event.Value[0];
				break;
			case TypeCode.DateTime:
				value = DateTime.Parse(@event.Value, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
				break;
			default:
				if (expectedType == typeof(object))
				{
					if (!@event.IsKey && attemptUnknownTypeDeserialization)
					{
						value = AttemptUnknownTypeDeserialization(@event);
					}
					else
					{
						value = @event.Value;
					}
				}
				else
				{
					value = typeConverter.ChangeType(@event.Value, expectedType, enumNamingConvention, typeInspector);
				}
				break;
			}
			return true;
		}

		private static bool DeserializeBooleanHelper(string value)
		{
			if (Regex.IsMatch(value, "^(true|y|yes|on)$", RegexOptions.IgnoreCase))
			{
				return true;
			}
			if (Regex.IsMatch(value, "^(false|n|no|off)$", RegexOptions.IgnoreCase))
			{
				return false;
			}
			throw new FormatException("The value \"" + value + "\" is not a valid YAML Boolean");
		}

		private object DeserializeIntegerHelper(TypeCode typeCode, string value)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				int i = 0;
				bool flag = false;
				ulong num = 0uL;
				if (value[0] == '-')
				{
					i++;
					flag = true;
				}
				else if (value[0] == '+')
				{
					i++;
				}
				if (value[i] == '0')
				{
					int num2;
					if (i == value.Length - 1)
					{
						num2 = 10;
						num = 0uL;
					}
					else
					{
						i++;
						if (value[i] == 'b')
						{
							num2 = 2;
							i++;
						}
						else if (value[i] == 'x')
						{
							num2 = 16;
							i++;
						}
						else
						{
							num2 = 8;
						}
					}
					for (; i < value.Length; i++)
					{
						if (value[i] != '_')
						{
							builder.Append(value[i]);
						}
					}
					switch (num2)
					{
					case 2:
					case 8:
						num = Convert.ToUInt64(builder.ToString(), num2);
						break;
					case 16:
						num = ulong.Parse(builder.ToString(), NumberStyles.HexNumber, formatter.NumberFormat);
						break;
					}
				}
				else
				{
					string[] array = value.Substring(i).Split(new char[1] { ':' });
					num = 0uL;
					for (int j = 0; j < array.Length; j++)
					{
						num *= 60;
						num += ulong.Parse(array[j].Replace("_", ""), CultureInfo.InvariantCulture);
					}
				}
				if (!flag)
				{
					return CastInteger(num, typeCode);
				}
				long number = ((num != 9223372036854775808uL) ? checked(-(long)num) : long.MinValue);
				return CastInteger(number, typeCode);
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

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

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

		private object? AttemptUnknownTypeDeserialization(YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar value)
		{
			if (value.Style == <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.SingleQuoted || value.Style == <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.DoubleQuoted || value.Style == <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Folded)
			{
				return value.Value;
			}
			string v = value.Value;
			switch (v)
			{
			case "null":
			case "Null":
			case "NULL":
			case "~":
			case "":
				return null;
			case "true":
			case "True":
			case "TRUE":
				return true;
			case "False":
			case "FALSE":
			case "false":
				return false;
			default:
				if (Regex.IsMatch(v, "^0x[0-9a-fA-F]+$"))
				{
					v = v.Substring(2);
					if (byte.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result))
					{
						return result;
					}
					if (short.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result2))
					{
						return result2;
					}
					if (int.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result3))
					{
						return result3;
					}
					if (long.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result4))
					{
						return result4;
					}
					if (ulong.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result5))
					{
						return result5;
					}
					return v;
				}
				if (Regex.IsMatch(v, "^0o[0-9a-fA-F]+$"))
				{
					if (!TryAndSwallow(() => Convert.ToByte(v, 8), out object value2) && !TryAndSwallow(() => Convert.ToInt16(v, 8), out value2) && !TryAndSwallow(() => Convert.ToInt32(v, 8), out value2) && !TryAndSwallow(() => Convert.ToInt64(v, 8), out value2) && !TryAndSwallow(() => Convert.ToUInt64(v, 8), out value2))
					{
						return v;
					}
					return value2;
				}
				if (Regex.IsMatch(v, "^[-+]?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?$"))
				{
					if (byte.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result6))
					{
						return result6;
					}
					if (short.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result7))
					{
						return result7;
					}
					if (int.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result8))
					{
						return result8;
					}
					if (long.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result9))
					{
						return result9;
					}
					if (ulong.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result10))
					{
						return result10;
					}
					if (float.TryParse(v, NumberStyles.Float, formatter.NumberFormat, out var result11))
					{
						return result11;
					}
					if (double.TryParse(v, NumberStyles.Float, formatter.NumberFormat, out var result12))
					{
						return result12;
					}
					return v;
				}
				if (Regex.IsMatch(v, "^[-+]?(\\.inf|\\.Inf|\\.INF)$"))
				{
					if (Polyfills.StartsWith(v, '-'))
					{
						return float.NegativeInfinity;
					}
					return float.PositiveInfinity;
				}
				if (Regex.IsMatch(v, "^(\\.nan|\\.NaN|\\.NAN)$"))
				{
					return float.NaN;
				}
				return v;
			}
		}

		private static bool TryAndSwallow(Func<object> attempt, out object? value)
		{
			try
			{
				value = attempt();
				return true;
			}
			catch
			{
				value = null;
				return false;
			}
		}
	}
	internal sealed class StaticArrayNodeDeserializer : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer
	{
		private sealed class ArrayList : IList, ICollection, IEnumerable
		{
			private object?[] data;

			public bool IsFixedSize => false;

			public bool IsReadOnly => false;

			public object? this[int index]
			{
				get
				{
					return data[index];
				}
				set
				{
					data[index] = value;
				}
			}

			public int Count { get; private set; }

			public bool IsSynchronized => false;

			public object SyncRoot => data;

			public ArrayList()
			{
				Clear();
			}

			public int Add(object? value)
			{
				if (Count == data.Length)
				{
					Array.Resize(ref data, data.Length * 2);
				}
				data[Count] = value;
				return Count++;
			}

			public void Clear()
			{
				data = new object[10];
				Count = 0;
			}

			bool IList.Contains(object? value)
			{
				throw new NotSupportedException();
			}

			int IList.IndexOf(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Insert(int index, object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Remove(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.RemoveAt(int index)
			{
				throw new NotSupportedException();
			}

			public void CopyTo(Array array, int index)
			{
				Array.Copy(data, 0, array, index, Count);
			}

			public IEnumerator GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return data[i];
					int num = i + 1;
					i = num;
				}
			}
		}

		private readonly StaticObjectFactory factory;

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

		public bool Deserialize(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type expectedType, Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser, Type, object?> nestedObjectDeserializer, out object? value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer)
		{
			if (!factory.IsArray(expectedType))
			{
				value = false;
				return false;
			}
			Type valueType = factory.GetValueType(expectedType);
			ArrayList arrayList = new ArrayList();
			StaticCollectionNodeDeserializer.DeserializeHelper(valueType, parser, nestedObjectDeserializer, arrayList, factory);
			Array array = factory.CreateArray(expectedType, arrayList.Count);
			arrayList.CopyTo(array, 0);
			value = array;
			return true;
		}
	}
	internal sealed class StaticCollectionNodeDeserializer : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer
	{
		private readonly StaticObjectFactory factory;

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

		public bool Deserialize(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type expectedType, Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser, Type, object?> nestedObjectDeserializer, out object? value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer)
		{
			if (!factory.IsList(expectedType))
			{
				value = null;
				return false;
			}
			DeserializeHelper(result: (IList)(value = factory.Create(expectedType) as IList), tItem: factory.GetValueType(expectedType), parser: parser, nestedObjectDeserializer: nestedObjectDeserializer, factory: factory);
			return true;
		}

		internal static void DeserializeHelper(Type tItem, <cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser, Type, object?> nestedObjectDeserializer, IList result, <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory factory)
		{
			IList result2 = result;
			parser.Consume<<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart>();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEnd @event;
			while (!parser.TryConsume<<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEnd>(out @event))
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem);
				if (obj is <cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise <cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise)
				{
					int index = result2.Add(factory.CreatePrimitive(tItem));
					<cba6ec40-2546-4a46-9577-18d27987fd9e>IValuePromise.ValueAvailable += delegate(object? v)
					{
						result2[index] = v;
					};
				}
				else
				{
					result2.Add(obj);
				}
			}
		}
	}
	internal class StaticDictionaryNodeDeserializer : DictionaryDeserializer, <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer
	{
		private readonly StaticObjectFactory objectFactory;

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

		public bool Deserialize(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser reader, Type expectedType, Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser, Type, object?> nestedObjectDeserializer, out object? value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer)
		{
			if (objectFactory.IsDictionary(expectedType))
			{
				if (!(objectFactory.Create(expectedType) is IDictionary dictionary))
				{
					value = null;
					return false;
				}
				Type keyType = objectFactory.GetKeyType(expectedType);
				Type valueType = objectFactory.GetValueType(expectedType);
				value = dictionary;
				base.Deserialize(keyType, valueType, reader, nestedObjectDeserializer, dictionary, rootDeserializer);
				return true;
			}
			value = null;
			return false;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>TypeConverterNodeDeserializer : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer
	{
		private readonly TypeConverterCache converters;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>TypeConverterNodeDeserializer(IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter> converters)
		{
			this.converters = new TypeConverterCache(converters);
		}

		public bool Deserialize(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type expectedType, Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser, Type, object?> nestedObjectDeserializer, out object? value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer)
		{
			if (!converters.TryGetConverterForType(expectedType, out <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter typeConverter))
			{
				value = null;
				return false;
			}
			value = typeConverter.ReadYaml(parser, expectedType, rootDeserializer);
			return true;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlConvertibleNodeDeserializer : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer
	{
		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory objectFactory;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlConvertibleNodeDeserializer(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type expectedType, Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser, Type, object?> nestedObjectDeserializer, out object? value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer)
		{
			Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser, Type, object?> nestedObjectDeserializer2 = nestedObjectDeserializer;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser2 = parser;
			if (typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlConvertible).IsAssignableFrom(expectedType))
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlConvertible <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlConvertible = (<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlConvertible)objectFactory.Create(expectedType);
				<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlConvertible.Read(parser2, expectedType, (Type type) => nestedObjectDeserializer2(parser2, type));
				value = <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlConvertible;
				return true;
			}
			value = null;
			return false;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSerializableNodeDeserializer : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer
	{
		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory objectFactory;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSerializableNodeDeserializer(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type expectedType, Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser, Type, object?> nestedObjectDeserializer, out object? value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer)
		{
			if (typeof(<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlSerializable).IsAssignableFrom(expectedType))
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlSerializable <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlSerializable = (<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlSerializable)objectFactory.Create(expectedType);
				<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlSerializable.ReadYaml(parser);
				value = <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlSerializable;
				return true;
			}
			value = null;
			return false;
		}
	}
}
namespace YamlDotNet.Serialization.NamingConventions
{
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>CamelCaseNamingConvention : <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention
	{
		public static readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention Instance = new <cba6ec40-2546-4a46-9577-18d27987fd9e>CamelCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>CamelCaseNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>StringExtensions.ToCamelCase(value);
		}

		public string Reverse(string value)
		{
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>StringExtensions.ToPascalCase(value);
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>HyphenatedNamingConvention : <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention
	{
		public static readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention Instance = new <cba6ec40-2546-4a46-9577-18d27987fd9e>HyphenatedNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>HyphenatedNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>StringExtensions.FromCamelCase(value, "-");
		}

		public string Reverse(string value)
		{
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>StringExtensions.ToPascalCase(value);
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>LowerCaseNamingConvention : <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention
	{
		public static readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention Instance = new <cba6ec40-2546-4a46-9577-18d27987fd9e>LowerCaseNamingConvention();

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>LowerCaseNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>StringExtensions.ToCamelCase(value).ToLower(CultureInfo.InvariantCulture);
		}

		public string Reverse(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return value;
			}
			return char.ToUpperInvariant(value[0]) + value.Substring(1);
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>NullNamingConvention : <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention
	{
		public static readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention Instance = new <cba6ec40-2546-4a46-9577-18d27987fd9e>NullNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>NullNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value;
		}

		public string Reverse(string value)
		{
			return value;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>PascalCaseNamingConvention : <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention
	{
		public static readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention Instance = new <cba6ec40-2546-4a46-9577-18d27987fd9e>PascalCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>PascalCaseNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>StringExtensions.ToPascalCase(value);
		}

		public string Reverse(string value)
		{
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>StringExtensions.ToPascalCase(value);
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>UnderscoredNamingConvention : <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention
	{
		public static readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention Instance = new <cba6ec40-2546-4a46-9577-18d27987fd9e>UnderscoredNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>UnderscoredNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>StringExtensions.FromCamelCase(value, "_");
		}

		public string Reverse(string value)
		{
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>StringExtensions.ToPascalCase(value);
		}
	}
}
namespace YamlDotNet.Serialization.EventEmitters
{
	internal abstract class <cba6ec40-2546-4a46-9577-18d27987fd9e>ChainedEventEmitter : <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter
	{
		protected readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter nextEmitter;

		protected <cba6ec40-2546-4a46-9577-18d27987fd9e>ChainedEventEmitter(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter nextEmitter)
		{
			this.nextEmitter = nextEmitter ?? throw new ArgumentNullException("nextEmitter");
		}

		public virtual void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>AliasEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStartEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEndEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStartEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEndEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>JsonEventEmitter : <cba6ec40-2546-4a46-9577-18d27987fd9e>ChainedEventEmitter
	{
		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlFormatter formatter;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>JsonEventEmitter(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter nextEmitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlFormatter formatter, <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector)
			: base(nextEmitter)
		{
			this.formatter = formatter;
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public override void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>AliasEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter)
		{
			eventInfo.NeedsExpansion = true;
		}

		public override void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter)
		{
			eventInfo.IsPlainImplicit = true;
			eventInfo.Style = <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Plain;
			object value = eventInfo.Source.Value;
			if (value == null)
			{
				eventInfo.RenderedValue = "null";
			}
			else
			{
				TypeCode typeCode = <cba6ec40-2546-4a46-9577-18d27987fd9e>ReflectionExtensions.GetTypeCode(eventInfo.Source.Type);
				switch (typeCode)
				{
				case TypeCode.Boolean:
					eventInfo.RenderedValue = formatter.FormatBoolean(value);
					break;
				case TypeCode.SByte:
				case TypeCode.Byte:
				case TypeCode.Int16:
				case TypeCode.UInt16:
				case TypeCode.Int32:
				case TypeCode.UInt32:
				case TypeCode.Int64:
				case TypeCode.UInt64:
					if (<cba6ec40-2546-4a46-9577-18d27987fd9e>ReflectionExtensions.IsEnum(eventInfo.Source.Type))
					{
						eventInfo.RenderedValue = formatter.FormatEnum(value, typeInspector, enumNamingConvention);
						eventInfo.Style = ((!formatter.PotentiallyQuoteEnums(value)) ? <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Plain : <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.DoubleQuoted);
					}
					else
					{
						eventInfo.RenderedValue = formatter.FormatNumber(value);
					}
					break;
				case TypeCode.Single:
				{
					float f = (float)value;
					eventInfo.RenderedValue = f.ToString("G", CultureInfo.InvariantCulture);
					if (float.IsNaN(f) || float.IsInfinity(f))
					{
						eventInfo.Style = <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.DoubleQuoted;
					}
					break;
				}
				case TypeCode.Double:
				{
					double d = (double)value;
					eventInfo.RenderedValue = d.ToString("G", CultureInfo.InvariantCulture);
					if (double.IsNaN(d) || double.IsInfinity(d))
					{
						eventInfo.Style = <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.DoubleQuoted;
					}
					break;
				}
				case TypeCode.Decimal:
					eventInfo.RenderedValue = ((decimal)value).ToString(CultureInfo.InvariantCulture);
					break;
				case TypeCode.Char:
				case TypeCode.String:
					eventInfo.RenderedValue = value.ToString();
					eventInfo.Style = <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.DoubleQuoted;
					break;
				case TypeCode.DateTime:
					eventInfo.RenderedValue = formatter.FormatDateTime(value);
					break;
				case TypeCode.Empty:
					eventInfo.RenderedValue = "null";
					break;
				default:
					if (eventInfo.Source.Type == typeof(TimeSpan))
					{
						eventInfo.RenderedValue = formatter.FormatTimeSpan(value);
						break;
					}
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
			}
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStartEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter)
		{
			eventInfo.Style = <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStyle.Flow;
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStartEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter)
		{
			eventInfo.Style = <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStyle.Flow;
			base.Emit(eventInfo, emitter);
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>TypeAssigningEventEmitter : <cba6ec40-2546-4a46-9577-18d27987fd9e>ChainedEventEmitter
	{
		private readonly IDictionary<Type, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName> tagMappings;

		private readonly bool quoteNecessaryStrings;

		private readonly Regex? isSpecialStringValue_Regex;

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

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

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle defaultScalarStyle;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlFormatter formatter;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>TypeAssigningEventEmitter(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter nextEmitter, IDictionary<Type, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName> tagMappings, bool quoteNecessaryStrings, bool quoteYaml1_1Strings, <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle defaultScalarStyle, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlFormatter formatter, <cba6ec40-2546-4a46-9577-18d27987fd9e>INamingConvention enumNamingConvention, <cba6ec40-2546-4a46-9577-18d27987fd9e>ITypeInspector typeInspector)
			: base(nextEmitter)
		{
			this.defaultScalarStyle = defaultScalarStyle;
			this.formatter = formatter;
			this.tagMappings = tagMappings;
			this.quoteNecessaryStrings = quoteNecessaryStrings;
			isSpecialStringValue_Regex = new Regex(quoteYaml1_1Strings ? CombinedYaml1_1SpecialStrings_Pattern : SpecialStrings_Pattern, RegexOptions.Compiled);
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public override void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle style = <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Plain;
			object value = eventInfo.Source.Value;
			if (value == null)
			{
				eventInfo.Tag = <cba6ec40-2546-4a46-9577-18d27987fd9e>JsonSchema.Tags.Null;
				eventInfo.RenderedValue = "";
			}
			else
			{
				TypeCode typeCode = <cba6ec40-2546-4a46-9577-18d27987fd9e>ReflectionExtensions.GetTypeCode(eventInfo.Source.Type);
				switch (typeCode)
				{
				case TypeCode.Boolean:
					eventInfo.Tag = <cba6ec40-2546-4a46-9577-18d27987fd9e>JsonSchema.Tags.Bool;
					eventInfo.RenderedValue = formatter.FormatBoolean(value);
					break;
				case TypeCode.SByte:
				case TypeCode.Byte:
				case TypeCode.Int16:
				case TypeCode.UInt16:
				case TypeCode.Int32:
				case TypeCode.UInt32:
				case TypeCode.Int64:
				case TypeCode.UInt64:
					if (eventInfo.Source.Type.IsEnum)
					{
						eventInfo.Tag = <cba6ec40-2546-4a46-9577-18d27987fd9e>FailsafeSchema.Tags.Str;
						eventInfo.RenderedValue = formatter.FormatEnum(value, typeInspector, enumNamingConvention);
						style = ((!quoteNecessaryStrings || !IsSpecialStringValue(eventInfo.RenderedValue) || !formatter.PotentiallyQuoteEnums(value)) ? defaultScalarStyle : <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.DoubleQuoted);
					}
					else
					{
						eventInfo.Tag = <cba6ec40-2546-4a46-9577-18d27987fd9e>JsonSchema.Tags.Int;
						eventInfo.RenderedValue = formatter.FormatNumber(value);
					}
					break;
				case TypeCode.Single:
					eventInfo.Tag = <cba6ec40-2546-4a46-9577-18d27987fd9e>JsonSchema.Tags.Float;
					eventInfo.RenderedValue = formatter.FormatNumber((float)value);
					break;
				case TypeCode.Double:
					eventInfo.Tag = <cba6ec40-2546-4a46-9577-18d27987fd9e>JsonSchema.Tags.Float;
					eventInfo.RenderedValue = formatter.FormatNumber((double)value);
					break;
				case TypeCode.Decimal:
					eventInfo.Tag = <cba6ec40-2546-4a46-9577-18d27987fd9e>JsonSchema.Tags.Float;
					eventInfo.RenderedValue = formatter.FormatNumber(value);
					break;
				case TypeCode.Char:
				case TypeCode.String:
					eventInfo.Tag = <cba6ec40-2546-4a46-9577-18d27987fd9e>FailsafeSchema.Tags.Str;
					eventInfo.RenderedValue = value.ToString();
					style = ((!quoteNecessaryStrings || !IsSpecialStringValue(eventInfo.RenderedValue)) ? defaultScalarStyle : <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.DoubleQuoted);
					break;
				case TypeCode.DateTime:
					eventInfo.Tag = <cba6ec40-2546-4a46-9577-18d27987fd9e>DefaultSchema.Tags.Timestamp;
					eventInfo.RenderedValue = formatter.FormatDateTime(value);
					break;
				case TypeCode.Empty:
					eventInfo.Tag = <cba6ec40-2546-4a46-9577-18d27987fd9e>JsonSchema.Tags.Null;
					eventInfo.RenderedValue = "";
					break;
				default:
					if (eventInfo.Source.Type == typeof(TimeSpan))
					{
						eventInfo.RenderedValue = formatter.FormatTimeSpan(value);
						break;
					}
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
			}
			eventInfo.IsPlainImplicit = true;
			if (eventInfo.Style == <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Any)
			{
				eventInfo.Style = style;
			}
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStartEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter)
		{
			AssignTypeIfNeeded(eventInfo);
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStartEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter)
		{
			AssignTypeIfNeeded(eventInfo);
			base.Emit(eventInfo, emitter);
		}

		private void AssignTypeIfNeeded(<cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectEventInfo eventInfo)
		{
			if (tagMappings.TryGetValue(eventInfo.Source.Type, out var value))
			{
				eventInfo.Tag = value;
			}
		}

		private bool IsSpecialStringValue(string value)
		{
			if (value.Trim() == string.Empty)
			{
				return true;
			}
			return isSpecialStringValue_Regex?.IsMatch(value) ?? false;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>WriterEventEmitter : <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter
	{
		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter.Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>AliasEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter)
		{
			emitter.Emit(new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias(eventInfo.Alias));
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter.Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter)
		{
			emitter.Emit(new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar(eventInfo.Anchor, eventInfo.Tag, eventInfo.RenderedValue, eventInfo.Style, eventInfo.IsPlainImplicit, eventInfo.IsQuotedImplicit));
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter.Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStartEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter)
		{
			emitter.Emit(new <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart(eventInfo.Anchor, eventInfo.Tag, eventInfo.IsImplicit, eventInfo.Style));
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter.Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEndEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter)
		{
			emitter.Emit(new <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEnd());
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter.Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStartEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter)
		{
			emitter.Emit(new <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart(eventInfo.Anchor, eventInfo.Tag, eventInfo.IsImplicit, eventInfo.Style));
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IEventEmitter.Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEndEventInfo eventInfo, <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter)
		{
			emitter.Emit(new <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEnd());
		}
	}
}
namespace YamlDotNet.Serialization.Converters
{
	internal class DateTime8601Converter : <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter
	{
		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle scalarStyle;

		public DateTime8601Converter()
			: this(<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Any)
		{
		}

		public DateTime8601Converter(<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle scalarStyle)
		{
			this.scalarStyle = scalarStyle;
		}

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

		public object ReadYaml(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type type, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar>().Value;
			DateTime dateTime = DateTime.ParseExact(value, "O", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
			return dateTime;
		}

		public void WriteYaml(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, object? value, Type type, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			string value2 = ((DateTime)value).ToString("O", CultureInfo.InvariantCulture);
			emitter.Emit(new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName.Empty, value2, scalarStyle, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>DateTimeConverter : <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter
	{
		private readonly DateTimeKind kind;

		private readonly IFormatProvider provider;

		private readonly bool doubleQuotes;

		private readonly string[] formats;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DateTimeConverter(DateTimeKind kind = DateTimeKind.Utc, IFormatProvider? provider = null, bool doubleQuotes = false, params string[] formats)
		{
			this.kind = ((kind == DateTimeKind.Unspecified) ? DateTimeKind.Utc : kind);
			this.provider = provider ?? CultureInfo.InvariantCulture;
			this.doubleQuotes = doubleQuotes;
			this.formats = formats.DefaultIfEmpty("G").ToArray();
		}

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

		public object ReadYaml(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type type, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar>().Value;
			DateTimeStyles style = ((kind == DateTimeKind.Local) ? DateTimeStyles.AssumeLocal : DateTimeStyles.AssumeUniversal);
			DateTime dt = DateTime.ParseExact(value, formats, provider, style);
			dt = EnsureDateTimeKind(dt, kind);
			return dt;
		}

		public void WriteYaml(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, object? value, Type type, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			DateTime dateTime = (DateTime)value;
			string value2 = ((kind == DateTimeKind.Local) ? dateTime.ToLocalTime() : dateTime.ToUniversalTime()).ToString(formats.First(), provider);
			emitter.Emit(new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName.Empty, value2, doubleQuotes ? <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.DoubleQuoted : <cba6ec40-2546-4a46-9577-18d27987fd9e>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 DateTimeOffsetConverter : <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter
	{
		private readonly IFormatProvider provider;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle style;

		private readonly DateTimeStyles dateStyle;

		private readonly string[] formats;

		public DateTimeOffsetConverter(IFormatProvider? provider = null, <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle style = <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Any, DateTimeStyles dateStyle = DateTimeStyles.None, params string[] formats)
		{
			this.provider = provider ?? CultureInfo.InvariantCulture;
			this.style = style;
			this.dateStyle = dateStyle;
			this.formats = formats.DefaultIfEmpty("O").ToArray();
		}

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

		public object ReadYaml(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type type, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar>().Value;
			DateTimeOffset dateTimeOffset = DateTimeOffset.ParseExact(value, formats, provider, dateStyle);
			return dateTimeOffset;
		}

		public void WriteYaml(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, object? value, Type type, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			string value2 = ((DateTimeOffset)value).ToString(formats.First(), provider);
			emitter.Emit(new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName.Empty, value2, style, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>GuidConverter : <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter
	{
		private readonly bool jsonCompatible;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>GuidConverter(bool jsonCompatible)
		{
			this.jsonCompatible = jsonCompatible;
		}

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

		public object ReadYaml(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type type, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar>().Value;
			return new Guid(value);
		}

		public void WriteYaml(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, object? value, Type type, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			Guid guid = (Guid)value;
			emitter.Emit(new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName.Empty, guid.ToString("D"), jsonCompatible ? <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.DoubleQuoted : <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>SystemTypeConverter : <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlTypeConverter
	{
		public bool Accepts(Type type)
		{
			return typeof(Type).IsAssignableFrom(type);
		}

		public object ReadYaml(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type type, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar>().Value;
			return Type.GetType(value, throwOnError: true);
		}

		public void WriteYaml(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, object? value, Type type, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer serializer)
		{
			Type type2 = (Type)value;
			emitter.Emit(new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName.Empty, type2.AssemblyQualifiedName, <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
}
namespace YamlDotNet.Serialization.Callbacks
{
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class OnDeserializedAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class OnDeserializingAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class OnSerializedAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class OnSerializingAttribute : Attribute
	{
	}
}
namespace YamlDotNet.Serialization.BufferedDeserialization
{
	internal interface ITypeDiscriminatingNodeDeserializerOptions
	{
		void AddTypeDiscriminator(ITypeDiscriminator discriminator);

		void AddKeyValueTypeDiscriminator<T>(string discriminatorKey, IDictionary<string, Type> valueTypeMapping);

		void AddUniqueKeyTypeDiscriminator<T>(IDictionary<string, Type> uniqueKeyTypeMapping);
	}
	internal class ParserBuffer : <cba6ec40-2546-4a46-9577-18d27987fd9e>IParser
	{
		private readonly LinkedList<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> buffer;

		private LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent>? current;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent? Current => current?.Value;

		public ParserBuffer(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parserToBuffer, int maxDepth, int maxLength)
		{
			buffer = new LinkedList<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent>();
			buffer.AddLast(parserToBuffer.Consume<<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart>());
			int num = 0;
			do
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent = parserToBuffer.Consume<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent>();
				num += <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent.NestingIncrease;
				buffer.AddLast(<cba6ec40-2546-4a46-9577-18d27987fd9e>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;
		}
	}
	internal class TypeDiscriminatingNodeDeserializer : <cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer
	{
		private readonly IList<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer> innerDeserializers;

		private readonly IList<ITypeDiscriminator> typeDiscriminators;

		private readonly int maxDepthToBuffer;

		private readonly int maxLengthToBuffer;

		public TypeDiscriminatingNodeDeserializer(IList<<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer> innerDeserializers, IList<ITypeDiscriminator> typeDiscriminators, int maxDepthToBuffer, int maxLengthToBuffer)
		{
			this.innerDeserializers = innerDeserializers;
			this.typeDiscriminators = typeDiscriminators;
			this.maxDepthToBuffer = maxDepthToBuffer;
			this.maxLengthToBuffer = maxLengthToBuffer;
		}

		public bool Deserialize(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser reader, Type expectedType, Func<<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser, Type, object?> nestedObjectDeserializer, out object? value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer rootDeserializer)
		{
			Type expectedType2 = expectedType;
			if (!reader.Accept<<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart>(out var _))
			{
				value = null;
				return false;
			}
			IEnumerable<ITypeDiscriminator> enumerable = typeDiscriminators.Where((ITypeDiscriminator t) => t.BaseType.IsAssignableFrom(expectedType2));
			if (!enumerable.Any())
			{
				value = null;
				return false;
			}
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = reader.Current.Start;
			Type expectedType3 = expectedType2;
			ParserBuffer parserBuffer;
			try
			{
				parserBuffer = new ParserBuffer(reader, maxDepthToBuffer, maxLengthToBuffer);
			}
			catch (Exception innerException)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = reader.Current.End;
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException(in start, in end, "Failed to buffer yaml node", innerException);
			}
			try
			{
				foreach (ITypeDiscriminator item in enumerable)
				{
					parserBuffer.Reset();
					if (item.TryDiscriminate(parserBuffer, out Type suggestedType))
					{
						expectedType3 = suggestedType;
						break;
					}
				}
			}
			catch (Exception innerException2)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = reader.Current.End;
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException(in start, in end, "Failed to discriminate type", innerException2);
			}
			parserBuffer.Reset();
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>INodeDeserializer innerDeserializer in innerDeserializers)
			{
				if (innerDeserializer.Deserialize(parserBuffer, expectedType3, nestedObjectDeserializer, out value, rootDeserializer))
				{
					return true;
				}
			}
			value = null;
			return false;
		}
	}
	internal class TypeDiscriminatingNodeDeserializerOptions : ITypeDiscriminatingNodeDeserializerOptions
	{
		internal readonly List<ITypeDiscriminator> discriminators = new List<ITypeDiscriminator>();

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

		public void AddKeyValueTypeDiscriminator<T>(string discriminatorKey, IDictionary<string, Type> valueTypeMapping)
		{
			discriminators.Add(new KeyValueTypeDiscriminator(typeof(T), discriminatorKey, valueTypeMapping));
		}

		public void AddUniqueKeyTypeDiscriminator<T>(IDictionary<string, Type> uniqueKeyTypeMapping)
		{
			discriminators.Add(new UniqueKeyTypeDiscriminator(typeof(T), uniqueKeyTypeMapping));
		}
	}
}
namespace YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators
{
	internal interface ITypeDiscriminator
	{
		Type BaseType { get; }

		bool TryDiscriminate(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser buffer, out Type? suggestedType);
	}
	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(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, out Type? suggestedType)
		{
			if (parser.TryFindMappingEntry((YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar scalar) => targetKey == scalar.Value, out YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar _, out <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent value) && value is YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar && typeMapping.TryGetValue(<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar.Value, out Type value2))
			{
				suggestedType = value2;
				return true;
			}
			suggestedType = null;
			return false;
		}
	}
	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(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, out Type? suggestedType)
		{
			if (parser.TryFindMappingEntry((YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar scalar) => typeMapping.ContainsKey(scalar.Value), out YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar key, out <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent _))
			{
				suggestedType = typeMapping[key.Value];
				return true;
			}
			suggestedType = null;
			return false;
		}
	}
}
namespace YamlDotNet.RepresentationModel
{
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentLoadingState
	{
		private readonly Dictionary<<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> anchors = new Dictionary<<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode>();

		private readonly List<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> nodesWithUnresolvedAliases = new List<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode>();

		public void AddAnchor(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode node)
		{
			if (node.Anchor.IsEmpty)
			{
				throw new ArgumentException("The specified node does not have an anchor");
			}
			anchors[node.Anchor] = node;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode GetNode(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName anchor, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
		{
			if (anchors.TryGetValue(anchor, out <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode value))
			{
				return value;
			}
			throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorNotFoundException(in start, in end, $"The anchor '{anchor}' does not exists");
		}

		public bool TryGetNode(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName anchor, [<cba6ec40-2546-4a46-9577-18d27987fd9e>NotNullWhen(true)] out <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode? node)
		{
			return anchors.TryGetValue(anchor, out node);
		}

		public void AddNodeWithUnresolvedAliases(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode node)
		{
			nodesWithUnresolvedAliases.Add(node);
		}

		public void ResolveAliases()
		{
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode nodesWithUnresolvedAlias in nodesWithUnresolvedAliases)
			{
				nodesWithUnresolvedAlias.ResolveAliases(this);
			}
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState
	{
		public HashSet<<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName> EmittedAnchors { get; } = new HashSet<<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName>();

	}
	internal interface <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlVisitor
	{
		void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlStream stream);

		void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument document);

		void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode scalar);

		void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSequenceNode sequence);

		void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode mapping);
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>LibYamlEventStream
	{
		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>LibYamlEventStream(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser iParser)
		{
			parser = iParser ?? throw new ArgumentNullException("iParser");
		}

		public void WriteTo(TextWriter textWriter)
		{
			while (parser.MoveNext())
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent current = parser.Current;
				if (!(current is YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias))
				{
					if (!(current is YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd))
					{
						if (!(current is YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart))
						{
							if (!(current is <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEnd))
							{
								if (!(current is <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart nodeEvent))
								{
									if (!(current is YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar))
									{
										if (!(current is <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEnd))
										{
											if (!(current is <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart nodeEvent2))
											{
												if (!(current is YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamEnd))
												{
													if (current is YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>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, <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar);
										switch (<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar.Style)
										{
										case <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.DoubleQuoted:
											textWriter.Write(" \"");
											break;
										case <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.SingleQuoted:
											textWriter.Write(" '");
											break;
										case <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Folded:
											textWriter.Write(" >");
											break;
										case <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Literal:
											textWriter.Write(" |");
											break;
										default:
											textWriter.Write(" :");
											break;
										}
										string value = <cba6ec40-2546-4a46-9577-18d27987fd9e>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 (!<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart.IsImplicit)
							{
								textWriter.Write(" ---");
							}
						}
					}
					else
					{
						textWriter.Write("-DOC");
						if (!<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd.IsImplicit)
						{
							textWriter.Write(" ...");
						}
					}
				}
				else
				{
					textWriter.Write("=ALI *");
					textWriter.Write(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias.Value);
				}
				textWriter.WriteLine();
			}
		}

		private static void WriteAnchorAndTag(TextWriter textWriter, <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAliasNode : <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode
	{
		public override <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNodeType NodeType => <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNodeType.Alias;

		internal <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAliasNode(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName anchor)
		{
			base.Anchor = anchor;
		}

		internal override void ResolveAliases(<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentLoadingState state)
		{
			throw new NotSupportedException("Resolving an alias on an alias node does not make sense");
		}

		internal override void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState state)
		{
			throw new NotSupportedException("A YamlAliasNode is an implementation detail and should never be saved.");
		}

		public override void Accept(<cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAliasNode <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAliasNode2 && Equals(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAliasNode2))
			{
				return object.Equals(base.Anchor, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAliasNode2.Anchor);
			}
			return false;
		}

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

		internal override string ToString(<cba6ec40-2546-4a46-9577-18d27987fd9e>RecursionLevel level)
		{
			return "*" + base.Anchor;
		}

		internal override IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> SafeAllNodes(<cba6ec40-2546-4a46-9577-18d27987fd9e>RecursionLevel level)
		{
			yield return this;
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument
	{
		private class AnchorAssigningVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlVisitorBase
		{
			private readonly HashSet<<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName> existingAnchors = new HashSet<<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName>();

			private readonly Dictionary<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, bool> visitedNodes = new Dictionary<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, bool>();

			public void AssignAnchors(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument document)
			{
				existingAnchors.Clear();
				visitedNodes.Clear();
				document.Accept(this);
				Random random = new Random();
				foreach (KeyValuePair<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, bool> visitedNode in visitedNodes)
				{
					if (!visitedNode.Value)
					{
						continue;
					}
					<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName;
					if (!visitedNode.Key.Anchor.IsEmpty && !existingAnchors.Contains(visitedNode.Key.Anchor))
					{
						<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName = visitedNode.Key.Anchor;
					}
					else
					{
						do
						{
							<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName = new <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName(random.Next().ToString(CultureInfo.InvariantCulture));
						}
						while (existingAnchors.Contains(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName));
					}
					existingAnchors.Add(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName);
					visitedNode.Key.Anchor = <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName;
				}
			}

			private bool VisitNodeAndFindDuplicates(<cba6ec40-2546-4a46-9577-18d27987fd9e>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(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode scalar)
			{
				VisitNodeAndFindDuplicates(scalar);
			}

			public override void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode mapping)
			{
				if (!VisitNodeAndFindDuplicates(mapping))
				{
					base.Visit(mapping);
				}
			}

			public override void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSequenceNode sequence)
			{
				if (!VisitNodeAndFindDuplicates(sequence))
				{
					base.Visit(sequence);
				}
			}
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode RootNode { get; private set; }

		public IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> AllNodes => RootNode.AllNodes;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode rootNode)
		{
			RootNode = rootNode;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument(string rootNode)
		{
			RootNode = new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode(rootNode);
		}

		internal <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentLoadingState <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentLoadingState2 = new <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentLoadingState();
			parser.Consume<YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart>();
			YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd @event;
			while (!parser.TryConsume<YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd>(out @event))
			{
				RootNode = <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode.ParseNode(parser, <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentLoadingState2);
				if (RootNode is <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAliasNode)
				{
					throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException("A document cannot contain only an alias");
				}
			}
			<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentLoadingState2.ResolveAliases();
			if (RootNode == null)
			{
				throw new ArgumentException("Atempted to parse an empty document");
			}
		}

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

		internal void Save(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, bool assignAnchors = true)
		{
			if (assignAnchors)
			{
				AssignAnchors();
			}
			emitter.Emit(new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart());
			RootNode.Save(emitter, new <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState());
			emitter.Emit(new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd(isImplicit: false));
		}

		public void Accept(<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode : <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, IEnumerable<KeyValuePair<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode>>, IEnumerable, <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlConvertible
	{
		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>OrderedDictionary<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> children = new <cba6ec40-2546-4a46-9577-18d27987fd9e>OrderedDictionary<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode>();

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>IOrderedDictionary<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> Children => children;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStyle Style { get; set; }

		public override <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNodeType NodeType => <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNodeType.Mapping;

		internal <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentLoadingState state)
		{
			Load(parser, state);
		}

		private void Load(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentLoadingState state)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart = parser.Consume<<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart>();
			Load(<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart, state);
			Style = <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart.Style;
			bool flag = false;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEnd @event;
			while (!parser.TryConsume<<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEnd>(out @event))
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode2 = <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode.ParseNode(parser, state);
				<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode3 = <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode.ParseNode(parser, state);
				if (!children.TryAdd(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode2, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode3))
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode2.Start;
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode2.End;
					throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException(in start, in end, $"Duplicate key {<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode2}");
				}
				flag = flag || <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode2 is <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAliasNode || <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode3 is <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAliasNode;
			}
			if (flag)
			{
				state.AddNodeWithUnresolvedAliases(this);
			}
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode()
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode(params KeyValuePair<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode>[] children)
			: this((IEnumerable<KeyValuePair<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode>>)children)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode(IEnumerable<KeyValuePair<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode>> children)
		{
			foreach (KeyValuePair<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> child in children)
			{
				this.children.Add(child);
			}
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode(params <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode[] children)
			: this((IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode>)children)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode(IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> children)
		{
			using IEnumerator<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> enumerator = children.GetEnumerator();
			while (enumerator.MoveNext())
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>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(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode key, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode value)
		{
			children.Add(key, value);
		}

		public void Add(string key, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode value)
		{
			children.Add(new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode(key), value);
		}

		public void Add(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode key, string value)
		{
			children.Add(key, new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode(value));
		}

		public void Add(string key, string value)
		{
			children.Add(new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode(key), new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode(value));
		}

		internal override void ResolveAliases(<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentLoadingState state)
		{
			Dictionary<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> dictionary = null;
			Dictionary<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> dictionary2 = null;
			foreach (KeyValuePair<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> child in children)
			{
				if (child.Key is <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAliasNode)
				{
					if (dictionary == null)
					{
						dictionary = new Dictionary<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode>();
					}
					dictionary.Add(child.Key, state.GetNode(child.Key.Anchor, child.Key.Start, child.Key.End));
				}
				if (child.Value is <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAliasNode)
				{
					if (dictionary2 == null)
					{
						dictionary2 = new Dictionary<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode>();
					}
					dictionary2.Add(child.Key, state.GetNode(child.Value.Anchor, child.Value.Start, child.Value.End));
				}
			}
			if (dictionary2 != null)
			{
				foreach (KeyValuePair<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> item in dictionary2)
				{
					children[item.Key] = item.Value;
				}
			}
			if (dictionary == null)
			{
				return;
			}
			foreach (KeyValuePair<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> item2 in dictionary)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode value = children[item2.Key];
				children.Remove(item2.Key);
				children.Add(item2.Value, value);
			}
		}

		internal override void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState state)
		{
			emitter.Emit(new <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart(base.Anchor, base.Tag, isImplicit: true, Style));
			foreach (KeyValuePair<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> child in children)
			{
				child.Key.Save(emitter, state);
				child.Value.Save(emitter, state);
			}
			emitter.Emit(new <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEnd());
		}

		public override void Accept(<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override bool Equals(object? obj)
		{
			if (!(obj is <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode2) || !object.Equals(base.Tag, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode2.Tag) || children.Count != <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode2.children.Count)
			{
				return false;
			}
			foreach (KeyValuePair<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> child in children)
			{
				if (!<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode2.children.TryGetValue(child.Key, out <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode value) || !object.Equals(child.Value, value))
				{
					return false;
				}
			}
			return true;
		}

		public override int GetHashCode()
		{
			int num = base.GetHashCode();
			foreach (KeyValuePair<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> child in children)
			{
				num = <cba6ec40-2546-4a46-9577-18d27987fd9e>HashCode.CombineHashCodes(num, child.Key);
				num = (child.Value.Anchor.IsEmpty ? <cba6ec40-2546-4a46-9577-18d27987fd9e>HashCode.CombineHashCodes(num, child.Value) : <cba6ec40-2546-4a46-9577-18d27987fd9e>HashCode.CombineHashCodes(num, child.Value.Anchor));
			}
			return num;
		}

		internal override IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> SafeAllNodes(<cba6ec40-2546-4a46-9577-18d27987fd9e>RecursionLevel level)
		{
			level.Increment();
			yield return this;
			foreach (KeyValuePair<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> child in children)
			{
				foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode item in child.Key.SafeAllNodes(level))
				{
					yield return item;
				}
				foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode item2 in child.Value.SafeAllNodes(level))
				{
					yield return item2;
				}
			}
			level.Decrement();
		}

		internal override string ToString(<cba6ec40-2546-4a46-9577-18d27987fd9e>RecursionLevel level)
		{
			if (!level.TryIncrement())
			{
				return "WARNING! INFINITE RECURSION!";
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				builder.Append("{ ");
				foreach (KeyValuePair<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> child in children)
				{
					if (builder.Length > 2)
					{
						builder.Append(", ");
					}
					builder.Append("{ ").Append(child.Key.ToString(level)).Append(", ")
						.Append(child.Value.ToString(level))
						.Append(" }");
				}
				builder.Append(" }");
				level.Decrement();
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		public IEnumerator<KeyValuePair<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode>> GetEnumerator()
		{
			return children.GetEnumerator();
		}

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

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlConvertible.Read(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type expectedType, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentLoadingState());
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlConvertible.Write(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState());
		}

		public static <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode FromObject(object mapping)
		{
			if (mapping == null)
			{
				throw new ArgumentNullException("mapping");
			}
			<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode2 = new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode();
			foreach (PropertyInfo publicProperty in <cba6ec40-2546-4a46-9577-18d27987fd9e>ReflectionExtensions.GetPublicProperties(mapping.GetType()))
			{
				if (publicProperty.CanRead && publicProperty.GetGetMethod(nonPublic: false).GetParameters().Length == 0)
				{
					object value = publicProperty.GetValue(mapping, null);
					<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode2 = value as <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode;
					if (<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode2 == null)
					{
						string text = Convert.ToString(value, CultureInfo.InvariantCulture);
						<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode2 = text ?? string.Empty;
					}
					<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode2.Add(publicProperty.Name, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode2);
				}
			}
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode2;
		}
	}
	internal abstract class <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode
	{
		private const int MaximumRecursionLevel = 1000;

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

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName Anchor { get; set; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName Tag { get; set; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark Start { get; private set; } = <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;


		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark End { get; private set; } = <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;


		public IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> AllNodes
		{
			get
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>RecursionLevel level = new <cba6ec40-2546-4a46-9577-18d27987fd9e>RecursionLevel(1000);
				return SafeAllNodes(level);
			}
		}

		public abstract <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNodeType NodeType { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode this[int index]
		{
			get
			{
				if (!(this is <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSequenceNode <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSequenceNode2))
				{
					throw new ArgumentException($"Accessed '{NodeType}' with an invalid index: {index}. Only Sequences can be indexed by number.");
				}
				return <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSequenceNode2.Children[index];
			}
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode this[<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode key]
		{
			get
			{
				if (!(this is <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode2))
				{
					throw new ArgumentException($"Accessed '{NodeType}' with an invalid index: {key}. Only Mappings can be indexed by key.");
				}
				return <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode2.Children[key];
			}
		}

		internal void Load(<cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent yamlEvent, <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentLoadingState state)
		{
			Tag = yamlEvent.Tag;
			if (!yamlEvent.Anchor.IsEmpty)
			{
				Anchor = yamlEvent.Anchor;
				state.AddAnchor(this);
			}
			Start = yamlEvent.Start;
			End = yamlEvent.End;
		}

		internal static <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode ParseNode(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentLoadingState state)
		{
			if (parser.Accept<YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar>(out var _))
			{
				return new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode(parser, state);
			}
			if (parser.Accept<<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart>(out var _))
			{
				return new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSequenceNode(parser, state);
			}
			if (parser.Accept<<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart>(out var _))
			{
				return new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode(parser, state);
			}
			if (parser.TryConsume<YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias>(out var event4))
			{
				if (!state.TryGetNode(event4.Value, out <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode node))
				{
					return new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAliasNode(event4.Value);
				}
				return node;
			}
			throw new ArgumentException("The current event is of an unsupported type.", "parser");
		}

		internal abstract void ResolveAliases(<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentLoadingState state);

		internal void Save(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState state)
		{
			if (!Anchor.IsEmpty && !state.EmittedAnchors.Add(Anchor))
			{
				emitter.Emit(new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias(Anchor));
			}
			else
			{
				Emit(emitter, state);
			}
		}

		internal abstract void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState state);

		public abstract void Accept(<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlVisitor visitor);

		public override string ToString()
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>RecursionLevel <cba6ec40-2546-4a46-9577-18d27987fd9e>RecursionLevel = new <cba6ec40-2546-4a46-9577-18d27987fd9e>RecursionLevel(1000);
			return ToString(<cba6ec40-2546-4a46-9577-18d27987fd9e>RecursionLevel);
		}

		internal abstract string ToString(<cba6ec40-2546-4a46-9577-18d27987fd9e>RecursionLevel level);

		internal abstract IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> SafeAllNodes(<cba6ec40-2546-4a46-9577-18d27987fd9e>RecursionLevel level);

		public static implicit operator <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode(string value)
		{
			return new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode(value);
		}

		public static implicit operator <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode(string[] sequence)
		{
			return new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSequenceNode(((IEnumerable<string>)sequence).Select((Func<string, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode>)((string i) => i)));
		}

		public static explicit operator string?(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode node)
		{
			if (!(node is <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode2))
			{
				throw new ArgumentException($"Attempted to convert a '{node.NodeType}' to string. This conversion is valid only for Scalars.");
			}
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode2.Value;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNodeIdentityEqualityComparer : IEqualityComparer<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode>
	{
		public bool Equals([<cba6ec40-2546-4a46-9577-18d27987fd9e>AllowNull] <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode x, [<cba6ec40-2546-4a46-9577-18d27987fd9e>AllowNull] <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode y)
		{
			return x == y;
		}

		public int GetHashCode(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode obj)
		{
			return obj.GetHashCode();
		}
	}
	internal enum <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNodeType
	{
		Alias,
		Mapping,
		Scalar,
		Sequence
	}
	[DebuggerDisplay("{Value}")]
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode : <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlConvertible
	{
		private bool forceImplicitPlain;

		private string? value;

		public string? Value
		{
			get
			{
				return value;
			}
			set
			{
				if (value == null)
				{
					forceImplicitPlain = true;
				}
				else
				{
					forceImplicitPlain = false;
				}
				this.value = value;
			}
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle Style { get; set; }

		public override <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNodeType NodeType => <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNodeType.Scalar;

		internal <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentLoadingState state)
		{
			Load(parser, state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void Load(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentLoadingState state)
		{
			YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar = parser.Consume<YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar>();
			Load(<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar, state);
			string text = <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar.Value;
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar.Style == <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Plain && base.Tag.IsEmpty)
			{
				forceImplicitPlain = text.Length switch
				{
					0 => true, 
					1 => text == "~", 
					4 => text == "null" || text == "Null" || text == "NULL", 
					_ => false, 
				};
			}
			value = text;
			Style = <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar.Style;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode()
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode(string? value)
		{
			Value = value;
		}

		internal override void ResolveAliases(<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentLoadingState state)
		{
			throw new NotSupportedException("Resolving an alias on a scalar node does not make sense");
		}

		internal override void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState state)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>TagName tag = base.Tag;
			bool isPlainImplicit = tag.IsEmpty;
			if (forceImplicitPlain && Style == <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Plain && (Value == null || Value == ""))
			{
				tag = <cba6ec40-2546-4a46-9577-18d27987fd9e>JsonSchema.Tags.Null;
				isPlainImplicit = true;
			}
			else if (tag.IsEmpty && Value == null && (Style == <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Plain || Style == <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Any))
			{
				tag = <cba6ec40-2546-4a46-9577-18d27987fd9e>JsonSchema.Tags.Null;
				isPlainImplicit = true;
			}
			emitter.Emit(new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar(base.Anchor, tag, Value ?? string.Empty, Style, isPlainImplicit, isQuotedImplicit: false));
		}

		public override void Accept(<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override bool Equals(object? obj)
		{
			if (obj is <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode2 && object.Equals(base.Tag, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode2.Tag))
			{
				return object.Equals(Value, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode2.Value);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>HashCode.CombineHashCodes(base.Tag.GetHashCode(), Value);
		}

		public static explicit operator string?(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode value)
		{
			return value.Value;
		}

		internal override string ToString(<cba6ec40-2546-4a46-9577-18d27987fd9e>RecursionLevel level)
		{
			return Value ?? string.Empty;
		}

		internal override IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> SafeAllNodes(<cba6ec40-2546-4a46-9577-18d27987fd9e>RecursionLevel level)
		{
			yield return this;
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlConvertible.Read(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type expectedType, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentLoadingState());
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlConvertible.Write(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState());
		}
	}
	[DebuggerDisplay("Count = {children.Count}")]
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSequenceNode : <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode>, IEnumerable, <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlConvertible
	{
		private readonly List<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> children = new List<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode>();

		public IList<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> Children => children;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStyle Style { get; set; }

		public override <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNodeType NodeType => <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNodeType.Sequence;

		internal <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSequenceNode(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentLoadingState state)
		{
			Load(parser, state);
		}

		private void Load(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentLoadingState state)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart = parser.Consume<<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart>();
			Load(<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart, state);
			Style = <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart.Style;
			bool flag = false;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEnd @event;
			while (!parser.TryConsume<<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEnd>(out @event))
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode2 = <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode.ParseNode(parser, state);
				children.Add(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode2);
				flag = flag || <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode2 is <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAliasNode;
			}
			if (flag)
			{
				state.AddNodeWithUnresolvedAliases(this);
			}
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSequenceNode()
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSequenceNode(params <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode[] children)
			: this((IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode>)children)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSequenceNode(IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> children)
		{
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode child in children)
			{
				this.children.Add(child);
			}
		}

		public void Add(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode child)
		{
			children.Add(child);
		}

		public void Add(string child)
		{
			children.Add(new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode(child));
		}

		internal override void ResolveAliases(<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentLoadingState state)
		{
			for (int i = 0; i < children.Count; i++)
			{
				if (children[i] is <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlAliasNode)
				{
					children[i] = state.GetNode(children[i].Anchor, children[i].Start, children[i].End);
				}
			}
		}

		internal override void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState state)
		{
			emitter.Emit(new <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart(base.Anchor, base.Tag, base.Tag.IsEmpty, Style));
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode child in children)
			{
				child.Save(emitter, state);
			}
			emitter.Emit(new <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEnd());
		}

		public override void Accept(<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override bool Equals(object? obj)
		{
			if (!(obj is <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSequenceNode <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSequenceNode2) || !object.Equals(base.Tag, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSequenceNode2.Tag) || children.Count != <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSequenceNode2.children.Count)
			{
				return false;
			}
			for (int i = 0; i < children.Count; i++)
			{
				if (!object.Equals(children[i], <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSequenceNode2.children[i]))
				{
					return false;
				}
			}
			return true;
		}

		public override int GetHashCode()
		{
			int h = 0;
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode child in children)
			{
				h = <cba6ec40-2546-4a46-9577-18d27987fd9e>HashCode.CombineHashCodes(h, child);
			}
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>HashCode.CombineHashCodes(h, base.Tag);
		}

		internal override IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> SafeAllNodes(<cba6ec40-2546-4a46-9577-18d27987fd9e>RecursionLevel level)
		{
			level.Increment();
			yield return this;
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode child in children)
			{
				foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode item in child.SafeAllNodes(level))
				{
					yield return item;
				}
			}
			level.Decrement();
		}

		internal override string ToString(<cba6ec40-2546-4a46-9577-18d27987fd9e>RecursionLevel level)
		{
			if (!level.TryIncrement())
			{
				return "WARNING! INFINITE RECURSION!";
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				builder.Append("[ ");
				foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>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<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> GetEnumerator()
		{
			return Children.GetEnumerator();
		}

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

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlConvertible.Read(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Type expectedType, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentLoadingState());
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlConvertible.Write(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, <cba6ec40-2546-4a46-9577-18d27987fd9e>ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState());
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlStream : IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument>, IEnumerable
	{
		private readonly List<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument> documents = new List<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument>();

		public IList<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument> Documents => documents;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlStream()
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlStream(params <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument[] documents)
			: this((IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument>)documents)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlStream(IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument> documents)
		{
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument document in documents)
			{
				this.documents.Add(document);
			}
		}

		public void Add(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument document)
		{
			documents.Add(document);
		}

		public void Load(TextReader input)
		{
			Load(new <cba6ec40-2546-4a46-9577-18d27987fd9e>Parser(input));
		}

		public void Load(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser)
		{
			documents.Clear();
			parser.Consume<YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamStart>();
			YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamEnd @event;
			while (!parser.TryConsume<YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamEnd>(out @event))
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument item = new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument(parser);
				documents.Add(item);
			}
		}

		public void Save(TextWriter output)
		{
			Save(output, assignAnchors: true);
		}

		public void Save(TextWriter output, bool assignAnchors)
		{
			Save(new <cba6ec40-2546-4a46-9577-18d27987fd9e>Emitter(output), assignAnchors);
		}

		public void Save(<cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter emitter, bool assignAnchors)
		{
			emitter.Emit(new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamStart());
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument document in documents)
			{
				document.Save(emitter, assignAnchors);
			}
			emitter.Emit(new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamEnd());
		}

		public void Accept(<cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public IEnumerator<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument> GetEnumerator()
		{
			return documents.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	[Obsolete("Use YamlVisitorBase")]
	internal abstract class <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlVisitor : <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlVisitor
	{
		protected virtual void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlStream stream)
		{
		}

		protected virtual void Visited(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlStream stream)
		{
		}

		protected virtual void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument document)
		{
		}

		protected virtual void Visited(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument document)
		{
		}

		protected virtual void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode scalar)
		{
		}

		protected virtual void Visited(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode scalar)
		{
		}

		protected virtual void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSequenceNode sequence)
		{
		}

		protected virtual void Visited(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSequenceNode sequence)
		{
		}

		protected virtual void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode mapping)
		{
		}

		protected virtual void Visited(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode mapping)
		{
		}

		protected virtual void VisitChildren(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlStream stream)
		{
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument document in stream.Documents)
			{
				document.Accept(this);
			}
		}

		protected virtual void VisitChildren(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument document)
		{
			if (document.RootNode != null)
			{
				document.RootNode.Accept(this);
			}
		}

		protected virtual void VisitChildren(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSequenceNode sequence)
		{
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode child in sequence.Children)
			{
				child.Accept(this);
			}
		}

		protected virtual void VisitChildren(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode mapping)
		{
			foreach (KeyValuePair<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> child in mapping.Children)
			{
				child.Key.Accept(this);
				child.Value.Accept(this);
			}
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlVisitor.Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlStream stream)
		{
			Visit(stream);
			VisitChildren(stream);
			Visited(stream);
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlVisitor.Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument document)
		{
			Visit(document);
			VisitChildren(document);
			Visited(document);
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlVisitor.Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode scalar)
		{
			Visit(scalar);
			Visited(scalar);
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlVisitor.Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSequenceNode sequence)
		{
			Visit(sequence);
			VisitChildren(sequence);
			Visited(sequence);
		}

		void <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlVisitor.Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode mapping)
		{
			Visit(mapping);
			VisitChildren(mapping);
			Visited(mapping);
		}
	}
	internal abstract class <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlVisitorBase : <cba6ec40-2546-4a46-9577-18d27987fd9e>IYamlVisitor
	{
		public virtual void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlStream stream)
		{
			VisitChildren(stream);
		}

		public virtual void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument document)
		{
			VisitChildren(document);
		}

		public virtual void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlScalarNode scalar)
		{
		}

		public virtual void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSequenceNode sequence)
		{
			VisitChildren(sequence);
		}

		public virtual void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode mapping)
		{
			VisitChildren(mapping);
		}

		protected virtual void VisitPair(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode key, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode value)
		{
			key.Accept(this);
			value.Accept(this);
		}

		protected virtual void VisitChildren(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlStream stream)
		{
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument document in stream.Documents)
			{
				document.Accept(this);
			}
		}

		protected virtual void VisitChildren(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlDocument document)
		{
			if (document.RootNode != null)
			{
				document.RootNode.Accept(this);
			}
		}

		protected virtual void VisitChildren(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlSequenceNode sequence)
		{
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode child in sequence.Children)
			{
				child.Accept(this);
			}
		}

		protected virtual void VisitChildren(<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlMappingNode mapping)
		{
			foreach (KeyValuePair<<cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode, <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlNode> child in mapping.Children)
			{
				VisitPair(child.Key, child.Value);
			}
		}
	}
}
namespace YamlDotNet.Helpers
{
	internal class DefaultFsharpHelper : IFsharpHelper
	{
		private static bool IsFsharpCore(Type t)
		{
			return t.Namespace == "Microsoft.FSharp.Core";
		}

		public bool IsOptionType(Type t)
		{
			if (IsFsharpCore(t))
			{
				return t.Name == "FSharpOption`1";
			}
			return false;
		}

		public Type? GetOptionUnderlyingType(Type t)
		{
			if (!t.IsGenericType || !IsOptionType(t))
			{
				return null;
			}
			return t.GenericTypeArguments[0];
		}

		public object? GetValue(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor objectDescriptor)
		{
			if (!IsOptionType(objectDescriptor.Type))
			{
				throw new InvalidOperationException("Should not be called on non-Option<> type");
			}
			if (objectDescriptor.Value == null)
			{
				return null;
			}
			return objectDescriptor.Type.GetProperty("Value").GetValue(objectDescriptor.Value);
		}

		public bool IsFsharpListType(Type t)
		{
			if (t.Namespace == "Microsoft.FSharp.Collections")
			{
				return t.Name == "FSharpList`1";
			}
			return false;
		}

		public object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr)
		{
			if (!IsFsharpListType(t))
			{
				return null;
			}
			return t.Assembly.GetType("Microsoft.FSharp.Collections.ListModule").GetMethod("OfArray").MakeGenericMethod(itemsType)
				.Invoke(null, new object[1] { arr });
		}
	}
	internal static class DictionaryExtensions
	{
		public static bool TryAdd<T, V>(this Dictionary<T, V> dictionary, T key, V value)
		{
			if (dictionary.ContainsKey(key))
			{
				return false;
			}
			dictionary.Add(key, value);
			return true;
		}

		public static TValue GetOrAdd<TKey, TValue, TArg>(this ConcurrentDictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TArg, TValue> valueFactory, TArg arg)
		{
			if (dictionary == null)
			{
				throw new ArgumentNullException("dictionary");
			}
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			if (valueFactory == null)
			{
				throw new ArgumentNullException("valueFactory");
			}
			TValue value;
			do
			{
				if (dictionary.TryGetValue(key, out value))
				{
					return value;
				}
				value = valueFactory(key, arg);
			}
			while (!dictionary.TryAdd(key, value));
			return value;
		}
	}
	internal static class <cba6ec40-2546-4a46-9577-18d27987fd9e>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: <cba6ec40-2546-4a46-9577-18d27987fd9e>MaybeNull]
		private static TMemberInfo TryGetMemberExpression<TMemberInfo>(LambdaExpression lambdaExpression) where TMemberInfo : MemberInfo
		{
			if (lambdaExpression.Parameters.Count != 1)
			{
				return null;
			}
			Expression expression = lambdaExpression.Body;
			if (expression is UnaryExpression unaryExpression)
			{
				if (unaryExpression.NodeType != ExpressionType.Convert)
				{
					return null;
				}
				expression = unaryExpression.Operand;
			}
			if (expression is MemberExpression memberExpression)
			{
				if (memberExpression.Expression != lambdaExpression.Parameters[0])
				{
					return null;
				}
				return memberExpression.Member as TMemberInfo;
			}
			return null;
		}
	}
	internal static class FsharpHelper
	{
		public static IFsharpHelper? Instance { get; set; }

		public static bool IsOptionType(Type t)
		{
			return Instance?.IsOptionType(t) ?? false;
		}

		public static Type? GetOptionUnderlyingType(Type t)
		{
			return Instance?.GetOptionUnderlyingType(t);
		}

		public static object? GetValue(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor objectDescriptor)
		{
			return Instance?.GetValue(objectDescriptor);
		}

		public static bool IsFsharpListType(Type t)
		{
			return Instance?.IsFsharpListType(t) ?? false;
		}

		public static object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr)
		{
			return Instance?.CreateFsharpListFromArray(t, itemsType, arr);
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>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 IFsharpHelper
	{
		bool IsOptionType(Type t);

		Type? GetOptionUnderlyingType(Type t);

		object? GetValue(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor objectDescriptor);

		bool IsFsharpListType(Type t);

		object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr);
	}
	internal interface <cba6ec40-2546-4a46-9577-18d27987fd9e>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 class NullFsharpHelper : IFsharpHelper
	{
		public object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr)
		{
			return null;
		}

		public Type? GetOptionUnderlyingType(Type t)
		{
			return null;
		}

		public object? GetValue(<cba6ec40-2546-4a46-9577-18d27987fd9e>IObjectDescriptor objectDescriptor)
		{
			return null;
		}

		public bool IsFsharpListType(Type t)
		{
			return false;
		}

		public bool IsOptionType(Type t)
		{
			return false;
		}
	}
	internal static class <cba6ec40-2546-4a46-9577-18d27987fd9e>NumberExtensions
	{
		public static bool IsPowerOfTwo(this int value)
		{
			return (value & (value - 1)) == 0;
		}
	}
	[Serializable]
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>OrderedDictionary<TKey, TValue> : <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>OrderedDictionary<TKey, TValue> orderedDictionary;

			public int Count => orderedDictionary.list.Count;

			public bool IsReadOnly => true;

			public void Add(TKey item)
			{
				throw new NotSupportedException();
			}

			public void Clear()
			{
				throw new NotSupportedException();
			}

			public bool Contains(TKey item)
			{
				return orderedDictionary.dictionary.ContainsKey(item);
			}

			public KeyCollection(<cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>OrderedDictionary<TKey, TValue> orderedDictionary;

			public int Count => orderedDictionary.list.Count;

			public bool IsReadOnly => true;

			public void Add(TValue item)
			{
				throw new NotSupportedException();
			}

			public void Clear()
			{
				throw new NotSupportedException();
			}

			public bool Contains(TValue item)
			{
				return orderedDictionary.dictionary.ContainsValue(item);
			}

			public ValueCollection(<cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>OrderedDictionary()
			: this((IEqualityComparer<TKey>)EqualityComparer<TKey>.Default)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>OrderedDictionary(IEqualityComparer<TKey> comparer)
		{
			list = new List<KeyValuePair<TKey, TValue>>();
			dictionary = new Dictionary<TKey, TValue>(comparer);
			this.comparer = comparer;
		}

		public void Add(KeyValuePair<TKey, TValue> item)
		{
			if (!TryAdd(item))
			{
				ThrowDuplicateKeyException(item.Key);
			}
		}

		public void Add(TKey key, TValue value)
		{
			if (!TryAdd(key, value))
			{
				ThrowDuplicateKeyException(key);
			}
		}

		private static void ThrowDuplicateKeyException(TKey key)
		{
			throw new ArgumentException($"An item with the same key {key} has already been added.");
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryAdd(TKey key, TValue value)
		{
			if (DictionaryExtensions.TryAdd(dictionary, key, value))
			{
				list.Add(new KeyValuePair<TKey, TValue>(key, value));
				return true;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryAdd(KeyValuePair<TKey, TValue> item)
		{
			if (DictionaryExtensions.TryAdd(dictionary, item.Key, item.Value))
			{
				list.Add(item);
				return true;
			}
			return false;
		}

		public void Clear()
		{
			dictionary.Clear();
			list.Clear();
		}

		public bool Contains(KeyValuePair<TKey, TValue> item)
		{
			return dictionary.Contains(item);
		}

		public bool ContainsKey(TKey key)
		{
			return dictionary.ContainsKey(key);
		}

		public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			list.CopyTo(array, arrayIndex);
		}

		public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
		{
			return list.GetEnumerator();
		}

		public void Insert(int index, TKey key, TValue value)
		{
			dictionary.Add(key, value);
			list.Insert(index, new KeyValuePair<TKey, TValue>(key, value));
		}

		public bool Remove(TKey key)
		{
			TKey key2 = key;
			if (dictionary.ContainsKey(key2))
			{
				int index = list.FindIndex((KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key2));
				list.RemoveAt(index);
				if (!dictionary.Remove(key2))
				{
					throw new InvalidOperationException();
				}
				return true;
			}
			return false;
		}

		public bool Remove(KeyValuePair<TKey, TValue> item)
		{
			return Remove(item.Key);
		}

		public void RemoveAt(int index)
		{
			TKey key = list[index].Key;
			dictionary.Remove(key);
			list.RemoveAt(index);
		}

		public bool TryGetValue(TKey key, [<cba6ec40-2546-4a46-9577-18d27987fd9e>MaybeNullWhen(false)] out TValue value)
		{
			return dictionary.TryGetValue(key, out value);
		}

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

		[System.Runtime.Serialization.OnDeserialized]
		internal void OnDeserializedMethod(StreamingContext context)
		{
			dictionary = new Dictionary<TKey, TValue>();
			foreach (KeyValuePair<TKey, TValue> item in list)
			{
				dictionary[item.Key] = item.Value;
			}
		}
	}
	internal static class <cba6ec40-2546-4a46-9577-18d27987fd9e>ReadOnlyCollectionExtensions
	{
		public static IReadOnlyList<T> AsReadonlyList<T>(this List<T> list)
		{
			return list;
		}

		public static IReadOnlyDictionary<TKey, TValue> AsReadonlyDictionary<TKey, TValue>(this Dictionary<TKey, TValue> dictionary) where TKey : notnull
		{
			return dictionary;
		}
	}
	internal static class ThrowHelper
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void ThrowArgumentOutOfRangeException(string paramName, string message)
		{
			throw new ArgumentOutOfRangeException(paramName, message);
		}
	}
}
namespace YamlDotNet.Core
{
	public readonly struct <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName : IEquatable<<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName>
	{
		public static readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName Empty;

		private static readonly Regex AnchorPattern = new Regex("^[^\\[\\]\\{\\},]+$", RegexOptions.Compiled);

		private readonly string? value;

		public string Value => value ?? throw new InvalidOperationException("Cannot read the Value of an empty anchor");

		public bool IsEmpty => value == null;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>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(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName other)
		{
			return object.Equals(value, other.value);
		}

		public override bool Equals(object? obj)
		{
			if (obj is <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return value?.GetHashCode() ?? 0;
		}

		public static bool operator ==(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName left, <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName left, <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName right)
		{
			return !(left == right);
		}

		public static implicit operator <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName(string? value)
		{
			if (value != null)
			{
				return new <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName(value);
			}
			return Empty;
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorNotFoundException : <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorNotFoundException(string message)
			: base(message)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorNotFoundException(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorNotFoundException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[DebuggerStepThrough]
	internal readonly struct <cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer<TBuffer> where TBuffer : <cba6ec40-2546-4a46-9577-18d27987fd9e>ILookAheadBuffer
	{
		public TBuffer Buffer { get; }

		public bool EndOfInput => Buffer.EndOfInput;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer(TBuffer buffer)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer");
			}
			Buffer = buffer;
		}

		public char Peek(int offset)
		{
			return Buffer.Peek(offset);
		}

		public void Skip(int length)
		{
			Buffer.Skip(length);
		}

		public bool IsAlphaNumericDashOrUnderscore(int offset = 0)
		{
			char c = Buffer.Peek(offset);
			if ((c < '0' || c > '9') && (c < 'A' || c > 'Z') && (c < 'a' || c > 'z') && c != '_')
			{
				return c == '-';
			}
			return true;
		}

		public bool IsAscii(int offset = 0)
		{
			return Buffer.Peek(offset) <= '\u007f';
		}

		public bool IsPrintable(int offset = 0)
		{
			char c = Buffer.Peek(offset);
			switch (c)
			{
			default:
				if (c != '\u0085' && (c < '\u00a0' || c > '\ud7ff'))
				{
					if (c >= '\ue000')
					{
						return c <= '\ufffd';
					}
					return false;
				}
				break;
			case '\t':
			case '\n':
			case '\r':
			case ' ':
			case '!':
			case '"':
			case '#':
			case '$':
			case '%':
			case '&':
			case '\'':
			case '(':
			case ')':
			case '*':
			case '+':
			case ',':
			case '-':
			case '.':
			case '/':
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			case ':':
			case ';':
			case '<':
			case '=':
			case '>':
			case '?':
			case '@':
			case 'A':
			case 'B':
			case 'C':
			case 'D':
			case 'E':
			case 'F':
			case 'G':
			case 'H':
			case 'I':
			case 'J':
			case 'K':
			case 'L':
			case 'M':
			case 'N':
			case 'O':
			case 'P':
			case 'Q':
			case 'R':
			case 'S':
			case 'T':
			case 'U':
			case 'V':
			case 'W':
			case 'X':
			case 'Y':
			case 'Z':
			case '[':
			case '\\':
			case ']':
			case '^':
			case '_':
			case '`':
			case 'a':
			case 'b':
			case 'c':
			case 'd':
			case 'e':
			case 'f':
			case 'g':
			case 'h':
			case 'i':
			case 'j':
			case 'k':
			case 'l':
			case 'm':
			case 'n':
			case 'o':
			case 'p':
			case 'q':
			case 'r':
			case 's':
			case 't':
			case 'u':
			case 'v':
			case 'w':
			case 'x':
			case 'y':
			case 'z':
			case '{':
			case '|':
			case '}':
			case '~':
				break;
			}
			return true;
		}

		public bool IsDigit(int offset = 0)
		{
			char c = Buffer.Peek(offset);
			if (c >= '0')
			{
				return c <= '9';
			}
			return false;
		}

		public int AsDigit(int offset = 0)
		{
			return Buffer.Peek(offset) - 48;
		}

		public bool IsHex(int offset)
		{
			char c = Buffer.Peek(offset);
			if ((c < '0' || c > '9') && (c < 'A' || c > 'F'))
			{
				if (c >= 'a')
				{
					return c <= 'f';
				}
				return false;
			}
			return true;
		}

		public int AsHex(int offset)
		{
			char c = Buffer.Peek(offset);
			if (c <= '9')
			{
				return c - 48;
			}
			if (c <= 'F')
			{
				return c - 65 + 10;
			}
			return c - 97 + 10;
		}

		public bool IsSpace(int offset = 0)
		{
			return Check(' ', offset);
		}

		public bool IsZero(int offset = 0)
		{
			return Check('\0', offset);
		}

		public bool IsTab(int offset = 0)
		{
			return Check('\t', offset);
		}

		public bool IsWhite(int offset = 0)
		{
			if (!IsSpace(offset))
			{
				return IsTab(offset);
			}
			return true;
		}

		public bool IsBreak(int offset = 0)
		{
			return Check("\r\n\u0085\u2028\u2029", offset);
		}

		public bool IsCrLf(int offset = 0)
		{
			if (Check('\r', offset))
			{
				return Check('\n', offset + 1);
			}
			return false;
		}

		public bool IsBreakOrZero(int offset = 0)
		{
			if (!IsBreak(offset))
			{
				return IsZero(offset);
			}
			return true;
		}

		public bool IsWhiteBreakOrZero(int offset = 0)
		{
			if (!IsWhite(offset))
			{
				return IsBreakOrZero(offset);
			}
			return true;
		}

		public bool Check(char expected, int offset = 0)
		{
			return Buffer.Peek(offset) == expected;
		}

		public bool Check(string expectedCharacters, int offset = 0)
		{
			char c = Buffer.Peek(offset);
			return Polyfills.Contains(expectedCharacters, c);
		}
	}
	internal static class <cba6ec40-2546-4a46-9577-18d27987fd9e>Constants
	{
		public static readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective[] DefaultTagDirectives = new <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective[2]
		{
			new <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective("!", "!"),
			new <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective("!!", "tag:yaml.org,2002:")
		};

		public const int MajorVersion = 1;

		public const int MinorVersion = 3;
	}
	[DebuggerStepThrough]
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>Cursor
	{
		public long Index { get; private set; }

		public long Line { get; private set; }

		public long LineOffset { get; private set; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Cursor()
		{
			Line = 1L;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Cursor(<cba6ec40-2546-4a46-9577-18d27987fd9e>Cursor cursor)
		{
			Index = cursor.Index;
			Line = cursor.Line;
			LineOffset = cursor.LineOffset;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark Mark()
		{
			return new <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark(Index, Line, LineOffset + 1);
		}

		public void Skip()
		{
			Index++;
			LineOffset++;
		}

		public void SkipLineByOffset(int offset)
		{
			Index += offset;
			Line++;
			LineOffset = 0L;
		}

		public void ForceSkipLineAfterNonBreak()
		{
			if (LineOffset != 0L)
			{
				Line++;
				LineOffset = 0L;
			}
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>Emitter : <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter
	{
		private class AnchorData
		{
			public <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState state;

		private readonly Stack<<cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState> states = new Stack<<cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState>();

		private readonly Queue<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> events = new Queue<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent>();

		private readonly Stack<int> indents = new Stack<int>();

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection tagDirectives = new <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection();

		private int indent;

		private int flowLevel;

		private bool isMappingContext;

		private bool isSimpleKeyContext;

		private int column;

		private bool isWhitespace;

		private bool isIndentation;

		private readonly bool forceIndentLess;

		private readonly bool useUtf16SurrogatePair;

		private bool isDocumentEndWritten;

		private readonly AnchorData anchorData = new AnchorData();

		private readonly TagData tagData = new TagData();

		private readonly ScalarData scalarData = new ScalarData();

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Emitter(TextWriter output)
			: this(output, <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings.Default)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Emitter(TextWriter output, int bestIndent)
			: this(output, bestIndent, int.MaxValue)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Emitter(TextWriter output, int bestIndent, int bestWidth)
			: this(output, bestIndent, bestWidth, isCanonical: false)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Emitter(TextWriter output, int bestIndent, int bestWidth, bool isCanonical)
			: this(output, new <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings(bestIndent, bestWidth, isCanonical, 1024))
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Emitter(TextWriter output, <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings settings)
		{
			bestIndent = settings.BestIndent;
			bestWidth = settings.BestWidth;
			isCanonical = settings.IsCanonical;
			maxSimpleKeyLength = settings.MaxSimpleKeyLength;
			skipAnchorName = settings.SkipAnchorName;
			forceIndentLess = !settings.IndentSequences;
			useUtf16SurrogatePair = settings.UseUtf16SurrogatePairs;
			this.output = output;
			this.output.NewLine = settings.NewLine;
			outputUsesUnicodeEncoding = IsUnicode(output.Encoding);
		}

		public void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent @event)
		{
			events.Enqueue(@event);
			while (!NeedMoreEvents())
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.DocumentStart:
				num = 1;
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.SequenceStart:
				num = 2;
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.MappingStart:
				num = 3;
				break;
			default:
				return false;
			}
			if (events.Count > num)
			{
				return false;
			}
			int num2 = 0;
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent @event in events)
			{
				switch (@event.Type)
				{
				case <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.DocumentStart:
				case <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.SequenceStart:
				case <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.MappingStart:
					num2++;
					break;
				case <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.DocumentEnd:
				case <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.SequenceEnd:
				case <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.MappingEnd:
					num2--;
					break;
				}
				if (num2 == 0)
				{
					return false;
				}
			}
			return true;
		}

		private void AnalyzeEvent(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent evt)
		{
			anchorData.Anchor = <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName.Empty;
			tagData.Handle = null;
			tagData.Suffix = null;
			if (evt is YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias)
			{
				AnalyzeAnchor(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias.Value, isAlias: true);
			}
			else if (evt is <cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent <cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent)
			{
				if (evt is YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar scalar)
				{
					AnalyzeScalar(scalar);
				}
				AnalyzeAnchor(<cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent.Anchor, isAlias: false);
				if (!<cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent.Tag.IsEmpty && (isCanonical || <cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent.IsCanonical))
				{
					AnalyzeTag(<cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent.Tag);
				}
			}
		}

		private void AnalyzeAnchor(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName anchor, bool isAlias)
		{
			anchorData.Anchor = anchor;
			anchorData.IsAlias = isAlias;
		}

		private void AnalyzeScalar(YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar scalar)
		{
			string value = scalar.Value;
			scalarData.Value = value;
			if (value.Length == 0)
			{
				if (scalar.Tag == "tag:yaml.org,2002:null")
				{
					scalarData.IsMultiline = false;
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = true;
					scalarData.IsSingleQuotedAllowed = false;
					scalarData.IsBlockAllowed = false;
				}
				else
				{
					scalarData.IsMultiline = false;
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = false;
					scalarData.IsSingleQuotedAllowed = true;
					scalarData.IsBlockAllowed = false;
				}
				return;
			}
			bool flag = false;
			bool flag2 = false;
			if (value.StartsWith("---", StringComparison.Ordinal) || value.StartsWith("...", StringComparison.Ordinal))
			{
				flag = true;
				flag2 = true;
			}
			StringLookAheadBufferPool.BufferWrapper bufferWrapper = StringLookAheadBufferPool.Rent(value);
			try
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer<<cba6ec40-2546-4a46-9577-18d27987fd9e>StringLookAheadBuffer> <cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2 = new <cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer<<cba6ec40-2546-4a46-9577-18d27987fd9e>StringLookAheadBuffer>(bufferWrapper.Buffer);
				bool flag3 = true;
				bool flag4 = <cba6ec40-2546-4a46-9577-18d27987fd9e>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 (!<cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2.EndOfInput)
				{
					if (flag19)
					{
						if (<cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2.Check("#,[]{}&*!|>\"%@`'"))
						{
							flag = true;
							flag2 = true;
							flag9 = <cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2.Check('\'');
							flag17 |= <cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2.Check('\'');
						}
						if (<cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2.Check("?:"))
						{
							flag = true;
							if (flag4)
							{
								flag2 = true;
							}
						}
						if (<cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2.Check('-') && flag4)
						{
							flag = true;
							flag2 = true;
						}
					}
					else
					{
						if (<cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2.Check(",?[]{}"))
						{
							flag = true;
						}
						if (<cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2.Check(':'))
						{
							flag = true;
							if (flag4)
							{
								flag2 = true;
							}
						}
						if (<cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2.Check('#') && flag3)
						{
							flag = true;
							flag2 = true;
						}
						flag17 |= <cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2.Check('\'');
					}
					if (!flag16 && !<cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2.IsPrintable())
					{
						flag16 = true;
					}
					if (<cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2.IsBreak())
					{
						flag15 = true;
					}
					if (<cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2.IsSpace())
					{
						if (flag19)
						{
							flag5 = true;
						}
						if (<cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2.Buffer.Position >= <cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2.Buffer.Length - 1)
						{
							flag7 = true;
						}
						if (flag13)
						{
							flag10 = true;
							flag14 = true;
						}
						flag12 = true;
						flag13 = false;
					}
					else if (<cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2.IsBreak())
					{
						if (flag19)
						{
							flag6 = true;
						}
						if (<cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2.Buffer.Position >= <cba6ec40-2546-4a46-9577-18d27987fd9e>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 = <cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2.IsWhiteBreakOrZero();
					<cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2.Skip(1);
					if (!<cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2.EndOfInput)
					{
						flag4 = <cba6ec40-2546-4a46-9577-18d27987fd9e>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;
			}
			finally
			{
				((IDisposable)bufferWrapper).Dispose();
			}
		}

		private bool ValueIsRepresentableInOutputEncoding(string value)
		{
			if (outputUsesUnicodeEncoding)
			{
				return true;
			}
			try
			{
				byte[] bytes = output.Encoding.GetBytes(value);
				string @string = output.Encoding.GetString(bytes, 0, bytes.Length);
				return @string.Equals(value);
			}
			catch (EncoderFallbackException)
			{
				return false;
			}
			catch (ArgumentOutOfRangeException)
			{
				return false;
			}
		}

		private static bool IsUnicode(Encoding encoding)
		{
			if (!(encoding is UTF8Encoding) && !(encoding is UnicodeEncoding))
			{
				return encoding is UTF7Encoding;
			}
			return true;
		}

		private void AnalyzeTag(<cba6ec40-2546-4a46-9577-18d27987fd9e>TagName tag)
		{
			tagData.Handle = tag.Value;
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>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(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent evt)
		{
			if (evt is YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Comment comment)
			{
				EmitComment(comment);
				return;
			}
			switch (state)
			{
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.StreamStart:
				EmitStreamStart(evt);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.FirstDocumentStart:
				EmitDocumentStart(evt, isFirst: true);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.DocumentStart:
				EmitDocumentStart(evt, isFirst: false);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.DocumentContent:
				EmitDocumentContent(evt);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.DocumentEnd:
				EmitDocumentEnd(evt);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.FlowSequenceFirstItem:
				EmitFlowSequenceItem(evt, isFirst: true);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.FlowSequenceItem:
				EmitFlowSequenceItem(evt, isFirst: false);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.FlowMappingFirstKey:
				EmitFlowMappingKey(evt, isFirst: true);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.FlowMappingKey:
				EmitFlowMappingKey(evt, isFirst: false);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.FlowMappingSimpleValue:
				EmitFlowMappingValue(evt, isSimple: true);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.FlowMappingValue:
				EmitFlowMappingValue(evt, isSimple: false);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.BlockSequenceFirstItem:
				EmitBlockSequenceItem(evt, isFirst: true);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.BlockSequenceItem:
				EmitBlockSequenceItem(evt, isFirst: false);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.BlockMappingFirstKey:
				EmitBlockMappingKey(evt, isFirst: true);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.BlockMappingKey:
				EmitBlockMappingKey(evt, isFirst: false);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.BlockMappingSimpleValue:
				EmitBlockMappingValue(evt, isSimple: true);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.BlockMappingValue:
				EmitBlockMappingValue(evt, isSimple: false);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.StreamEnd:
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException("Expected nothing after STREAM-END");
			default:
				throw new InvalidOperationException();
			}
		}

		private void EmitComment(YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Comment comment)
		{
			if (flowLevel > 0 || state == <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.FlowMappingFirstKey || state == <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.FlowSequenceFirstItem)
			{
				return;
			}
			string[] array = comment.Value.Split(NewLineSeparators, StringSplitOptions.None);
			if (comment.IsInline)
			{
				Write(" # ");
				Write(string.Join(" ", array));
			}
			else
			{
				bool flag = state == <cba6ec40-2546-4a46-9577-18d27987fd9e>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(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent evt)
		{
			if (!(evt is YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamStart))
			{
				throw new ArgumentException("Expected STREAM-START.", "evt");
			}
			indent = -1;
			column = 0;
			isWhitespace = true;
			isIndentation = true;
			state = <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.FirstDocumentStart;
		}

		private void EmitDocumentStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent evt, bool isFirst)
		{
			if (evt is YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart)
			{
				bool flag = <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart.IsImplicit && isFirst && !isCanonical;
				<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection2 = NonDefaultTagsAmong(<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart.Tags);
				if (!isFirst && !isDocumentEndWritten && (<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart.Version != null || <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection2.Count > 0))
				{
					isDocumentEndWritten = false;
					WriteIndicator("...", needWhitespace: true, whitespace: false, indentation: false);
					WriteIndent();
				}
				if (<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart.Version != null)
				{
					AnalyzeVersionDirective(<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart.Version);
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Version version = <cba6ec40-2546-4a46-9577-18d27987fd9e>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 (<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective item in <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection2)
				{
					AppendTagDirectiveTo(item, allowDuplicates: false, tagDirectives);
				}
				<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective[] defaultTagDirectives = <cba6ec40-2546-4a46-9577-18d27987fd9e>Constants.DefaultTagDirectives;
				foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective value in defaultTagDirectives)
				{
					AppendTagDirectiveTo(value, allowDuplicates: true, tagDirectives);
				}
				if (<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection2.Count > 0)
				{
					flag = false;
					<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective[] defaultTagDirectives2 = <cba6ec40-2546-4a46-9577-18d27987fd9e>Constants.DefaultTagDirectives;
					foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective value2 in defaultTagDirectives2)
					{
						AppendTagDirectiveTo(value2, allowDuplicates: true, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection2);
					}
					foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective item2 in <cba6ec40-2546-4a46-9577-18d27987fd9e>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 = <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.DocumentContent;
			}
			else
			{
				if (!(evt is YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamEnd))
				{
					throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException("Expected DOCUMENT-START or STREAM-END");
				}
				state = <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.StreamEnd;
			}
		}

		private static <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection NonDefaultTagsAmong(IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective>? tagCollection)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection2 = new <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection();
			if (tagCollection == null)
			{
				return <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection2;
			}
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective item2 in tagCollection)
			{
				AppendTagDirectiveTo(item2, allowDuplicates: false, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection2);
			}
			<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective[] defaultTagDirectives = <cba6ec40-2546-4a46-9577-18d27987fd9e>Constants.DefaultTagDirectives;
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective item in defaultTagDirectives)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection2.Remove(item);
			}
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection2;
		}

		private static void AnalyzeVersionDirective(<cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective versionDirective)
		{
			if (versionDirective.Version.Major != 1 || versionDirective.Version.Minor > 3)
			{
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException("Incompatible %YAML directive");
			}
		}

		private static void AppendTagDirectiveTo(<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective value, bool allowDuplicates, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection tagDirectives)
		{
			if (tagDirectives.Contains(value))
			{
				if (!allowDuplicates)
				{
					throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException("Duplicate %TAG directive.");
				}
			}
			else
			{
				tagDirectives.Add(value);
			}
		}

		private void EmitDocumentContent(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent evt)
		{
			states.Push(<cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.DocumentEnd);
			EmitNode(evt, isMapping: false, isSimpleKey: false);
		}

		private void EmitNode(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent evt, bool isMapping, bool isSimpleKey)
		{
			isMappingContext = isMapping;
			isSimpleKeyContext = isSimpleKey;
			switch (evt.Type)
			{
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.Alias:
				EmitAlias();
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.Scalar:
				EmitScalar(evt);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.SequenceStart:
				EmitSequenceStart(evt);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.MappingStart:
				EmitMappingStart(evt);
				break;
			default:
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException($"Expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS, got {evt.Type}");
			}
		}

		private void EmitAlias()
		{
			ProcessAnchor();
			state = states.Pop();
		}

		private void EmitScalar(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent evt)
		{
			SelectScalarStyle(evt);
			ProcessAnchor();
			ProcessTag();
			IncreaseIndent(isFlow: true, isIndentless: false);
			ProcessScalar();
			indent = indents.Pop();
			state = states.Pop();
		}

		private void SelectScalarStyle(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent evt)
		{
			YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar = (YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar)evt;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle2 = <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar.Style;
			bool flag = tagData.Handle == null && tagData.Suffix == null;
			if (flag && !<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar.IsPlainImplicit && !<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar.IsQuotedImplicit)
			{
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException("Neither tag nor isImplicit flags are specified.");
			}
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle2 == <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Any)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle2 = ((!scalarData.IsMultiline) ? <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Plain : <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Folded);
			}
			if (isCanonical)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle2 = <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.DoubleQuoted;
			}
			if (isSimpleKeyContext && scalarData.IsMultiline)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle2 = <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.DoubleQuoted;
			}
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle2 == <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Plain)
			{
				if ((flowLevel != 0 && !scalarData.IsFlowPlainAllowed) || (flowLevel == 0 && !scalarData.IsBlockPlainAllowed))
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle2 = ((scalarData.IsSingleQuotedAllowed && !scalarData.HasSingleQuotes) ? <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.SingleQuoted : <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.DoubleQuoted);
				}
				if (string.IsNullOrEmpty(scalarData.Value) && (flowLevel != 0 || isSimpleKeyContext))
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle2 = <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.SingleQuoted;
				}
				if (flag && !<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar.IsPlainImplicit)
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle2 = <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.SingleQuoted;
				}
			}
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle2 == <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.SingleQuoted && !scalarData.IsSingleQuotedAllowed)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle2 = <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.DoubleQuoted;
			}
			if ((<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle2 == <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Literal || <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle2 == <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Folded) && (!scalarData.IsBlockAllowed || flowLevel != 0 || isSimpleKeyContext))
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle2 = <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.DoubleQuoted;
			}
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle2 == <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.ForcePlain)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle2 = <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Plain;
			}
			scalarData.Style = <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle2;
		}

		private void ProcessScalar()
		{
			switch (scalarData.Style)
			{
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Plain:
				WritePlainScalar(scalarData.Value, !isSimpleKeyContext);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.SingleQuoted:
				WriteSingleQuotedScalar(scalarData.Value, !isSimpleKeyContext);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.DoubleQuoted:
				WriteDoubleQuotedScalar(scalarData.Value, !isSimpleKeyContext);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Literal:
				WriteLiteralScalar(scalarData.Value);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException("While writing a quoted scalar, found an orphaned high surrogate.");
						}
						if (useUtf16SurrogatePair)
						{
							Write('u');
							Write(num.ToString("X04", CultureInfo.InvariantCulture));
							Write('\\');
							Write('u');
							Write(((ushort)value[i + 1]).ToString("X04", CultureInfo.InvariantCulture));
						}
						else
						{
							Write('U');
							Write(char.ConvertToUtf32(c, value[i + 1]).ToString("X08", CultureInfo.InvariantCulture));
						}
						i++;
					}
					else
					{
						Write('u');
						Write(num.ToString("X04", CultureInfo.InvariantCulture));
					}
					break;
				}
				}
				flag = false;
			}
			WriteIndicator("\"", needWhitespace: false, whitespace: false, indentation: false);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteLiteralScalar(string value)
		{
			bool flag = true;
			WriteIndicator("|", needWhitespace: true, whitespace: false, indentation: false);
			WriteBlockScalarHints(value);
			WriteBreak();
			isIndentation = true;
			isWhitespace = true;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (c == '\r' && i + 1 < value.Length && value[i + 1] == '\n')
				{
					continue;
				}
				if (IsBreak(c, out var breakChar))
				{
					WriteBreak(breakChar);
					isIndentation = true;
					flag = true;
					continue;
				}
				if (flag)
				{
					WriteIndent();
				}
				Write(c);
				isIndentation = false;
				flag = false;
			}
		}

		private void WriteFoldedScalar(string value)
		{
			bool flag = true;
			bool flag2 = true;
			WriteIndicator(">", needWhitespace: true, whitespace: false, indentation: false);
			WriteBlockScalarHints(value);
			WriteBreak();
			isIndentation = true;
			isWhitespace = true;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (IsBreak(c, out var breakChar))
				{
					if (c == '\r' && i + 1 < value.Length && value[i + 1] == '\n')
					{
						continue;
					}
					if (!flag && !flag2 && breakChar == '\n')
					{
						int j;
						char breakChar2;
						for (j = 0; i + j < value.Length && IsBreak(value[i + j], out breakChar2); j++)
						{
						}
						if (i + j < value.Length && !IsBlank(value[i + j]) && !IsBreak(value[i + j], out breakChar2))
						{
							WriteBreak();
						}
					}
					WriteBreak(breakChar);
					isIndentation = true;
					flag = true;
				}
				else
				{
					if (flag)
					{
						WriteIndent();
						flag2 = IsBlank(c);
					}
					if (!flag && c == ' ' && i + 1 < value.Length && value[i + 1] != ' ' && column > bestWidth)
					{
						WriteIndent();
					}
					else
					{
						Write(c);
					}
					isIndentation = false;
					flag = false;
				}
			}
		}

		private static bool IsSpace(char character)
		{
			return character == ' ';
		}

		private static bool IsBreak(char character, out char breakChar)
		{
			switch (character)
			{
			case '\n':
			case '\r':
			case '\u0085':
				breakChar = '\n';
				return true;
			case '\u2028':
			case '\u2029':
				breakChar = character;
				return true;
			default:
				breakChar = '\0';
				return false;
			}
		}

		private static bool IsBlank(char character)
		{
			if (character != ' ')
			{
				return character == '\t';
			}
			return true;
		}

		private static bool IsPrintable(char character)
		{
			switch (character)
			{
			default:
				if (character != '\u0085' && (character < '\u00a0' || character > '\ud7ff'))
				{
					if (character >= '\ue000')
					{
						return character <= '\ufffd';
					}
					return false;
				}
				break;
			case '\t':
			case '\n':
			case '\r':
			case ' ':
			case '!':
			case '"':
			case '#':
			case '$':
			case '%':
			case '&':
			case '\'':
			case '(':
			case ')':
			case '*':
			case '+':
			case ',':
			case '-':
			case '.':
			case '/':
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			case ':':
			case ';':
			case '<':
			case '=':
			case '>':
			case '?':
			case '@':
			case 'A':
			case 'B':
			case 'C':
			case 'D':
			case 'E':
			case 'F':
			case 'G':
			case 'H':
			case 'I':
			case 'J':
			case 'K':
			case 'L':
			case 'M':
			case 'N':
			case 'O':
			case 'P':
			case 'Q':
			case 'R':
			case 'S':
			case 'T':
			case 'U':
			case 'V':
			case 'W':
			case 'X':
			case 'Y':
			case 'Z':
			case '[':
			case '\\':
			case ']':
			case '^':
			case '_':
			case '`':
			case 'a':
			case 'b':
			case 'c':
			case 'd':
			case 'e':
			case 'f':
			case 'g':
			case 'h':
			case 'i':
			case 'j':
			case 'k':
			case 'l':
			case 'm':
			case 'n':
			case 'o':
			case 'p':
			case 'q':
			case 'r':
			case 's':
			case 't':
			case 'u':
			case 'v':
			case 'w':
			case 'x':
			case 'y':
			case 'z':
			case '{':
			case '|':
			case '}':
			case '~':
				break;
			}
			return true;
		}

		private static bool IsHighSurrogate(char c)
		{
			if ('\ud800' <= c)
			{
				return c <= '\udbff';
			}
			return false;
		}

		private static bool IsLowSurrogate(char c)
		{
			if ('\udc00' <= c)
			{
				return c <= '\udfff';
			}
			return false;
		}

		private void EmitSequenceStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent evt)
		{
			ProcessAnchor();
			ProcessTag();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart = (<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart)evt;
			if (flowLevel != 0 || isCanonical || <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart.Style == <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStyle.Flow || CheckEmptySequence())
			{
				state = <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.FlowSequenceFirstItem;
			}
			else
			{
				state = <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.BlockSequenceFirstItem;
			}
		}

		private void EmitMappingStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent evt)
		{
			ProcessAnchor();
			ProcessTag();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart = (<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart)evt;
			if (flowLevel != 0 || isCanonical || <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart.Style == <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStyle.Flow || CheckEmptyMapping())
			{
				state = <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.FlowMappingFirstKey;
			}
			else
			{
				state = <cba6ec40-2546-4a46-9577-18d27987fd9e>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(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent evt)
		{
			if (evt is YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd)
			{
				WriteIndent();
				if (!<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd.IsImplicit)
				{
					WriteIndicator("...", needWhitespace: true, whitespace: false, indentation: false);
					WriteIndent();
					isDocumentEndWritten = true;
				}
				state = <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.DocumentStart;
				tagDirectives.Clear();
				return;
			}
			throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException("Expected DOCUMENT-END.");
		}

		private void EmitFlowSequenceItem(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				WriteIndicator("[", needWhitespace: true, whitespace: true, indentation: false);
				IncreaseIndent(isFlow: true, isIndentless: false);
				flowLevel++;
			}
			if (evt is <cba6ec40-2546-4a46-9577-18d27987fd9e>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(<cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.FlowSequenceItem);
				EmitNode(evt, isMapping: false, isSimpleKey: false);
			}
		}

		private void EmitFlowMappingKey(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				WriteIndicator("{", needWhitespace: true, whitespace: true, indentation: false);
				IncreaseIndent(isFlow: true, isIndentless: false);
				flowLevel++;
			}
			if (evt is <cba6ec40-2546-4a46-9577-18d27987fd9e>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(<cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.FlowMappingSimpleValue);
				EmitNode(evt, isMapping: true, isSimpleKey: true);
			}
			else
			{
				WriteIndicator("?", needWhitespace: true, whitespace: false, indentation: false);
				states.Push(<cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.FlowMappingValue);
				EmitNode(evt, isMapping: true, isSimpleKey: false);
			}
		}

		private void EmitFlowMappingValue(<cba6ec40-2546-4a46-9577-18d27987fd9e>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(<cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.FlowMappingKey);
			EmitNode(evt, isMapping: true, isSimpleKey: false);
		}

		private void EmitBlockSequenceItem(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				IncreaseIndent(isFlow: false, isMappingContext && !isIndentation);
			}
			if (evt is <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEnd)
			{
				indent = indents.Pop();
				state = states.Pop();
				return;
			}
			WriteIndent();
			WriteIndicator("-", needWhitespace: true, whitespace: false, indentation: true);
			states.Push(<cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.BlockSequenceItem);
			EmitNode(evt, isMapping: false, isSimpleKey: false);
		}

		private void EmitBlockMappingKey(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				IncreaseIndent(isFlow: false, isIndentless: false);
			}
			if (evt is <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEnd)
			{
				indent = indents.Pop();
				state = states.Pop();
				return;
			}
			WriteIndent();
			if (CheckSimpleKey())
			{
				states.Push(<cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.BlockMappingSimpleValue);
				EmitNode(evt, isMapping: true, isSimpleKey: true);
				WriteIndicator(":", needWhitespace: false, whitespace: false, indentation: false);
			}
			else
			{
				WriteIndicator("?", needWhitespace: true, whitespace: false, indentation: true);
				states.Push(<cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState.BlockMappingValue);
				EmitNode(evt, isMapping: true, isSimpleKey: false);
			}
		}

		private void EmitBlockMappingValue(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent evt, bool isSimple)
		{
			if (!isSimple)
			{
				WriteIndent();
				WriteIndicator(":", needWhitespace: true, whitespace: false, indentation: true);
			}
			states.Push(<cba6ec40-2546-4a46-9577-18d27987fd9e>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 (<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent @event in events)
			{
				num++;
				if (num == 2)
				{
					if (@event is YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar)
					{
						return string.IsNullOrEmpty(<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar.Value);
					}
					break;
				}
			}
			return false;
		}

		private bool CheckSimpleKey()
		{
			if (events.Count < 1)
			{
				return false;
			}
			int num;
			switch (events.Peek().Type)
			{
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.Alias:
				num = AnchorNameLength(anchorData.Anchor);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.Scalar:
				if (scalarData.IsMultiline)
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix) + SafeStringLength(scalarData.Value);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.SequenceStart:
				if (!CheckEmptySequence())
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix);
				break;
			case <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.MappingStart:
				if (!CheckEmptySequence())
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix);
				break;
			default:
				return false;
			}
			return num <= maxSimpleKeyLength;
		}

		private static int AnchorNameLength(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName value)
		{
			if (!value.IsEmpty)
			{
				return value.Value.Length;
			}
			return 0;
		}

		private static int SafeStringLength(string? value)
		{
			return value?.Length ?? 0;
		}

		private bool CheckEmptySequence()
		{
			return CheckEmptyStructure<<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart, <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEnd>();
		}

		private bool CheckEmptyMapping()
		{
			return CheckEmptyStructure<<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart, <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEnd>();
		}

		private bool CheckEmptyStructure<TStart, TEnd>() where TStart : <cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent where TEnd : <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent
		{
			if (events.Count < 2)
			{
				return false;
			}
			using Queue<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent>.Enumerator enumerator = events.GetEnumerator();
			return enumerator.MoveNext() && enumerator.Current is TStart && enumerator.MoveNext() && enumerator.Current is TEnd;
		}

		private void WriteBlockScalarHints(string value)
		{
			StringLookAheadBufferPool.BufferWrapper bufferWrapper = StringLookAheadBufferPool.Rent(value);
			try
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer<<cba6ec40-2546-4a46-9577-18d27987fd9e>StringLookAheadBuffer> <cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2 = new <cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer<<cba6ec40-2546-4a46-9577-18d27987fd9e>StringLookAheadBuffer>(bufferWrapper.Buffer);
				if (<cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2.IsSpace() || <cba6ec40-2546-4a46-9577-18d27987fd9e>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 || !<cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2.IsBreak(value.Length - 1))
				{
					text = "-";
				}
				else if (value.Length >= 2 && <cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer2.IsBreak(value.Length - 2))
				{
					text = "+";
				}
				if (text != null)
				{
					WriteIndicator(text, needWhitespace: false, whitespace: false, indentation: false);
				}
			}
			finally
			{
				((IDisposable)bufferWrapper).Dispose();
			}
		}

		private void WriteIndicator(string indicator, bool needWhitespace, bool whitespace, bool indentation)
		{
			if (needWhitespace && !isWhitespace)
			{
				Write(' ');
			}
			Write(indicator);
			isWhitespace = whitespace;
			isIndentation &= indentation;
		}

		private void WriteIndent()
		{
			int num = Math.Max(indent, 0);
			if (!isIndentation || column > num || (column == num && !isWhitespace))
			{
				WriteBreak();
			}
			while (column < num)
			{
				Write(' ');
			}
			isWhitespace = true;
			isIndentation = true;
		}

		private void WriteAnchor(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName value)
		{
			Write(value.Value);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteTagHandle(string value)
		{
			if (!isWhitespace)
			{
				Write(' ');
			}
			Write(value);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteTagContent(string value, bool needsWhitespace)
		{
			if (needsWhitespace && !isWhitespace)
			{
				Write(' ');
			}
			Write(UrlEncode(value));
			isWhitespace = false;
			isIndentation = false;
		}

		private static string UrlEncode(string text)
		{
			return UriReplacer.Replace(text, delegate(Match match)
			{
				StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder = builderWrapper.Builder;
					byte[] bytes = Encoding.UTF8.GetBytes(match.Value);
					foreach (byte b in bytes)
					{
						builder.AppendFormat(CultureInfo.InvariantCulture, "%{0:X02}", b);
					}
					return builder.ToString();
				}
				finally
				{
					((IDisposable)builderWrapper).Dispose();
				}
			});
		}

		private void Write(char value)
		{
			output.Write(value);
			column++;
		}

		private void Write(string value)
		{
			output.Write(value);
			column += value.Length;
		}

		private void WriteBreak(char breakCharacter = '\n')
		{
			if (breakCharacter == '\n')
			{
				output.WriteLine();
			}
			else
			{
				output.Write(breakCharacter);
			}
			column = 0;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings
	{
		public static readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings Default = new <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings();

		public int BestIndent { get; } = 2;


		public int BestWidth { get; } = int.MaxValue;


		public string NewLine { get; } = Environment.NewLine;


		public bool IsCanonical { get; }

		public bool SkipAnchorName { get; private set; }

		public int MaxSimpleKeyLength { get; } = 1024;


		public bool IndentSequences { get; }

		public bool UseUtf16SurrogatePairs { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings()
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings(int bestIndent, int bestWidth, bool isCanonical, int maxSimpleKeyLength, bool skipAnchorName = false, bool indentSequences = false, string? newLine = null, bool useUtf16SurrogatePairs = false)
		{
			if (bestIndent < 2 || bestIndent > 9)
			{
				throw new ArgumentOutOfRangeException("bestIndent", "BestIndent must be between 2 and 9, inclusive");
			}
			if (bestWidth <= bestIndent * 2)
			{
				throw new ArgumentOutOfRangeException("bestWidth", "BestWidth must be greater than BestIndent x 2.");
			}
			if (maxSimpleKeyLength < 0)
			{
				throw new ArgumentOutOfRangeException("maxSimpleKeyLength", "MaxSimpleKeyLength must be >= 0");
			}
			BestIndent = bestIndent;
			BestWidth = bestWidth;
			IsCanonical = isCanonical;
			MaxSimpleKeyLength = maxSimpleKeyLength;
			SkipAnchorName = skipAnchorName;
			IndentSequences = indentSequences;
			NewLine = newLine ?? Environment.NewLine;
			UseUtf16SurrogatePairs = useUtf16SurrogatePairs;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings WithBestIndent(int bestIndent)
		{
			return new <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings(bestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings WithBestWidth(int bestWidth)
		{
			return new <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings(BestIndent, bestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings WithMaxSimpleKeyLength(int maxSimpleKeyLength)
		{
			return new <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings(BestIndent, BestWidth, IsCanonical, maxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings WithNewLine(string newLine)
		{
			return new <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, newLine, UseUtf16SurrogatePairs);
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings Canonical()
		{
			return new <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings(BestIndent, BestWidth, isCanonical: true, MaxSimpleKeyLength, SkipAnchorName);
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings WithoutAnchorName()
		{
			return new <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, skipAnchorName: true, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings WithIndentedSequences()
		{
			return new <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, indentSequences: true, NewLine, UseUtf16SurrogatePairs);
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings WithUtf16SurrogatePairs()
		{
			return new <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, useUtf16SurrogatePairs: true);
		}
	}
	internal enum <cba6ec40-2546-4a46-9577-18d27987fd9e>EmitterState
	{
		StreamStart,
		StreamEnd,
		FirstDocumentStart,
		DocumentStart,
		DocumentContent,
		DocumentEnd,
		FlowSequenceFirstItem,
		FlowSequenceItem,
		FlowMappingFirstKey,
		FlowMappingKey,
		FlowMappingSimpleValue,
		FlowMappingValue,
		BlockSequenceFirstItem,
		BlockSequenceItem,
		BlockMappingFirstKey,
		BlockMappingKey,
		BlockMappingSimpleValue,
		BlockMappingValue
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>ForwardAnchorNotSupportedException : <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ForwardAnchorNotSupportedException(string message)
			: base(message)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ForwardAnchorNotSupportedException(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ForwardAnchorNotSupportedException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	internal static class <cba6ec40-2546-4a46-9577-18d27987fd9e>HashCode
	{
		public static int CombineHashCodes(int h1, int h2)
		{
			return ((h1 << 5) + h1) ^ h2;
		}

		public static int CombineHashCodes(int h1, object? o2)
		{
			return CombineHashCodes(h1, GetHashCode(o2));
		}

		private static int GetHashCode(object? obj)
		{
			return obj?.GetHashCode() ?? 0;
		}
	}
	public interface <cba6ec40-2546-4a46-9577-18d27987fd9e>IEmitter
	{
		void Emit(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent @event);
	}
	internal interface <cba6ec40-2546-4a46-9577-18d27987fd9e>ILookAheadBuffer
	{
		bool EndOfInput { get; }

		char Peek(int offset);

		void Skip(int length);
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>InsertionQueue(int initialCapacity = 128)
		{
			if (initialCapacity <= 0)
			{
				throw new ArgumentOutOfRangeException("initialCapacity", "The initial capacity must be a positive number.");
			}
			if (!<cba6ec40-2546-4a46-9577-18d27987fd9e>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();
		}
	}
	public interface <cba6ec40-2546-4a46-9577-18d27987fd9e>IParser
	{
		<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent? Current { get; }

		bool MoveNext();
	}
	internal interface <cba6ec40-2546-4a46-9577-18d27987fd9e>IScanner
	{
		<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark CurrentPosition { get; }

		<cba6ec40-2546-4a46-9577-18d27987fd9e>Token? Current { get; }

		bool MoveNext();

		bool MoveNextWithoutConsuming();

		void ConsumeCurrent();
	}
	[DebuggerStepThrough]
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>LookAheadBuffer : <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>LookAheadBuffer(TextReader input, int capacity)
		{
			if (capacity < 1)
			{
				throw new ArgumentOutOfRangeException("capacity", "The capacity must be positive.");
			}
			if (!<cba6ec40-2546-4a46-9577-18d27987fd9e>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;
		}
	}
	public readonly struct <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark : IEquatable<<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark>, IComparable<<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark>, IComparable
	{
		public static readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark Empty = new <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark(0L, 1L, 1L);

		public long Index { get; }

		public long Line { get; }

		public long Column { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark(long index, long line, long column)
		{
			if (index < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("index", "Index must be greater than or equal to zero.");
			}
			if (line < 1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("line", "Line must be greater than or equal to 1.");
			}
			if (column < 1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("column", "Column must be greater than or equal to 1.");
			}
			Index = index;
			Line = line;
			Column = column;
		}

		public override string ToString()
		{
			return $"Line: {Line}, Col: {Column}, Idx: {Index}";
		}

		public override bool Equals(object? obj)
		{
			return Equals((<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark)(obj ?? ((object)Empty)));
		}

		public bool Equals(<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark other)
		{
			if (Index == other.Index && Line == other.Line)
			{
				return Column == other.Column;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>HashCode.CombineHashCodes(Index.GetHashCode(), <cba6ec40-2546-4a46-9577-18d27987fd9e>HashCode.CombineHashCodes(Line.GetHashCode(), Column.GetHashCode()));
		}

		public int CompareTo(object? obj)
		{
			return CompareTo((<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark)(obj ?? ((object)Empty)));
		}

		public int CompareTo(<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark other)
		{
			int num = Line.CompareTo(other.Line);
			if (num == 0)
			{
				num = Column.CompareTo(other.Column);
			}
			return num;
		}

		public static bool operator ==(<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark left, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark left, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark right)
		{
			return !(left == right);
		}

		public static bool operator <(<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark left, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark right)
		{
			return left.CompareTo(right) < 0;
		}

		public static bool operator <=(<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark left, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark right)
		{
			return left.CompareTo(right) <= 0;
		}

		public static bool operator >(<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark left, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark right)
		{
			return left.CompareTo(right) > 0;
		}

		public static bool operator >=(<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark left, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark right)
		{
			return left.CompareTo(right) >= 0;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>MaximumRecursionLevelReachedException : <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>MaximumRecursionLevelReachedException(string message)
			: base(message)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>MaximumRecursionLevelReachedException(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>MaximumRecursionLevelReachedException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>MergingParser : <cba6ec40-2546-4a46-9577-18d27987fd9e>IParser
	{
		private sealed class ParsingEventCollection : IEnumerable<LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent>>, IEnumerable
		{
			private readonly LinkedList<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> events;

			private readonly HashSet<LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent>> deleted;

			private readonly Dictionary<<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName, LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent>> references;

			public ParsingEventCollection()
			{
				events = new LinkedList<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent>();
				deleted = new HashSet<LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent>>();
				references = new Dictionary<<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName, LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent>>();
			}

			public void AddAfter(LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> node, IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> items)
			{
				foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent item in items)
				{
					node = events.AddAfter(node, item);
				}
			}

			public void Add(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent item)
			{
				LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> node = events.AddLast(item);
				AddReference(item, node);
			}

			public void MarkDeleted(LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> node)
			{
				deleted.Add(node);
			}

			public bool IsDeleted(LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> node)
			{
				return deleted.Contains(node);
			}

			public void CleanMarked()
			{
				foreach (LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> item in deleted)
				{
					events.Remove(item);
				}
			}

			public IEnumerable<LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent>> FromAnchor(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName anchor)
			{
				LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> next = references[anchor].Next;
				return Enumerate(next);
			}

			public IEnumerator<LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent>> GetEnumerator()
			{
				return Enumerate(events.First).GetEnumerator();
			}

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

			private static IEnumerable<LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent>> Enumerate(LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent>? node)
			{
				while (node != null)
				{
					yield return node;
					node = node.Next;
				}
			}

			private void AddReference(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent item, LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> node)
			{
				if (item is <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart)
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName anchor = <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart.Anchor;
					if (!anchor.IsEmpty)
					{
						references[anchor] = node;
					}
				}
			}
		}

		private sealed class ParsingEventCloner : <cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor
		{
			private <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent? clonedEvent;

			public <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent Clone(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent e)
			{
				e.Accept(this);
				if (clonedEvent == null)
				{
					throw new InvalidOperationException($"Could not clone event of type '{e.Type}'");
				}
				return clonedEvent;
			}

			void <cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor.Visit(YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias e)
			{
				clonedEvent = new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias(e.Value, e.Start, e.End);
			}

			void <cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor.Visit(YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamStart e)
			{
				throw new NotSupportedException();
			}

			void <cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor.Visit(YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamEnd e)
			{
				throw new NotSupportedException();
			}

			void <cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor.Visit(YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart e)
			{
				throw new NotSupportedException();
			}

			void <cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor.Visit(YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd e)
			{
				throw new NotSupportedException();
			}

			void <cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor.Visit(YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar e)
			{
				clonedEvent = new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName.Empty, e.Tag, e.Value, e.Style, e.IsPlainImplicit, e.IsQuotedImplicit, e.Start, e.End);
			}

			void <cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor.Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart e)
			{
				clonedEvent = new <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
			}

			void <cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor.Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEnd e)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = e.Start;
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = e.End;
				clonedEvent = new <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEnd(in start, in end);
			}

			void <cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor.Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart e)
			{
				clonedEvent = new <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
			}

			void <cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor.Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEnd e)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = e.Start;
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = e.End;
				clonedEvent = new <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEnd(in start, in end);
			}

			void <cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor.Visit(YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Comment e)
			{
				throw new NotSupportedException();
			}
		}

		private readonly ParsingEventCollection events;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IParser innerParser;

		private IEnumerator<LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent>> iterator;

		private bool merged;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent? Current => iterator.Current?.Value;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>MergingParser(<cba6ec40-2546-4a46-9577-18d27987fd9e>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<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> @event in events)
			{
				if (IsMergeToken(@event))
				{
					events.MarkDeleted(@event);
					if (!HandleMerge(@event.Next))
					{
						<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = @event.Value.Start;
						<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = @event.Value.End;
						throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(in start, in end, "Unrecognized merge key pattern");
					}
				}
			}
		}

		private bool HandleMerge(LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent>? node)
		{
			if (node == null)
			{
				return false;
			}
			if (node.Value is YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias anchorAlias)
			{
				return HandleAnchorAlias(node, node, anchorAlias);
			}
			if (node.Value is <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart)
			{
				return HandleSequence(node);
			}
			return false;
		}

		private bool HandleMergeSequence(LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> sequenceStart, LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent>? node)
		{
			if (node == null)
			{
				return false;
			}
			if (node.Value is YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias anchorAlias)
			{
				return HandleAnchorAlias(sequenceStart, node, anchorAlias);
			}
			if (node.Value is <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart)
			{
				return HandleSequence(node);
			}
			return false;
		}

		private static bool IsMergeToken(LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> node)
		{
			if (node.Value is YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar)
			{
				return <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar.Value == "<<";
			}
			return false;
		}

		private bool HandleAnchorAlias(LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> node, LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> anchorNode, YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias anchorAlias)
		{
			IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> mappingEvents = GetMappingEvents(anchorAlias.Value);
			events.AddAfter(node, mappingEvents);
			events.MarkDeleted(anchorNode);
			return true;
		}

		private bool HandleSequence(LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> node)
		{
			events.MarkDeleted(node);
			LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> linkedListNode = node;
			while (linkedListNode != null)
			{
				if (linkedListNode.Value is <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEnd)
				{
					events.MarkDeleted(linkedListNode);
					return true;
				}
				LinkedListNode<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> next = linkedListNode.Next;
				HandleMergeSequence(node, next);
				linkedListNode = next;
			}
			return true;
		}

		private IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> GetMappingEvents(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName anchor)
		{
			ParsingEventCloner @object = new ParsingEventCloner();
			int nesting = 0;
			return (from e in events.FromAnchor(anchor)
				where !events.IsDeleted(e)
				select e.Value).TakeWhile((<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent e) => (nesting += e.NestingIncrease) >= 0).Select(@object.Clone);
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>Parser : <cba6ec40-2546-4a46-9577-18d27987fd9e>IParser
	{
		private class EventQueue
		{
			private readonly Queue<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> highPriorityEvents = new Queue<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent>();

			private readonly Queue<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent> normalPriorityEvents = new Queue<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent>();

			public int Count => highPriorityEvents.Count + normalPriorityEvents.Count;

			public void Enqueue(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent @event)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>EventType type = @event.Type;
				if (type == <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.StreamStart || type == <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.DocumentStart)
				{
					highPriorityEvents.Enqueue(@event);
				}
				else
				{
					normalPriorityEvents.Enqueue(@event);
				}
			}

			public <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent Dequeue()
			{
				if (highPriorityEvents.Count <= 0)
				{
					return normalPriorityEvents.Dequeue();
				}
				return highPriorityEvents.Dequeue();
			}
		}

		private readonly Stack<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState> states = new Stack<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState>();

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection tagDirectives = new <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection();

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState state;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>IScanner scanner;

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>Token? currentToken;

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective? version;

		private readonly EventQueue pendingEvents = new EventQueue();

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent? Current { get; private set; }

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>Token? GetCurrentToken()
		{
			if (currentToken == null)
			{
				while (scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (!(currentToken is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>Comment <cba6ec40-2546-4a46-9577-18d27987fd9e>Comment))
					{
						break;
					}
					pendingEvents.Enqueue(new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Comment(<cba6ec40-2546-4a46-9577-18d27987fd9e>Comment.Value, <cba6ec40-2546-4a46-9577-18d27987fd9e>Comment.IsInline, <cba6ec40-2546-4a46-9577-18d27987fd9e>Comment.Start, <cba6ec40-2546-4a46-9577-18d27987fd9e>Comment.End));
					scanner.ConsumeCurrent();
				}
			}
			return currentToken;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Parser(TextReader input)
			: this(new <cba6ec40-2546-4a46-9577-18d27987fd9e>Scanner(input))
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Parser(<cba6ec40-2546-4a46-9577-18d27987fd9e>IScanner scanner)
		{
			this.scanner = scanner;
		}

		public bool MoveNext()
		{
			if (state == <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.StreamEnd)
			{
				Current = null;
				return false;
			}
			if (pendingEvents.Count == 0)
			{
				pendingEvents.Enqueue(StateMachine());
			}
			Current = pendingEvents.Dequeue();
			return true;
		}

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent StateMachine()
		{
			return state switch
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.StreamStart => ParseStreamStart(), 
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.ImplicitDocumentStart => ParseDocumentStart(isImplicit: true), 
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.DocumentStart => ParseDocumentStart(isImplicit: false), 
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.DocumentContent => ParseDocumentContent(), 
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.DocumentEnd => ParseDocumentEnd(), 
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.BlockNode => ParseNode(isBlock: true, isIndentlessSequence: false), 
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.BlockNodeOrIndentlessSequence => ParseNode(isBlock: true, isIndentlessSequence: true), 
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowNode => ParseNode(isBlock: false, isIndentlessSequence: false), 
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.BlockSequenceFirstEntry => ParseBlockSequenceEntry(isFirst: true), 
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.BlockSequenceEntry => ParseBlockSequenceEntry(isFirst: false), 
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.IndentlessSequenceEntry => ParseIndentlessSequenceEntry(), 
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.BlockMappingFirstKey => ParseBlockMappingKey(isFirst: true), 
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.BlockMappingKey => ParseBlockMappingKey(isFirst: false), 
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.BlockMappingValue => ParseBlockMappingValue(), 
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowSequenceFirstEntry => ParseFlowSequenceEntry(isFirst: true), 
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowSequenceEntry => ParseFlowSequenceEntry(isFirst: false), 
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowSequenceEntryMappingKey => ParseFlowSequenceEntryMappingKey(), 
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowSequenceEntryMappingValue => ParseFlowSequenceEntryMappingValue(), 
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowSequenceEntryMappingEnd => ParseFlowSequenceEntryMappingEnd(), 
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowMappingFirstKey => ParseFlowMappingKey(isFirst: true), 
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowMappingKey => ParseFlowMappingKey(isFirst: false), 
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowMappingValue => ParseFlowMappingValue(isEmpty: false), 
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowMappingEmptyValue => ParseFlowMappingValue(isEmpty: true), 
				_ => throw new InvalidOperationException(), 
			};
		}

		private void Skip()
		{
			if (currentToken != null)
			{
				currentToken = null;
				scanner.ConsumeCurrent();
			}
		}

		private YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamStart ParseStreamStart()
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Token <cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end;
			if (!(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamStart <cba6ec40-2546-4a46-9577-18d27987fd9e>StreamStart))
			{
				start = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token?.Start ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
				end = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token?.End ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(in start, in end, "Did not find expected <stream-start>.");
			}
			Skip();
			state = <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.ImplicitDocumentStart;
			start = <cba6ec40-2546-4a46-9577-18d27987fd9e>StreamStart.Start;
			end = <cba6ec40-2546-4a46-9577-18d27987fd9e>StreamStart.End;
			return new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamStart(in start, in end);
		}

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent ParseDocumentStart(bool isImplicit)
		{
			if (currentToken is <cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective)
			{
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException("While parsing a document start node, could not find document end marker before version directive.");
			}
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Token <cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken();
			if (!isImplicit)
			{
				while (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd)
				{
					Skip();
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken();
				}
			}
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token == null)
			{
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException("Reached the end of the stream while parsing a document start.");
			}
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar && (state == <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.ImplicitDocumentStart || state == <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.DocumentStart))
			{
				isImplicit = true;
			}
			if ((isImplicit && !(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective) && !(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective) && !(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart) && !(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamEnd) && !(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd)) || <cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockMappingStart)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection tags = new <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection();
				ProcessDirectives(tags);
				states.Push(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.DocumentEnd);
				state = <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.BlockNode;
				return new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart(null, tags, isImplicit: true, <cba6ec40-2546-4a46-9577-18d27987fd9e>Token.Start, <cba6ec40-2546-4a46-9577-18d27987fd9e>Token.End);
			}
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start2;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end;
			if (!(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamEnd) && !(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd))
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token.Start;
				<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection tags2 = new <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection();
				<cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective <cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective = ProcessDirectives(tags2);
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken() ?? throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException("Reached the end of the stream while parsing a document start");
				if (!(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart))
				{
					start2 = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token.Start;
					end = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token.End;
					throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(in start2, in end, "Did not find expected <document start>.");
				}
				states.Push(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.DocumentEnd);
				state = <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.DocumentContent;
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end2 = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token.End;
				Skip();
				return new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective, tags2, isImplicit: false, start, end2);
			}
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd)
			{
				Skip();
			}
			state = <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.StreamEnd;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken() ?? throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException("Reached the end of the stream while parsing a document start");
			start2 = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token.Start;
			end = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token.End;
			YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamEnd result = new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamEnd(in start2, in end);
			if (scanner.MoveNextWithoutConsuming())
			{
				throw new InvalidOperationException("The scanner should contain no more tokens.");
			}
			return result;
		}

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective? ProcessDirectives(<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection tags)
		{
			bool flag = false;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective result = null;
			while (true)
			{
				if (GetCurrentToken() is <cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective <cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective)
				{
					if (version != null)
					{
						<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = <cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective.Start;
						<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = <cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective.End;
						throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(in start, in end, "Found duplicate %YAML directive.");
					}
					if (<cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective.Version.Major != 1 || <cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective.Version.Minor > 3)
					{
						<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = <cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective.Start;
						<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = <cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective.End;
						throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(in start, in end, "Found incompatible YAML document.");
					}
					result = (version = <cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective);
					flag = true;
				}
				else
				{
					if (!(GetCurrentToken() is <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective))
					{
						break;
					}
					if (tags.Contains(<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective.Handle))
					{
						<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective.Start;
						<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective.End;
						throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(in start, in end, "Found duplicate %TAG directive.");
					}
					tags.Add(<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective);
					flag = true;
				}
				Skip();
			}
			if (GetCurrentToken() is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart && (version == null || (version.Version.Major == 1 && version.Version.Minor > 1)))
			{
				if (GetCurrentToken() is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart && version == null)
				{
					version = new <cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective(new <cba6ec40-2546-4a46-9577-18d27987fd9e>Version(1, 2));
				}
				flag = true;
			}
			AddTagDirectives(tags, <cba6ec40-2546-4a46-9577-18d27987fd9e>Constants.DefaultTagDirectives);
			if (flag)
			{
				tagDirectives.Clear();
			}
			AddTagDirectives(tagDirectives, tags);
			return result;
		}

		private static void AddTagDirectives(<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection directives, IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective> source)
		{
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective item in source)
			{
				if (!directives.Contains(item))
				{
					directives.Add(item);
				}
			}
		}

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent ParseDocumentContent()
		{
			if (GetCurrentToken() is <cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective || GetCurrentToken() is <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective || GetCurrentToken() is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart || GetCurrentToken() is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd || GetCurrentToken() is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamEnd)
			{
				state = states.Pop();
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark position = scanner.CurrentPosition;
				return ProcessEmptyScalar(in position);
			}
			return ParseNode(isBlock: true, isIndentlessSequence: false);
		}

		private static YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar ProcessEmptyScalar(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark position)
		{
			return new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName.Empty, string.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Plain, isPlainImplicit: true, isQuotedImplicit: false, position, position);
		}

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent ParseNode(bool isBlock, bool isIndentlessSequence)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end;
			if (GetCurrentToken() is <cba6ec40-2546-4a46-9577-18d27987fd9e>Error <cba6ec40-2546-4a46-9577-18d27987fd9e>Error)
			{
				start = <cba6ec40-2546-4a46-9577-18d27987fd9e>Error.Start;
				end = <cba6ec40-2546-4a46-9577-18d27987fd9e>Error.End;
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(in start, in end, <cba6ec40-2546-4a46-9577-18d27987fd9e>Error.Value);
			}
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Token <cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken() ?? throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException("Reached the end of the stream while parsing a node");
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias)
			{
				state = states.Pop();
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent result = new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias.Value, <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias.Start, <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias.End);
				Skip();
				return result;
			}
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start2 = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token.Start;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName anchor = <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName.Empty;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>TagName tag = <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName.Empty;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Anchor <cba6ec40-2546-4a46-9577-18d27987fd9e>Anchor = null;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Tag <cba6ec40-2546-4a46-9577-18d27987fd9e>Tag = null;
			while (true)
			{
				if (anchor.IsEmpty && <cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>Anchor <cba6ec40-2546-4a46-9577-18d27987fd9e>Anchor2)
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Anchor = <cba6ec40-2546-4a46-9577-18d27987fd9e>Anchor2;
					anchor = <cba6ec40-2546-4a46-9577-18d27987fd9e>Anchor2.Value;
					Skip();
				}
				else
				{
					if (!tag.IsEmpty || !(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>Tag <cba6ec40-2546-4a46-9577-18d27987fd9e>Tag2))
					{
						if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>Anchor <cba6ec40-2546-4a46-9577-18d27987fd9e>Anchor3)
						{
							start = <cba6ec40-2546-4a46-9577-18d27987fd9e>Anchor3.Start;
							end = <cba6ec40-2546-4a46-9577-18d27987fd9e>Anchor3.End;
							throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(in start, in end, "While parsing a node, found more than one anchor.");
						}
						if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias2)
						{
							start = <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias2.Start;
							end = <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias2.End;
							throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(in start, in end, "While parsing a node, did not find expected token.");
						}
						if (!(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>Error <cba6ec40-2546-4a46-9577-18d27987fd9e>Error2))
						{
							break;
						}
						if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Tag != null && <cba6ec40-2546-4a46-9577-18d27987fd9e>Anchor != null && !anchor.IsEmpty)
						{
							return new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar(anchor, default(<cba6ec40-2546-4a46-9577-18d27987fd9e>TagName), string.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Any, isPlainImplicit: false, isQuotedImplicit: false, <cba6ec40-2546-4a46-9577-18d27987fd9e>Anchor.Start, <cba6ec40-2546-4a46-9577-18d27987fd9e>Anchor.End);
						}
						start = <cba6ec40-2546-4a46-9577-18d27987fd9e>Error2.Start;
						end = <cba6ec40-2546-4a46-9577-18d27987fd9e>Error2.End;
						throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(in start, in end, <cba6ec40-2546-4a46-9577-18d27987fd9e>Error2.Value);
					}
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Tag = <cba6ec40-2546-4a46-9577-18d27987fd9e>Tag2;
					if (string.IsNullOrEmpty(<cba6ec40-2546-4a46-9577-18d27987fd9e>Tag2.Handle))
					{
						tag = new <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName(<cba6ec40-2546-4a46-9577-18d27987fd9e>Tag2.Suffix);
					}
					else
					{
						if (!tagDirectives.Contains(<cba6ec40-2546-4a46-9577-18d27987fd9e>Tag2.Handle))
						{
							start = <cba6ec40-2546-4a46-9577-18d27987fd9e>Tag2.Start;
							end = <cba6ec40-2546-4a46-9577-18d27987fd9e>Tag2.End;
							throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(in start, in end, "While parsing a node, found undefined tag handle.");
						}
						tag = new <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName(tagDirectives[<cba6ec40-2546-4a46-9577-18d27987fd9e>Tag2.Handle].Prefix + <cba6ec40-2546-4a46-9577-18d27987fd9e>Tag2.Suffix);
					}
					Skip();
				}
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken() ?? throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException("Reached the end of the stream while parsing a node");
			}
			bool isEmpty = tag.IsEmpty;
			if (isIndentlessSequence && GetCurrentToken() is <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEntry)
			{
				state = <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.IndentlessSequenceEntry;
				return new <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart(anchor, tag, isEmpty, <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStyle.Block, start2, <cba6ec40-2546-4a46-9577-18d27987fd9e>Token.End);
			}
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar)
			{
				bool isPlainImplicit = false;
				bool isQuotedImplicit = false;
				if ((<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar.Style == <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Plain && tag.IsEmpty) || tag.IsNonSpecific)
				{
					isPlainImplicit = true;
				}
				else if (tag.IsEmpty)
				{
					isQuotedImplicit = true;
				}
				state = states.Pop();
				Skip();
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent result2 = new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar(anchor, tag, <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar.Value, <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar.Style, isPlainImplicit, isQuotedImplicit, start2, <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar.End, <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar.IsKey);
				if (!anchor.IsEmpty && scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (currentToken is <cba6ec40-2546-4a46-9577-18d27987fd9e>Error)
					{
						<cba6ec40-2546-4a46-9577-18d27987fd9e>Error <cba6ec40-2546-4a46-9577-18d27987fd9e>Error3 = currentToken as <cba6ec40-2546-4a46-9577-18d27987fd9e>Error;
						start = <cba6ec40-2546-4a46-9577-18d27987fd9e>Error3.Start;
						end = <cba6ec40-2546-4a46-9577-18d27987fd9e>Error3.End;
						throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(in start, in end, <cba6ec40-2546-4a46-9577-18d27987fd9e>Error3.Value);
					}
				}
				if (state == <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowMappingKey && !(scanner.Current is <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowMappingEnd) && scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (currentToken != null && !(currentToken is <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowEntry) && !(currentToken is <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowMappingEnd))
					{
						start = currentToken.Start;
						end = currentToken.End;
						throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(in start, in end, "While parsing a flow mapping, did not find expected ',' or '}'.");
					}
				}
				return result2;
			}
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowSequenceStart <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowSequenceStart)
			{
				state = <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowSequenceFirstEntry;
				return new <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart(anchor, tag, isEmpty, <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStyle.Flow, start2, <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowSequenceStart.End);
			}
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowMappingStart <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowMappingStart)
			{
				state = <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowMappingFirstKey;
				return new <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart(anchor, tag, isEmpty, <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStyle.Flow, start2, <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowMappingStart.End);
			}
			if (isBlock)
			{
				if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockSequenceStart <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockSequenceStart)
				{
					state = <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.BlockSequenceFirstEntry;
					return new <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart(anchor, tag, isEmpty, <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStyle.Block, start2, <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockSequenceStart.End);
				}
				if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockMappingStart <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockMappingStart)
				{
					state = <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.BlockMappingFirstKey;
					return new <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart(anchor, tag, isEmpty, <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStyle.Block, start2, <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockMappingStart.End);
				}
			}
			if (!anchor.IsEmpty || !tag.IsEmpty)
			{
				state = states.Pop();
				return new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar(anchor, tag, string.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Plain, isEmpty, isQuotedImplicit: false, start2, <cba6ec40-2546-4a46-9577-18d27987fd9e>Token.End);
			}
			start = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token.Start;
			end = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token.End;
			throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(in start, in end, "While parsing a node, did not find expected node content.");
		}

		private YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd ParseDocumentEnd()
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Token <cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken() ?? throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException("Reached the end of the stream while parsing a document end");
			bool isImplicit = true;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token.Start;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = start;
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd)
			{
				end = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token.End;
				Skip();
				isImplicit = false;
			}
			else if (!(currentToken is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamEnd) && !(currentToken is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart) && !(currentToken is <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowSequenceEnd) && !(currentToken is <cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective) && (!(Current is YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar) || !(currentToken is <cba6ec40-2546-4a46-9577-18d27987fd9e>Error)))
			{
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>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 = <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.DocumentStart;
			return new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd(isImplicit, start, end);
		}

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent ParseBlockSequenceEntry(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Token <cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken();
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEntry <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEntry)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark position = <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEntry.End;
				Skip();
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken();
				if (!(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEntry) && !(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEnd))
				{
					states.Push(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.BlockSequenceEntry);
					return ParseNode(isBlock: true, isIndentlessSequence: false);
				}
				state = <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.BlockSequenceEntry;
				return ProcessEmptyScalar(in position);
			}
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end;
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEnd <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEnd)
			{
				state = states.Pop();
				start = <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEnd.Start;
				end = <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEnd.End;
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent result = new <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEnd(in start, in end);
				Skip();
				return result;
			}
			start = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token?.Start ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
			end = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token?.End ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
			throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(in start, in end, "While parsing a block collection, did not find expected '-' indicator.");
		}

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent ParseIndentlessSequenceEntry()
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Token <cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken();
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEntry <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEntry)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark position = <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEntry.End;
				Skip();
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken();
				if (!(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEntry) && !(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>Key) && !(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>Value) && !(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEnd))
				{
					states.Push(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.IndentlessSequenceEntry);
					return ParseNode(isBlock: true, isIndentlessSequence: false);
				}
				state = <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.IndentlessSequenceEntry;
				return ProcessEmptyScalar(in position);
			}
			state = states.Pop();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token?.Start ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token?.End ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
			return new <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEnd(in start, in end);
		}

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent ParseBlockMappingKey(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Token <cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken();
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>Key <cba6ec40-2546-4a46-9577-18d27987fd9e>Key)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark position = <cba6ec40-2546-4a46-9577-18d27987fd9e>Key.End;
				Skip();
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken();
				if (!(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>Key) && !(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>Value) && !(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEnd))
				{
					states.Push(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.BlockMappingValue);
					return ParseNode(isBlock: true, isIndentlessSequence: true);
				}
				state = <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.BlockMappingValue;
				return ProcessEmptyScalar(in position);
			}
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark position2;
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>Value <cba6ec40-2546-4a46-9577-18d27987fd9e>Value)
			{
				Skip();
				position2 = <cba6ec40-2546-4a46-9577-18d27987fd9e>Value.End;
				return ProcessEmptyScalar(in position2);
			}
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias)
			{
				Skip();
				return new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias.Value, <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias.Start, <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias.End);
			}
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end;
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEnd <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEnd)
			{
				state = states.Pop();
				position2 = <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEnd.Start;
				end = <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEnd.End;
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent result = new <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEnd(in position2, in end);
				Skip();
				return result;
			}
			if (GetCurrentToken() is <cba6ec40-2546-4a46-9577-18d27987fd9e>Error <cba6ec40-2546-4a46-9577-18d27987fd9e>Error)
			{
				position2 = <cba6ec40-2546-4a46-9577-18d27987fd9e>Error.Start;
				end = <cba6ec40-2546-4a46-9577-18d27987fd9e>Error.End;
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException(in position2, in end, <cba6ec40-2546-4a46-9577-18d27987fd9e>Error.Value);
			}
			position2 = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token?.Start ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
			end = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token?.End ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
			throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(in position2, in end, "While parsing a block mapping, did not find expected key.");
		}

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent ParseBlockMappingValue()
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Token <cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken();
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>Value <cba6ec40-2546-4a46-9577-18d27987fd9e>Value)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark position = <cba6ec40-2546-4a46-9577-18d27987fd9e>Value.End;
				Skip();
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken();
				if (!(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>Key) && !(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>Value) && !(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEnd))
				{
					states.Push(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.BlockMappingKey);
					return ParseNode(isBlock: true, isIndentlessSequence: true);
				}
				state = <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.BlockMappingKey;
				return ProcessEmptyScalar(in position);
			}
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start;
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>Error <cba6ec40-2546-4a46-9577-18d27987fd9e>Error)
			{
				start = <cba6ec40-2546-4a46-9577-18d27987fd9e>Error.Start;
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = <cba6ec40-2546-4a46-9577-18d27987fd9e>Error.End;
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(in start, in end, <cba6ec40-2546-4a46-9577-18d27987fd9e>Error.Value);
			}
			state = <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.BlockMappingKey;
			start = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token?.Start ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
			return ProcessEmptyScalar(in start);
		}

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent ParseFlowSequenceEntry(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Token <cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent result;
			if (!(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowSequenceEnd))
			{
				if (!isFirst)
				{
					if (!(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowEntry))
					{
						start = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token?.Start ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
						end = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token?.End ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
						throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(in start, in end, "While parsing a flow sequence, did not find expected ',' or ']'.");
					}
					Skip();
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken();
				}
				if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>Key)
				{
					state = <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowSequenceEntryMappingKey;
					result = new <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName.Empty, isImplicit: true, <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStyle.Flow);
					Skip();
					return result;
				}
				if (!(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowSequenceEnd))
				{
					states.Push(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowSequenceEntry);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = states.Pop();
			start = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token?.Start ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
			end = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token?.End ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
			result = new <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEnd(in start, in end);
			Skip();
			return result;
		}

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent ParseFlowSequenceEntryMappingKey()
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Token <cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken();
			if (!(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>Value) && !(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowEntry) && !(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowSequenceEnd))
			{
				states.Push(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowSequenceEntryMappingValue);
				return ParseNode(isBlock: false, isIndentlessSequence: false);
			}
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark position = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token?.End ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
			Skip();
			state = <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowSequenceEntryMappingValue;
			return ProcessEmptyScalar(in position);
		}

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent ParseFlowSequenceEntryMappingValue()
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Token <cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken();
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>Value)
			{
				Skip();
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken();
				if (!(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowEntry) && !(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowSequenceEnd))
				{
					states.Push(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowSequenceEntryMappingEnd);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowSequenceEntryMappingEnd;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark position = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token?.Start ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
			return ProcessEmptyScalar(in position);
		}

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEnd ParseFlowSequenceEntryMappingEnd()
		{
			state = <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowSequenceEntry;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Token <cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token?.Start ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token?.End ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
			return new <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEnd(in start, in end);
		}

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent ParseFlowMappingKey(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Token <cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end;
			if (!(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowMappingEnd))
			{
				if (!isFirst)
				{
					if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowEntry)
					{
						Skip();
						<cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken();
					}
					else if (!(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar))
					{
						start = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token?.Start ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
						end = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token?.End ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
						throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(in start, in end, "While parsing a flow mapping,  did not find expected ',' or '}'.");
					}
				}
				if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>Key)
				{
					Skip();
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken();
					if (!(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>Value) && !(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowEntry) && !(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowMappingEnd))
					{
						states.Push(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowMappingValue);
						return ParseNode(isBlock: false, isIndentlessSequence: false);
					}
					state = <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowMappingValue;
					start = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token?.Start ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
					return ProcessEmptyScalar(in start);
				}
				if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar)
				{
					states.Push(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowMappingValue);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
				if (!(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowMappingEnd))
				{
					states.Push(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowMappingEmptyValue);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = states.Pop();
			Skip();
			start = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token?.Start ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
			end = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token?.End ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
			return new <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEnd(in start, in end);
		}

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent ParseFlowMappingValue(bool isEmpty)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Token <cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken();
			if (!isEmpty && <cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>Value)
			{
				Skip();
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Token = GetCurrentToken();
				if (!(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowEntry) && !(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token is <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowMappingEnd))
				{
					states.Push(<cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowMappingKey);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserState.FlowMappingKey;
			if (!isEmpty && <cba6ec40-2546-4a46-9577-18d27987fd9e>Token is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar)
			{
				Skip();
				return new YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar.Value, <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar.Style, isPlainImplicit: false, isQuotedImplicit: false, <cba6ec40-2546-4a46-9577-18d27987fd9e>Token.Start, <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar.End);
			}
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark position = <cba6ec40-2546-4a46-9577-18d27987fd9e>Token?.Start ?? <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty;
			return ProcessEmptyScalar(in position);
		}
	}
	internal static class <cba6ec40-2546-4a46-9577-18d27987fd9e>ParserExtensions
	{
		public static T Consume<T>(this <cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser) where T : <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent
		{
			T result = parser.Require<T>();
			parser.MoveNext();
			return result;
		}

		public static bool TryConsume<T>(this <cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, [<cba6ec40-2546-4a46-9577-18d27987fd9e>MaybeNullWhen(false)] out T @event) where T : <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent
		{
			if (parser.Accept<T>(out @event))
			{
				parser.MoveNext();
				return true;
			}
			return false;
		}

		public static T Require<T>(this <cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser) where T : <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent
		{
			if (!parser.Accept<T>(out var @event))
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent current = parser.Current;
				if (current == null)
				{
					throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException("Expected '" + typeof(T).Name + "', got nothing.");
				}
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = current.Start;
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = current.End;
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException(in start, in end, $"Expected '{typeof(T).Name}', got '{current.GetType().Name}' (at {current.Start}).");
			}
			return @event;
		}

		public static bool Accept<T>(this <cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, [<cba6ec40-2546-4a46-9577-18d27987fd9e>MaybeNullWhen(false)] out T @event) where T : <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser)
		{
			int num = 0;
			do
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent = parser.Consume<<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent>();
				num += <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent.NestingIncrease;
			}
			while (num > 0);
		}

		[Obsolete("Please use Consume<T>() instead")]
		public static T Expect<T>(this <cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser) where T : <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent
		{
			return parser.Consume<T>();
		}

		[Obsolete("Please use TryConsume<T>(out var evt) instead")]
		[return: <cba6ec40-2546-4a46-9577-18d27987fd9e>MaybeNull]
		public static T? Allow<T>(this <cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser) where T : <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent
		{
			if (!parser.TryConsume<T>(out var @event))
			{
				return null;
			}
			return @event;
		}

		[Obsolete("Please use Accept<T>(out var evt) instead")]
		[return: <cba6ec40-2546-4a46-9577-18d27987fd9e>MaybeNull]
		public static T? Peek<T>(this <cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser) where T : <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser) where T : <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent
		{
			T @event;
			return parser.Accept<T>(out @event);
		}

		public static bool TryFindMappingEntry(this <cba6ec40-2546-4a46-9577-18d27987fd9e>IParser parser, Func<YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar, bool> selector, [<cba6ec40-2546-4a46-9577-18d27987fd9e>MaybeNullWhen(false)] out YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar? key, [<cba6ec40-2546-4a46-9577-18d27987fd9e>MaybeNullWhen(false)] out <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent? value)
		{
			if (parser.TryConsume<<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart>(out var _))
			{
				while (parser.Current != null)
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent current = parser.Current;
					if (!(current is YamlDotNet.Core.Events.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar))
					{
						if (current is <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart || current is <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart)
						{
							parser.SkipThisAndNestedEvents();
						}
						else
						{
							parser.MoveNext();
						}
						continue;
					}
					bool flag = selector(<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar);
					parser.MoveNext();
					if (flag)
					{
						value = parser.Current;
						key = <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar;
						return true;
					}
					parser.SkipThisAndNestedEvents();
				}
			}
			key = null;
			value = null;
			return false;
		}
	}
	internal enum <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>RecursionLevel
	{
		private int current;

		public int Maximum { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>RecursionLevel(int maximum)
		{
			Maximum = maximum;
		}

		public void Increment()
		{
			if (!TryIncrement())
			{
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>MaximumRecursionLevelReachedException("Maximum level of recursion reached");
			}
		}

		public bool TryIncrement()
		{
			if (current < Maximum)
			{
				current++;
				return true;
			}
			return false;
		}

		public void Decrement()
		{
			if (current == 0)
			{
				throw new InvalidOperationException("Attempted to decrement RecursionLevel to a negative value");
			}
			current--;
		}
	}
	public enum <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle
	{
		Any,
		Plain,
		SingleQuoted,
		DoubleQuoted,
		Literal,
		Folded,
		ForcePlain
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>Scanner : <cba6ec40-2546-4a46-9577-18d27987fd9e>IScanner
	{
		private const int MaxVersionNumberLength = 9;

		private static readonly SortedDictionary<char, char> SimpleEscapeCodes = new SortedDictionary<char, char>
		{
			{ '0', '\0' },
			{ 'a', '\a' },
			{ 'b', '\b' },
			{ 't', '\t' },
			{ '\t', '\t' },
			{ 'n', '\n' },
			{ 'v', '\v' },
			{ 'f', '\f' },
			{ 'r', '\r' },
			{ 'e', '\u001b' },
			{ ' ', ' ' },
			{ '"', '"' },
			{ '\\', '\\' },
			{ '/', '/' },
			{ 'N', '\u0085' },
			{ '_', '\u00a0' },
			{ 'L', '\u2028' },
			{ 'P', '\u2029' }
		};

		private readonly Stack<long> indents = new Stack<long>();

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>InsertionQueue<<cba6ec40-2546-4a46-9577-18d27987fd9e>Token> tokens = new <cba6ec40-2546-4a46-9577-18d27987fd9e>InsertionQueue<<cba6ec40-2546-4a46-9577-18d27987fd9e>Token>();

		private readonly Stack<<cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey> simpleKeys = new Stack<<cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey>();

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer<<cba6ec40-2546-4a46-9577-18d27987fd9e>LookAheadBuffer> analyzer;

		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>Cursor cursor;

		private bool streamStartProduced;

		private bool streamEndProduced;

		private bool plainScalarFollowedByComment;

		private bool flowCollectionFetched;

		private bool startFlowCollectionFetched;

		private long indent = -1L;

		private bool flowScalarFetched;

		private bool simpleKeyAllowed;

		private int flowLevel;

		private int tokensParsed;

		private bool tokenAvailable;

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>Token? previous;

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>Anchor? previousAnchor;

		private YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar? lastScalar;

		private readonly int maxKeySize;

		private static readonly byte[] EmptyBytes = Array.Empty<byte>();

		public bool SkipComments { get; private set; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Token? Current { get; private set; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark CurrentPosition => cursor.Mark();

		private bool IsDocumentStart()
		{
			if (!analyzer.EndOfInput && cursor.LineOffset == 0L && analyzer.Check('-') && analyzer.Check('-', 1) && analyzer.Check('-', 2))
			{
				return analyzer.IsWhiteBreakOrZero(3);
			}
			return false;
		}

		private bool IsDocumentEnd()
		{
			if (!analyzer.EndOfInput && cursor.LineOffset == 0L && analyzer.Check('.') && analyzer.Check('.', 1) && analyzer.Check('.', 2))
			{
				return analyzer.IsWhiteBreakOrZero(3);
			}
			return false;
		}

		private bool IsDocumentIndicator()
		{
			if (!IsDocumentStart())
			{
				return IsDocumentEnd();
			}
			return true;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Scanner(TextReader input, bool skipComments = true)
			: this(input, skipComments, 1024)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Scanner(TextReader input, bool skipComments, int maxKeySize)
		{
			analyzer = new <cba6ec40-2546-4a46-9577-18d27987fd9e>CharacterAnalyzer<<cba6ec40-2546-4a46-9577-18d27987fd9e>LookAheadBuffer>(new <cba6ec40-2546-4a46-9577-18d27987fd9e>LookAheadBuffer(input, 1024));
			cursor = new <cba6ec40-2546-4a46-9577-18d27987fd9e>Cursor();
			SkipComments = skipComments;
			this.maxKeySize = maxKeySize;
		}

		public bool MoveNext()
		{
			if (Current != null)
			{
				ConsumeCurrent();
			}
			return MoveNextWithoutConsuming();
		}

		public bool MoveNextWithoutConsuming()
		{
			if (!tokenAvailable && !streamEndProduced)
			{
				FetchMoreTokens();
			}
			if (tokens.Count > 0)
			{
				Current = tokens.Dequeue();
				tokenAvailable = false;
				return true;
			}
			Current = null;
			return false;
		}

		public void ConsumeCurrent()
		{
			tokensParsed++;
			tokenAvailable = false;
			previous = Current;
			Current = null;
		}

		private char ReadCurrentCharacter()
		{
			char result = analyzer.Peek(0);
			Skip();
			return result;
		}

		private char ReadLine()
		{
			if (analyzer.Check("\r\n\u0085"))
			{
				SkipLine();
				return '\n';
			}
			char result = analyzer.Peek(0);
			SkipLine();
			return result;
		}

		private void FetchMoreTokens()
		{
			while (true)
			{
				bool flag = false;
				if (tokens.Count == 0)
				{
					flag = true;
				}
				else
				{
					foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>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 (<cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey simpleKey in simpleKeys)
			{
				if (simpleKey.IsPossible && (simpleKey.Line < cursor.Line || simpleKey.Index + maxKeySize < cursor.Index))
				{
					if (simpleKey.IsRequired)
					{
						<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark2 = cursor.Mark();
						tokens.Enqueue(new <cba6ec40-2546-4a46-9577-18d27987fd9e>Error("While scanning a simple key, could not find expected ':'.", <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark2, <cba6ec40-2546-4a46-9577-18d27987fd9e>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 == 0L && analyzer.Check('%'))
			{
				lastScalar = null;
				FetchDirective();
				return;
			}
			if (IsDocumentStart())
			{
				lastScalar = null;
				FetchDocumentIndicator(isStartToken: true);
				return;
			}
			if (IsDocumentEnd())
			{
				lastScalar = null;
				FetchDocumentIndicator(isStartToken: false);
				return;
			}
			if (analyzer.Check('['))
			{
				lastScalar = null;
				FetchFlowCollectionStart(isSequenceToken: true);
				return;
			}
			if (analyzer.Check('{'))
			{
				lastScalar = null;
				FetchFlowCollectionStart(isSequenceToken: false);
				return;
			}
			if (analyzer.Check(']'))
			{
				lastScalar = null;
				FetchFlowCollectionEnd(isSequenceToken: true);
				return;
			}
			if (analyzer.Check('}'))
			{
				lastScalar = null;
				FetchFlowCollectionEnd(isSequenceToken: false);
				return;
			}
			if (analyzer.Check(','))
			{
				lastScalar = null;
				FetchFlowEntry();
				return;
			}
			if (analyzer.Check('-'))
			{
				if (analyzer.IsWhiteBreakOrZero(1))
				{
					FetchBlockEntry();
					return;
				}
				if (flowLevel > 0 && analyzer.Check(",[]{}", 1))
				{
					tokens.Enqueue(new <cba6ec40-2546-4a46-9577-18d27987fd9e>Error("Invalid key indicator format.", cursor.Mark(), cursor.Mark()));
				}
			}
			if (analyzer.Check('?') && (flowLevel > 0 || analyzer.IsWhiteBreakOrZero(1)) && analyzer.IsWhiteBreakOrZero(1))
			{
				FetchKey();
			}
			else if (analyzer.Check(':') && (flowLevel > 0 || analyzer.IsWhiteBreakOrZero(1)) && (!simpleKeyAllowed || flowLevel <= 0) && (!flowScalarFetched || !analyzer.Check(':', 1)) && (analyzer.IsWhiteBreakOrZero(1) || analyzer.Check(',', 1) || flowScalarFetched || flowCollectionFetched || startFlowCollectionFetched))
			{
				if (lastScalar != null)
				{
					lastScalar.IsKey = true;
					lastScalar = null;
				}
				FetchValue();
			}
			else if (analyzer.Check('*'))
			{
				FetchAnchor(isAlias: true);
			}
			else if (analyzer.Check('&'))
			{
				FetchAnchor(isAlias: false);
			}
			else if (analyzer.Check('!'))
			{
				FetchTag();
			}
			else if (analyzer.Check('|') && flowLevel == 0)
			{
				FetchBlockScalar(isLiteral: true);
			}
			else if (analyzer.Check('>') && flowLevel == 0)
			{
				FetchBlockScalar(isLiteral: false);
			}
			else if (analyzer.Check('\''))
			{
				FetchQuotedScalar(isSingleQuoted: true);
			}
			else if (analyzer.Check('"'))
			{
				FetchQuotedScalar(isSingleQuoted: false);
			}
			else if ((!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("-?:,[]{}#&*!|>'\"%@`")) || (analyzer.Check('-') && !analyzer.IsWhite(1)) || (analyzer.Check("?:") && !analyzer.IsWhiteBreakOrZero(1)) || (simpleKeyAllowed && flowLevel > 0))
			{
				if (plainScalarFollowedByComment)
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark2 = cursor.Mark();
					tokens.Enqueue(new <cba6ec40-2546-4a46-9577-18d27987fd9e>Error("While scanning plain scalar, found a comment between adjacent scalars.", <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark2, <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException("While scanning a mapping, found invalid tab as indentation.");
				}
				if (!analyzer.IsWhiteBreakOrZero())
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = cursor.Mark();
					Skip();
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
					throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>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;
			}
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = cursor.Mark();
			Skip();
			while (analyzer.IsSpace())
			{
				Skip();
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				while (!analyzer.IsBreakOrZero())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (!SkipComments)
				{
					bool isInline = previous != null && previous.End.Line == start.Line && previous.End.Column != 1 && !(previous is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamStart);
					tokens.Enqueue(new YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>Comment(builder.ToString(), isInline, start, cursor.Mark()));
				}
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void FetchStreamStart()
		{
			simpleKeys.Push(new <cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey());
			simpleKeyAllowed = true;
			streamStartProduced = true;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = cursor.Mark();
			tokens.Enqueue(new YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamStart(in start, in start));
		}

		private void UnrollIndent(long column)
		{
			if (flowLevel == 0)
			{
				while (indent > column)
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = cursor.Mark();
					tokens.Enqueue(new <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEnd(in start, in start));
					indent = indents.Pop();
				}
			}
		}

		private void FetchStreamEnd()
		{
			cursor.ForceSkipLineAfterNonBreak();
			UnrollIndent(-1L);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			streamEndProduced = true;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = cursor.Mark();
			tokens.Enqueue(new YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamEnd(in start, in start));
		}

		private void FetchDirective()
		{
			UnrollIndent(-1L);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Token <cba6ec40-2546-4a46-9577-18d27987fd9e>Token = ScanDirective();
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token != null)
			{
				tokens.Enqueue(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token);
			}
		}

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>Token? ScanDirective()
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = cursor.Mark();
			Skip();
			string text = ScanDirectiveName(in start);
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Token result;
			if (!(text == "YAML"))
			{
				if (!(text == "TAG"))
				{
					while (!analyzer.EndOfInput && !analyzer.Check('#') && !analyzer.IsBreak())
					{
						Skip();
					}
					return null;
				}
				result = ScanTagDirectiveValue(in start);
			}
			else
			{
				if (!(previous is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart) && !(previous is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamStart) && !(previous is YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd))
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
					throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>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())
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException(in start, in end, "While scanning a directive, did not find expected comment or line break.");
			}
			if (analyzer.IsBreak())
			{
				SkipLine();
			}
			return result;
		}

		private void FetchDocumentIndicator(bool isStartToken)
		{
			UnrollIndent(-1L);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
			Skip();
			Skip();
			Skip();
			if (isStartToken)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>InsertionQueue<<cba6ec40-2546-4a46-9577-18d27987fd9e>Token> obj = tokens;
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end2 = cursor.Mark();
				obj.Enqueue(new YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart(in end, in end2));
				return;
			}
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Token <cba6ec40-2546-4a46-9577-18d27987fd9e>Token = null;
			while (!analyzer.EndOfInput && !analyzer.IsBreak() && !analyzer.Check('#'))
			{
				if (!analyzer.IsWhite())
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Token = new <cba6ec40-2546-4a46-9577-18d27987fd9e>Error("While scanning a document end, found invalid content after '...' marker.", end, cursor.Mark());
					break;
				}
				Skip();
			}
			tokens.Enqueue(new YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd(in end, in end));
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token != null)
			{
				tokens.Enqueue(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token);
			}
		}

		private void FetchFlowCollectionStart(bool isSequenceToken)
		{
			SaveSimpleKey();
			IncreaseFlowLevel();
			simpleKeyAllowed = true;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = cursor.Mark();
			Skip();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Token item = ((!isSequenceToken) ? ((<cba6ec40-2546-4a46-9577-18d27987fd9e>Token)new <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowMappingStart(in start, in start)) : ((<cba6ec40-2546-4a46-9577-18d27987fd9e>Token)new <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowSequenceStart(in start, in start)));
			tokens.Enqueue(item);
			startFlowCollectionFetched = true;
		}

		private void IncreaseFlowLevel()
		{
			simpleKeys.Push(new <cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey());
			flowLevel++;
		}

		private void FetchFlowCollectionEnd(bool isSequenceToken)
		{
			RemoveSimpleKey();
			DecreaseFlowLevel();
			simpleKeyAllowed = false;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = cursor.Mark();
			Skip();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Token <cba6ec40-2546-4a46-9577-18d27987fd9e>Token = null;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Token item;
			if (isSequenceToken)
			{
				if (analyzer.Check('#'))
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Token = new <cba6ec40-2546-4a46-9577-18d27987fd9e>Error("While scanning a flow sequence end, found invalid comment after ']'.", start, start);
				}
				item = new <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowSequenceEnd(in start, in start);
			}
			else
			{
				item = new <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowMappingEnd(in start, in start);
			}
			tokens.Enqueue(item);
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>Token != null)
			{
				tokens.Enqueue(<cba6ec40-2546-4a46-9577-18d27987fd9e>Token);
			}
			flowCollectionFetched = true;
		}

		private void DecreaseFlowLevel()
		{
			if (flowLevel > 0)
			{
				flowLevel--;
				simpleKeys.Pop();
			}
		}

		private void FetchFlowEntry()
		{
			RemoveSimpleKey();
			simpleKeyAllowed = true;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = cursor.Mark();
			Skip();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
			if (analyzer.Check('#'))
			{
				tokens.Enqueue(new <cba6ec40-2546-4a46-9577-18d27987fd9e>Error("While scanning a flow entry, found invalid comment after comma.", start, end));
			}
			else
			{
				tokens.Enqueue(new <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowEntry(in start, in end));
			}
		}

		private void FetchBlockEntry()
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start;
			if (flowLevel == 0)
			{
				if (!simpleKeyAllowed)
				{
					if (previousAnchor != null && previousAnchor.End.Line == cursor.Line)
					{
						start = previousAnchor.Start;
						<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = previousAnchor.End;
						throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(in start, in end, "Anchor before sequence entry on same line is not allowed.");
					}
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark2 = cursor.Mark();
					tokens.Enqueue(new <cba6ec40-2546-4a46-9577-18d27987fd9e>Error("Block sequence entries are not allowed in this context.", <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark2, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark2));
				}
				RollIndent(cursor.LineOffset, -1, isSequence: true, cursor.Mark());
			}
			RemoveSimpleKey();
			simpleKeyAllowed = true;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start2 = cursor.Mark();
			Skip();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>InsertionQueue<<cba6ec40-2546-4a46-9577-18d27987fd9e>Token> obj = tokens;
			start = cursor.Mark();
			obj.Enqueue(new <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEntry(in start2, in start));
		}

		private void FetchKey()
		{
			if (flowLevel == 0)
			{
				if (!simpleKeyAllowed)
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = cursor.Mark();
					throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>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;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start2 = cursor.Mark();
			Skip();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>InsertionQueue<<cba6ec40-2546-4a46-9577-18d27987fd9e>Token> obj = tokens;
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
			obj.Enqueue(new <cba6ec40-2546-4a46-9577-18d27987fd9e>Key(in start2, in end));
		}

		private void FetchValue()
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey <cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey2 = simpleKeys.Peek();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start;
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey2.IsPossible)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>InsertionQueue<<cba6ec40-2546-4a46-9577-18d27987fd9e>Token> obj = tokens;
				int index = <cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey2.TokenNumber - tokensParsed;
				start = <cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey2.Mark;
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = <cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey2.Mark;
				obj.Insert(index, new <cba6ec40-2546-4a46-9577-18d27987fd9e>Key(in start, in end));
				RollIndent(<cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey2.LineOffset, <cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey2.TokenNumber, isSequence: false, <cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey2.Mark);
				<cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey2.MarkAsImpossible();
				simpleKeyAllowed = false;
			}
			else
			{
				bool flag = flowLevel == 0;
				if (flag)
				{
					if (!simpleKeyAllowed)
					{
						<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark2 = cursor.Mark();
						tokens.Enqueue(new <cba6ec40-2546-4a46-9577-18d27987fd9e>Error("Mapping values are not allowed in this context.", <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark2, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark2));
						return;
					}
					RollIndent(cursor.LineOffset, -1, isSequence: false, cursor.Mark());
					if (cursor.LineOffset == 0L && <cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey2.LineOffset == 0L)
					{
						<cba6ec40-2546-4a46-9577-18d27987fd9e>InsertionQueue<<cba6ec40-2546-4a46-9577-18d27987fd9e>Token> obj2 = tokens;
						int count = tokens.Count;
						start = <cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey2.Mark;
						<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = <cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey2.Mark;
						obj2.Insert(count, new <cba6ec40-2546-4a46-9577-18d27987fd9e>Key(in start, in end));
						flag = false;
					}
				}
				simpleKeyAllowed = flag;
			}
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start2 = cursor.Mark();
			Skip();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>InsertionQueue<<cba6ec40-2546-4a46-9577-18d27987fd9e>Token> obj3 = tokens;
			start = cursor.Mark();
			obj3.Enqueue(new <cba6ec40-2546-4a46-9577-18d27987fd9e>Value(in start2, in start));
		}

		private void RollIndent(long column, int number, bool isSequence, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark position)
		{
			if (flowLevel <= 0 && indent < column)
			{
				indents.Push(indent);
				indent = column;
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Token item = ((!isSequence) ? ((<cba6ec40-2546-4a46-9577-18d27987fd9e>Token)new <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockMappingStart(in position, in position)) : ((<cba6ec40-2546-4a46-9577-18d27987fd9e>Token)new <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>Token ScanAnchor(bool isAlias)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = cursor.Mark();
			Skip();
			bool flag = false;
			if (isAlias)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey <cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey2 = simpleKeys.Peek();
				flag = <cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey2.IsRequired && <cba6ec40-2546-4a46-9577-18d27987fd9e>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("?:,]}%@`")))
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
					throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException(in start, in end, "While scanning an anchor or alias, found value containing disallowed: []{},");
				}
				<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName value = new <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName(builder.ToString());
				if (isAlias)
				{
					return new YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias(value, start, cursor.Mark());
				}
				return previousAnchor = new <cba6ec40-2546-4a46-9577-18d27987fd9e>Anchor(value, start, cursor.Mark());
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void FetchTag()
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			tokens.Enqueue(ScanTag());
		}

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>Tag ScanTag()
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = cursor.Mark();
			string text;
			string text2;
			if (analyzer.Check('<', 1))
			{
				text = string.Empty;
				Skip();
				Skip();
				text2 = ScanTagUri(null, start);
				if (!analyzer.Check('>'))
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
					throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>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(','))
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException(in start, in end, "While scanning a tag, did not find expected whitespace, comma or line break.");
			}
			return new <cba6ec40-2546-4a46-9577-18d27987fd9e>Tag(text, text2, start, cursor.Mark());
		}

		private void FetchBlockScalar(bool isLiteral)
		{
			SaveSimpleKey();
			simpleKeyAllowed = true;
			tokens.Enqueue(ScanBlockScalar(isLiteral));
		}

		private YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar ScanBlockScalar(bool isLiteral)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				StringBuilderPool.BuilderWrapper builderWrapper2 = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder2 = builderWrapper2.Builder;
					StringBuilderPool.BuilderWrapper builderWrapper3 = StringBuilderPool.Rent();
					try
					{
						StringBuilder builder3 = builderWrapper3.Builder;
						int num = 0;
						int num2 = 0;
						long currentIndent = 0L;
						bool flag = false;
						bool? isFirstLine = null;
						<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = cursor.Mark();
						Skip();
						if (analyzer.Check("+-"))
						{
							num = (analyzer.Check('+') ? 1 : (-1));
							Skip();
							if (analyzer.IsDigit())
							{
								if (analyzer.Check('0'))
								{
									<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
									throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>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'))
							{
								<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
								throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>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('#'))
						{
							<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
							throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>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())
						{
							<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
							throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException(in start, in end, "While scanning a block scalar, did not find expected comment or line break.");
						}
						if (analyzer.IsBreak())
						{
							SkipLine();
							if (!isFirstLine.HasValue)
							{
								isFirstLine = true;
							}
							else if (isFirstLine.GetValueOrDefault())
							{
								isFirstLine = false;
							}
						}
						<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end2 = cursor.Mark();
						if (num2 != 0)
						{
							currentIndent = ((indent >= 0) ? (indent + num2) : num2);
						}
						currentIndent = ScanBlockScalarBreaks(currentIndent, builder3, isLiteral, ref end2, ref isFirstLine);
						isFirstLine = false;
						while (cursor.LineOffset == currentIndent && !analyzer.IsZero() && !IsDocumentEnd())
						{
							bool flag2 = analyzer.IsWhite();
							if (!isLiteral && StartsWith(builder2, '\n') && !flag && !flag2)
							{
								if (builder3.Length == 0)
								{
									builder.Append(' ');
								}
								builder2.Length = 0;
							}
							else
							{
								builder.Append((object?)builder2);
								builder2.Length = 0;
							}
							builder.Append((object?)builder3);
							builder3.Length = 0;
							flag = analyzer.IsWhite();
							while (!analyzer.IsBreakOrZero())
							{
								builder.Append(ReadCurrentCharacter());
							}
							char c = ReadLine();
							if (c != 0)
							{
								builder2.Append(c);
							}
							currentIndent = ScanBlockScalarBreaks(currentIndent, builder3, isLiteral, ref end2, ref isFirstLine);
						}
						if (num != -1)
						{
							builder.Append((object?)builder2);
						}
						if (num == 1)
						{
							builder.Append((object?)builder3);
						}
						<cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle style = (isLiteral ? <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Literal : <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Folded);
						return new YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar(builder.ToString(), style, start, end2);
					}
					finally
					{
						((IDisposable)builderWrapper3).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private long ScanBlockScalarBreaks(long currentIndent, StringBuilder breaks, bool isLiteral, ref <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end, ref bool? isFirstLine)
		{
			long num = 0L;
			long num2 = -1L;
			end = cursor.Mark();
			while (true)
			{
				if ((currentIndent == 0L || cursor.LineOffset < currentIndent) && analyzer.IsSpace())
				{
					Skip();
					continue;
				}
				if (cursor.LineOffset > num)
				{
					num = cursor.LineOffset;
				}
				if (!analyzer.IsBreak())
				{
					break;
				}
				if (isFirstLine.GetValueOrDefault())
				{
					isFirstLine = false;
					num2 = cursor.LineOffset;
				}
				breaks.Append(ReadLine());
				end = cursor.Mark();
			}
			if (isLiteral && isFirstLine.GetValueOrDefault())
			{
				long num3 = cursor.LineOffset;
				int num4 = 0;
				while (!analyzer.IsBreak(num4) && analyzer.IsSpace(num4))
				{
					num4++;
					num3++;
				}
				if (analyzer.IsBreak(num4) && num3 > cursor.LineOffset)
				{
					isFirstLine = false;
					num2 = num3;
				}
			}
			if (isLiteral && num2 > 1 && currentIndent < num2 - 1)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end2 = cursor.Mark();
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(in end, in end2, "While scanning a literal block scalar, found extra spaces in first line.");
			}
			if (!isLiteral && num > cursor.LineOffset && num2 > -1)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end2 = cursor.Mark();
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(in end, in end2, "While scanning a literal block scalar, found more spaces in lines above first content line.");
			}
			if (currentIndent == 0L && (cursor.LineOffset > 0 || indent > -1))
			{
				currentIndent = Math.Max(num, Math.Max(indent + 1, 1L));
			}
			return currentIndent;
		}

		private void FetchQuotedScalar(bool isSingleQuoted)
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			flowScalarFetched = flowLevel > 0;
			YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar item = ScanFlowScalar(isSingleQuoted);
			tokens.Enqueue(item);
			lastScalar = item;
			if (!isSingleQuoted && analyzer.Check('#'))
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark2 = cursor.Mark();
				tokens.Enqueue(new <cba6ec40-2546-4a46-9577-18d27987fd9e>Error("While scanning a flow sequence end, found invalid comment after double-quoted scalar.", <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark2, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark2));
			}
		}

		private YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar ScanFlowScalar(bool isSingleQuoted)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>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())
								{
									<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
									throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found unexpected document indicator.");
								}
								if (analyzer.IsZero())
								{
									<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
									throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found unexpected end of stream.");
								}
								if (flag && !isSingleQuoted && indent >= cursor.LineOffset)
								{
									<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
									throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>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;
											}
											<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
											throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>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))
											{
												<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
												throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException(in start, in end, "While scanning a quoted scalar, did not find expected hexadecimal number.");
											}
											num2 = (num2 << 4) + analyzer.AsHex(i);
										}
										if (num2 >= 55296 && num2 <= 57343)
										{
											for (int j = 0; j < num; j++)
											{
												Skip();
											}
											if (analyzer.Peek(0) != '\\' || (analyzer.Peek(1) != 'u' && analyzer.Peek(1) != 'U'))
											{
												<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
												throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found invalid Unicode surrogates.");
											}
											Skip();
											num = ((analyzer.Peek(0) != 'u') ? 8 : 4);
											Skip();
											int num3 = 0;
											for (int k = 0; k < num; k++)
											{
												if (!analyzer.IsHex(0))
												{
													<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
													throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException(in start, in end, "While scanning a quoted scalar, did not find expected hexadecimal number.");
												}
												num3 = (num3 << 4) + analyzer.AsHex(k);
											}
											for (int l = 0; l < num; l++)
											{
												Skip();
											}
											num2 = char.ConvertToUtf32((char)num2, (char)num3);
										}
										else
										{
											if (num2 > 1114111)
											{
												<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
												throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException(in start, in end, "While scanning a quoted scalar, found invalid Unicode character escape code.");
											}
											for (int m = 0; m < num; m++)
											{
												Skip();
											}
										}
										builder.Append(char.ConvertFromUtf32(num2));
									}
									else
									{
										builder.Append(ReadCurrentCharacter());
									}
								}
								if (analyzer.Check(isSingleQuoted ? '\'' : '"'))
								{
									break;
								}
								while (analyzer.IsWhite() || analyzer.IsBreak())
								{
									if (analyzer.IsWhite())
									{
										if (!flag)
										{
											builder2.Append(ReadCurrentCharacter());
										}
										else
										{
											Skip();
										}
									}
									else if (!flag)
									{
										builder2.Length = 0;
										builder3.Append(ReadLine());
										flag = true;
									}
									else
									{
										builder4.Append(ReadLine());
									}
								}
								if (flag)
								{
									if (StartsWith(builder3, '\n'))
									{
										if (builder4.Length == 0)
										{
											builder.Append(' ');
										}
										else
										{
											builder.Append((object?)builder4);
										}
									}
									else
									{
										builder.Append((object?)builder3);
										builder.Append((object?)builder4);
									}
									builder3.Length = 0;
									builder4.Length = 0;
								}
								else
								{
									builder.Append((object?)builder2);
									builder2.Length = 0;
								}
							}
							Skip();
							return new YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar(builder.ToString(), isSingleQuoted ? <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.SingleQuoted : <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.DoubleQuoted, start, cursor.Mark());
						}
						finally
						{
							((IDisposable)builderWrapper4).Dispose();
						}
					}
					finally
					{
						((IDisposable)builderWrapper3).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void FetchPlainScalar()
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			bool isMultiline = false;
			YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar item = (lastScalar = ScanPlainScalar(ref isMultiline));
			if (isMultiline && analyzer.Check(':') && flowLevel == 0 && indent < cursor.LineOffset)
			{
				tokens.Enqueue(new <cba6ec40-2546-4a46-9577-18d27987fd9e>Error("While scanning a multiline plain scalar, found invalid mapping.", cursor.Mark(), cursor.Mark()));
			}
			tokens.Enqueue(item);
		}

		private YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar ScanPlainScalar(ref bool isMultiline)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				StringBuilderPool.BuilderWrapper builderWrapper2 = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder2 = builderWrapper2.Builder;
					StringBuilderPool.BuilderWrapper builderWrapper3 = StringBuilderPool.Rent();
					try
					{
						StringBuilder builder3 = builderWrapper3.Builder;
						StringBuilderPool.BuilderWrapper builderWrapper4 = StringBuilderPool.Rent();
						try
						{
							StringBuilder builder4 = builderWrapper4.Builder;
							bool flag = false;
							long num = indent + 1;
							<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = cursor.Mark();
							<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = start;
							<cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey <cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey2 = simpleKeys.Peek();
							while (!IsDocumentIndicator())
							{
								if (analyzer.Check('#'))
								{
									if (indent < 0 && flowLevel == 0)
									{
										plainScalarFollowedByComment = true;
									}
									break;
								}
								bool flag2 = analyzer.Check('*') && (!<cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey2.IsPossible || !<cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey2.IsRequired);
								while (!analyzer.IsWhiteBreakOrZero())
								{
									if ((analyzer.Check(':') && !flag2 && (analyzer.IsWhiteBreakOrZero(1) || (flowLevel > 0 && analyzer.Check(',', 1)))) || (flowLevel > 0 && analyzer.Check(",[]{}")))
									{
										if (flowLevel == 0 && !<cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey2.IsPossible)
										{
											tokens.Enqueue(new <cba6ec40-2546-4a46-9577-18d27987fd9e>Error("While scanning a plain scalar value, found invalid mapping.", cursor.Mark(), cursor.Mark()));
										}
										break;
									}
									if (flag || builder2.Length > 0)
									{
										if (flag)
										{
											if (StartsWith(builder3, '\n'))
											{
												if (builder4.Length == 0)
												{
													builder.Append(' ');
												}
												else
												{
													builder.Append((object?)builder4);
												}
											}
											else
											{
												builder.Append((object?)builder3);
												builder.Append((object?)builder4);
											}
											builder3.Length = 0;
											builder4.Length = 0;
											flag = false;
										}
										else
										{
											builder.Append((object?)builder2);
											builder2.Length = 0;
										}
									}
									if (flowLevel > 0 && cursor.LineOffset < num)
									{
										throw new InvalidOperationException();
									}
									builder.Append(ReadCurrentCharacter());
									end = cursor.Mark();
								}
								if (!analyzer.IsWhite() && !analyzer.IsBreak())
								{
									break;
								}
								while (analyzer.IsWhite() || analyzer.IsBreak())
								{
									if (analyzer.IsWhite())
									{
										if (flag && cursor.LineOffset < num && analyzer.IsTab())
										{
											<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end2 = cursor.Mark();
											throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException(in start, in end2, "While scanning a plain scalar, found a tab character that violate indentation.");
										}
										if (!flag)
										{
											builder2.Append(ReadCurrentCharacter());
										}
										else
										{
											Skip();
										}
									}
									else
									{
										isMultiline = true;
										if (!flag)
										{
											builder2.Length = 0;
											builder3.Append(ReadLine());
											flag = true;
										}
										else
										{
											builder4.Append(ReadLine());
										}
									}
								}
								if (flowLevel == 0 && cursor.LineOffset < num)
								{
									break;
								}
							}
							if (flag)
							{
								simpleKeyAllowed = true;
							}
							return new YamlDotNet.Core.Tokens.<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar(builder.ToString(), <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Plain, start, end);
						}
						finally
						{
							((IDisposable)builderWrapper4).Dispose();
						}
					}
					finally
					{
						((IDisposable)builderWrapper3).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void RemoveSimpleKey()
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey <cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey2 = simpleKeys.Peek();
			if (<cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey2.IsPossible && <cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey2.IsRequired)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start = <cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey2.Mark;
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = <cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey2.Mark;
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException(in start, in end, "While scanning a simple key, could not find expected ':'.");
			}
			<cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey2.MarkAsImpossible();
		}

		private string ScanDirectiveName(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				while (analyzer.IsAlphaNumericDashOrUnderscore())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (builder.Length == 0)
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
					throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException(in start, in end, "While scanning a directive, could not find expected directive name.");
				}
				if (analyzer.EndOfInput)
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
					throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException(in start, in end, "While scanning a directive, found unexpected end of stream.");
				}
				if (!analyzer.IsWhiteBreakOrZero())
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
					throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective ScanVersionDirectiveValue(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start)
		{
			SkipWhitespaces();
			int major = ScanVersionDirectiveNumber(in start);
			if (!analyzer.Check('.'))
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective(new <cba6ec40-2546-4a46-9577-18d27987fd9e>Version(major, minor), start, start);
		}

		private <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective ScanTagDirectiveValue(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start)
		{
			SkipWhitespaces();
			string handle = ScanTagHandle(isDirective: true, start);
			if (!analyzer.IsWhite())
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException(in start, in end, "While scanning a %TAG directive, did not find expected whitespace.");
			}
			SkipWhitespaces();
			string prefix = ScanTagUri(null, start);
			if (!analyzer.IsWhiteBreakOrZero())
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException(in start, in end, "While scanning a %TAG directive, did not find expected whitespace or line break.");
			}
			return new <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective(handle, prefix, start, start);
		}

		private string ScanTagUri(string? head, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				if (head != null && head.Length > 1)
				{
					builder.Append(head.Substring(1));
				}
				while (analyzer.IsAlphaNumericDashOrUnderscore() || analyzer.Check(";/?:@&=+$.!~*'()[]%") || (analyzer.Check(',') && !analyzer.IsBreak(1)))
				{
					if (analyzer.Check('%'))
					{
						builder.Append(ScanUriEscapes(in start));
					}
					else if (analyzer.Check('+'))
					{
						builder.Append(' ');
						Skip();
					}
					else
					{
						builder.Append(ReadCurrentCharacter());
					}
				}
				if (builder.Length == 0)
				{
					return string.Empty;
				}
				string text = builder.ToString();
				if (Polyfills.EndsWith(text, ','))
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start2 = cursor.Mark();
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
					throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException(in start2, in end, "Unexpected comma at end of tag");
				}
				return text;
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private string ScanUriEscapes(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start)
		{
			byte[] array = EmptyBytes;
			int count = 0;
			int num = 0;
			do
			{
				if (!analyzer.Check('%') || !analyzer.IsHex(1) || !analyzer.IsHex(2))
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
					throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>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)
					{
						<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
						throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>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)
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
					throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>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)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException(in start, in end, "While scanning a tag, found an incorrect UTF-8 sequence.");
			}
			return @string;
		}

		private string ScanTagHandle(bool isDirective, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start)
		{
			if (!analyzer.Check('!'))
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>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] != '!'))
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
					throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start)
		{
			int num = 0;
			int num2 = 0;
			while (analyzer.IsDigit())
			{
				if (++num2 > 9)
				{
					<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
					throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException(in start, in end, "While scanning a %YAML directive, found extremely long version number.");
				}
				num = num * 10 + analyzer.AsDigit();
				Skip();
			}
			if (num2 == 0)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end = cursor.Mark();
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>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)
			{
				<cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey item = new <cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey(isRequired, tokensParsed + tokens.Count, cursor);
				RemoveSimpleKey();
				simpleKeys.Pop();
				simpleKeys.Push(item);
			}
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException : <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(string message)
			: base(message)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SemanticErrorException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey
	{
		private readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>Cursor cursor;

		public bool IsPossible { get; private set; }

		public bool IsRequired { get; }

		public int TokenNumber { get; }

		public long Index => cursor.Index;

		public long Line => cursor.Line;

		public long LineOffset => cursor.LineOffset;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark Mark => cursor.Mark();

		public void MarkAsImpossible()
		{
			IsPossible = false;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey()
		{
			cursor = new <cba6ec40-2546-4a46-9577-18d27987fd9e>Cursor();
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SimpleKey(bool isRequired, int tokenNumber, <cba6ec40-2546-4a46-9577-18d27987fd9e>Cursor cursor)
		{
			IsPossible = true;
			IsRequired = isRequired;
			TokenNumber = tokenNumber;
			this.cursor = new <cba6ec40-2546-4a46-9577-18d27987fd9e>Cursor(cursor);
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>StringLookAheadBuffer : <cba6ec40-2546-4a46-9577-18d27987fd9e>ILookAheadBuffer, IResettable
	{
		public string Value { get; set; } = string.Empty;


		public int Position { get; private set; }

		public int Length => Value.Length;

		public bool EndOfInput => IsOutside(Position);

		public char Peek(int offset)
		{
			int index = Position + offset;
			if (!IsOutside(index))
			{
				return Value[index];
			}
			return '\0';
		}

		private bool IsOutside(int index)
		{
			return index >= Value.Length;
		}

		public void Skip(int length)
		{
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", "The length must be positive.");
			}
			Position += length;
		}

		public bool TryReset()
		{
			Position = 0;
			Value = string.Empty;
			return true;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException : <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException(string message)
			: base(message)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SyntaxErrorException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	public sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection : KeyedCollection<string, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective>
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection()
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection(IEnumerable<<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective> tagDirectives)
		{
			foreach (<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective tagDirective in tagDirectives)
			{
				Add(tagDirective);
			}
		}

		protected override string GetKeyForItem(<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective item)
		{
			return item.Handle;
		}

		public new bool Contains(<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective directive)
		{
			return Contains(GetKeyForItem(directive));
		}
	}
	public readonly struct <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName : IEquatable<<cba6ec40-2546-4a46-9577-18d27987fd9e>TagName>
	{
		public static readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>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(<cba6ec40-2546-4a46-9577-18d27987fd9e>TagName other)
		{
			return object.Equals(value, other.value);
		}

		public override bool Equals(object? obj)
		{
			if (obj is <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return value?.GetHashCode() ?? 0;
		}

		public static bool operator ==(<cba6ec40-2546-4a46-9577-18d27987fd9e>TagName left, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(<cba6ec40-2546-4a46-9577-18d27987fd9e>TagName left, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName right)
		{
			return !(left == right);
		}

		public static bool operator ==(<cba6ec40-2546-4a46-9577-18d27987fd9e>TagName left, string right)
		{
			return object.Equals(left.value, right);
		}

		public static bool operator !=(<cba6ec40-2546-4a46-9577-18d27987fd9e>TagName left, string right)
		{
			return !(left == right);
		}

		public static implicit operator <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName(string? value)
		{
			if (value != null)
			{
				return new <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName(value);
			}
			return Empty;
		}
	}
	public sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>Version
	{
		public int Major { get; }

		public int Minor { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>Version <cba6ec40-2546-4a46-9577-18d27987fd9e>Version2 && Major == <cba6ec40-2546-4a46-9577-18d27987fd9e>Version2.Major)
			{
				return Minor == <cba6ec40-2546-4a46-9577-18d27987fd9e>Version2.Minor;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return <cba6ec40-2546-4a46-9577-18d27987fd9e>HashCode.CombineHashCodes(Major.GetHashCode(), Minor.GetHashCode());
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException : Exception
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark Start { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark End { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException(string message)
			: this(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, message)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end, string message)
			: this(in start, in end, message, null)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end, string message, Exception? innerException)
			: base(message, innerException)
		{
			Start = start;
			End = end;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException(string message, Exception inner)
			: this(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, message, inner)
		{
		}

		public override string ToString()
		{
			return $"({Start}) - ({End}): {Message}";
		}
	}
}
namespace YamlDotNet.Core.Tokens
{
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>Anchor : <cba6ec40-2546-4a46-9577-18d27987fd9e>Token
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName Value { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Anchor(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName value)
			: this(value, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Anchor(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName value, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
			if (value.IsEmpty)
			{
				throw new ArgumentNullException("value");
			}
			Value = value;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias : <cba6ec40-2546-4a46-9577-18d27987fd9e>Token
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName Value { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName value)
			: this(value, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName value, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
			if (value.IsEmpty)
			{
				throw new ArgumentNullException("value");
			}
			Value = value;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEnd : <cba6ec40-2546-4a46-9577-18d27987fd9e>Token
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEnd()
			: this(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEnd(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEntry : <cba6ec40-2546-4a46-9577-18d27987fd9e>Token
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEntry()
			: this(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockEntry(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockMappingStart : <cba6ec40-2546-4a46-9577-18d27987fd9e>Token
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockMappingStart()
			: this(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockMappingStart(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockSequenceStart : <cba6ec40-2546-4a46-9577-18d27987fd9e>Token
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockSequenceStart()
			: this(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>BlockSequenceStart(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>Comment : <cba6ec40-2546-4a46-9577-18d27987fd9e>Token
	{
		public string Value { get; }

		public bool IsInline { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Comment(string value, bool isInline)
			: this(value, isInline, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Comment(string value, bool isInline, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
			Value = value ?? throw new ArgumentNullException("value");
			IsInline = isInline;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd : <cba6ec40-2546-4a46-9577-18d27987fd9e>Token
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd()
			: this(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart : <cba6ec40-2546-4a46-9577-18d27987fd9e>Token
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart()
			: this(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
		}
	}
	internal class <cba6ec40-2546-4a46-9577-18d27987fd9e>Error : <cba6ec40-2546-4a46-9577-18d27987fd9e>Token
	{
		public string Value { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Error(string value, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
			Value = value;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowEntry : <cba6ec40-2546-4a46-9577-18d27987fd9e>Token
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowEntry()
			: this(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowEntry(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowMappingEnd : <cba6ec40-2546-4a46-9577-18d27987fd9e>Token
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowMappingEnd()
			: this(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowMappingEnd(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowMappingStart : <cba6ec40-2546-4a46-9577-18d27987fd9e>Token
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowMappingStart()
			: this(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowMappingStart(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowSequenceEnd : <cba6ec40-2546-4a46-9577-18d27987fd9e>Token
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowSequenceEnd()
			: this(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowSequenceEnd(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowSequenceStart : <cba6ec40-2546-4a46-9577-18d27987fd9e>Token
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowSequenceStart()
			: this(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>FlowSequenceStart(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>Key : <cba6ec40-2546-4a46-9577-18d27987fd9e>Token
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Key()
			: this(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Key(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar : <cba6ec40-2546-4a46-9577-18d27987fd9e>Token
	{
		public bool IsKey { get; set; }

		public string Value { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle Style { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar(string value)
			: this(value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Any)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar(string value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle style)
			: this(value, style, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar(string value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle style, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
			Value = value ?? throw new ArgumentNullException("value");
			Style = style;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>StreamEnd : <cba6ec40-2546-4a46-9577-18d27987fd9e>Token
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>StreamEnd()
			: this(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>StreamEnd(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>StreamStart : <cba6ec40-2546-4a46-9577-18d27987fd9e>Token
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>StreamStart()
			: this(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>StreamStart(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>Tag : <cba6ec40-2546-4a46-9577-18d27987fd9e>Token
	{
		public string Handle { get; }

		public string Suffix { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Tag(string handle, string suffix)
			: this(handle, suffix, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Tag(string handle, string suffix, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
			Handle = handle ?? throw new ArgumentNullException("handle");
			Suffix = suffix ?? throw new ArgumentNullException("suffix");
		}
	}
	public class <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective : <cba6ec40-2546-4a46-9577-18d27987fd9e>Token
	{
		private static readonly Regex TagHandlePattern = new Regex("^!([0-9A-Za-z_\\-]*!)?$", RegexOptions.Compiled);

		public string Handle { get; }

		public string Prefix { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective(string handle, string prefix)
			: this(handle, prefix, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective(string handle, string prefix, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
			if (string.IsNullOrEmpty(handle))
			{
				throw new ArgumentNullException("handle", "Tag handle must not be empty.");
			}
			if (!TagHandlePattern.IsMatch(handle))
			{
				throw new ArgumentException("Tag handle must start and end with '!' and contain alphanumerical characters only.", "handle");
			}
			Handle = handle;
			if (string.IsNullOrEmpty(prefix))
			{
				throw new ArgumentNullException("prefix", "Tag prefix must not be empty.");
			}
			Prefix = prefix;
		}

		public override bool Equals(object? obj)
		{
			if (obj is <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective2 && Handle.Equals(<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective2.Handle))
			{
				return Prefix.Equals(<cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirective2.Prefix);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Handle.GetHashCode() ^ Prefix.GetHashCode();
		}

		public override string ToString()
		{
			return Handle + " => " + Prefix;
		}
	}
	public abstract class <cba6ec40-2546-4a46-9577-18d27987fd9e>Token
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark Start { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark End { get; }

		protected <cba6ec40-2546-4a46-9577-18d27987fd9e>Token(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
		{
			Start = start;
			End = end;
		}
	}
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>Value : <cba6ec40-2546-4a46-9577-18d27987fd9e>Token
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Value()
			: this(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Value(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
		}
	}
	public sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective : <cba6ec40-2546-4a46-9577-18d27987fd9e>Token
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Version Version { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective(<cba6ec40-2546-4a46-9577-18d27987fd9e>Version version)
			: this(version, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective(<cba6ec40-2546-4a46-9577-18d27987fd9e>Version version, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
			Version = version;
		}

		public override bool Equals(object? obj)
		{
			if (obj is <cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective <cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective2)
			{
				return Version.Equals(<cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective2.Version);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Version.GetHashCode();
		}
	}
}
namespace YamlDotNet.Core.ObjectPool
{
	internal class DefaultObjectPool<T> : ObjectPool<T> where T : class
	{
		private readonly Func<T> createFunc;

		private readonly Func<T, bool> returnFunc;

		private readonly int maxCapacity;

		private int numItems;

		private protected readonly ConcurrentQueue<T> items = new ConcurrentQueue<T>();

		private protected T? fastItem;

		public DefaultObjectPool(IPooledObjectPolicy<T> policy)
			: this(policy, Environment.ProcessorCount * 2)
		{
		}

		public DefaultObjectPool(IPooledObjectPolicy<T> policy, int maximumRetained)
		{
			createFunc = policy.Create;
			returnFunc = policy.Return;
			maxCapacity = maximumRetained - 1;
		}

		public override T Get()
		{
			T result = fastItem;
			if (result == null || Interlocked.CompareExchange(ref fastItem, null, result) != result)
			{
				if (items.TryDequeue(out result))
				{
					Interlocked.Decrement(ref numItems);
					return result;
				}
				return createFunc();
			}
			return result;
		}

		public override void Return(T obj)
		{
			ReturnCore(obj);
		}

		private protected bool ReturnCore(T obj)
		{
			if (!returnFunc(obj))
			{
				return false;
			}
			if (fastItem != null || Interlocked.CompareExchange(ref fastItem, obj, null) != null)
			{
				if (Interlocked.Increment(ref numItems) <= maxCapacity)
				{
					items.Enqueue(obj);
					return true;
				}
				Interlocked.Decrement(ref numItems);
				return false;
			}
			return true;
		}
	}
	internal class DefaultPooledObjectPolicy<T> : IPooledObjectPolicy<T> where T : class, new()
	{
		public T Create()
		{
			return new T();
		}

		public bool Return(T obj)
		{
			if (obj is IResettable resettable)
			{
				return resettable.TryReset();
			}
			return true;
		}
	}
	internal interface IPooledObjectPolicy<T> where T : notnull
	{
		T Create();

		bool Return(T obj);
	}
	internal interface IResettable
	{
		bool TryReset();
	}
	internal abstract class ObjectPool<T> where T : class
	{
		public abstract T Get();

		public abstract void Return(T obj);
	}
	internal static class ObjectPool
	{
		public static ObjectPool<T> Create<T>(IPooledObjectPolicy<T>? policy = null) where T : class, new()
		{
			return new DefaultObjectPool<T>(policy ?? new DefaultPooledObjectPolicy<T>());
		}

		public static ObjectPool<T> Create<T>(int maximumRetained, IPooledObjectPolicy<T>? policy = null) where T : class, new()
		{
			return new DefaultObjectPool<T>(policy ?? new DefaultPooledObjectPolicy<T>(), maximumRetained);
		}
	}
	[DebuggerStepThrough]
	internal static class StringBuilderPool
	{
		internal readonly struct BuilderWrapper : IDisposable
		{
			public readonly StringBuilder Builder;

			private readonly ObjectPool<StringBuilder> pool;

			public BuilderWrapper(StringBuilder builder, ObjectPool<StringBuilder> pool)
			{
				Builder = builder;
				this.pool = pool;
			}

			public override string ToString()
			{
				return Builder.ToString();
			}

			public void Dispose()
			{
				pool.Return(Builder);
			}
		}

		private static readonly ObjectPool<StringBuilder> Pool = ObjectPool.Create(new StringBuilderPooledObjectPolicy
		{
			InitialCapacity = 16,
			MaximumRetainedCapacity = 1024
		});

		public static BuilderWrapper Rent()
		{
			StringBuilder builder = Pool.Get();
			return new BuilderWrapper(builder, Pool);
		}
	}
	internal class StringBuilderPooledObjectPolicy : IPooledObjectPolicy<StringBuilder>
	{
		public int InitialCapacity { get; set; } = 100;


		public int MaximumRetainedCapacity { get; set; } = 4096;


		public StringBuilder Create()
		{
			return new StringBuilder(InitialCapacity);
		}

		public bool Return(StringBuilder obj)
		{
			if (obj.Capacity > MaximumRetainedCapacity)
			{
				return false;
			}
			obj.Clear();
			return true;
		}
	}
	internal static class StringLookAheadBufferPool
	{
		internal readonly struct BufferWrapper : IDisposable
		{
			public readonly <cba6ec40-2546-4a46-9577-18d27987fd9e>StringLookAheadBuffer Buffer;

			private readonly ObjectPool<<cba6ec40-2546-4a46-9577-18d27987fd9e>StringLookAheadBuffer> pool;

			public BufferWrapper(<cba6ec40-2546-4a46-9577-18d27987fd9e>StringLookAheadBuffer buffer, ObjectPool<<cba6ec40-2546-4a46-9577-18d27987fd9e>StringLookAheadBuffer> pool)
			{
				Buffer = buffer;
				this.pool = pool;
			}

			public override string ToString()
			{
				return Buffer.ToString();
			}

			public void Dispose()
			{
				pool.Return(Buffer);
			}
		}

		private static readonly ObjectPool<<cba6ec40-2546-4a46-9577-18d27987fd9e>StringLookAheadBuffer> Pool = ObjectPool.Create(new DefaultPooledObjectPolicy<<cba6ec40-2546-4a46-9577-18d27987fd9e>StringLookAheadBuffer>());

		public static BufferWrapper Rent(string value)
		{
			<cba6ec40-2546-4a46-9577-18d27987fd9e>StringLookAheadBuffer <cba6ec40-2546-4a46-9577-18d27987fd9e>StringLookAheadBuffer = Pool.Get();
			<cba6ec40-2546-4a46-9577-18d27987fd9e>StringLookAheadBuffer.Value = value;
			return new BufferWrapper(<cba6ec40-2546-4a46-9577-18d27987fd9e>StringLookAheadBuffer, Pool);
		}
	}
}
namespace YamlDotNet.Core.Events
{
	public sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias : <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent
	{
		internal override <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType Type => <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.Alias;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName Value { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName value, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
			if (value.IsEmpty)
			{
				throw new <cba6ec40-2546-4a46-9577-18d27987fd9e>YamlException(in start, in end, "Anchor value must not be empty.");
			}
			Value = value;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName value)
			: this(value, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Alias [value = {Value}]";
		}

		public override void Accept(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	public sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>Comment : <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent
	{
		public string Value { get; }

		public bool IsInline { get; }

		internal override <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType Type => <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.Comment;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Comment(string value, bool isInline)
			: this(value, isInline, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Comment(string value, bool isInline, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
			Value = value;
			IsInline = isInline;
		}

		public override void Accept(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override string ToString()
		{
			return (IsInline ? "Inline" : "Block") + " Comment [" + Value + "]";
		}
	}
	public sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd : <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType Type => <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.DocumentEnd;

		public bool IsImplicit { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd(bool isImplicit, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
			IsImplicit = isImplicit;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd(bool isImplicit)
			: this(isImplicit, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Document end [isImplicit = {IsImplicit}]";
		}

		public override void Accept(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	public sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart : <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent
	{
		public override int NestingIncrease => 1;

		internal override <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType Type => <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.DocumentStart;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection? Tags { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective? Version { get; }

		public bool IsImplicit { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective? version, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection? tags, bool isImplicit, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
			Version = version;
			Tags = tags;
			IsImplicit = isImplicit;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>VersionDirective? version, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagDirectiveCollection? tags, bool isImplicit)
			: this(version, tags, isImplicit, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: this(null, null, isImplicit: true, start, end)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart()
			: this(null, null, isImplicit: true, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Document start [isImplicit = {IsImplicit}]";
		}

		public override void Accept(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType
	{
		None,
		StreamStart,
		StreamEnd,
		DocumentStart,
		DocumentEnd,
		Alias,
		Scalar,
		SequenceStart,
		SequenceEnd,
		MappingStart,
		MappingEnd,
		Comment
	}
	public interface <cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor
	{
		void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorAlias e);

		void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamStart e);

		void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>StreamEnd e);

		void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentStart e);

		void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>DocumentEnd e);

		void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar e);

		void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart e);

		void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEnd e);

		void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart e);

		void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEnd e);

		void Visit(<cba6ec40-2546-4a46-9577-18d27987fd9e>Comment e);
	}
	public class <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEnd : <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType Type => <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.MappingEnd;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEnd(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingEnd()
			: this(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public override string ToString()
		{
			return "Mapping end";
		}

		public override void Accept(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	public sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart : <cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent
	{
		public override int NestingIncrease => 1;

		internal override <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType Type => <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.MappingStart;

		public bool IsImplicit { get; }

		public override bool IsCanonical => !IsImplicit;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStyle Style { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName anchor, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName tag, bool isImplicit, <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStyle style, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(anchor, tag, start, end)
		{
			IsImplicit = isImplicit;
			Style = style;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName anchor, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName tag, bool isImplicit, <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStyle style)
			: this(anchor, tag, isImplicit, style, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStart()
			: this(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName.Empty, isImplicit: true, <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStyle.Any, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Mapping start [anchor = {base.Anchor}, tag = {base.Tag}, isImplicit = {IsImplicit}, style = {Style}]";
		}

		public override void Accept(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	public enum <cba6ec40-2546-4a46-9577-18d27987fd9e>MappingStyle
	{
		Any,
		Block,
		Flow
	}
	public abstract class <cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent : <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent
	{
		public <cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName Anchor { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName Tag { get; }

		public abstract bool IsCanonical { get; }

		protected <cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName anchor, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName tag, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
			Anchor = anchor;
			Tag = tag;
		}

		protected <cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName anchor, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName tag)
			: this(anchor, tag, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}
	}
	public abstract class <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent
	{
		public virtual int NestingIncrease => 0;

		internal abstract <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType Type { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark Start { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark End { get; }

		public abstract void Accept(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor visitor);

		internal <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
		{
			Start = start;
			End = end;
		}
	}
	public sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar : <cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent
	{
		internal override <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType Type => <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.Scalar;

		public string Value { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>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 <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName anchor, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName tag, string value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle style, bool isPlainImplicit, bool isQuotedImplicit, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end, bool isKey = false)
			: base(anchor, tag, start, end)
		{
			Value = value;
			Style = style;
			IsPlainImplicit = isPlainImplicit;
			IsQuotedImplicit = isQuotedImplicit;
			IsKey = isKey;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName anchor, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName tag, string value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle style, bool isPlainImplicit, bool isQuotedImplicit)
			: this(anchor, tag, value, style, isPlainImplicit, isQuotedImplicit, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar(string value)
			: this(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName.Empty, value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar(<cba6ec40-2546-4a46-9577-18d27987fd9e>TagName tag, string value)
			: this(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName.Empty, tag, value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>Scalar(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName anchor, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName tag, string value)
			: this(anchor, tag, value, <cba6ec40-2546-4a46-9577-18d27987fd9e>ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>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(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	public sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEnd : <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType Type => <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.SequenceEnd;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEnd(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceEnd()
			: this(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public override string ToString()
		{
			return "Sequence end";
		}

		public override void Accept(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	public sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart : <cba6ec40-2546-4a46-9577-18d27987fd9e>NodeEvent
	{
		public override int NestingIncrease => 1;

		internal override <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType Type => <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.SequenceStart;

		public bool IsImplicit { get; }

		public override bool IsCanonical => !IsImplicit;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStyle Style { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName anchor, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName tag, bool isImplicit, <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStyle style, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(anchor, tag, start, end)
		{
			IsImplicit = isImplicit;
			Style = style;
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStart(<cba6ec40-2546-4a46-9577-18d27987fd9e>AnchorName anchor, <cba6ec40-2546-4a46-9577-18d27987fd9e>TagName tag, bool isImplicit, <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStyle style)
			: this(anchor, tag, isImplicit, style, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Sequence start [anchor = {base.Anchor}, tag = {base.Tag}, isImplicit = {IsImplicit}, style = {Style}]";
		}

		public override void Accept(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	public enum <cba6ec40-2546-4a46-9577-18d27987fd9e>SequenceStyle
	{
		Any,
		Block,
		Flow
	}
	public sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>StreamEnd : <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType Type => <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.StreamEnd;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>StreamEnd(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>StreamEnd()
			: this(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public override string ToString()
		{
			return "Stream end";
		}

		public override void Accept(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	public sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>StreamStart : <cba6ec40-2546-4a46-9577-18d27987fd9e>ParsingEvent
	{
		public override int NestingIncrease => 1;

		internal override <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType Type => <cba6ec40-2546-4a46-9577-18d27987fd9e>EventType.StreamStart;

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>StreamStart()
			: this(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark.Empty)
		{
		}

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>StreamStart(in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark start, in <cba6ec40-2546-4a46-9577-18d27987fd9e>Mark end)
			: base(in start, in end)
		{
		}

		public override string ToString()
		{
			return "Stream start";
		}

		public override void Accept(<cba6ec40-2546-4a46-9577-18d27987fd9e>IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>AllowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>DisallowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>DoesNotReturnAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>DoesNotReturnIfAttribute : Attribute
	{
		public bool ParameterValue { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>DoesNotReturnIfAttribute(bool parameterValue)
		{
			ParameterValue = parameterValue;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>MaybeNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>MaybeNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>MaybeNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>NotNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>NotNullIfNotNullAttribute : Attribute
	{
		public string ParameterName { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>NotNullIfNotNullAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class <cba6ec40-2546-4a46-9577-18d27987fd9e>NotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public <cba6ec40-2546-4a46-9577-18d27987fd9e>NotNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
}
namespace ServerSync
{
	[PublicAPI]
	public abstract class OwnConfigEntryBase
	{
		public object? LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[PublicAPI]
	public class SyncedConfigEntry<T> : OwnConfigEntryBase
	{
		public readonly ConfigEntry<T> SourceConfig;

		public override ConfigEntryBase BaseConfig => (ConfigEntryBase)(object)SourceConfig;

		public T Value
		{
			get
			{
				return SourceConfig.Value;
			}
			set
			{
				SourceConfig.Value = value;
			}
		}

		public SyncedConfigEntry(ConfigEntry<T> sourceConfig)
		{
			SourceConfig = sourceConfig;
			base..ctor();
		}

		public void AssignLocalValue(T value)
		{
			if (LocalBaseValue == null)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal abstract class CustomSyncedValueBase
	{
		public object? LocalBaseValue;

		public readonly string Identifier;

		public readonly Type Type;

		private object? boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

		public object? BoxedValue
		{
			get
			{
				return boxedValue;
			}
			set
			{
				boxedValue = value;
				this.ValueChanged?.Invoke();
			}
		}

		public event Action? ValueChanged;

		protected CustomSyncedValueBase(ConfigSync configSync, string identifier, Type type, int priority)
		{
			Priority = priority;
			Identifier = identifier;
			Type = type;
			configSync.AddCustomValue(this);
			localIsOwner = configSync.IsSourceOfTruth;
			configSync.SourceOfTruthChanged += delegate(bool truth)
			{
				localIsOwner = truth;
			};
		}
	}
	[PublicAPI]
	internal sealed class CustomSyncedValue<T> : CustomSyncedValueBase
	{
		public T Value
		{
			get
			{
				return (T)base.BoxedValue;
			}
			set
			{
				base.BoxedValue = value;
			}
		}

		public CustomSyncedValue(ConfigSync configSync, string identifier, T value = default(T), int priority = 0)
			: base(configSync, identifier, typeof(T), priority)
		{
			Value = value;
		}

		public void AssignLocalValue(T value)
		{
			if (localIsOwner)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal class ConfigurationManagerAttributes
	{
		[UsedImplicitly]
		public bool? ReadOnly = false;
	}
	[PublicAPI]
	public class ConfigSync
	{
		[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
		private static class SnatchCurrentlyHandlingRPC
		{
			public static ZRpc? currentRpc;

			[HarmonyPrefix]
			private static void Prefix(ZRpc __instance)
			{
				currentRpc = __instance;
			}
		}

		[HarmonyPatch(typeof(ZNet), "Awake")]
		internal static class RegisterRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance)
			{
				isServer = __instance.IsServer();
				foreach (ConfigSync configSync2 in configSyncs)
				{
					ZRoutedRpc.instance.Register<ZPackage>(configSync2.Name + " ConfigSync", (Action<long, ZPackage>)configSync2.RPC_FromOtherClientConfigSync);
					if (isServer)
					{
						configSync2.InitialSyncDone = true;
						Debug.Log((object)("Registered '" + configSync2.Name + " ConfigSync' RPC - waiting for incoming connections"));
					}
				}
				if (isServer)
				{
					((MonoBehaviour)__instance).StartCoroutine(WatchAdminListChanges());
				}
				static void SendAdmin(List<ZNetPeer> peers, bool isAdmin)
				{
					ZPackage package = ConfigsToPackage(null, null, new PackageEntry[1]
					{
						new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = isAdmin
						}
					});
					ConfigSync configSync = configSyncs.First();
					if (configSync != null)
					{
						((MonoBehaviour)ZNet.instance).StartCoroutine(configSync.sendZPackage(peers, package));
					}
				}
				static IEnumerator WatchAdminListChanges()
				{
					MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
					SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
					List<string> CurrentList = new List<string>(adminList.GetList());
					while (true)
					{
						yield return (object)new WaitForSeconds(30f);
						if (!adminList.GetList().SequenceEqual(CurrentList))
						{
							CurrentList = new List<string>(adminList.GetList());
							List<ZNetPeer> adminPeer = ZNet.instance.GetPeers().Where(delegate(ZNetPeer p)
							{
								string hostName = p.m_rpc.GetSocket().GetHostName();
								return ((object)listContainsId == null) ? adminList.Contains(hostName) : ((bool)listContainsId.Invoke(ZNet.instance, new object[2] { adminList, hostName }));
							}).ToList();
							List<ZNetPeer> nonAdminPeer = ZNet.instance.GetPeers().Except(adminPeer).ToList();
							SendAdmin(nonAdminPeer, isAdmin: false);
							SendAdmin(adminPeer, isAdmin: true);
						}
					}
				}
			}
		}

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

		private class ParsedConfigs
		{
			public readonly Dictionary<OwnConfigEntryBase, object?> configValues = new Dictionary<OwnConfigEntryBase, object>();

			public readonly Dictionary<CustomSyncedValueBase, object?> customValues = new Dictionary<CustomSyncedValueBase, object>();
		}

		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		private class ResetConfigsOnShutdown
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				ProcessingServerUpdate = true;
				foreach (ConfigSync configSync in configSyncs)
				{
					configSync.resetConfigsFromServer();
					configSync.IsSourceOfTruth = true;
					configSync.InitialSyncDone = false;
				}
				ProcessingServerUpdate = false;
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private class SendConfigsAfterLogin
		{
			private class BufferingSocket : ZPlayFabSocket, ISocket
			{
				public volatile bool finished = false;

				public volatile int versionMatchQueued = -1;

				public readonly List<ZPackage> Package = new List<ZPackage>();

				public readonly ISocket Original;

				public BufferingSocket(ISocket original)
				{
					Original = original;
					((ZPlayFabSocket)this)..ctor();
				}

				public bool IsConnected()
				{
					return Original.IsConnected();
				}

				public ZPackage Recv()
				{
					return Original.Recv();
				}

				public int GetSendQueueSize()
				{
					return Original.GetSendQueueSize();
				}

				public int GetCurrentSendRate()
				{
					return Original.GetCurrentSendRate();
				}

				public bool IsHost()
				{
					return Original.IsHost();
				}

				public void Dispose()
				{
					Original.Dispose();
				}

				public bool GotNewData()
				{
					return Original.GotNewData();
				}

				public void Close()
				{
					Original.Close();
				}

				public string GetEndPointString()
				{
					return Original.GetEndPointString();
				}

				public void GetAndResetStats(out int totalSent, out int totalRecv)
				{
					Original.GetAndResetStats(ref totalSent, ref totalRecv);
				}

				public void GetConnectionQuality(out float localQuality, out float remoteQuality, out int ping, out float outByteSec, out float inByteSec)
				{
					Original.GetConnectionQuality(ref localQuality, ref remoteQuality, ref ping, ref outByteSec, ref inByteSec);
				}

				public ISocket Accept()
				{
					return Original.Accept();
				}

				public int GetHostPort()
				{
					return Original.GetHostPort();
				}

				public bool Flush()
				{
					return Original.Flush();
				}

				public string GetHostName()
				{
					return Original.GetHostName();
				}

				public void VersionMatch()
				{
					if (finished)
					{
						Original.VersionMatch();
					}
					else
					{
						versionMatchQueued = Package.Count;
					}
				}

				public void Send(ZPackage pkg)
				{
					//IL_0057: Unknown result type (might be due to invalid IL or missing references)
					//IL_005d: Expected O, but got Unknown
					int pos = pkg.GetPos();
					pkg.SetPos(0);
					int num = pkg.ReadInt();
					if ((num == StringExtensionMethods.GetStableHashCode("PeerInfo") || num == StringExtensionMethods.GetStableHashCode("RoutedRPC") || num == StringExtensionMethods.GetStableHashCode("ZDOData")) && !finished)
					{
						ZPackage val = new ZPackage(pkg.GetArray());
						val.SetPos(pos);
						Package.Add(val);
					}
					else
					{
						pkg.SetPos(pos);
						Original.Send(pkg);
					}
				}
			}

			[HarmonyPriority(800)]
			[HarmonyPrefix]
			private static void Prefix(ref Dictionary<Assembly, BufferingSocket>? __state, ZNet __instance, ZRpc rpc)
			{
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Invalid comparison between Unknown and I4
				if (!__instance.IsServer())
				{
					return;
				}
				BufferingSocket bufferingSocket = new BufferingSocket(rpc.GetSocket());
				AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket);
				object? obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
				ZNetPeer val = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
				if (val != null && (int)ZNet.m_onlineBackend > 0)
				{
					FieldInfo fieldInfo = AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket");
					object? value = fieldInfo.GetValue(val);
					ZPlayFabSocket val2 = (ZPlayFabSocket)((value is ZPlayFabSocket) ? value : null);
					if (val2 != null)
					{
						typeof(ZPlayFabSocket).GetField("m_remotePlayerId").SetValue(bufferingSocket, val2.m_remotePlayerId);
					}
					fieldInfo.SetValue(val, bufferingSocket);
				}
				if (__state == null)
				{
					__state = new Dictionary<Assembly, BufferingSocket>();
				}
				__state[Assembly.GetExecutingAssembly()] = bufferingSocket;
			}

			[HarmonyPostfix]
			private static void Postfix(Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
			{
				ZRpc rpc2 = rpc;
				ZNet __instance2 = __instance;
				Dictionary<Assembly, BufferingSocket> __state2 = __state;
				ZNetPeer peer;
				if (__instance2.IsServer())
				{
					object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance2, new object[1] { rpc2 });
					peer = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
					if (peer == null)
					{
						SendBufferedData();
					}
					else
					{
						((MonoBehaviour)__instance2).StartCoroutine(sendAsync());
					}
				}
				void SendBufferedData()
				{
					if (rpc2.GetSocket() is BufferingSocket bufferingSocket)
					{
						AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc2, bufferingSocket.Original);
						object? obj2 = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance2, new object[1] { rpc2 });
						ZNetPeer val = (ZNetPeer)((obj2 is ZNetPeer) ? obj2 : null);
						if (val != null)
						{
							AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, bufferingSocket.Original);
						}
					}
					BufferingSocket bufferingSocket2 = __state2[Assembly.GetExecutingAssembly()];
					bufferingSocket2.finished = true;
					for (int i = 0; i < bufferingSocket2.Package.Count; i++)
					{
						if (i == bufferingSocket2.versionMatchQueued)
						{
							bufferingSocket2.Original.VersionMatch();
						}
						bufferingSocket2.Original.Send(bufferingSocket2.Package[i]);
					}
					if (bufferingSocket2.Package.Count == bufferingSocket2.versionMatchQueued)
					{
						bufferingSocket2.Original.VersionMatch();
					}
				}
				IEnumerator sendAsync()
				{
					foreach (ConfigSync configSync in configSyncs)
					{
						List<PackageEntry> entries = new List<PackageEntry>();
						if (configSync.CurrentVersion != null)
						{
							entries.Add(new PackageEntry
							{
								section = "Internal",
								key = "serverversion",
								type = typeof(string),
								value = configSync.CurrentVersion
							});
						}
						MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						entries.Add(new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = (((object)listContainsId == null) ? ((object)adminList.Contains(rpc2.GetSocket().GetHostName())) : listContainsId.Invoke(ZNet.instance, new object[2]
							{
								adminList,
								rpc2.GetSocket().GetHostName()
							}))
						});
						ZPackage package = ConfigsToPackage(configSync.allConfigs.Select((OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, entries, partial: false);
						yield return ((MonoBehaviour)__instance2).StartCoroutine(configSync.sendZPackage(new List<ZNetPeer> { peer }, package));
					}
					SendBufferedData();
				}
			}
		}

		private class PackageEntry
		{
			public string section = null;

			public string key = null;

			public Type type = null;

			public object? value;
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
		private static class PreventSavingServerInfo
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, ref string __result)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || isWritableConfig(ownConfigEntryBase))
				{
					return true;
				}
				__result = TomlTypeConverter.ConvertToString(ownConfigEntryBase.LocalBaseValue, __instance.SettingType);
				return false;
			}
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "SetSerializedValue")]
		private static class PreventConfigRereadChangingValues
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, string value)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || ownConfigEntryBase.LocalBaseValue == null)
				{
					return true;
				}
				try
				{
					ownConfigEntryBase.LocalBaseValue = TomlTypeConverter.ConvertToValue(value, __instance.SettingType);
				}
				catch (Exception ex)
				{
					Debug.LogWarning((object)$"Config value of setting \"{__instance.Definition}\" could not be parsed and will be ignored. Reason: {ex.Message}; Value: {value}");
				}
				return false;
			}
		}

		private class InvalidDeserializationTypeException : Exception
		{
			public string expected = null;

			public string received = null;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		public string? DisplayName;

		public string? CurrentVersion;

		public string? MinimumRequiredVersion;

		public bool ModRequired = false;

		private bool? forceConfigLocking;

		private bool isSourceOfTruth = true;

		private static readonly HashSet<ConfigSync> configSyncs;

		private readonly HashSet<OwnConfigEntryBase> allConfigs = new HashSet<OwnConfigEntryBase>();

		private HashSet<CustomSyncedValueBase> allCustomValues = new HashSet<CustomSyncedValueBase>();

		private static bool isServer;

		private static bool lockExempt;

		private OwnConfigEntryBase? lockedConfig = null;

		private const byte PARTIAL_CONFIGS = 1;

		private const byte FRAGMENTED_CONFIG = 2;

		private const byte COMPRESSED_CONFIG = 4;

		private readonly Dictionary<string, SortedDictionary<int, byte[]>> configValueCache = new Dictionary<string, SortedDictionary<int, byte[]>>();

		private readonly List<KeyValuePair<long, string>> cacheExpirations = new List<KeyValuePair<long, string>>();

		private static long packageCounter;

		public bool IsLocked
		{
			get
			{
				bool? flag = forceConfigLocking;
				bool num;
				if (!flag.HasValue)
				{
					if (lockedConfig == null)
					{
						goto IL_0052;
					}
					num = ((IConvertible)lockedConfig.BaseConfig.BoxedValue).ToInt32(CultureInfo.InvariantCulture) != 0;
				}
				else
				{
					num = flag.GetValueOrDefault();
				}
				if (!num)
				{
					goto IL_0052;
				}
				int result = ((!lockExempt) ? 1 : 0);
				goto IL_0053;
				IL_0053:
				return (byte)result != 0;
				IL_0052:
				result = 0;
				goto IL_0053;
			}
			set
			{
				forceConfigLocking = value;
			}
		}

		public bool IsAdmin => lockExempt || isSourceOfTruth;

		public bool IsSourceOfTruth
		{
			get
			{
				return isSourceOfTruth;
			}
			private set
			{
				if (value != isSourceOfTruth)
				{
					isSourceOfTruth = value;
					this.SourceOfTruthChanged?.Invoke(value);
				}
			}
		}

		public bool InitialSyncDone { get; private set; } = false;


		public event Action<bool>? SourceOfTruthChanged;

		private event Action? lockedConfigChanged;

		static ConfigSync()
		{
			ProcessingServerUpdate = false;
			configSyncs = new HashSet<ConfigSync>();
			lockExempt = false;
			packageCounter = 0L;
			RuntimeHelpers.RunClassConstructor(typeof(VersionCheck).TypeHandle);
		}

		public ConfigSync(string name)
		{
			Name = name;
			configSyncs.Add(this);
			new VersionCheck(this);
		}

		public SyncedConfigEntry<T> AddConfigEntry<T>(ConfigEntry<T> configEntry)
		{
			ConfigEntry<T> configEntry2 = configEntry;
			OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)(object)configEntry2);
			SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
			if (syncedEntry == null)
			{
				syncedEntry = new SyncedConfigEntry<T>(configEntry2);
				AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(((ConfigEntryBase)configEntry2).Description, new object[1]
				{
					new ConfigurationManagerAttributes()
				}.Concat(((ConfigEntryBase)configEntry2).Description.Tags ?? Array.Empty<object>()).Concat(new SyncedConfigEntry<T>[1] { syncedEntry }).ToArray());
				configEntry2.SettingChanged += delegate
				{
					if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
					{
						Broadcast(ZRoutedRpc.Everybody, (ConfigEntryBase)configEntry2);
					}
				};
				allConfigs.Add(syncedEntry);
			}
			return syncedEntry;
		}

		public SyncedConfigEntry<T> AddLockingConfigEntry<T>(ConfigEntry<T> lockingConfig) where T : IConvertible
		{
			if (lockedConfig != null)
			{
				throw new Exception("Cannot initialize locking ConfigEntry twice");
			}
			lockedConfig = AddConfigEntry<T>(lockingConfig);
			lockingConfig.SettingChanged += delegate
			{
				this.lockedConfigChanged?.Invoke();
			};
			return (SyncedConfigEntry<T>)lockedConfig;
		}

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

		private void RPC_FromServerConfigSync(ZRpc rpc, ZPackage package)
		{
			lockedConfigChanged += serverLockedSettingChanged;
			IsSourceOfTruth = false;
			if (HandleConfigSyncRPC(0L, package, clientUpdate: false))
			{
				InitialSyncDone = true;
			}
		}

		private void RPC_FromOtherClientConfigSync(long sender, ZPackage package)
		{
			HandleConfigSyncRPC(sender, package, clientUpdate: true);
		}

		private bool HandleConfigSyncRPC(long sender, ZPackage package, bool clientUpdate)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Expected O, but got Unknown
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Expected O, but got Unknown
			try
			{
				if (isServer && IsLocked)
				{
					ZRpc? currentRpc = SnatchCurrentlyHandlingRPC.currentRpc;
					object obj;
					if (currentRpc == null)
					{
						obj = null;
					}
					else
					{
						ISocket socket = currentRpc.GetSocket();
						obj = ((socket != null) ? socket.GetHostName() : null);
					}
					string text = (string)obj;
					if (text != null)
					{
						MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						if (!(((object)methodInfo == null) ? val.Contains(text) : ((bool)methodInfo.Invoke(ZNet.instance, new object[2] { val, text }))))
						{
							return false;
						}
					}
				}
				cacheExpirations.RemoveAll(delegate(KeyValuePair<long, string> kv)
				{
					if (kv.Key < DateTimeOffset.Now.Ticks)
					{
						configValueCache.Remove(kv.Value);
						return true;
					}
					return false;
				});
				byte b = package.ReadByte();
				if ((b & 2u) != 0)
				{
					long num = package.ReadLong();
					string text2 = sender.ToString() + num;
					if (!configValueCache.TryGetValue(text2, out SortedDictionary<int, byte[]> value))
					{
						value = new SortedDictionary<int, byte[]>();
						configValueCache[text2] = value;
						cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text2));
					}
					int key = package.ReadInt();
					int num2 = package.ReadInt();
					value.Add(key, package.ReadByteArray());
					if (value.Count < num2)
					{
						return false;
					}
					configValueCache.Remove(text2);
					package = new ZPackage(value.Values.SelectMany((byte[] a) => a).ToArray());
					b = package.ReadByte();
				}
				ProcessingServerUpdate = true;
				if ((b & 4u) != 0)
				{
					byte[] buffer = package.ReadByteArray();
					MemoryStream stream = new MemoryStream(buffer);
					MemoryStream memoryStream = new MemoryStream();
					using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
					{
						deflateStream.CopyTo(memoryStream);
					}
					package = new ZPackage(memoryStream.ToArray());
					b = package.ReadByte();
				}
				if ((b & 1) == 0)
				{
					resetConfigsFromServer();
				}
				ParsedConfigs parsedConfigs = ReadConfigsFromPackage(package);
				ConfigFile val2 = null;
				bool saveOnConfigSet = false;
				foreach (KeyValuePair<OwnConfigEntryBase, object> configValue in parsedConfigs.configValues)
				{
					if (!isServer && configValue.Key.LocalBaseValue == null)
					{
						configValue.Key.LocalBaseValue = configValue.Key.BaseConfig.BoxedValue;
					}
					if (val2 == null)
					{
						val2 = configValue.Key.BaseConfig.ConfigFile;
						saveOnConfigSet = val2.SaveOnConfigSet;
						val2.SaveOnConfigSet = false;
					}
					configValue.Key.BaseConfig.BoxedValue = configValue.Value;
				}
				if (val2 != null)
				{
					val2.SaveOnConfigSet = saveOnConfigSet;
					val2.Save();
				}
				foreach (KeyValuePair<CustomSyncedValueBase, object> customValue in parsedConfigs.customValues)
				{
					if (!isServer)
					{
						CustomSyncedValueBase key2 = customValue.Key;
						if (key2.LocalBaseValue == null)
						{
							key2.LocalBaseValue = customValue.Key.BoxedValue;
						}
					}
					customValue.Key.BoxedValue = customValue.Value;
				}
				Debug.Log((object)string.Format("Received {0} configs and {1} custom values from {2} for mod {3}", parsedConfigs.configValues.Count, parsedConfigs.customValues.Count, (isServer || clientUpdate) ? $"client {sender}" : "the server", DisplayName ?? Name));
				if (!isServer)
				{
					serverLockedSettingChanged();
				}
				return true;
			}
			finally
			{
				ProcessingServerUpdate = false;
			}
		}

		private ParsedConfigs ReadConfigsFromPackage(ZPackage package)
		{
			ParsedConfigs parsedConfigs = new ParsedConfigs();
			Dictionary<string, OwnConfigEntryBase> dictionary = allConfigs.Where((OwnConfigEntryBase c) => c.SynchronizedConfig).ToDictionary((OwnConfigEntryBase c) => c.BaseConfig.Definition.Section + "_" + c.BaseConfig.Definition.Key, (OwnConfigEntryBase c) => c);
			Dictionary<string, CustomSyncedValueBase> dictionary2 = allCustomValues.ToDictionary((CustomSyncedValueBase c) => c.Identifier, (CustomSyncedValueBase c) => c);
			int num = package.ReadInt();
			for (int i = 0; i < num; i++)
			{
				string text = package.ReadString();
				string text2 = package.ReadString();
				string text3 = package.ReadString();
				Type type = Type.GetType(text3);
				if (text3 == "" || type != null)
				{
					object obj;
					try
					{
						obj = ((text3 == "") ? null : ReadValueWithTypeFromZPackage(package, type));
					}
					catch (InvalidDeserializationTypeException ex)
					{
						Debug.LogWarning((object)("Got unexpected struct internal type " + ex.received + " for field " + ex.field + " struct " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + ex.expected));
						continue;
					}
					OwnConfigEntryBase value2;
					if (text == "Internal")
					{
						CustomSyncedValueBase value;
						if (text2 == "serverversion")
						{
							if (obj?.ToString() != CurrentVersion)
							{
								Debug.LogWarning((object)("Received server version is not equal: server version = " + (obj?.ToString() ?? "null") + "; local version = " + (CurrentVersion ?? "unknown")));
							}
						}
						else if (text2 == "lockexempt")
						{
							if (obj is bool flag)
							{
								lockExempt = flag;
							}
						}
						else if (dictionary2.TryGetValue(text2, out value))
						{
							if ((text3 == "" && (!value.Type.IsValueType || Nullable.GetUnderlyingType(value.Type) != null)) || GetZPackageTypeString(value.Type) == text3)
							{
								parsedConfigs.customValues[value] = obj;
								continue;
							}
							Debug.LogWarning((object)("Got unexpected type " + text3 + " for internal value " + text2 + " for mod " + (DisplayName ?? Name) + ", expecting " + value.Type.AssemblyQualifiedName));
						}
					}
					else if (dictionary.TryGetValue(text + "_" + text2, out value2))
					{
						Type type2 = configType(value2.BaseConfig);
						if ((text3 == "" && (!type2.IsValueType || Nullable.GetUnderlyingType(type2) != null)) || GetZPackageTypeString(type2) == text3)
						{
							parsedConfigs.configValues[value2] = obj;
							continue;
						}
						Debug.LogWarning((object)("Got unexpected type " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + type2.AssemblyQualifiedName));
					}
					else
					{
						Debug.LogWarning((object)("Received unknown config entry " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ". This may happen if client and server versions of the mod do not match."));
					}
					continue;
				}
				Debug.LogWarning((object)("Got invalid type " + text3 + ", abort reading of received configs"));
				return new ParsedConfigs();
			}
			return parsedConfigs;
		}

		private static bool isWritableConfig(OwnConfigEntryBase config)
		{
			OwnConfigEntryBase config2 = config;
			ConfigSync configSync = configSyncs.FirstOrDefault((ConfigSync cs) => cs.allConfigs.Contains(config2));
			if (configSync == null)
			{
				return true;
			}
			return configSync.IsSourceOfTruth || !config2.SynchronizedConfig || config2.LocalBaseValue == null || (!configSync.IsLocked && (config2 != configSync.lockedConfig || lockExempt));
		}

		private void serverLockedSettingChanged()
		{
			foreach (OwnConfigEntryBase allConfig in allConfigs)
			{
				configAttribute<ConfigurationManagerAttributes>(allConfig.BaseConfig).ReadOnly = !isWritableConfig(allConfig);
			}
		}

		private void resetConfigsFromServer()
		{
			ConfigFile val = null;
			bool saveOnConfigSet = false;
			foreach (OwnConfigEntryBase item in allConfigs.Where((OwnConfigEntryBase config) => config.LocalBaseValue != null))
			{
				if (val == null)
				{
					val = item.BaseConfig.ConfigFile;
					saveOnConfigSet = val.SaveOnConfigSet;
					val.SaveOnConfigSet = false;
				}
				item.BaseConfig.BoxedValue = item.LocalBaseValue;
				item.LocalBaseValue = null;
			}
			if (val != null)
			{
				val.SaveOnConfigSet = saveOnConfigSet;
			}
			foreach (CustomSyncedValueBase item2 in allCustomValues.Where((CustomSyncedValueBase config) => config.LocalBaseValue != null))
			{
				item2.BoxedValue = item2.LocalBaseValue;
				item2.LocalBaseValue = null;
			}
			lockedConfigChanged -= serverLockedSettingChanged;
			serverLockedSettingChanged();
		}

		private IEnumerator<bool> distributeConfigToPeers(ZNetPeer peer, ZPackage package)
		{
			ZNetPeer peer2 = peer;
			ZRoutedRpc rpc = ZRoutedRpc.instance;
			if (rpc == null)
			{
				yield break;
			}
			byte[] data = package.GetArray();
			if (data != null && data.LongLength > 250000)
			{
				int fragments = (int)(1 + (data.LongLength - 1) / 250000);
				long packageIdentifier = ++packageCounter;
				int fragment = 0;
				while (fragment < fragments)
				{
					foreach (bool item in waitForQueue())
					{
						yield return item;
					}
					if (peer2.m_socket.IsConnected())
					{
						ZPackage fragmentedPackage = new ZPackage();
						fragmentedPackage.Write((byte)2);
						fragmentedPackage.Write(packageIdentifier);
						fragmentedPackage.Write(fragment);
						fragmentedPackage.Write(fragments);
						fragmentedPackage.Write(data.Skip(250000 * fragment).Take(250000).ToArray());
						SendPackage(fragmentedPackage);
						if (fragment != fragments - 1)
						{
							yield return true;
						}
						int num = fragment + 1;
						fragment = num;
						continue;
					}
					break;
				}
				yield break;
			}
			foreach (bool item2 in waitForQueue())
			{
				yield return item2;
			}
			SendPackage(package);
			void SendPackage(ZPackage pkg)
			{
				string text = Name + " ConfigSync";
				if (isServer)
				{
					peer2.m_rpc.Invoke(text, new object[1] { pkg });
				}
				else
				{
					rpc.InvokeRoutedRPC(peer2.m_server ? 0 : peer2.m_uid, text, new object[1] { pkg });
				}
			}
			IEnumerable<bool> waitForQueue()
			{
				float timeout = Time.time + 30f;
				while (peer2.m_socket.GetSendQueueSize() > 20000)
				{
					if (Time.time > timeout)
					{
						Debug.Log((object)$"Disconnecting {peer2.m_uid} after 30 seconds config sending timeout");
						peer2.m_rpc.Invoke("Error", new object[1] { (object)(ConnectionStatus)5 });
						ZNet.instance.Disconnect(peer2);
						break;
					}
					yield return false;
				}
			}
		}

		private IEnumerator sendZPackage(long target, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return Enumerable.Empty<object>().GetEnumerator();
			}
			List<ZNetPeer> list = (List<ZNetPeer>)AccessTools.DeclaredField(typeof(ZRoutedRpc), "m_peers").GetValue(ZRoutedRpc.instance);
			if (target != ZRoutedRpc.Everybody)
			{
				list = list.Where((ZNetPeer p) => p.m_uid == target).ToList();
			}
			return sendZPackage(list, package);
		}

		private IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
		{
			ZPackage package2 = package;
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				yield break;
			}
			byte[] rawData = package2.GetArray();
			if (rawData != null && rawData.LongLength > 10000)
			{
				ZPackage compressedPackage = new ZPackage();
				compressedPackage.Write((byte)4);
				MemoryStream output = new MemoryStream();
				using (DeflateStream deflateStream = new DeflateStream(output, CompressionLevel.Optimal))
				{
					deflateStream.Write(rawData, 0, rawData.Length);
				}
				compressedPackage.Write(output.ToArray());
				package2 = compressedPackage;
			}
			List<IEnumerator<bool>> writers = (from peer in peers
				where peer.IsReady()
				select peer into p
				select distributeConfigToPeers(p, package2)).ToList();
			writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			while (writers.Count > 0)
			{
				yield return null;
				writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			}
		}

		private void Broadcast(long target, params ConfigEntryBase[] configs)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(configs);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private void Broadcast(long target, params CustomSyncedValueBase[] customValues)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(null, customValues);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private static OwnConfigEntryBase? configData(ConfigEntryBase config)
		{
			return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
		}

		public static SyncedConfigEntry<T>? ConfigData<T>(ConfigEntry<T> config)
		{
			return ((ConfigEntryBase)config).Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
		}

		private static T configAttribute<T>(ConfigEntryBase config)
		{
			return config.Description.Tags.OfType<T>().First();
		}

		private static Type configType(ConfigEntryBase config)
		{
			return configType(config.SettingType);
		}

		private static Type configType(Type type)
		{
			return type.IsEnum ? Enum.GetUnderlyingType(type) : type;
		}

		private static ZPackage ConfigsToPackage(IEnumerable<ConfigEntryBase>? configs = null, IEnumerable<CustomSyncedValueBase>? customValues = null, IEnumerable<PackageEntry>? packageEntries = null, bool partial = true)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			List<ConfigEntryBase> list = configs?.Where((ConfigEntryBase config) => configData(config).SynchronizedConfig).ToList() ?? new List<ConfigEntryBase>();
			List<CustomSyncedValueBase> list2 = customValues?.ToList() ?? new List<CustomSyncedValueBase>();
			ZPackage val = new ZPackage();
			val.Write((byte)(partial ? 1 : 0));
			val.Write(list.Count + list2.Count + (packageEntries?.Count() ?? 0));
			foreach (PackageEntry item in packageEntries ?? Array.Empty<PackageEntry>())
			{
				AddEntryToPackage(val, item);
			}
			foreach (CustomSyncedValueBase item2 in list2)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = "Internal",
					key = item2.Identifier,
					type = item2.Type,
					value = item2.BoxedValue
				});
			}
			foreach (ConfigEntryBase item3 in list)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = item3.Definition.Section,
					key = item3.Definition.Key,
					type = configType(item3),
					value = item3.BoxedValue
				});
			}
			return val;
		}

		private static void AddEntryToPackage(ZPackage package, PackageEntry entry)
		{
			package.Write(entry.section);
			package.Write(entry.key);
			package.Write((entry.value == null) ? "" : GetZPackageTypeString(entry.type));
			AddValueToZPackage(package, entry.value);
		}

		private static string GetZPackageTypeString(Type type)
		{
			return type.AssemblyQualifiedName;
		}

		private static void AddValueToZPackage(ZPackage package, object? value)
		{
			Type type = value?.GetType();
			if (value is Enum)
			{
				value = ((IConvertible)value).ToType(Enum.GetUnderlyingType(value.GetType()), CultureInfo.InvariantCulture);
			}
			else
			{
				if (value is ICollection collection)
				{
					package.Write(collection.Count);
					{
						foreach (object item in collection)
						{
							AddValueToZPackage(package, item);
						}
						return;
					}
				}
				if ((object)type != null && type.IsValueType && !type.IsPrimitive)
				{
					FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					package.Write(fields.Length);
					FieldInfo[] array = fields;
					foreach (FieldInfo fieldInfo in array)
					{
						package.Write(GetZPackageTypeString(fieldInfo.FieldType));
						AddValueToZPackage(package, fieldInfo.GetValue(value));
					}
					return;
				}
			}
			ZRpc.Serialize(new object[1] { value }, ref package);
		}

		private static object ReadValueWithTypeFromZPackage(ZPackage package, Type type)
		{
			if ((object)type != null && type.IsValueType && !type.IsPrimitive && !type.IsEnum)
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				int num = package.ReadInt();
				if (num != fields.Length)
				{
					throw new InvalidDeserializationTypeException
					{
						received = $"(field count: {num})",
						expected = $"(field count: {fields.Length})"
					};
				}
				object uninitializedObject = FormatterServices.GetUninitializedObject(type);
				FieldInfo[] array = fields;
				foreach (FieldInfo fieldInfo in array)
				{
					string text = package.ReadString();
					if (text != GetZPackageTypeString(fieldInfo.FieldType))
					{
						throw new InvalidDeserializationTypeException
						{
							received = text,
							expected = GetZPackageTypeString(fieldInfo.FieldType),
							field = fieldInfo.Name
						};
					}
					fieldInfo.SetValue(uninitializedObject, ReadValueWithTypeFromZPackage(package, fieldInfo.FieldType));
				}
				return uninitializedObject;
			}
			if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<, >))
			{
				int num2 = package.ReadInt();
				IDictionary dictionary = (IDictionary)Activator.CreateInstance(type);
				Type type2 = typeof(KeyValuePair<, >).MakeGenericType(type.GenericTypeArguments);
				FieldInfo field = type2.GetField("key", BindingFlags.Instance | BindingFlags.NonPublic);
				FieldInfo field2 = type2.GetField("value", BindingFlags.Instance | BindingFlags.NonPublic);
				for (int j = 0; j < num2; j++)
				{
					object obj = ReadValueWithTypeFromZPackage(package, type2);
					dictionary.Add(field.GetValue(obj), field2.GetValue(obj));
				}
				return dictionary;
			}
			if (type != typeof(List<string>) && type.IsGenericType)
			{
				Type type3 = typeof(ICollection<>).MakeGenericType(type.GenericTypeArguments[0]);
				if ((object)type3 != null && type3.IsAssignableFrom(type))
				{
					int num3 = package.ReadInt();
					object obj2 = Activator.CreateInstance(type);
					MethodInfo method = type3.GetMethod("Add");
					for (int k = 0; k < num3; k++)
					{
						method.Invoke(obj2, new object[1] { ReadValueWithTypeFromZPackage(package, type.GenericTypeArguments[0]) });
					}
					return obj2;
				}
			}
			ParameterInfo parameterInfo = (ParameterInfo)FormatterServices.GetUninitializedObject(typeof(ParameterInfo));
			AccessTools.DeclaredField(typeof(ParameterInfo), "ClassImpl").SetValue(parameterInfo, type);
			List<object> source = new List<object>();
			ZRpc.Deserialize(new ParameterInfo[2] { null, parameterInfo }, package, ref source);
			return source.First();
		}
	}
	[PublicAPI]
	[HarmonyPatch]
	internal class VersionCheck
	{
		private static readonly HashSet<VersionCheck> versionChecks;

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		private string? displayName;

		private string? currentVersion;

		private string? minimumRequiredVersion;

		public bool ModRequired = true;

		private string? ReceivedCurrentVersion;

		private string? ReceivedMinimumRequiredVersion;

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

		private ConfigSync? ConfigSync;

		public string DisplayName
		{
			get
			{
				return displayName ?? Name;
			}
			set
			{
				displayName = value;
			}
		}

		public string CurrentVersion
		{
			get
			{
				return currentVersion ?? "0.0.0";
			}
			set
			{
				currentVersion = value;
			}
		}

		public string MinimumRequiredVersion
		{
			get
			{
				return minimumRequiredVersion ?? (ModRequired ? CurrentVersion : "0.0.0");
			}
			set
			{
				minimumRequiredVersion = value;
			}
		}

		private static void PatchServerSync()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			Patches patchInfo = PatchProcessor.GetPatchInfo((MethodBase)AccessTools.DeclaredMethod(typeof(ZNet), "Awake", (Type[])null, (Type[])null));
			if (patchInfo != null && patchInfo.Postfixes.Count((Patch p) => p.PatchMethod.DeclaringType == typeof(ConfigSync.RegisterRPCPatch)) > 0)
			{
				return;
			}
			Harmony val = new Harmony("org.bepinex.helpers.ServerSync");
			foreach (Type item in from t in typeof(ConfigSync).GetNestedTypes(BindingFlags.NonPublic).Concat(new Type[1] { typeof(VersionCheck) })
				where t.IsClass
				select t)
			{
				val.PatchAll(item);
			}
		}

		static VersionCheck()
		{
			versionChecks = new HashSet<VersionCheck>();
			notProcessedNames = new Dictionary<string, string>();
			typeof(ThreadingHelper).GetMethod("StartSyncInvoke").Invoke(ThreadingHelper.Instance, new object[1]
			{
				new Action(PatchServerSync)
			});
		}

		public VersionCheck(string name)
		{
			Name = name;
			ModRequired = true;
			versionChecks.Add(this);
		}

		public VersionCheck(ConfigSync configSync)
		{
			ConfigSync = configSync;
			Name = ConfigSync.Name;
			versionChecks.Add(this);
		}

		public void Initialize()
		{
			ReceivedCurrentVersion = null;
			ReceivedMinimumRequiredVersion = null;
			if (ConfigSync != null)
			{
				Name = ConfigSync.Name;
				DisplayName = ConfigSync.DisplayName;
				CurrentVersion = ConfigSync.CurrentVersion;
				MinimumRequiredVersion = ConfigSync.MinimumRequiredVersion;
				ModRequired = ConfigSync.ModRequired;
			}
		}

		private bool IsVersionOk()
		{
			if (ReceivedMinimumRequiredVersion == null || ReceivedCurrentVersion == null)
			{
				return !ModRequired;
			}
			bool flag = new System.Version(CurrentVersion) >= new System.Version(ReceivedMinimumRequiredVersion);
			bool flag2 = new System.Version(ReceivedCurrentVersion) >= new System.Version(MinimumRequiredVersion);
			return flag && flag2;
		}

		private string ErrorClient()
		{
			if (ReceivedMinimumRequiredVersion == null)
			{
				return DisplayName + " is not installed on the server.";
			}
			return (new System.Version(CurrentVersion) >= new System.Version(ReceivedMinimumRequiredVersion)) ? (DisplayName + " may not be higher than version " + ReceivedCurrentVersion + ". You have version " + CurrentVersion + ".") : (DisplayName + " needs to be at least version " + ReceivedMinimumRequiredVersion + ". You have version " + CurrentVersion + ".");
		}

		private string ErrorServer(ZRpc rpc)
		{
			return "Disconnect: The client (" + rpc.GetSocket().GetHostName() + ") doesn't have the correct " + DisplayName + " version " + MinimumRequiredVersion;
		}

		private string Error(ZRpc? rpc = null)
		{
			return (rpc == null) ? ErrorClient() : ErrorServer(rpc);
		}

		private static VersionCheck[] GetFailedClient()
		{
			return versionChecks.Where((VersionCheck check) => !check.IsVersionOk()).ToArray();
		}

		private static VersionCheck[] GetFailedServer(ZRpc rpc)
		{
			ZRpc rpc2 = rpc;
			return versionChecks.Where((VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc2)).ToArray();
		}

		private static void Logout()
		{
			Game.instance.Logout(true, true);
			AccessTools.DeclaredField(typeof(ZNet), "m_connectionStatus").SetValue(null, (object)(ConnectionStatus)3);
		}

		private static void DisconnectClient(ZRpc rpc)
		{
			rpc.Invoke("Error", new object[1] { 3 });
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg)
		{
			CheckVersion(rpc, pkg, null);
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg, Action<ZRpc, ZPackage>? original)
		{
			string text = pkg.ReadString();
			string text2 = pkg.ReadString();
			string text3 = pkg.ReadString();
			bool flag = false;
			foreach (VersionCheck versionCheck in versionChecks)
			{
				if (!(text != versionCheck.Name))
				{
					Debug.Log((object)("Received " + versionCheck.DisplayName + " version " + text3 + " and minimum version " + text2 + " from the " + (ZNet.instance.IsServer() ? "client" : "server") + "."));
					versionCheck.ReceivedMinimumRequiredVersion = text2;
					versionCheck.ReceivedCurrentVersion = text3;
					if (ZNet.instance.IsServer() && versionCheck.IsVersionOk())
					{
						versionCheck.ValidatedClients.Add(rpc);
					}
					flag = true;
				}
			}
			if (flag)
			{
				return;
			}
			pkg.SetPos(0);
			if (original != null)
			{
				original(rpc, pkg);
				if (pkg.GetPos() == 0)
				{
					notProcessedNames.Add(text, text3);
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		[HarmonyPrefix]
		private static bool RPC_PeerInfo(ZRpc rpc, ZNet __instance)
		{
			VersionCheck[] array = (__instance.IsServer() ? GetFailedServer(rpc) : GetFailedClient());
			if (array.Length == 0)
			{
				return true;
			}
			VersionCheck[] array2 = array;
			foreach (VersionCheck versionCheck in array2)
			{
				Debug.LogWarning((object)versionCheck.Error(rpc));
			}
			if (__instance.IsServer())
			{
				DisconnectClient(rpc);
			}
			else
			{
				Logout();
			}
			return false;
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		[HarmonyPrefix]
		private static void RegisterAndCheckVersion(ZNetPeer peer, ZNet __instance)
		{
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Expected O, but got Unknown
			notProcessedNames.Clear();
			IDictionary dictionary = (IDictionary)typeof(ZRpc).GetField("m_functions", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(peer.m_rpc);
			if (dictionary.Contains(StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")))
			{
				object obj = dictionary[StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")];
				Action<ZRpc, ZPackage> action = (Action<ZRpc, ZPackage>)obj.GetType().GetField("m_action", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj);
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)delegate(ZRpc rpc, ZPackage pkg)
				{
					CheckVersion(rpc, pkg, action);
				});
			}
			else
			{
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)CheckVersion);
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.Initialize();
				if (versionCheck.ModRequired || __instance.IsServer())
				{
					Debug.Log((object)("Sending " + versionCheck.DisplayName + " version " + versionCheck.CurrentVersion + " and minimum version " + versionCheck.MinimumRequiredVersion + " to the " + (__instance.IsServer() ? "client" : "server") + "."));
					ZPackage val = new ZPackage();
					val.Write(versionCheck.Name);
					val.Write(versionCheck.MinimumRequiredVersion);
					val.Write(versionCheck.CurrentVersion);
					peer.m_rpc.Invoke("ServerSync VersionCheck", new object[1] { val });
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "Disconnect")]
		[HarmonyPrefix]
		private static void RemoveDisconnected(ZNetPeer peer, ZNet __instance)
		{
			if (!__instance.IsServer())
			{
				return;
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.ValidatedClients.Remove(peer.m_rpc);
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
		[HarmonyPostfix]
		private static void ShowConnectionError(FejdStartup __instance)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.m_connectionFailedPanel.activeSelf || (int)ZNet.GetConnectionStatus() != 3)
			{
				return;
			}
			bool flag = false;
			VersionCheck[] failedClient = GetFailedClient();
			if (failedClient.Length != 0)
			{
				string text = string.Join("\n", failedClient.Select((VersionCheck check) => check.Error()));
				TMP_Text connectionFailedError = __instance.m_connectionFailedError;
				connectionFailedError.text = connectionFailedError.text + "\n" + text;
				flag = true;
			}
			foreach (KeyValuePair<string, string> item in notProcessedNames.OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> kv) => kv.Key))
			{
				if (!__instance.m_connectionFailedError.text.Contains(item.Key))
				{
					TMP_Text connectionFailedError2 = __instance.m_connectionFailedError;
					connectionFailedError2.text = connectionFailedError2.text + "\nServer expects you to have " + item.Key + " (Version: " + item.Value + ") installed.";
					flag = true;
				}
			}
			if (flag)
			{
				RectTransform component = ((Component)__instance.m_connectionFailedPanel.transform.Find("Image")).GetComponent<RectTransform>();
				Vector2 sizeDelta = component.sizeDelta;
				sizeDelta.x = 675f;
				component.sizeDelta = sizeDelta;
				__instance.m_connectionFailedError.ForceMeshUpdate(false, false);
				float num = __instance.m_connectionFailedError.renderedHeight + 105f;
				RectTransform component2 = ((Component)((Component)component).transform.Find("ButtonOk")).GetComponent<RectTransform>();
				component2.anchoredPosition = new Vector2(component2.anchoredPosition.x, component2.anchoredPosition.y - (num - component.sizeDelta.y) / 2f);
				sizeDelta = component.sizeDelta;
				sizeDelta.y = num;
				component.sizeDelta = sizeDelta;
			}
		}
	}
}
namespace 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;
		}
	}
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[<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;
		}
	}
}
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 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 ex.Unwrap();
						}
					}
				}
			}
			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 ex2.Unwrap();
				}
			}
			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();
		}

		[System.Runtime.Serialization.OnDeserialized]
		internal void OnDeserializedMethod(StreamingContext context)
		{
			dictionary = new Dictionary<TKey, TValue>();
			foreach (KeyValuePair<TKey, TValue> item in list)
			{
				dictionary[item.Key] = item.Value;
			}
		}
	}
	internal static class 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);
		}
	}
}
namespace StatManager
{
	[PublicAPI]
	internal class Stat
	{
		private static readonly Dictionary<string, PlayerStatType> stats;

		private static bool patched;

		public readonly PlayerStatType StatType;

		public Stat(string englishName)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected I4, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			StatType = fromName(englishName);
			stats.Add(englishName, StatType);
			if (patched)
			{
				AddStats(new string[1] { englishName }, (IEnumerable<PlayerStatType>)(object)new PlayerStatType[1] { (PlayerStatType)(int)StatType });
				PlayerProfile playerProfile = Game.instance.m_playerProfile;
				if (playerProfile != null)
				{
					playerProfile.m_playerStats[StatType] = 0f;
				}
			}
		}

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

		public void Increment(float amount = 1f)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)Game.instance))
			{
				Game.instance.IncrementPlayerStat(StatType, amount);
			}
		}

		public float Get()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)Game.instance))
			{
				return Game.instance.GetPlayerStat(StatType);
			}
			return 0f;
		}

		static Stat()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected O, but got Unknown
			//IL_011d: Expected O, but got Unknown
			stats = new Dictionary<string, PlayerStatType>();
			patched = false;
			Harmony val = new Harmony("org.bepinex.helpers.statmanager");
			val.Patch((MethodBase)AccessTools.DeclaredConstructor(typeof(PlayerStats), (Type[])null, false), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Stat), "Patch_PlayerStats", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Stat), "Patch_FejdStartup", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(PlayerProfile), "LoadPlayerFromDisk", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Stat), "Patch_LoadPlayer", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(PlayerProfile), "SavePlayerToDisk", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Stat), "Patch_SavePlayer", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Stat), "Patch_SavePlayerCleanup", (Type[])null, (Type[])null)), (HarmonyMethod)null);
		}

		private static void Patch_PlayerStats(PlayerStats __instance)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			foreach (PlayerStatType value in stats.Values)
			{
				__instance.m_stats[value] = 0f;
			}
		}

		private static void AddStats(IEnumerable<string> names, IEnumerable<PlayerStatType> values)
		{
			object obj = AccessTools.DeclaredMethod(typeof(Enum), "GetCachedValuesAndNames", (Type[])null, (Type[])null).Invoke(null, new object[2]
			{
				typeof(PlayerStatType),
				true
			});
			FieldInfo fieldInfo = AccessTools.DeclaredField(obj.GetType(), "Values");
			FieldInfo fieldInfo2 = AccessTools.DeclaredField(obj.GetType(), "Names");
			fieldInfo.SetValue(obj, ((ulong[])fieldInfo.GetValue(obj)).Concat(values.Select((PlayerStatType v) => (ulong)(long)v)).ToArray());
			fieldInfo2.SetValue(obj, ((string[])fieldInfo2.GetValue(obj)).Concat(names).ToArray());
		}

		private static void Patch_FejdStartup()
		{
			if (!patched)
			{
				patched = true;
				AddStats(stats.Keys, stats.Values);
			}
		}

		private static void Patch_LoadPlayer(PlayerProfile __instance)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<string, PlayerStatType> stat in stats)
			{
				string key = "StatManager " + stat.Key;
				if (__instance.m_knownCommands.TryGetValue(key, out var value))
				{
					__instance.m_playerStats.m_stats[stat.Value] = value;
					__instance.m_knownCommands.Remove(key);
				}
			}
		}

		private static void Patch_SavePlayer(PlayerProfile __instance)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<string, PlayerStatType> stat in stats)
			{
				__instance.m_knownCommands["StatManager " + stat.Key] = __instance.m_playerStats[stat.Value];
			}
		}

		private static void Patch_SavePlayerCleanup(PlayerProfile __instance)
		{
			foreach (KeyValuePair<string, PlayerStatType> stat in stats)
			{
				__instance.m_knownCommands.Remove("StatManager " + stat.Key);
			}
		}
	}
	[PublicAPI]
	internal static class StatExtensions
	{
		public static void IncrementPlayerStat(this Game game, string name, float amount = 1f)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			game.IncrementPlayerStat(Stat.fromName(name), 1f);
		}

		public static float GetPlayerStat(this PlayerStats playerStats, string name)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return playerStats[Stat.fromName(name)];
		}

		public static float GetPlayerStat(this Game game, PlayerStatType statType)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return game.GetPlayerProfile().m_playerStats[statType];
		}

		public static float GetPlayerStat(this Game game, string name)
		{
			return game.GetPlayerProfile().m_playerStats.GetPlayerStat(name);
		}
	}
}
namespace APIManager
{
	internal static class Patcher
	{
		private class MonoAssemblyResolver : IAssemblyResolver, IDisposable
		{
			public AssemblyDefinition Resolve(AssemblyNameReference name)
			{
				return AssemblyDefinition.ReadAssembly(AppDomain.CurrentDomain.Load(name.FullName).Location);
			}

			public AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters)
			{
				return Resolve(name);
			}

			public void Dispose()
			{
			}
		}

		private class AssemblyLoadInterceptor
		{
			private static string? assemblyPath;

			private static MethodInfo TargetMethod()
			{
				return AccessTools.DeclaredMethod(typeof(Assembly), "Load", new Type[1] { typeof(byte[]) }, (Type[])null);
			}

			private static bool Prefix(ref byte[] __0, ref Assembly? __result)
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Expected O, but got Unknown
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Expected O, but got Unknown
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e5: Expected O, but got Unknown
				//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0106: Expected O, but got Unknown
				//IL_011d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0127: Expected O, but got Unknown
				//IL_0133: 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_0169: Expected O, but got Unknown
				//IL_0185: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0201: Unknown result type (might be due to invalid IL or missing references)
				//IL_0207: Expected O, but got Unknown
				//IL_0222: Unknown result type (might be due to invalid IL or missing references)
				//IL_0260: Unknown result type (might be due to invalid IL or missing references)
				assemblyPath = null;
				if (modifyNextLoad)
				{
					modifyNextLoad = false;
					try
					{
						AssemblyDefinition val = AssemblyDefinition.ReadAssembly((Stream)new MemoryStream(__0), new ReaderParameters
						{
							AssemblyResolver = (IAssemblyResolver)(object)new MonoAssemblyResolver()
						});
						try
						{
							((Dictionary<string, string>)typeof(EnvVars).Assembly.GetType("BepInEx.Preloader.RuntimeFixes.UnityPatches").GetProperty("AssemblyLocations").GetValue(null))[val.FullName] = currentAssemblyPath;
							FixupModuleReferences(val.MainModule);
							TypeDefinition val2 = val.MainModule.GetType("APIManager", "PatchedAttribute");
							if (val2 == null)
							{
								val2 = new TypeDefinition("APIManager", "PatchedAttribute", (TypeAttributes)3)
								{
									BaseType = val.MainModule.ImportReference(typeof(Attribute))
								};
								MethodDefinition val3 = new MethodDefinition(".ctor", (MethodAttributes)6278, val.MainModule.TypeSystem.Void);
								((MethodReference)val3).Parameters.Add(new ParameterDefinition(val.MainModule.TypeSystem.String));
								((MethodReference)val3).Parameters.Add(new ParameterDefinition(val.MainModule.TypeSystem.String));
								val3.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
								val2.Methods.Add(val3);
								val.MainModule.Types.Add(val2);
								CustomAttribute val4 = new CustomAttribute((MethodReference)(object)val3);
								val4.ConstructorArguments.Add(new CustomAttributeArgument(val.MainModule.TypeSystem.String, (object)""));
								val4.ConstructorArguments.Add(new CustomAttributeArgument(val.MainModule.TypeSystem.String, (object)val.MainModule.Mvid.ToString()));
								val.CustomAttributes.Add(val4);
							}
							CustomAttribute val5 = new CustomAttribute((MethodReference)(object)((IEnumerable<MethodDefinition>)val2.Methods).First((MethodDefinition m) => ((MemberReference)m).Name == ".ctor"));
							val5.ConstructorArguments.Add(new CustomAttributeArgument(val.MainModule.TypeSystem.String, (object)modGUID));
							val5.ConstructorArguments.Add(new CustomAttributeArgument(val.MainModule.TypeSystem.String, (object)patchingAssembly.ManifestModule.ModuleVersionId.ToString()));
							val.CustomAttributes.Add(val5);
							using MemoryStream memoryStream = new MemoryStream();
							val.Write((Stream)memoryStream);
							__0 = memoryStream.ToArray();
							string dumpedAssembliesPath = Patcher.dumpedAssembliesPath;
							char directorySeparatorChar = Path.DirectorySeparatorChar;
							string path = dumpedAssembliesPath + directorySeparatorChar + ((AssemblyNameReference)val.Name).Name + ".dll";
							Directory.CreateDirectory(Patcher.dumpedAssembliesPath);
							File.WriteAllBytes(path, __0);
							assemblyPath = path;
							__result = null;
							return false;
						}
						finally
						{
							((IDisposable)val)?.Dispose();
						}
					}
					catch (BadImageFormatException)
					{
					}
					catch (Exception ex2)
					{
						Debug.LogError((object)("Failed patching ... " + ex2));
					}
				}
				return true;
			}

			private static void Postfix(ref Assembly? __result)
			{
				if (assemblyPath != null && __result == null)
				{
					__result = Assembly.LoadFrom(assemblyPath);
					assemblyPath = null;
				}
			}
		}

		private static PluginInfo? lastPluginInfo;

		private static bool modifyNextLoad = false;

		private static string modGUID = null;

		private static HashSet<string> redirectedNamespaces = null;

		private static readonly Assembly patchingAssembly = Assembly.GetExecutingAssembly();

		private static string currentAssemblyPath = null;

		private static readonly string dumpedAssembliesPath = (string)AccessTools.DeclaredField(typeof(AssemblyPatcher), "DumpedAssembliesPath").GetValue(null);

		private static void GrabPluginInfo(PluginInfo __instance)
		{
			lastPluginInfo = __instance;
		}

		[HarmonyPriority(700)]
		private static void CheckAssemblyLoadFile(string __0)
		{
			PluginInfo? obj = lastPluginInfo;
			if (__0 == ((obj != null) ? obj.Location : null) && lastPluginInfo.Dependencies.Any((BepInDependency d) => d.DependencyGUID == modGUID))
			{
				modifyNextLoad = true;
				currentAssemblyPath = __0;
			}
			lastPluginInfo = null;
		}

		[HarmonyPriority(500)]
		private static bool InterceptAssemblyLoadFile(string __0, ref Assembly? __result)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			if (modifyNextLoad && (object)__result == null)
			{
				string text = dumpedAssembliesPath;
				char directorySeparatorChar = Path.DirectorySeparatorChar;
				string text2 = text + directorySeparatorChar + Path.GetFileName(__0);
				if (File.Exists(text2))
				{
					AssemblyDefinition val = AssemblyDefinition.ReadAssembly(text2, new ReaderParameters
					{
						AssemblyResolver = (IAssemblyResolver)(object)new MonoAssemblyResolver()
					});
					try
					{
						bool flag = false;
						Enumerator<CustomAttribute> enumerator = val.CustomAttributes.GetEnumerator();
						try
						{
							while (enumerator.MoveNext())
							{
								CustomAttribute current = enumerator.Current;
								TypeReference declaringType = ((MemberReference)current.Constructor).DeclaringType;
								if (declaringType.Namespace == "APIManager" && ((MemberReference)declaringType).Name == "PatchedAttribute")
								{
									CustomAttributeArgument val2 = current.ConstructorArguments[0];
									if ((string)((CustomAttributeArgument)(ref val2)).Value == modGUID)
									{
										val2 = current.ConstructorArguments[1];
										flag = (string)((CustomAttributeArgument)(ref val2)).Value == patchingAssembly.ManifestModule.ModuleVersionId.ToString();
										break;
									}
								}
							}
						}
						finally
						{
							((IDisposable)enumerator).Dispose();
						}
						if (flag)
						{
							return true;
						}
					}
					finally
					{
						((IDisposable)val)?.Dispose();
					}
				}
				__result = Assembly.Load(File.ReadAllBytes(__0));
				return false;
			}
			return true;
		}

		[HarmonyPriority(499)]
		private static bool ReplaceAssemblyLoadWithCache(ref string __0, ref Assembly? __result)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			if (modifyNextLoad && (object)__result == null && !__0.StartsWith(dumpedAssembliesPath))
			{
				string text = dumpedAssembliesPath;
				char directorySeparatorChar = Path.DirectorySeparatorChar;
				string text2 = text + directorySeparatorChar + Path.GetFileName(__0);
				AssemblyDefinition val = AssemblyDefinition.ReadAssembly(text2, new ReaderParameters
				{
					AssemblyResolver = (IAssemblyResolver)(object)new MonoAssemblyResolver()
				});
				AssemblyDefinition val2 = AssemblyDefinition.ReadAssembly(__0, new ReaderParameters
				{
					AssemblyResolver = (IAssemblyResolver)(object)new MonoAssemblyResolver()
				});
				Enumerator<CustomAttribute> enumerator = val.CustomAttributes.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						CustomAttribute current = enumerator.Current;
						TypeReference declaringType = ((MemberReference)current.Constructor).DeclaringType;
						if (declaringType.Namespace == "APIManager" && ((MemberReference)declaringType).Name == "PatchedAttribute")
						{
							CustomAttributeArgument val3 = current.ConstructorArguments[0];
							string text3 = (string)((CustomAttributeArgument)(ref val3)).Value;
							bool num;
							if (!(text3 == ""))
							{
								num = !Chainloader.PluginInfos.ContainsKey(text3);
							}
							else
							{
								val3 = current.ConstructorArguments[1];
								num = (string)((CustomAttributeArgument)(ref val3)).Value != val2.MainModule.Mvid.ToString();
							}
							if (num)
							{
								val2.Dispose();
								val.Dispose();
								__result = Assembly.Load(File.ReadAllBytes(__0));
								return false;
							}
						}
					}
				}
				finally
				{
					((IDisposable)enumerator).Dispose();
				}
				((Dictionary<string, string>)typeof(EnvVars).Assembly.GetType("BepInEx.Preloader.RuntimeFixes.UnityPatches").GetProperty("AssemblyLocations").GetValue(null))[val.FullName] = __0;
				val2.Dispose();
				val.Dispose();
				__0 = text2;
			}
			modifyNextLoad = false;
			return true;
		}

		private static void FixupModuleReferences(ModuleDefinition module)
		{
			ModuleDefinition module2 = module;
			foreach (TypeDefinition type4 in module2.GetTypes())
			{
				if ((object)patchingAssembly.GetType(((MemberReference)type4).FullName) == null)
				{
					Dispatch(type4);
				}
			}
			static bool AreSame(TypeReference a, TypeReference b)
			{
				return (bool)typeof(MetadataResolver).Assembly.GetType("Mono.Cecil.MetadataResolver").GetMethod("AreSame", BindingFlags.Static | BindingFlags.NonPublic, null, new Type[2]
				{
					typeof(TypeReference),
					typeof(TypeReference)
				}, null).Invoke(null, new object[2] { a, b });
			}
			void Dispatch(TypeDefinition type)
			{
				if (type.BaseType != null && type.BaseType.Scope == module2 && redirectedNamespaces.Contains(baseDeclaringType(type.BaseType).Namespace))
				{
					Type type3 = patchingAssembly.GetType(((MemberReference)type.BaseType).FullName);
					if ((object)type3 != null)
					{
						type.BaseType = module2.ImportReference(type3);
					}
				}
				DispatchGenericParameters((IGenericParameterProvider)(object)type, ((MemberReference)type).FullName);
				DispatchInterfaces(type, ((MemberReference)type).FullName);
				DispatchAttributes((ICustomAttributeProvider)(object)type, ((MemberReference)type).FullName);
				DispatchFields(type, ((MemberReference)type).FullName);
				DispatchProperties(type, ((MemberReference)type).FullName);
				DispatchEvents(type, ((MemberReference)type).FullName);
				DispatchMethods(type);
			}
			void DispatchAttributes(ICustomAttributeProvider provider, string referencingEntityName)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_010d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0112: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				//IL_012b: Unknown result type (might be due to invalid IL or missing references)
				//IL_013c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0141: Unknown result type (might be due to invalid IL or missing references)
				//IL_014a: Unknown result type (might be due to invalid IL or missing references)
				//IL_014f: Unknown result type (might be due to invalid IL or missing references)
				if (!provider.HasCustomAttributes)
				{
					return;
				}
				Enumerator<CustomAttribute> enumerator11 = provider.CustomAttributes.GetEnumerator();
				try
				{
					while (enumerator11.MoveNext())
					{
						CustomAttribute current11 = enumerator11.Current;
						MethodReference val12 = importMethodReference(current11.Constructor);
						if (val12 != null)
						{
							current11.Constructor = val12;
						}
						else
						{
							VisitMethod(current11.Constructor, referencingEntityName);
						}
						for (int n = 0; n < current11.ConstructorArguments.Count; n++)
						{
							CustomAttributeArgument val13 = current11.ConstructorArguments[n];
							current11.ConstructorArguments[n] = new CustomAttributeArgument(VisitType(((CustomAttributeArgument)(ref val13)).Type, referencingEntityName), ((CustomAttributeArgument)(ref val13)).Value);
						}
						CustomAttributeArgument argument;
						for (int num = 0; num < current11.Properties.Count; num++)
						{
							CustomAttributeNamedArgument val14 = current11.Properties[num];
							Collection<CustomAttributeNamedArgument> properties = current11.Properties;
							int num2 = num;
							string name = ((CustomAttributeNamedArgument)(ref val14)).Name;
							argument = ((CustomAttributeNamedArgument)(ref val14)).Argument;
							TypeReference? obj2 = VisitType(((CustomAttributeArgument)(ref argument)).Type, referencingEntityName);
							argument = ((CustomAttributeNamedArgument)(ref val14)).Argument;
							properties[num2] = new CustomAttributeNamedArgument(name, new CustomAttributeArgument(obj2, ((CustomAttributeArgument)(ref argument)).Value));
						}
						for (int num3 = 0; num3 < current11.Fields.Count; num3++)
						{
							CustomAttributeNamedArgument val15 = current11.Fields[num3];
							Collection<CustomAttributeNamedArgument> fields = current11.Fields;
							int num4 = num3;
							string name2 = ((CustomAttributeNamedArgument)(ref val15)).Name;
							argument = ((CustomAttributeNamedArgument)(ref val15)).Argument;
							TypeReference? obj3 = VisitType(((CustomAttributeArgument)(ref argument)).Type, referencingEntityName);
							argument = ((CustomAttributeNamedArgument)(ref val15)).Argument;
							fields[num4] = new CustomAttributeNamedArgument(name2, new CustomAttributeArgument(obj3, ((CustomAttributeArgument)(ref argument)).Value));
						}
					}
				}
				finally
				{
					((IDisposable)enumerator11).Dispose();
				}
			}
			void DispatchEvents(TypeDefinition type, string referencingEntityName)
			{
				//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)
				Enumerator<EventDefinition> enumerator6 = type.Events.GetEnumerator();
				try
				{
					while (enumerator6.MoveNext())
					{
						EventDefinition current6 = enumerator6.Current;
						((EventReference)current6).EventType = VisitType(((EventReference)current6).EventType, referencingEntityName);
						DispatchAttributes((ICustomAttributeProvider)(object)current6, referencingEntityName);
					}
				}
				finally
				{
					((IDisposable)enumerator6).Dispose();
				}
			}
			void DispatchFields(TypeDefinition type, string referencingEntityName)
			{
				//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)
				Enumerator<FieldDefinition> enumerator8 = type.Fields.GetEnumerator();
				try
				{
					while (enumerator8.MoveNext())
					{
						FieldDefinition current8 = enumerator8.Current;
						((FieldReference)current8).FieldType = VisitType(((FieldReference)current8).FieldType, referencingEntityName);
						DispatchAttributes((ICustomAttributeProvider)(object)current8, referencingEntityName);
					}
				}
				finally
				{
					((IDisposable)enumerator8).Dispose();
				}
			}
			void DispatchGenericArguments(IGenericInstance genericInstance, string referencingEntityName)
			{
				for (int j = 0; j < genericInstance.GenericArguments.Count; j++)
				{
					genericInstance.GenericArguments[j] = VisitType(genericInstance.GenericArguments[j], referencingEntityName);
				}
			}
			void DispatchGenericParameters(IGenericParameterProvider provider, string referencingEntityName)
			{
				//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)
				Enumerator<GenericParameter> enumerator12 = provider.GenericParameters.GetEnumerator();
				try
				{
					while (enumerator12.MoveNext())
					{
						GenericParameter current12 = enumerator12.Current;
						DispatchAttributes((ICustomAttributeProvider)(object)current12, referencingEntityName);
						for (int num5 = 0; num5 < current12.Constraints.Count; num5++)
						{
							current12.Constraints[num5] = VisitType(current12.Constraints[num5], referencingEntityName);
						}
					}
				}
				finally
				{
					((IDisposable)enumerator12).Dispose();
				}
			}
			void DispatchInterfaces(TypeDefinition type, string referencingEntityName)
			{
				//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)
				Enumerator<InterfaceImplementation> enumerator9 = type.Interfaces.GetEnumerator();
				try
				{
					while (enumerator9.MoveNext())
					{
						InterfaceImplementation current9 = enumerator9.Current;
						current9.InterfaceType = VisitType(current9.InterfaceType, referencingEntityName);
					}
				}
				finally
				{
					((IDisposable)enumerator9).Dispose();
				}
			}
			void DispatchMethod(MethodDefinition method)
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				((MethodReference)method).ReturnType = VisitType(((MethodReference)method).ReturnType, ((MemberReference)method).FullName);
				DispatchAttributes((ICustomAttributeProvider)(object)((MethodReference)method).MethodReturnType, ((MemberReference)method).FullName);
				DispatchGenericParameters((IGenericParameterProvider)(object)method, ((MemberReference)method).FullName);
				Enumerator<ParameterDefinition> enumerator4 = ((MethodReference)method).Parameters.GetEnumerator();
				try
				{
					while (enumerator4.MoveNext())
					{
						ParameterDefinition current4 = enumerator4.Current;
						((ParameterReference)current4).ParameterType = VisitType(((ParameterReference)current4).ParameterType, ((MemberReference)method).FullName);
						DispatchAttributes((ICustomAttributeProvider)(object)current4, ((MemberReference)method).FullName);
					}
				}
				finally
				{
					((IDisposable)enumerator4).Dispose();
				}
				for (int i = 0; i < method.Overrides.Count; i++)
				{
					MethodReference val6 = importMethodReference(method.Overrides[i]);
					if (val6 != null)
					{
						method.Overrides[i] = val6;
					}
					else
					{
						VisitMethod(method.Overrides[i], ((MemberReference)method).FullName);
					}
				}
				if (method.HasBody)
				{
					DispatchMethodBody(method.Body);
				}
			}
			void DispatchMethodBody(MethodBody body)
			{
				//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_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				Enumerator<VariableDefinition> enumerator2 = body.Variables.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						VariableDefinition current2 = enumerator2.Current;
						((VariableReference)current2).VariableType = VisitType(((VariableReference)current2).VariableType, ((MemberReference)body.Method).FullName);
					}
				}
				finally
				{
					((IDisposable)enumerator2).Dispose();
				}
				Enumerator<Instruction> enumerator3 = body.Instructions.GetEnumerator();
				try
				{
					while (enumerator3.MoveNext())
					{
						Instruction current3 = enumerator3.Current;
						object operand = current3.Operand;
						FieldReference val = (FieldReference)((operand is FieldReference) ? operand : null);
						if (val == null)
						{
							MethodReference val2 = (MethodReference)((operand is MethodReference) ? operand : null);
							if (val2 == null)
							{
								TypeReference val3 = (TypeReference)((operand is TypeReference) ? operand : null);
								if (val3 != null)
								{
									current3.Operand = VisitType(val3, ((MemberReference)body.Method).FullName);
								}
							}
							else
							{
								MethodReference val4 = importMethodReference(val2);
								if (val4 != null)
								{
									current3.Operand = val4;
								}
								else
								{
									VisitMethod(val2, ((MemberReference)body.Method).FullName);
								}
							}
						}
						else
						{
							FieldReference val5 = importFieldReference(val);
							if (val5 != null)
							{
								current3.Operand = val5;
							}
							else
							{
								VisitField(val, ((MemberReference)body.Method).FullName);
							}
						}
					}
				}
				finally
				{
					((IDisposable)enumerator3).Dispose();
				}
			}
			void DispatchMethods(TypeDefinition type)
			{
				//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)
				Enumerator<MethodDefinition> enumerator5 = type.Methods.GetEnumerator();
				try
				{
					while (enumerator5.MoveNext())
					{
						MethodDefinition current5 = enumerator5.Current;
						DispatchMethod(current5);
					}
				}
				finally
				{
					((IDisposable)enumerator5).Dispose();
				}
			}
			void DispatchProperties(TypeDefinition type, string referencingEntityName)
			{
				//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)
				Enumerator<PropertyDefinition> enumerator7 = type.Properties.GetEnumerator();
				try
				{
					while (enumerator7.MoveNext())
					{
						PropertyDefinition current7 = enumerator7.Current;
						((PropertyReference)current7).PropertyType = VisitType(((PropertyReference)current7).PropertyType, referencingEntityName);
						DispatchAttributes((ICustomAttributeProvider)(object)current7, referencingEntityName);
					}
				}
				finally
				{
					((IDisposable)enumerator7).Dispose();
				}
			}
			TypeReference FixupType(TypeReference type)
			{
				if (type.Scope == module2 && redirectedNamespaces.Contains(baseDeclaringType(type).Namespace))
				{
					if (type.IsNested)
					{
						return FixupType(((MemberReference)type).DeclaringType);
					}
					Type type2 = patchingAssembly.GetType(((MemberReference)type).FullName);
					if ((object)type2 != null)
					{
						return module2.ImportReference(type2);
					}
				}
				return type;
			}
			void VisitField(FieldReference? field, string referencingEntityName)
			{
				if (field != null)
				{
					field.FieldType = VisitType(field.FieldType, referencingEntityName);
					if (!(field is FieldDefinition))
					{
						((MemberReference)field).DeclaringType = VisitType(((MemberReference)field).DeclaringType, referencingEntityName);
					}
				}
			}
			void VisitMethod(MethodReference? method, string referencingEntityName)
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				if (method != null)
				{
					GenericInstanceMethod val7 = (GenericInstanceMethod)(object)((method is GenericInstanceMethod) ? method : null);
					if (val7 != null)
					{
						DispatchGenericArguments((IGenericInstance)(object)val7, referencingEntityName);
					}
					method.ReturnType = VisitType(method.ReturnType, referencingEntityName);
					Enumerator<ParameterDefinition> enumerator10 = method.Parameters.GetEnumerator();
					try
					{
						while (enumerator10.MoveNext())
						{
							ParameterDefinition current10 = enumerator10.Current;
							((ParameterReference)current10).ParameterType = VisitType(((ParameterReference)current10).ParameterType, referencingEntityName);
						}
					}
					finally
					{
						((IDisposable)enumerator10).Dispose();
					}
					if (!(method is MethodSpecification))
					{
						((MemberReference)method).DeclaringType = VisitType(((MemberReference)method).DeclaringType, referencingEntityName);
					}
				}
			}
			TypeReference? VisitType(TypeReference? type, string referencingEntityName)
			{
				if (type == null)
				{
					return type;
				}
				if (type.GetElementType().IsGenericParameter)
				{
					return type;
				}
				GenericInstanceType val8 = (GenericInstanceType)(object)((type is GenericInstanceType) ? type : null);
				if (val8 != null)
				{
					DispatchGenericArguments((IGenericInstance)(object)val8, referencingEntityName);
				}
				return FixupType(type);
			}
			static TypeReference baseDeclaringType(TypeReference type)
			{
				while (((MemberReference)type).DeclaringType != null)
				{
					type = ((MemberReference)type).DeclaringType;
				}
				return type;
			}
			FieldReference? importFieldReference(FieldReference field)
			{
				if (((MemberReference)field).DeclaringType.Scope == module2 && redirectedNamespaces.Contains(baseDeclaringType(((MemberReference)field).DeclaringType).Namespace))
				{
					FieldInfo fieldInfo = patchingAssembly.GetType(((MemberReference)((MemberReference)field).DeclaringType).FullName)?.GetField(((MemberReference)field).Name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
					if ((object)fieldInfo != null)
					{
						return module2.ImportReference(fieldInfo);
					}
				}
				return null;
			}
			MethodReference? importMethodReference(MethodReference method)
			{
				//IL_0176: Unknown result type (might be due to invalid IL or missing references)
				//IL_017d: Expected O, but got Unknown
				MethodReference method2 = method;
				if (((MemberReference)method2).DeclaringType.Scope == module2 && redirectedNamespaces.Contains(baseDeclaringType(((MemberReference)method2).DeclaringType).Namespace))
				{
					if (((MemberReference)method2).Name == ".cctor")
					{
						ConstructorInfo[] array = patchingAssembly.GetType(((MemberReference)((MemberReference)method2).DeclaringType).FullName)?.GetConstructors(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
						if (array != null && array.Length == 1)
						{
							return module2.ImportReference((MethodBase)array[0]);
						}
					}
					else if (((MemberReference)method2).Name == ".ctor")
					{
						ConstructorInfo constructorInfo = patchingAssembly.GetType(((MemberReference)((MemberReference)method2).DeclaringType).FullName)?.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault(CompareMethods);
						if ((object)constructorInfo != null)
						{
							return module2.ImportReference((MethodBase)constructorInfo);
						}
					}
					else
					{
						MethodInfo methodInfo = patchingAssembly.GetType(((MemberReference)((MemberReference)method2).DeclaringType).FullName)?.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault(delegate(MethodInfo m)
						{
							if (m.Name != ((MemberReference)method2).Name)
							{
								return false;
							}
							return (((MemberReference)method2.ReturnType).ContainsGenericParameter == m.ReturnType.IsGenericParameter || AreSame(method2.ReturnType, module2.ImportReference(m.ReturnType))) && CompareMethods(m);
						});
						if ((object)methodInfo != null)
						{
							MethodReference val9 = module2.ImportReference((MethodBase)methodInfo);
							MethodReference obj = method2;
							GenericInstanceMethod val10 = (GenericInstanceMethod)(object)((obj is GenericInstanceMethod) ? obj : null);
							if (val10 != null)
							{
								GenericInstanceMethod val11 = new GenericInstanceMethod(val9);
								for (int k = 0; k < val10.GenericArguments.Count; k++)
								{
									val10.GenericArguments[k] = VisitType(val10.GenericArguments[k], ((MemberReference)method2).FullName);
									val11.GenericArguments.Add(val10.GenericArguments[k]);
								}
								val9 = (MethodReference)(object)val11;
							}
							return val9;
						}
					}
				}
				return null;
				bool CompareMethods(MethodBase m)
				{
					ParameterInfo[] parameters = m.GetParameters();
					if (method2.IsGenericInstance != m.IsGenericMethodDefinition || parameters.Length != 0 != method2.HasParameters)
					{
						return false;
					}
					if (method2.HasParameters)
					{
						if (method2.Parameters.Count != parameters.Length)
						{
							return false;
						}
						for (int l = 0; l < method2.Parameters.Count; l++)
						{
							if (parameters[l].ParameterType.IsGenericParameter ? (!((ParameterReference)method2.Parameters[l]).ParameterType.IsGenericParameter) : (!AreSame(((ParameterReference)method2.Parameters[l]).ParameterType, module2.ImportReference(parameters[l].ParameterType))))
							{
								return false;
							}
						}
					}
					return true;
				}
			}
		}

		public static bool PreventHarmonyInteropFixLoad(Assembly? __0)
		{
			return __0 == null;
		}

		public static void Patch(IEnumerable<string>? extraNamespaces = null)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Expected O, but got Unknown
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Expected O, but got Unknown
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Expected O, but got Unknown
			Harmony val = new Harmony("org.bepinex.plugins.APIManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(PluginInfo), "ToString", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Patcher), "GrabPluginInfo", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Assembly), "LoadFile", new Type[1] { typeof(string) }, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Patcher), "InterceptAssemblyLoadFile", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Assembly), "LoadFile", new Type[1] { typeof(string) }, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Patcher), "CheckAssemblyLoadFile", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Assembly), "LoadFile", new Type[1] { typeof(string) }, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Patcher), "ReplaceAssemblyLoadWithCache", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			new PatchClassProcessor(val, typeof(AssemblyLoadInterceptor), true).Patch();
			Type type = typeof(AssemblyPatcher).Assembly.GetType("BepInEx.Preloader.RuntimeFixes.HarmonyInteropFix");
			if ((object)type != null)
			{
				val.Patch((MethodBase)AccessTools.DeclaredMethod(type, "OnAssemblyLoad", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Patcher), "PreventHarmonyInteropFixLoad", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			IEnumerable<TypeInfo> source;
			try
			{
				source = patchingAssembly.DefinedTypes.ToList();
			}
			catch (ReflectionTypeLoadException ex)
			{
				source = from t in ex.Types
					where t != null
					select t.GetTypeInfo();
			}
			BaseUnityPlugin val2 = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First((TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
			redirectedNamespaces = new HashSet<string>(extraNamespaces ?? Array.Empty<string>()) { ((object)val2).GetType().Namespace };
			modGUID = val2.Info.Metadata.GUID;
		}
	}
}