using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using JetBrains.Annotations;
using LocalizationManager;
using Microsoft.CodeAnalysis;
using ResidualRemnants.Data;
using ServerSync;
using TMPro;
using UnityEngine;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Core.Tokens;
using YamlDotNet.Helpers;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.BufferedDeserialization;
using YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators;
using YamlDotNet.Serialization.Converters;
using YamlDotNet.Serialization.EventEmitters;
using YamlDotNet.Serialization.NamingConventions;
using YamlDotNet.Serialization.NodeDeserializers;
using YamlDotNet.Serialization.NodeTypeResolvers;
using YamlDotNet.Serialization.ObjectFactories;
using YamlDotNet.Serialization.ObjectGraphTraversalStrategies;
using YamlDotNet.Serialization.ObjectGraphVisitors;
using YamlDotNet.Serialization.Schemas;
using YamlDotNet.Serialization.TypeInspectors;
using YamlDotNet.Serialization.TypeResolvers;
using YamlDotNet.Serialization.Utilities;
using YamlDotNet.Serialization.ValueDeserializers;

[assembly: AssemblyProduct("ResidualRemnants")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyCompany("ResidualRemnants")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: AssemblyTitle("ResidualRemnants")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<47ed7673-c10f-4f80-a126-35f040f969a9>Embedded]
	internal sealed class <47ed7673-c10f-4f80-a126-35f040f969a9>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	[<47ed7673-c10f-4f80-a126-35f040f969a9>Embedded]
	internal sealed class <e01f053a-b7ce-4947-8061-1cf9c050be01>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <e01f053a-b7ce-4947-8061-1cf9c050be01>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <e01f053a-b7ce-4947-8061-1cf9c050be01>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[<47ed7673-c10f-4f80-a126-35f040f969a9>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	internal sealed class <5040a701-4271-4836-bdbc-8977f6bd8e36>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <5040a701-4271-4836-bdbc-8977f6bd8e36>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace ResidualRemnants
{
	[BepInPlugin("maxfoxgaming.residualremnants", "ResidualRemnants", "1.1.3")]
	[<5040a701-4271-4836-bdbc-8977f6bd8e36>NullableContext(1)]
	[<e01f053a-b7ce-4947-8061-1cf9c050be01>Nullable(0)]
	public class Main : BaseUnityPlugin
	{
		public const string PluginGUID = "maxfoxgaming.residualremnants";

		public const string PluginName = "ResidualRemnants";

		public const string PluginVersion = "1.1.3";

		[<e01f053a-b7ce-4947-8061-1cf9c050be01>Nullable(2)]
		private static Main instance;

		public static Harmony harmony = new Harmony("maxfoxgaming.residualremnants");

		public static readonly string ModPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

		[<e01f053a-b7ce-4947-8061-1cf9c050be01>Nullable(2)]
		public static ManualLogSource Log;

		public void Awake()
		{
			Localizer.Load();
			Log = ((BaseUnityPlugin)this).Logger;
			instance = this;
			ConfigManager.CreateConfigValues((BaseUnityPlugin)(object)this);
			Harmony val = harmony;
			if (val != null)
			{
				val.PatchAll();
			}
		}

		public void OnDestroy()
		{
			Harmony val = harmony;
			if (val != null)
			{
				val.UnpatchSelf();
			}
			instance = null;
		}

		[<5040a701-4271-4836-bdbc-8977f6bd8e36>NullableContext(2)]
		public static Main GetInstance()
		{
			return instance;
		}

		public static void LogMessage(string message)
		{
			if (ConfigManager.DebugLogging.Value)
			{
				Log.LogMessage((object)message);
			}
		}
	}
}
namespace ResidualRemnants.Patch
{
	internal class ItemDrop_ItemData_GetTooltip
	{
		[HarmonyPriority(0)]
		[HarmonyPatch(typeof(ItemData), "GetTooltip", new Type[]
		{
			typeof(ItemData),
			typeof(int),
			typeof(bool),
			typeof(float),
			typeof(int),
			typeof(bool)
		})]
		public static class ItemDrop_ItemData_GetTooltip_Patches
		{
			[<5040a701-4271-4836-bdbc-8977f6bd8e36>NullableContext(1)]
			public static void Postfix(ItemData item, ref string __result)
			{
				if ((Object)(object)item.m_dropPrefab == (Object)null)
				{
					Main.LogMessage("Could not find drop prefab.");
					return;
				}
				string text = ((Object)item.m_dropPrefab).name.Replace("(Clone)", "").Trim();
				Main.LogMessage("Hovering over item with prefab name " + text);
				Dictionary<string, RemnantData> remnantsForConsumable = Helper.GetRemnantsForConsumable(text);
				if (remnantsForConsumable.Count == 0)
				{
					Main.LogMessage("Consumable item does not have any remnants.");
					return;
				}
				ItemData.m_stringBuilder.Append("\n\n");
				ItemData.m_stringBuilder.Append("$dropswhenconsumed:");
				foreach (KeyValuePair<string, RemnantData> item2 in remnantsForConsumable)
				{
					GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(item2.Key);
					if ((Object)(object)itemPrefab == (Object)null)
					{
						Main.LogMessage("Failed to find item prefab " + item2.Key + " in ObjedtDB.");
						continue;
					}
					ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
					if ((Object)(object)component == (Object)null)
					{
						Main.LogMessage("Invalid item " + item2.Key);
						continue;
					}
					string name = component.m_itemData.m_shared.m_name;
					ItemData.m_stringBuilder.AppendFormat("\n - {0} {1}", item2.Value.Amount, name);
					if (item2.Value.Prob < 1f)
					{
						float num = Mathf.Floor(item2.Value.Prob * 1000f) / 10f;
						ItemData.m_stringBuilder.AppendFormat(" ({0}% $chance)", num);
					}
				}
				__result = ItemData.m_stringBuilder.ToString();
			}
		}
	}
	internal class Player_ConsumeItem
	{
		[HarmonyPriority(0)]
		[HarmonyPatch(typeof(Player), "ConsumeItem")]
		public static class Player_ConsumeItem_Patches
		{
			[<5040a701-4271-4836-bdbc-8977f6bd8e36>NullableContext(1)]
			public static void Postfix(Player __instance, Inventory inventory, ItemData item, ref bool __result)
			{
				//IL_0273: Unknown result type (might be due to invalid IL or missing references)
				//IL_027e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0283: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_029e: Unknown result type (might be due to invalid IL or missing references)
				if (!__result)
				{
					Main.LogMessage("Consume failed. Drop prefab not generated.");
					return;
				}
				if ((Object)(object)item.m_dropPrefab == (Object)null)
				{
					Main.LogMessage("Drop prefab not found.");
					return;
				}
				string text = ((Object)item.m_dropPrefab).name.Replace("(Clone)", "").Trim();
				Main.LogMessage("Item consumed: " + text);
				Dictionary<string, RemnantData> remnantsForConsumable = Helper.GetRemnantsForConsumable(text);
				if (remnantsForConsumable.Count == 0)
				{
					Main.LogMessage("Consumable item does not have any remnants.");
					return;
				}
				foreach (KeyValuePair<string, RemnantData> item2 in remnantsForConsumable)
				{
					Main.LogMessage("Attempting to add " + item2.Value.Amount + "x " + item2.Key + " to the player's inventory with probability " + item2.Value.Prob + ".");
					GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(item2.Key);
					if ((Object)(object)itemPrefab == (Object)null)
					{
						Main.LogMessage("Failed to find item prefab " + item2.Key + " in ObjedtDB.");
						continue;
					}
					ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
					if ((Object)(object)component == (Object)null)
					{
						Main.LogMessage("Invalid item " + item2.Key);
						continue;
					}
					float num = Random.Range(0f, 1f);
					if (num > item2.Value.Prob)
					{
						Main.LogMessage("Probability condition not met. Item will not be added.");
						continue;
					}
					int quality = component.m_itemData.m_quality;
					int variant = component.m_itemData.m_variant;
					if (inventory.AddItem(item2.Key, item2.Value.Amount, quality, variant, 0L, "", false, false) != null)
					{
						Main.LogMessage("Added to inventory.");
						continue;
					}
					Main.LogMessage("Could not add item to inventory. Dropping on the ground instead.");
					component.m_autoPickup = true;
					if ((Object)(object)component.m_itemData.m_dropPrefab == (Object)null)
					{
						component.m_itemData.m_dropPrefab = itemPrefab.gameObject;
					}
					ItemDrop.DropItem(component.m_itemData, item2.Value.Amount, ((Component)__instance).transform.position + ((Component)__instance).transform.forward + ((Component)__instance).transform.up, ((Component)__instance).transform.rotation);
				}
			}
		}
	}
}
namespace ResidualRemnants.Data
{
	[<5040a701-4271-4836-bdbc-8977f6bd8e36>NullableContext(1)]
	[<e01f053a-b7ce-4947-8061-1cf9c050be01>Nullable(0)]
	public class ConfigManager
	{
		[<e01f053a-b7ce-4947-8061-1cf9c050be01>Nullable(2)]
		public static ConfigSync configSync;

		private static string ConfigFileName = "maxfoxgaming.residualremnants.yml";

		private static string ConfigFileFullPath;

		[<e01f053a-b7ce-4947-8061-1cf9c050be01>Nullable(2)]
		public static ConfigEntry<bool> DebugLogging;

		[<e01f053a-b7ce-4947-8061-1cf9c050be01>Nullable(new byte[] { 2, 1, 1 })]
		public static CustomSyncedValue<List<RemnantConfig>> Remnants;

		public static void CreateConfigValues(BaseUnityPlugin plugin)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			configSync = new ConfigSync("maxfoxgaming.residualremnants")
			{
				DisplayName = "ResidualRemnants",
				CurrentVersion = "1.1.3",
				MinimumRequiredVersion = "1.1.3"
			};
			plugin.Config.SaveOnConfigSet = true;
			DebugLogging = plugin.Config.BindServer("0. Logging", "Logs Enabled", value: false, new ConfigDescription("Whether the mod should print outputs and data to the console. Only needed for debugging.", (AcceptableValueBase)null, Array.Empty<object>()));
			WriteDefaultYML();
			Remnants = new CustomSyncedValue<List<RemnantConfig>>(configSync, "RemnantConfigs", ReadYML());
		}

		private static List<RemnantConfig> ReadYML()
		{
			if (!File.Exists(ConfigFileFullPath))
			{
				Main.LogMessage("Could not load from file " + ConfigFileFullPath + ".");
				return new List<RemnantConfig>();
			}
			string input = File.ReadAllText(ConfigFileFullPath);
			IDeserializer deserializer = new DeserializerBuilder().Build();
			try
			{
				return deserializer.Deserialize<List<RemnantConfig>>(input);
			}
			catch (Exception ex)
			{
				Main.LogMessage("Could not read contents of " + ConfigFileName + " - please check that data is correctly formatted.");
				Main.LogMessage(ex.StackTrace);
				return new List<RemnantConfig>();
			}
		}

		public static void WriteDefaultYML()
		{
			if (!File.Exists(ConfigFileFullPath))
			{
				Main.LogMessage("YAML not found. Creating file.");
				FileStream fileStream = File.Create(ConfigFileFullPath);
				fileStream.Close();
				List<RemnantConfig> list = new List<RemnantConfig>();
				list.Add(new RemnantConfig
				{
					RemnantPrefabName = "BoneFragments",
					Enabled = true,
					Amount = 1,
					Probability = 1f,
					ConsumablePrefabs = new List<string>
					{
						"CookedMeat", "CookedDeerMeat", "NeckTailGrilled", "BoarJerky", "FishCooked", "CookedBjornMeat", "CookedWolfMeat", "WolfJerky", "SerpentMeatCooked", "CookedLoxMeat",
						"CookedHareMeat", "CookedBugMeat", "CookedChickenMeat", "CookedVoltureMeat", "CookedAsksvinMeat", "CookedBoneMawSerpentMeat", "CookedMooseMeat"
					}
				});
				ISerializer serializer = new SerializerBuilder().ConfigureDefaultValuesHandling(DefaultValuesHandling.OmitEmptyCollections).Build();
				string contents = serializer.Serialize(list);
				File.WriteAllText(ConfigFileFullPath, contents);
			}
		}

		static ConfigManager()
		{
			string configPath = Paths.ConfigPath;
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			ConfigFileFullPath = configPath + directorySeparatorChar + ConfigFileName;
		}
	}
	[<e01f053a-b7ce-4947-8061-1cf9c050be01>Nullable(0)]
	[<5040a701-4271-4836-bdbc-8977f6bd8e36>NullableContext(1)]
	public static class Helper
	{
		public static ConfigEntry<T> BindServer<[<e01f053a-b7ce-4947-8061-1cf9c050be01>Nullable(2)] T>(this ConfigFile config, string group, string name, T value, ConfigDescription description, bool synchronizedSetting = true)
		{
			ConfigEntry<T> val = config.Bind<T>(group, name, value, description);
			SyncedConfigEntry<T> syncedConfigEntry = ConfigManager.configSync.AddConfigEntry<T>(val);
			syncedConfigEntry.SynchronizedConfig = synchronizedSetting;
			return val;
		}

		public static Dictionary<string, RemnantData> GetRemnantsForConsumable(string consumable)
		{
			Dictionary<string, RemnantData> dictionary = new Dictionary<string, RemnantData>();
			foreach (RemnantConfig item in ConfigManager.Remnants.Value)
			{
				if (item.Enabled && item.ConsumablePrefabs.Contains(consumable))
				{
					string remnantPrefabName = item.RemnantPrefabName;
					RemnantData value = new RemnantData(item.Amount, item.Probability);
					if (!dictionary.ContainsKey(remnantPrefabName))
					{
						dictionary.Add(remnantPrefabName, value);
					}
				}
			}
			return dictionary;
		}
	}
	[<e01f053a-b7ce-4947-8061-1cf9c050be01>Nullable(0)]
	[<5040a701-4271-4836-bdbc-8977f6bd8e36>NullableContext(2)]
	public class RemnantConfig
	{
		public string RemnantPrefabName { get; set; }

		public bool Enabled { get; set; }

		public int? Amount { get; set; }

		public float? Probability { get; set; }

		[<e01f053a-b7ce-4947-8061-1cf9c050be01>Nullable(new byte[] { 2, 1 })]
		[field: <e01f053a-b7ce-4947-8061-1cf9c050be01>Nullable(new byte[] { 2, 1 })]
		public List<string> ConsumablePrefabs
		{
			[return: <e01f053a-b7ce-4947-8061-1cf9c050be01>Nullable(new byte[] { 2, 1 })]
			get;
			[param: <e01f053a-b7ce-4947-8061-1cf9c050be01>Nullable(new byte[] { 2, 1 })]
			set;
		}
	}
	public class RemnantData
	{
		public int Amount;

		public float Prob;

		public RemnantData(int? Amount, float? Prob)
		{
			this.Amount = ((!Amount.HasValue || !(Amount > 0)) ? 1 : Amount.Value);
			this.Prob = (Prob.HasValue ? Mathf.Clamp(Prob.Value, 0f, 1f) : 1f);
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[<b89b921d-8954-4084-bd4d-1feb826a594e>Embedded]
	[CompilerGenerated]
	internal sealed class <b89b921d-8954-4084-bd4d-1feb826a594e>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[<b89b921d-8954-4084-bd4d-1feb826a594e>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class <f6f8ff5f-fa45-43ba-9489-b740a9e7c98b>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <f6f8ff5f-fa45-43ba-9489-b740a9e7c98b>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <f6f8ff5f-fa45-43ba-9489-b740a9e7c98b>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[<b89b921d-8954-4084-bd4d-1feb826a594e>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	internal sealed class <bb5e3e5e-5c47-485a-88ef-ea5afd7f01c7>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <bb5e3e5e-5c47-485a-88ef-ea5afd7f01c7>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace LocalizationManager
{
	[<f6f8ff5f-fa45-43ba-9489-b740a9e7c98b>Nullable(0)]
	[PublicAPI]
	[<bb5e3e5e-5c47-485a-88ef-ea5afd7f01c7>NullableContext(1)]
	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;

		[<f6f8ff5f-fa45-43ba-9489-b740a9e7c98b>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([<bb5e3e5e-5c47-485a-88ef-ea5afd7f01c7>NullableContext(0)] (TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
				}
				return _plugin;
			}
		}

		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, [<bb5e3e5e-5c47-485a-88ef-ea5afd7f01c7>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, [<f6f8ff5f-fa45-43ba-9489-b740a9e7c98b>Nullable(new byte[] { 2, 1, 1 })] Func<T, string> convertConfigValue = null)
		{
			if (convertConfigValue == null)
			{
				convertConfigValue = [<bb5e3e5e-5c47-485a-88ef-ea5afd7f01c7>NullableContext(0)] [return: <f6f8ff5f-fa45-43ba-9489-b740a9e7c98b>Nullable(1)] (T val) => val.ToString();
			}
			if (!PlaceholderProcessors.ContainsKey(key))
			{
				PlaceholderProcessors[key] = new Dictionary<string, Func<string>>();
			}
			config.SettingChanged += [<bb5e3e5e-5c47-485a-88ef-ea5afd7f01c7>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()
		{
			LoadLocalization(Localization.instance, Localization.instance.GetSelectedLanguage());
		}

		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 <06ddffa5-6a52-4223-98ce-b92d0110a7d3>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.ContainsKey(language))
				{
					text2 = File.ReadAllText(dictionary[language]);
				}
				else
				{
					byte[] array2 = LoadTranslationFromAssembly(language);
					if (array2 != null)
					{
						text2 = Encoding.UTF8.GetString(array2);
					}
				}
			}
			if (text2 == null && dictionary.ContainsKey("English"))
			{
				text2 = File.ReadAllText(dictionary["English"]);
			}
			if (text2 != null)
			{
				foreach (KeyValuePair<string, string> item2 in new <06ddffa5-6a52-4223-98ce-b92d0110a7d3>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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: 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> { ".json", ".yml" };
			new Harmony("org.bepinex.helpers.LocalizationManager").Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Localization), "LoadCSV", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Localizer), "LoadLocalization", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		[return: <f6f8ff5f-fa45-43ba-9489-b740a9e7c98b>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;
		}

		[<bb5e3e5e-5c47-485a-88ef-ea5afd7f01c7>NullableContext(2)]
		public static byte[] ReadEmbeddedFileBytes([<f6f8ff5f-fa45-43ba-9489-b740a9e7c98b>Nullable(1)] string resourceFileName, Assembly containingAssembly = null)
		{
			using MemoryStream memoryStream = new MemoryStream();
			if ((object)containingAssembly == null)
			{
				containingAssembly = Assembly.GetCallingAssembly();
			}
			string text = containingAssembly.GetManifestResourceNames().FirstOrDefault([<bb5e3e5e-5c47-485a-88ef-ea5afd7f01c7>NullableContext(0)] (string str) => str.EndsWith(resourceFileName, StringComparison.Ordinal));
			if (text != null)
			{
				containingAssembly.GetManifestResourceStream(text)?.CopyTo(memoryStream);
			}
			return (memoryStream.Length == 0L) ? null : memoryStream.ToArray();
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<e6c293d4-fc16-466a-99df-54c305451392>Embedded]
	internal sealed class <e6c293d4-fc16-466a-99df-54c305451392>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	[<e6c293d4-fc16-466a-99df-54c305451392>Embedded]
	internal sealed class <c579b67b-4451-40fb-877c-98f898a17f45>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <c579b67b-4451-40fb-877c-98f898a17f45>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <c579b67b-4451-40fb-877c-98f898a17f45>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[<e6c293d4-fc16-466a-99df-54c305451392>Embedded]
	[CompilerGenerated]
	internal sealed class <22bce77b-269a-4949-8349-e960e814e7fa>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <22bce77b-269a-4949-8349-e960e814e7fa>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	internal sealed class <4c1e0a22-d8be-49ba-b1f4-c9cbd99d5c13>AllowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	internal sealed class <ab6919a2-e0c2-40f1-b031-5e5ef7fd5fa0>DisallowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	internal sealed class <478e233d-e8d5-4c50-8c68-0a71d34bcba7>DoesNotReturnAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class <0968a067-8da7-4bfc-9216-ef562574e94f>DoesNotReturnIfAttribute : Attribute
	{
		public bool ParameterValue { get; }

		public <0968a067-8da7-4bfc-9216-ef562574e94f>DoesNotReturnIfAttribute(bool parameterValue)
		{
			ParameterValue = parameterValue;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	internal sealed class <df17e6f9-6c00-4c0d-a909-b034cbe6a783>MaybeNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class <fd121f03-88d0-4813-9a8e-aac97e7f05c1>MaybeNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public <fd121f03-88d0-4813-9a8e-aac97e7f05c1>MaybeNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	internal sealed class <d39a1d6d-3b6a-4630-820a-a28fd335be5a>NotNullAttribute : Attribute
	{
	}
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)]
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
	internal sealed class <2895af6b-467d-4647-9b1f-add80b720662>NotNullIfNotNullAttribute : Attribute
	{
		public string ParameterName { get; }

		public <2895af6b-467d-4647-9b1f-add80b720662>NotNullIfNotNullAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class <cbae00b7-bcdc-479d-a21c-3289990d561d>NotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public <cbae00b7-bcdc-479d-a21c-3289990d561d>NotNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
}
namespace System.Collections.Generic
{
	internal static class <1f88b9a8-ba16-4ac5-959c-644b4c91c088>DeconstructionExtensions
	{
		[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
		public static void Deconstruct<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] TKey, [<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] TValue>([<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(new byte[] { 0, 1, 1 })] this KeyValuePair<TKey, TValue> pair, out TKey key, out TValue value)
		{
			key = pair.Key;
			value = pair.Value;
		}
	}
}
namespace YamlDotNet
{
	[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)]
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal sealed class <23bffd85-9912-4c9e-a476-4fd8f4cdfcef>CultureInfoAdapter : CultureInfo
	{
		private readonly IFormatProvider provider;

		public <23bffd85-9912-4c9e-a476-4fd8f4cdfcef>CultureInfoAdapter(CultureInfo baseCulture, IFormatProvider provider)
			: base(baseCulture.LCID)
		{
			this.provider = provider;
		}

		[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(2)]
		public override object GetFormat(Type formatType)
		{
			return provider.GetFormat(formatType);
		}
	}
	[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)]
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal static class <cc4294e4-6267-4061-888b-8b6c874e98be>ReflectionExtensions
	{
		[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
		private static readonly FieldInfo RemoteStackTraceField = typeof(Exception).GetField("_remoteStackTraceString", BindingFlags.Instance | BindingFlags.NonPublic);

		[return: <c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
		public static Type BaseType(this Type type)
		{
			return type.BaseType;
		}

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

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

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

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

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

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

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

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

		[return: <c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
		public static PropertyInfo GetPublicProperty(this Type type, string name)
		{
			return type.GetProperty(name);
		}

		[return: <c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
		public static FieldInfo GetPublicStaticField(this Type type, string name)
		{
			return type.GetField(name, BindingFlags.Static | BindingFlags.Public);
		}

		public static IEnumerable<PropertyInfo> GetProperties(this Type type, bool includeNonPublic)
		{
			BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public;
			if (includeNonPublic)
			{
				bindingFlags |= BindingFlags.NonPublic;
			}
			if (!type.IsInterface)
			{
				return type.GetProperties(bindingFlags);
			}
			return new Type[1] { type }.Concat(type.GetInterfaces()).SelectMany([<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(0)] (Type i) => i.GetProperties(bindingFlags));
		}

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

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

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

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

		[return: <c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
		public static MethodInfo GetPublicStaticMethod(this Type type, string name, params Type[] parameterTypes)
		{
			return type.GetMethod(name, BindingFlags.Static | BindingFlags.Public, null, parameterTypes, null);
		}

		[return: <c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
		public static MethodInfo GetPublicInstanceMethod(this Type type, string name)
		{
			return type.GetMethod(name, BindingFlags.Instance | BindingFlags.Public);
		}

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

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

		public static Attribute[] GetAllCustomAttributes<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] TAttribute>(this PropertyInfo property)
		{
			return Attribute.GetCustomAttributes(property, typeof(TAttribute));
		}
	}
	internal static class <688b50e1-0b92-4ed7-af9b-32cdd2f0cd56>PropertyInfoExtensions
	{
		[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
		[return: <c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
		public static object ReadValue(this PropertyInfo property, object target)
		{
			return property.GetValue(target, null);
		}
	}
	internal static class <ef8b4105-21c8-4ae3-91e5-223978330435>StandardRegexOptions
	{
		public const RegexOptions Compiled = RegexOptions.Compiled;
	}
}
namespace YamlDotNet.Serialization
{
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)]
	internal abstract class <d88fecbd-100f-4182-8fa8-48caa1975340>BuilderSkeleton<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)] TBuilder> where TBuilder : <d88fecbd-100f-4182-8fa8-48caa1975340>BuilderSkeleton<TBuilder>
	{
		internal <0071aef2-27cc-4026-a91e-cbbc8138db22>INamingConvention namingConvention = <a9bac55b-be08-4e37-a6b7-944304904b85>NullNamingConvention.Instance;

		internal <1558472d-f28b-44f5-a675-6e51c1e82dc3>ITypeResolver typeResolver;

		internal readonly <08932b71-77fe-42ac-b4b8-592c0d27ba29>YamlAttributeOverrides overrides;

		internal readonly <0851c6f3-bd51-4b06-b83a-76c347b4c552>LazyComponentRegistrationList<<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing, <187093e5-c080-43a9-b9a1-7ad75d7c68ce>IYamlTypeConverter> typeConverterFactories;

		internal readonly <0851c6f3-bd51-4b06-b83a-76c347b4c552>LazyComponentRegistrationList<<df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector, <df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector> typeInspectorFactories;

		private bool ignoreFields;

		private bool includeNonPublicProperties;

		protected abstract TBuilder Self { get; }

		internal <d88fecbd-100f-4182-8fa8-48caa1975340>BuilderSkeleton(<1558472d-f28b-44f5-a675-6e51c1e82dc3>ITypeResolver typeResolver)
		{
			overrides = new <08932b71-77fe-42ac-b4b8-592c0d27ba29>YamlAttributeOverrides();
			typeConverterFactories = new <0851c6f3-bd51-4b06-b83a-76c347b4c552>LazyComponentRegistrationList<<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing, <187093e5-c080-43a9-b9a1-7ad75d7c68ce>IYamlTypeConverter>
			{
				{
					typeof(<958676f4-42d5-407a-9068-fd7df8b78f7b>GuidConverter),
					(<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing _) => new <958676f4-42d5-407a-9068-fd7df8b78f7b>GuidConverter(jsonCompatible: false)
				},
				{
					typeof(<5c0fd788-bbb3-412d-83af-ec34c30852ca>SystemTypeConverter),
					(<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing _) => new <5c0fd788-bbb3-412d-83af-ec34c30852ca>SystemTypeConverter()
				}
			};
			typeInspectorFactories = new <0851c6f3-bd51-4b06-b83a-76c347b4c552>LazyComponentRegistrationList<<df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector, <df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector>();
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
		}

		internal <df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector BuildTypeInspector()
		{
			<df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector <df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector2 = new <92554884-5fe5-4459-925a-f711e99172e5>ReadablePropertiesTypeInspector(typeResolver, includeNonPublicProperties);
			if (!ignoreFields)
			{
				<df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector2 = new <2a04f689-8140-4c6a-a9dc-5f751e6fbbcd>CompositeTypeInspector(new <c48cf689-3c91-403d-b9c0-6d5a2be61cde>ReadableFieldsTypeInspector(typeResolver), <df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector2);
			}
			return typeInspectorFactories.BuildComponentChain(<df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector2);
		}

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

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

		public TBuilder WithNamingConvention(<0071aef2-27cc-4026-a91e-cbbc8138db22>INamingConvention namingConvention)
		{
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
			return Self;
		}

		public TBuilder WithTypeResolver(<1558472d-f28b-44f5-a675-6e51c1e82dc3>ITypeResolver typeResolver)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			return Self;
		}

		public abstract TBuilder WithTagMapping(<c673adba-1f57-4a2d-a608-d9a0d6f306fa>TagName tag, Type type);

		public TBuilder WithAttributeOverride<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
		{
			overrides.Add(propertyAccessor, attribute);
			return Self;
		}

		public TBuilder WithAttributeOverride(Type type, string member, Attribute attribute)
		{
			overrides.Add(type, member, attribute);
			return Self;
		}

		public TBuilder WithTypeConverter(<187093e5-c080-43a9-b9a1-7ad75d7c68ce>IYamlTypeConverter typeConverter)
		{
			return WithTypeConverter(typeConverter, delegate(<7b8f4d6f-23fa-4250-bb5b-756dd5fdcab1>IRegistrationLocationSelectionSyntax<<187093e5-c080-43a9-b9a1-7ad75d7c68ce>IYamlTypeConverter> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeConverter(<187093e5-c080-43a9-b9a1-7ad75d7c68ce>IYamlTypeConverter typeConverter, Action<<7b8f4d6f-23fa-4250-bb5b-756dd5fdcab1>IRegistrationLocationSelectionSyntax<<187093e5-c080-43a9-b9a1-7ad75d7c68ce>IYamlTypeConverter>> where)
		{
			if (typeConverter == null)
			{
				throw new ArgumentNullException("typeConverter");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter.GetType(), (<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing _) => typeConverter));
			return Self;
		}

		public TBuilder WithTypeConverter<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)] TYamlTypeConverter>(<b87026b5-6714-42dd-9d1d-63f882256d7b>WrapperFactory<<187093e5-c080-43a9-b9a1-7ad75d7c68ce>IYamlTypeConverter, <187093e5-c080-43a9-b9a1-7ad75d7c68ce>IYamlTypeConverter> typeConverterFactory, Action<<cd763450-8c46-49cf-8c3f-f338650c0fda>ITrackingRegistrationLocationSelectionSyntax<<187093e5-c080-43a9-b9a1-7ad75d7c68ce>IYamlTypeConverter>> where) where TYamlTypeConverter : <187093e5-c080-43a9-b9a1-7ad75d7c68ce>IYamlTypeConverter
		{
			if (typeConverterFactory == null)
			{
				throw new ArgumentNullException("typeConverterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (<187093e5-c080-43a9-b9a1-7ad75d7c68ce>IYamlTypeConverter wrapped, <d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing _) => typeConverterFactory(wrapped)));
			return Self;
		}

		public TBuilder WithoutTypeConverter<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)] TYamlTypeConverter>() where TYamlTypeConverter : <187093e5-c080-43a9-b9a1-7ad75d7c68ce>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<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)] TTypeInspector>(Func<<df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : <df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector
		{
			return WithTypeInspector(typeInspectorFactory, delegate(<7b8f4d6f-23fa-4250-bb5b-756dd5fdcab1>IRegistrationLocationSelectionSyntax<<df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeInspector<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)] TTypeInspector>(Func<<df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector, TTypeInspector> typeInspectorFactory, Action<<7b8f4d6f-23fa-4250-bb5b-756dd5fdcab1>IRegistrationLocationSelectionSyntax<<df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector>> where) where TTypeInspector : <df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector
		{
			if (typeInspectorFactory == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (<df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector inner) => typeInspectorFactory(inner)));
			return Self;
		}

		public TBuilder WithTypeInspector<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)] TTypeInspector>(<ddab5535-605b-42cf-9dec-3114f28d35de>WrapperFactory<<df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector, <df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector, TTypeInspector> typeInspectorFactory, Action<<cd763450-8c46-49cf-8c3f-f338650c0fda>ITrackingRegistrationLocationSelectionSyntax<<df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector>> where) where TTypeInspector : <df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector
		{
			if (typeInspectorFactory == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (<df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector wrapped, <df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector inner) => typeInspectorFactory(wrapped, inner)));
			return Self;
		}

		public TBuilder WithoutTypeInspector<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)] TTypeInspector>() where TTypeInspector : <df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector
		{
			return WithoutTypeInspector(typeof(TTypeInspector));
		}

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

		protected IEnumerable<<187093e5-c080-43a9-b9a1-7ad75d7c68ce>IYamlTypeConverter> BuildTypeConverters()
		{
			return typeConverterFactories.BuildComponentList();
		}
	}
	internal delegate TComponent <b87026b5-6714-42dd-9d1d-63f882256d7b>WrapperFactory<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] TComponentBase, TComponent>(TComponentBase wrapped) where TComponent : TComponentBase;
	internal delegate TComponent <ddab5535-605b-42cf-9dec-3114f28d35de>WrapperFactory<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] TArgument, [<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] TComponentBase, TComponent>(TComponentBase wrapped, TArgument argument) where TComponent : TComponentBase;
	[Flags]
	internal enum <49a5c0a8-c72f-4e1c-b271-cd266a4a9f82>DefaultValuesHandling
	{
		Preserve = 0,
		OmitNull = 1,
		OmitDefaults = 2,
		OmitEmptyCollections = 4
	}
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)]
	internal sealed class <220832b7-a5f5-47c6-817d-c2b32be94016>Deserializer : <2dc08b1b-5030-4a1f-8d3c-b3b3870f858b>IDeserializer
	{
		private readonly <42bc1569-6f9a-4995-bf7e-25be7005dcfb>IValueDeserializer valueDeserializer;

		public <220832b7-a5f5-47c6-817d-c2b32be94016>Deserializer()
			: this(new <06ddffa5-6a52-4223-98ce-b92d0110a7d3>DeserializerBuilder().BuildValueDeserializer())
		{
		}

		private <220832b7-a5f5-47c6-817d-c2b32be94016>Deserializer(<42bc1569-6f9a-4995-bf7e-25be7005dcfb>IValueDeserializer valueDeserializer)
		{
			this.valueDeserializer = valueDeserializer ?? throw new ArgumentNullException("valueDeserializer");
		}

		public static <220832b7-a5f5-47c6-817d-c2b32be94016>Deserializer FromValueDeserializer(<42bc1569-6f9a-4995-bf7e-25be7005dcfb>IValueDeserializer valueDeserializer)
		{
			return new <220832b7-a5f5-47c6-817d-c2b32be94016>Deserializer(valueDeserializer);
		}

		public T Deserialize<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] T>(string input)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize<T>(input2);
		}

		public T Deserialize<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] T>(TextReader input)
		{
			return Deserialize<T>(new <781ba627-a3cb-44c8-a5e9-2df35b454730>Parser(input));
		}

		[return: <c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
		public object Deserialize(TextReader input)
		{
			return Deserialize(input, typeof(object));
		}

		[return: <c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
		public object Deserialize(string input, Type type)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize(input2, type);
		}

		[return: <c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
		public object Deserialize(TextReader input, Type type)
		{
			return Deserialize(new <781ba627-a3cb-44c8-a5e9-2df35b454730>Parser(input), type);
		}

		public T Deserialize<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] T>(<13f15550-4caa-4e7a-819f-016da83c14dd>IParser parser)
		{
			return (T)Deserialize(parser, typeof(T));
		}

		[return: <c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
		public object Deserialize(<13f15550-4caa-4e7a-819f-016da83c14dd>IParser parser)
		{
			return Deserialize(parser, typeof(object));
		}

		[return: <c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
		public object Deserialize(<13f15550-4caa-4e7a-819f-016da83c14dd>IParser parser, Type type)
		{
			if (parser == null)
			{
				throw new ArgumentNullException("parser");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			<696848f4-0348-48a4-b0b9-84326992eb76>StreamStart @event;
			bool flag = parser.TryConsume<<696848f4-0348-48a4-b0b9-84326992eb76>StreamStart>(out @event);
			<ce1cb708-9063-4b2d-9c02-8cb5e66d62af>DocumentStart event2;
			bool flag2 = parser.TryConsume<<ce1cb708-9063-4b2d-9c02-8cb5e66d62af>DocumentStart>(out event2);
			object result = null;
			if (!parser.Accept<<6d78caa8-9cee-4de6-a45b-21d5d7113d2b>DocumentEnd>(out var _) && !parser.Accept<<84202f61-a58e-430e-a444-65ecc6555a62>StreamEnd>(out var _))
			{
				using <68181cd0-5188-48a2-b304-4a218b4478c8>SerializerState <68181cd0-5188-48a2-b304-4a218b4478c8>SerializerState = new <68181cd0-5188-48a2-b304-4a218b4478c8>SerializerState();
				result = valueDeserializer.DeserializeValue(parser, type, <68181cd0-5188-48a2-b304-4a218b4478c8>SerializerState, valueDeserializer);
				<68181cd0-5188-48a2-b304-4a218b4478c8>SerializerState.OnDeserialization();
			}
			if (flag2)
			{
				parser.Consume<<6d78caa8-9cee-4de6-a45b-21d5d7113d2b>DocumentEnd>();
			}
			if (flag)
			{
				parser.Consume<<84202f61-a58e-430e-a444-65ecc6555a62>StreamEnd>();
			}
			return result;
		}
	}
	[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(new byte[] { 0, 1 })]
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal sealed class <06ddffa5-6a52-4223-98ce-b92d0110a7d3>DeserializerBuilder : <d88fecbd-100f-4182-8fa8-48caa1975340>BuilderSkeleton<<06ddffa5-6a52-4223-98ce-b92d0110a7d3>DeserializerBuilder>
	{
		private Lazy<<32dc5ad0-9dc3-4544-aff5-c883783f385c>IObjectFactory> objectFactory;

		private readonly <0851c6f3-bd51-4b06-b83a-76c347b4c552>LazyComponentRegistrationList<<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing, <7993b6b7-cb47-4245-8179-922e383ffde5>INodeDeserializer> nodeDeserializerFactories;

		private readonly <0851c6f3-bd51-4b06-b83a-76c347b4c552>LazyComponentRegistrationList<<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing, <07fe0529-a7db-41d2-ae0d-6a2d0e3a54c1>INodeTypeResolver> nodeTypeResolverFactories;

		private readonly Dictionary<<c673adba-1f57-4a2d-a608-d9a0d6f306fa>TagName, Type> tagMappings;

		private readonly Dictionary<Type, Type> typeMappings;

		private bool ignoreUnmatched;

		protected override <06ddffa5-6a52-4223-98ce-b92d0110a7d3>DeserializerBuilder Self => this;

		public <06ddffa5-6a52-4223-98ce-b92d0110a7d3>DeserializerBuilder()
			: base((<1558472d-f28b-44f5-a675-6e51c1e82dc3>ITypeResolver)new <b7853636-f094-4771-bd74-02a62f7bcd62>StaticTypeResolver())
		{
			typeMappings = new Dictionary<Type, Type>();
			objectFactory = new Lazy<<32dc5ad0-9dc3-4544-aff5-c883783f385c>IObjectFactory>(() => new <2b141fb8-8219-4f47-a2ed-20d16840bab6>DefaultObjectFactory(typeMappings), isThreadSafe: true);
			tagMappings = new Dictionary<<c673adba-1f57-4a2d-a608-d9a0d6f306fa>TagName, Type>
			{
				{
					<2dc791d6-e4fc-4481-bc18-d1e78ef032ee>FailsafeSchema.Tags.Map,
					typeof(Dictionary<object, object>)
				},
				{
					<2dc791d6-e4fc-4481-bc18-d1e78ef032ee>FailsafeSchema.Tags.Str,
					typeof(string)
				},
				{
					<5fe7c57b-dc59-48f8-abdd-2ef02f0d3bc8>JsonSchema.Tags.Bool,
					typeof(bool)
				},
				{
					<5fe7c57b-dc59-48f8-abdd-2ef02f0d3bc8>JsonSchema.Tags.Float,
					typeof(double)
				},
				{
					<5fe7c57b-dc59-48f8-abdd-2ef02f0d3bc8>JsonSchema.Tags.Int,
					typeof(int)
				},
				{
					<b0e4a44c-53b2-442d-b7b1-1b305f402498>DefaultSchema.Tags.Timestamp,
					typeof(DateTime)
				}
			};
			typeInspectorFactories.Add(typeof(<dc142513-5f3e-484e-9c2e-2ab1288c4b6c>CachedTypeInspector), (<df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector inner) => new <dc142513-5f3e-484e-9c2e-2ab1288c4b6c>CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(<3afa0c65-3d5d-4ef3-af88-5c414c9c56f3>NamingConventionTypeInspector), (<df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector inner) => (!(namingConvention is <a9bac55b-be08-4e37-a6b7-944304904b85>NullNamingConvention)) ? new <3afa0c65-3d5d-4ef3-af88-5c414c9c56f3>NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(<9502942f-9f4f-452b-9081-53e9a9cf93d7>YamlAttributesTypeInspector), (<df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector inner) => new <9502942f-9f4f-452b-9081-53e9a9cf93d7>YamlAttributesTypeInspector(inner));
			typeInspectorFactories.Add(typeof(<391137cb-794c-47e3-bc87-b87a31e0c5dc>YamlAttributeOverridesInspector), (<df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector inner) => (overrides == null) ? inner : new <391137cb-794c-47e3-bc87-b87a31e0c5dc>YamlAttributeOverridesInspector(inner, overrides.Clone()));
			typeInspectorFactories.Add(typeof(<0bbab62c-9c86-42f8-a3d9-8050020f3b6e>ReadableAndWritablePropertiesTypeInspector), (<df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector inner) => new <0bbab62c-9c86-42f8-a3d9-8050020f3b6e>ReadableAndWritablePropertiesTypeInspector(inner));
			nodeDeserializerFactories = new <0851c6f3-bd51-4b06-b83a-76c347b4c552>LazyComponentRegistrationList<<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing, <7993b6b7-cb47-4245-8179-922e383ffde5>INodeDeserializer>
			{
				{
					typeof(<0b738e4a-d386-44a4-86c7-601e8c151a14>YamlConvertibleNodeDeserializer),
					(<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing _) => new <0b738e4a-d386-44a4-86c7-601e8c151a14>YamlConvertibleNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(<7e858b85-1688-4b51-940f-e462911654e1>YamlSerializableNodeDeserializer),
					(<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing _) => new <7e858b85-1688-4b51-940f-e462911654e1>YamlSerializableNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(<cc8ff462-9369-4e7b-8d91-18b804814405>TypeConverterNodeDeserializer),
					(<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing _) => new <cc8ff462-9369-4e7b-8d91-18b804814405>TypeConverterNodeDeserializer(BuildTypeConverters())
				},
				{
					typeof(<351aa29a-4d2a-461e-b78c-3dd9b5c4b2bd>NullNodeDeserializer),
					(<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing _) => new <351aa29a-4d2a-461e-b78c-3dd9b5c4b2bd>NullNodeDeserializer()
				},
				{
					typeof(<1c434ce3-9a06-46a0-9ad6-2429e4fafba2>ScalarNodeDeserializer),
					(<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing _) => new <1c434ce3-9a06-46a0-9ad6-2429e4fafba2>ScalarNodeDeserializer()
				},
				{
					typeof(<d2ccd2fd-4956-4103-af21-1fe329b20daf>ArrayNodeDeserializer),
					(<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing _) => new <d2ccd2fd-4956-4103-af21-1fe329b20daf>ArrayNodeDeserializer()
				},
				{
					typeof(<e6bc3087-78a2-432a-b622-cccf1e918987>DictionaryNodeDeserializer),
					(<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing _) => new <e6bc3087-78a2-432a-b622-cccf1e918987>DictionaryNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(<1abd446a-369e-4485-b1b4-c535c6950aaf>CollectionNodeDeserializer),
					(<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing _) => new <1abd446a-369e-4485-b1b4-c535c6950aaf>CollectionNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(<29b54758-4f6c-48c3-936f-a6396e8c7122>EnumerableNodeDeserializer),
					(<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing _) => new <29b54758-4f6c-48c3-936f-a6396e8c7122>EnumerableNodeDeserializer()
				},
				{
					typeof(<13800e1f-c95b-4312-bfc7-54511d0aef50>ObjectNodeDeserializer),
					(<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing _) => new <13800e1f-c95b-4312-bfc7-54511d0aef50>ObjectNodeDeserializer(objectFactory.Value, BuildTypeInspector(), ignoreUnmatched)
				}
			};
			nodeTypeResolverFactories = new <0851c6f3-bd51-4b06-b83a-76c347b4c552>LazyComponentRegistrationList<<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing, <07fe0529-a7db-41d2-ae0d-6a2d0e3a54c1>INodeTypeResolver>
			{
				{
					typeof(<8c170d53-7d4d-417b-9110-dad731d6db25>MappingNodeTypeResolver),
					(<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing _) => new <8c170d53-7d4d-417b-9110-dad731d6db25>MappingNodeTypeResolver(typeMappings)
				},
				{
					typeof(<e532ae0d-37f7-4c1b-a9a1-d1fdc9734075>YamlConvertibleTypeResolver),
					(<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing _) => new <e532ae0d-37f7-4c1b-a9a1-d1fdc9734075>YamlConvertibleTypeResolver()
				},
				{
					typeof(<fc5143a9-ad52-4c57-a2bd-a9c444eb3f22>YamlSerializableTypeResolver),
					(<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing _) => new <fc5143a9-ad52-4c57-a2bd-a9c444eb3f22>YamlSerializableTypeResolver()
				},
				{
					typeof(<8c60cd13-5947-4db2-b221-eef07e7fecd6>TagNodeTypeResolver),
					(<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing _) => new <8c60cd13-5947-4db2-b221-eef07e7fecd6>TagNodeTypeResolver(tagMappings)
				},
				{
					typeof(<935a0ca0-7fee-474d-9aa5-fc1b19dea26e>PreventUnknownTagsNodeTypeResolver),
					(<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing _) => new <935a0ca0-7fee-474d-9aa5-fc1b19dea26e>PreventUnknownTagsNodeTypeResolver()
				},
				{
					typeof(<5b34bf0c-6fbf-42ed-9891-bbd4e9bd629c>DefaultContainersNodeTypeResolver),
					(<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing _) => new <5b34bf0c-6fbf-42ed-9891-bbd4e9bd629c>DefaultContainersNodeTypeResolver()
				}
			};
		}

		public <06ddffa5-6a52-4223-98ce-b92d0110a7d3>DeserializerBuilder WithObjectFactory(<32dc5ad0-9dc3-4544-aff5-c883783f385c>IObjectFactory objectFactory)
		{
			if (objectFactory == null)
			{
				throw new ArgumentNullException("objectFactory");
			}
			this.objectFactory = new Lazy<<32dc5ad0-9dc3-4544-aff5-c883783f385c>IObjectFactory>(() => objectFactory, isThreadSafe: true);
			return this;
		}

		public <06ddffa5-6a52-4223-98ce-b92d0110a7d3>DeserializerBuilder WithObjectFactory(Func<Type, object> objectFactory)
		{
			if (objectFactory == null)
			{
				throw new ArgumentNullException("objectFactory");
			}
			return WithObjectFactory(new <19905b33-aca1-4b89-8cda-ca2c738c9b05>LambdaObjectFactory(objectFactory));
		}

		public <06ddffa5-6a52-4223-98ce-b92d0110a7d3>DeserializerBuilder WithNodeDeserializer(<7993b6b7-cb47-4245-8179-922e383ffde5>INodeDeserializer nodeDeserializer)
		{
			return WithNodeDeserializer(nodeDeserializer, delegate(<7b8f4d6f-23fa-4250-bb5b-756dd5fdcab1>IRegistrationLocationSelectionSyntax<<7993b6b7-cb47-4245-8179-922e383ffde5>INodeDeserializer> w)
			{
				w.OnTop();
			});
		}

		public <06ddffa5-6a52-4223-98ce-b92d0110a7d3>DeserializerBuilder WithNodeDeserializer(<7993b6b7-cb47-4245-8179-922e383ffde5>INodeDeserializer nodeDeserializer, Action<<7b8f4d6f-23fa-4250-bb5b-756dd5fdcab1>IRegistrationLocationSelectionSyntax<<7993b6b7-cb47-4245-8179-922e383ffde5>INodeDeserializer>> where)
		{
			if (nodeDeserializer == null)
			{
				throw new ArgumentNullException("nodeDeserializer");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer.GetType(), (<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing _) => nodeDeserializer));
			return this;
		}

		public <06ddffa5-6a52-4223-98ce-b92d0110a7d3>DeserializerBuilder WithNodeDeserializer<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)] TNodeDeserializer>(<b87026b5-6714-42dd-9d1d-63f882256d7b>WrapperFactory<<7993b6b7-cb47-4245-8179-922e383ffde5>INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<<cd763450-8c46-49cf-8c3f-f338650c0fda>ITrackingRegistrationLocationSelectionSyntax<<7993b6b7-cb47-4245-8179-922e383ffde5>INodeDeserializer>> where) where TNodeDeserializer : <7993b6b7-cb47-4245-8179-922e383ffde5>INodeDeserializer
		{
			if (nodeDeserializerFactory == null)
			{
				throw new ArgumentNullException("nodeDeserializerFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (<7993b6b7-cb47-4245-8179-922e383ffde5>INodeDeserializer wrapped, <d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing _) => nodeDeserializerFactory(wrapped)));
			return this;
		}

		public <06ddffa5-6a52-4223-98ce-b92d0110a7d3>DeserializerBuilder WithoutNodeDeserializer<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)] TNodeDeserializer>() where TNodeDeserializer : <7993b6b7-cb47-4245-8179-922e383ffde5>INodeDeserializer
		{
			return WithoutNodeDeserializer(typeof(TNodeDeserializer));
		}

		public <06ddffa5-6a52-4223-98ce-b92d0110a7d3>DeserializerBuilder WithoutNodeDeserializer(Type nodeDeserializerType)
		{
			if (nodeDeserializerType == null)
			{
				throw new ArgumentNullException("nodeDeserializerType");
			}
			nodeDeserializerFactories.Remove(nodeDeserializerType);
			return this;
		}

		public <06ddffa5-6a52-4223-98ce-b92d0110a7d3>DeserializerBuilder WithNodeTypeResolver(<07fe0529-a7db-41d2-ae0d-6a2d0e3a54c1>INodeTypeResolver nodeTypeResolver)
		{
			return WithNodeTypeResolver(nodeTypeResolver, delegate(<7b8f4d6f-23fa-4250-bb5b-756dd5fdcab1>IRegistrationLocationSelectionSyntax<<07fe0529-a7db-41d2-ae0d-6a2d0e3a54c1>INodeTypeResolver> w)
			{
				w.OnTop();
			});
		}

		public <06ddffa5-6a52-4223-98ce-b92d0110a7d3>DeserializerBuilder WithNodeTypeResolver(<07fe0529-a7db-41d2-ae0d-6a2d0e3a54c1>INodeTypeResolver nodeTypeResolver, Action<<7b8f4d6f-23fa-4250-bb5b-756dd5fdcab1>IRegistrationLocationSelectionSyntax<<07fe0529-a7db-41d2-ae0d-6a2d0e3a54c1>INodeTypeResolver>> where)
		{
			if (nodeTypeResolver == null)
			{
				throw new ArgumentNullException("nodeTypeResolver");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver.GetType(), (<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing _) => nodeTypeResolver));
			return this;
		}

		public <06ddffa5-6a52-4223-98ce-b92d0110a7d3>DeserializerBuilder WithNodeTypeResolver<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)] TNodeTypeResolver>(<b87026b5-6714-42dd-9d1d-63f882256d7b>WrapperFactory<<07fe0529-a7db-41d2-ae0d-6a2d0e3a54c1>INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<<cd763450-8c46-49cf-8c3f-f338650c0fda>ITrackingRegistrationLocationSelectionSyntax<<07fe0529-a7db-41d2-ae0d-6a2d0e3a54c1>INodeTypeResolver>> where) where TNodeTypeResolver : <07fe0529-a7db-41d2-ae0d-6a2d0e3a54c1>INodeTypeResolver
		{
			if (nodeTypeResolverFactory == null)
			{
				throw new ArgumentNullException("nodeTypeResolverFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (<07fe0529-a7db-41d2-ae0d-6a2d0e3a54c1>INodeTypeResolver wrapped, <d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing _) => nodeTypeResolverFactory(wrapped)));
			return this;
		}

		public <06ddffa5-6a52-4223-98ce-b92d0110a7d3>DeserializerBuilder WithoutNodeTypeResolver<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)] TNodeTypeResolver>() where TNodeTypeResolver : <07fe0529-a7db-41d2-ae0d-6a2d0e3a54c1>INodeTypeResolver
		{
			return WithoutNodeTypeResolver(typeof(TNodeTypeResolver));
		}

		public <06ddffa5-6a52-4223-98ce-b92d0110a7d3>DeserializerBuilder WithoutNodeTypeResolver(Type nodeTypeResolverType)
		{
			if (nodeTypeResolverType == null)
			{
				throw new ArgumentNullException("nodeTypeResolverType");
			}
			nodeTypeResolverFactories.Remove(nodeTypeResolverType);
			return this;
		}

		public override <06ddffa5-6a52-4223-98ce-b92d0110a7d3>DeserializerBuilder WithTagMapping(<c673adba-1f57-4a2d-a608-d9a0d6f306fa>TagName tag, Type type)
		{
			if (tag.IsEmpty)
			{
				throw new ArgumentException("Non-specific tags cannot be maped");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (tagMappings.TryGetValue(tag, out var value))
			{
				throw new ArgumentException($"Type already has a registered type '{value.FullName}' for tag '{tag}'", "tag");
			}
			tagMappings.Add(tag, type);
			return this;
		}

		public <06ddffa5-6a52-4223-98ce-b92d0110a7d3>DeserializerBuilder WithTypeMapping<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] TInterface, [<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)] TConcrete>() where TConcrete : TInterface
		{
			Type typeFromHandle = typeof(TInterface);
			Type typeFromHandle2 = typeof(TConcrete);
			if (!typeFromHandle.IsAssignableFrom(typeFromHandle2))
			{
				throw new InvalidOperationException("The type '" + typeFromHandle2.Name + "' does not implement interface '" + typeFromHandle.Name + "'.");
			}
			if (typeMappings.ContainsKey(typeFromHandle))
			{
				typeMappings[typeFromHandle] = typeFromHandle2;
			}
			else
			{
				typeMappings.Add(typeFromHandle, typeFromHandle2);
			}
			return this;
		}

		public <06ddffa5-6a52-4223-98ce-b92d0110a7d3>DeserializerBuilder WithoutTagMapping(<c673adba-1f57-4a2d-a608-d9a0d6f306fa>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 <06ddffa5-6a52-4223-98ce-b92d0110a7d3>DeserializerBuilder IgnoreUnmatchedProperties()
		{
			ignoreUnmatched = true;
			return this;
		}

		public <2dc08b1b-5030-4a1f-8d3c-b3b3870f858b>IDeserializer Build()
		{
			return <220832b7-a5f5-47c6-817d-c2b32be94016>Deserializer.FromValueDeserializer(BuildValueDeserializer());
		}

		public <42bc1569-6f9a-4995-bf7e-25be7005dcfb>IValueDeserializer BuildValueDeserializer()
		{
			return new <7fe16a62-8764-43cb-8420-c2e8c13e2b1d>AliasValueDeserializer(new <dff99675-7c57-4bba-8671-d42af8d22750>NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList()));
		}
	}
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)]
	internal sealed class <dfdec0f1-cffe-44d9-a231-b262c836e94d>EmissionPhaseObjectGraphVisitorArgs
	{
		private readonly IEnumerable<<64acf476-042d-490f-9345-ba609215cf7e>IObjectGraphVisitor<<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing>> preProcessingPhaseVisitors;

		public <64acf476-042d-490f-9345-ba609215cf7e>IObjectGraphVisitor<<b591118d-ce1d-43f0-92dc-f53ac21f4701>IEmitter> InnerVisitor { get; private set; }

		public <2d3f46ad-13a8-4c23-8c8f-9cd47e58d082>IEventEmitter EventEmitter { get; private set; }

		public <0071067a-556a-49e6-a482-971912f6c36f>ObjectSerializer NestedObjectSerializer { get; private set; }

		public IEnumerable<<187093e5-c080-43a9-b9a1-7ad75d7c68ce>IYamlTypeConverter> TypeConverters { get; private set; }

		public <dfdec0f1-cffe-44d9-a231-b262c836e94d>EmissionPhaseObjectGraphVisitorArgs(<64acf476-042d-490f-9345-ba609215cf7e>IObjectGraphVisitor<<b591118d-ce1d-43f0-92dc-f53ac21f4701>IEmitter> innerVisitor, <2d3f46ad-13a8-4c23-8c8f-9cd47e58d082>IEventEmitter eventEmitter, IEnumerable<<64acf476-042d-490f-9345-ba609215cf7e>IObjectGraphVisitor<<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing>> preProcessingPhaseVisitors, IEnumerable<<187093e5-c080-43a9-b9a1-7ad75d7c68ce>IYamlTypeConverter> typeConverters, <0071067a-556a-49e6-a482-971912f6c36f>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<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)] T>() where T : <64acf476-042d-490f-9345-ba609215cf7e>IObjectGraphVisitor<<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing>
		{
			return preProcessingPhaseVisitors.OfType<T>().Single();
		}
	}
	[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)]
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal abstract class <229880ee-8641-40b6-9f2f-035305245629>EventInfo
	{
		public <b1d48846-afd0-45b2-a37b-baab73f095f2>IObjectDescriptor Source { get; }

		protected <229880ee-8641-40b6-9f2f-035305245629>EventInfo(<b1d48846-afd0-45b2-a37b-baab73f095f2>IObjectDescriptor source)
		{
			Source = source ?? throw new ArgumentNullException("source");
		}
	}
	internal class <e732c9f3-3282-4680-a530-72f22d6c8bcd>AliasEventInfo : <229880ee-8641-40b6-9f2f-035305245629>EventInfo
	{
		public <0416c33d-1568-4fa9-baca-7baf9f0ee657>AnchorName Alias { get; }

		public bool NeedsExpansion { get; set; }

		[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
		public <e732c9f3-3282-4680-a530-72f22d6c8bcd>AliasEventInfo(<b1d48846-afd0-45b2-a37b-baab73f095f2>IObjectDescriptor source, <0416c33d-1568-4fa9-baca-7baf9f0ee657>AnchorName alias)
			: base(source)
		{
			if (alias.IsEmpty)
			{
				throw new ArgumentNullException("alias");
			}
			Alias = alias;
		}
	}
	internal class <7284639b-cfec-4d63-a7bb-3d2948855c15>ObjectEventInfo : <229880ee-8641-40b6-9f2f-035305245629>EventInfo
	{
		public <0416c33d-1568-4fa9-baca-7baf9f0ee657>AnchorName Anchor { get; set; }

		public <c673adba-1f57-4a2d-a608-d9a0d6f306fa>TagName Tag { get; set; }

		[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
		protected <7284639b-cfec-4d63-a7bb-3d2948855c15>ObjectEventInfo(<b1d48846-afd0-45b2-a37b-baab73f095f2>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)]
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal sealed class <ab94f223-cc83-49e1-ad8f-f5a63b7f3174>ScalarEventInfo : <7284639b-cfec-4d63-a7bb-3d2948855c15>ObjectEventInfo
	{
		public string RenderedValue { get; set; }

		public <2de7437f-a0df-44a3-8126-c1e54322fdf7>ScalarStyle Style { get; set; }

		public bool IsPlainImplicit { get; set; }

		public bool IsQuotedImplicit { get; set; }

		public <ab94f223-cc83-49e1-ad8f-f5a63b7f3174>ScalarEventInfo(<b1d48846-afd0-45b2-a37b-baab73f095f2>IObjectDescriptor source)
			: base(source)
		{
			Style = source.ScalarStyle;
			RenderedValue = string.Empty;
		}
	}
	internal sealed class <b7a6515b-62b6-43a0-96a4-db523d682c1d>MappingStartEventInfo : <7284639b-cfec-4d63-a7bb-3d2948855c15>ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public <163c37af-5f08-419d-9ac3-081b74b504e8>MappingStyle Style { get; set; }

		[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
		public <b7a6515b-62b6-43a0-96a4-db523d682c1d>MappingStartEventInfo(<b1d48846-afd0-45b2-a37b-baab73f095f2>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class <0bd10be2-9c0d-441b-a10c-c90493bf2d88>MappingEndEventInfo : <229880ee-8641-40b6-9f2f-035305245629>EventInfo
	{
		[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
		public <0bd10be2-9c0d-441b-a10c-c90493bf2d88>MappingEndEventInfo(<b1d48846-afd0-45b2-a37b-baab73f095f2>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class <4d1f9b18-3619-47e0-ab31-3e9cb81b2a5a>SequenceStartEventInfo : <7284639b-cfec-4d63-a7bb-3d2948855c15>ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public <dada9c94-7275-46ab-974e-07822580732f>SequenceStyle Style { get; set; }

		[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
		public <4d1f9b18-3619-47e0-ab31-3e9cb81b2a5a>SequenceStartEventInfo(<b1d48846-afd0-45b2-a37b-baab73f095f2>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class <7c63a499-876a-46e2-97a3-7c5f57be7896>SequenceEndEventInfo : <229880ee-8641-40b6-9f2f-035305245629>EventInfo
	{
		[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
		public <7c63a499-876a-46e2-97a3-7c5f57be7896>SequenceEndEventInfo(<b1d48846-afd0-45b2-a37b-baab73f095f2>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal interface <b9dd79be-a840-4a0e-94ea-1a3ff8eed9ab>IAliasProvider
	{
		<0416c33d-1568-4fa9-baca-7baf9f0ee657>AnchorName GetAlias(object target);
	}
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal interface <2dc08b1b-5030-4a1f-8d3c-b3b3870f858b>IDeserializer
	{
		T Deserialize<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] T>(string input);

		T Deserialize<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] T>(TextReader input);

		[return: <c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
		object Deserialize(TextReader input);

		[return: <c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
		object Deserialize(string input, Type type);

		[return: <c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
		object Deserialize(TextReader input, Type type);

		T Deserialize<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] T>(<13f15550-4caa-4e7a-819f-016da83c14dd>IParser parser);

		[return: <c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
		object Deserialize(<13f15550-4caa-4e7a-819f-016da83c14dd>IParser parser);

		[return: <c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
		object Deserialize(<13f15550-4caa-4e7a-819f-016da83c14dd>IParser parser, Type type);
	}
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal interface <2d3f46ad-13a8-4c23-8c8f-9cd47e58d082>IEventEmitter
	{
		void Emit(<e732c9f3-3282-4680-a530-72f22d6c8bcd>AliasEventInfo eventInfo, <b591118d-ce1d-43f0-92dc-f53ac21f4701>IEmitter emitter);

		void Emit(<ab94f223-cc83-49e1-ad8f-f5a63b7f3174>ScalarEventInfo eventInfo, <b591118d-ce1d-43f0-92dc-f53ac21f4701>IEmitter emitter);

		void Emit(<b7a6515b-62b6-43a0-96a4-db523d682c1d>MappingStartEventInfo eventInfo, <b591118d-ce1d-43f0-92dc-f53ac21f4701>IEmitter emitter);

		void Emit(<0bd10be2-9c0d-441b-a10c-c90493bf2d88>MappingEndEventInfo eventInfo, <b591118d-ce1d-43f0-92dc-f53ac21f4701>IEmitter emitter);

		void Emit(<4d1f9b18-3619-47e0-ab31-3e9cb81b2a5a>SequenceStartEventInfo eventInfo, <b591118d-ce1d-43f0-92dc-f53ac21f4701>IEmitter emitter);

		void Emit(<7c63a499-876a-46e2-97a3-7c5f57be7896>SequenceEndEventInfo eventInfo, <b591118d-ce1d-43f0-92dc-f53ac21f4701>IEmitter emitter);
	}
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal interface <0071aef2-27cc-4026-a91e-cbbc8138db22>INamingConvention
	{
		string Apply(string value);
	}
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal interface <7993b6b7-cb47-4245-8179-922e383ffde5>INodeDeserializer
	{
		bool Deserialize(<13f15550-4caa-4e7a-819f-016da83c14dd>IParser reader, Type expectedType, [<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<13f15550-4caa-4e7a-819f-016da83c14dd>IParser, Type, object> nestedObjectDeserializer, [<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] out object value);
	}
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal interface <07fe0529-a7db-41d2-ae0d-6a2d0e3a54c1>INodeTypeResolver
	{
		bool Resolve([<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] <c4780d3f-1e4c-4af0-895e-ec264282ed16>NodeEvent nodeEvent, ref Type currentType);
	}
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal interface <b1d48846-afd0-45b2-a37b-baab73f095f2>IObjectDescriptor
	{
		[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
		object Value
		{
			[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(2)]
			get;
		}

		Type Type { get; }

		Type StaticType { get; }

		<2de7437f-a0df-44a3-8126-c1e54322fdf7>ScalarStyle ScalarStyle { get; }
	}
	internal static class <1cb26b1c-bcaf-4f0e-a2ac-b04be8a9c13b>ObjectDescriptorExtensions
	{
		[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
		public static object NonNullValue(this <b1d48846-afd0-45b2-a37b-baab73f095f2>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.");
		}
	}
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal interface <32dc5ad0-9dc3-4544-aff5-c883783f385c>IObjectFactory
	{
		object Create(Type type);
	}
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal interface <804be736-650f-4e9b-9823-8b06b58099e3>IObjectGraphTraversalStrategy
	{
		void Traverse<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] TContext>(<b1d48846-afd0-45b2-a37b-baab73f095f2>IObjectDescriptor graph, <64acf476-042d-490f-9345-ba609215cf7e>IObjectGraphVisitor<TContext> visitor, TContext context);
	}
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal interface <64acf476-042d-490f-9345-ba609215cf7e>IObjectGraphVisitor<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] TContext>
	{
		bool Enter(<b1d48846-afd0-45b2-a37b-baab73f095f2>IObjectDescriptor value, TContext context);

		bool EnterMapping(<b1d48846-afd0-45b2-a37b-baab73f095f2>IObjectDescriptor key, <b1d48846-afd0-45b2-a37b-baab73f095f2>IObjectDescriptor value, TContext context);

		bool EnterMapping(<e5161d61-33d3-4021-987b-59b9d04be268>IPropertyDescriptor key, <b1d48846-afd0-45b2-a37b-baab73f095f2>IObjectDescriptor value, TContext context);

		void VisitScalar(<b1d48846-afd0-45b2-a37b-baab73f095f2>IObjectDescriptor scalar, TContext context);

		void VisitMappingStart(<b1d48846-afd0-45b2-a37b-baab73f095f2>IObjectDescriptor mapping, Type keyType, Type valueType, TContext context);

		void VisitMappingEnd(<b1d48846-afd0-45b2-a37b-baab73f095f2>IObjectDescriptor mapping, TContext context);

		void VisitSequenceStart(<b1d48846-afd0-45b2-a37b-baab73f095f2>IObjectDescriptor sequence, Type elementType, TContext context);

		void VisitSequenceEnd(<b1d48846-afd0-45b2-a37b-baab73f095f2>IObjectDescriptor sequence, TContext context);
	}
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal interface <e5161d61-33d3-4021-987b-59b9d04be268>IPropertyDescriptor
	{
		string Name { get; }

		bool CanWrite { get; }

		Type Type { get; }

		[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
		Type TypeOverride
		{
			[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(2)]
			get;
			[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(2)]
			set;
		}

		int Order { get; set; }

		<2de7437f-a0df-44a3-8126-c1e54322fdf7>ScalarStyle ScalarStyle { get; set; }

		T GetCustomAttribute<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)] T>() where T : Attribute;

		<b1d48846-afd0-45b2-a37b-baab73f095f2>IObjectDescriptor Read(object target);

		void Write(object target, [<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] object value);
	}
	internal interface <7b8f4d6f-23fa-4250-bb5b-756dd5fdcab1>IRegistrationLocationSelectionSyntax<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;

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

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

		void OnTop();

		void OnBottom();
	}
	internal interface <cd763450-8c46-49cf-8c3f-f338650c0fda>ITrackingRegistrationLocationSelectionSyntax<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
	}
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal interface <411cf8ef-d3d5-4e42-a84f-f3732c0b4cc4>ISerializer
	{
		void Serialize(TextWriter writer, object graph);

		string Serialize(object graph);

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

		void Serialize(<b591118d-ce1d-43f0-92dc-f53ac21f4701>IEmitter emitter, object graph);

		void Serialize(<b591118d-ce1d-43f0-92dc-f53ac21f4701>IEmitter emitter, object graph, Type type);
	}
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal interface <df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector
	{
		IEnumerable<<e5161d61-33d3-4021-987b-59b9d04be268>IPropertyDescriptor> GetProperties(Type type, [<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] object container);

		<e5161d61-33d3-4021-987b-59b9d04be268>IPropertyDescriptor GetProperty(Type type, [<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] object container, string name, [<fd121f03-88d0-4813-9a8e-aac97e7f05c1>MaybeNullWhen(true)] bool ignoreUnmatched);
	}
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal interface <1558472d-f28b-44f5-a675-6e51c1e82dc3>ITypeResolver
	{
		Type Resolve(Type staticType, [<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] object actualValue);
	}
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal interface <42bc1569-6f9a-4995-bf7e-25be7005dcfb>IValueDeserializer
	{
		[return: <c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
		object DeserializeValue(<13f15550-4caa-4e7a-819f-016da83c14dd>IParser parser, Type expectedType, <68181cd0-5188-48a2-b304-4a218b4478c8>SerializerState state, <42bc1569-6f9a-4995-bf7e-25be7005dcfb>IValueDeserializer nestedObjectDeserializer);
	}
	internal interface <fc1801f5-3718-4e4e-9257-3b80e4e61aff>IValuePromise
	{
		[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(new byte[] { 1, 2 })]
		event Action<object> ValueAvailable;
	}
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(2)]
	internal interface <399cf34c-b81b-43f0-8f7a-0487e9bd807c>IValueSerializer
	{
		void SerializeValue([<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(1)] <b591118d-ce1d-43f0-92dc-f53ac21f4701>IEmitter emitter, object value, Type type);
	}
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal interface <b429c82d-09e4-4ed0-bee4-16dbe4e476fd>IYamlConvertible
	{
		void Read(<13f15550-4caa-4e7a-819f-016da83c14dd>IParser parser, Type expectedType, <f9c4cc76-9e66-4bb5-8d2f-4da8d607eb57>ObjectDeserializer nestedObjectDeserializer);

		void Write(<b591118d-ce1d-43f0-92dc-f53ac21f4701>IEmitter emitter, <0071067a-556a-49e6-a482-971912f6c36f>ObjectSerializer nestedObjectSerializer);
	}
	[return: <c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
	internal delegate object <f9c4cc76-9e66-4bb5-8d2f-4da8d607eb57>ObjectDeserializer(Type type);
	internal delegate void <0071067a-556a-49e6-a482-971912f6c36f>ObjectSerializer(object value, Type type = null);
	[Obsolete("Please use IYamlConvertible instead")]
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal interface <b8abbb61-f10f-4cf7-91b8-07ed601b2583>IYamlSerializable
	{
		void ReadYaml(<13f15550-4caa-4e7a-819f-016da83c14dd>IParser parser);

		void WriteYaml(<b591118d-ce1d-43f0-92dc-f53ac21f4701>IEmitter emitter);
	}
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal interface <187093e5-c080-43a9-b9a1-7ad75d7c68ce>IYamlTypeConverter
	{
		bool Accepts(Type type);

		[return: <c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
		object ReadYaml(<13f15550-4caa-4e7a-819f-016da83c14dd>IParser parser, Type type);

		void WriteYaml(<b591118d-ce1d-43f0-92dc-f53ac21f4701>IEmitter emitter, [<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] object value, Type type);
	}
	[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)]
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal sealed class <0851c6f3-bd51-4b06-b83a-76c347b4c552>LazyComponentRegistrationList<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] TArgument, [<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] TComponent> : IEnumerable<Func<TArgument, TComponent>>, IEnumerable
	{
		[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)]
		public sealed class LazyComponentRegistration
		{
			public readonly Type ComponentType;

			public readonly Func<TArgument, TComponent> Factory;

			public LazyComponentRegistration(Type componentType, Func<TArgument, TComponent> factory)
			{
				ComponentType = componentType;
				Factory = factory;
			}
		}

		[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)]
		public sealed class TrackingLazyComponentRegistration
		{
			public readonly Type ComponentType;

			public readonly Func<TComponent, TArgument, TComponent> Factory;

			public TrackingLazyComponentRegistration(Type componentType, Func<TComponent, TArgument, TComponent> factory)
			{
				ComponentType = componentType;
				Factory = factory;
			}
		}

		[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(0)]
		private class RegistrationLocationSelector : <7b8f4d6f-23fa-4250-bb5b-756dd5fdcab1>IRegistrationLocationSelectionSyntax<TComponent>
		{
			[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(1)]
			private readonly <0851c6f3-bd51-4b06-b83a-76c347b4c552>LazyComponentRegistrationList<TArgument, TComponent> registrations;

			[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(new byte[] { 1, 0, 0 })]
			private readonly LazyComponentRegistration newRegistration;

			[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
			public RegistrationLocationSelector(<0851c6f3-bd51-4b06-b83a-76c347b4c552>LazyComponentRegistrationList<TArgument, TComponent> registrations, [<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(new byte[] { 1, 0, 0 })] LazyComponentRegistration newRegistration)
			{
				this.registrations = registrations;
				this.newRegistration = newRegistration;
			}

			void <7b8f4d6f-23fa-4250-bb5b-756dd5fdcab1>IRegistrationLocationSelectionSyntax<TComponent>.InsteadOf<TRegistrationType>()
			{
				if (newRegistration.ComponentType != typeof(TRegistrationType))
				{
					registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				}
				int index = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries[index] = newRegistration;
			}

			void <7b8f4d6f-23fa-4250-bb5b-756dd5fdcab1>IRegistrationLocationSelectionSyntax<TComponent>.After<TRegistrationType>()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				int num = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries.Insert(num + 1, newRegistration);
			}

			void <7b8f4d6f-23fa-4250-bb5b-756dd5fdcab1>IRegistrationLocationSelectionSyntax<TComponent>.Before<TRegistrationType>()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				int index = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries.Insert(index, newRegistration);
			}

			void <7b8f4d6f-23fa-4250-bb5b-756dd5fdcab1>IRegistrationLocationSelectionSyntax<TComponent>.OnBottom()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				registrations.entries.Add(newRegistration);
			}

			void <7b8f4d6f-23fa-4250-bb5b-756dd5fdcab1>IRegistrationLocationSelectionSyntax<TComponent>.OnTop()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				registrations.entries.Insert(0, newRegistration);
			}
		}

		[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(0)]
		private class TrackingRegistrationLocationSelector : <cd763450-8c46-49cf-8c3f-f338650c0fda>ITrackingRegistrationLocationSelectionSyntax<TComponent>
		{
			[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(1)]
			private readonly <0851c6f3-bd51-4b06-b83a-76c347b4c552>LazyComponentRegistrationList<TArgument, TComponent> registrations;

			[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(new byte[] { 1, 0, 0 })]
			private readonly TrackingLazyComponentRegistration newRegistration;

			[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
			public TrackingRegistrationLocationSelector(<0851c6f3-bd51-4b06-b83a-76c347b4c552>LazyComponentRegistrationList<TArgument, TComponent> registrations, [<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(new byte[] { 1, 0, 0 })] TrackingLazyComponentRegistration newRegistration)
			{
				this.registrations = registrations;
				this.newRegistration = newRegistration;
			}

			void <cd763450-8c46-49cf-8c3f-f338650c0fda>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, [<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)] (TArgument arg) => newRegistration.Factory(innerComponentFactory(arg), arg));
			}
		}

		[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(new byte[] { 1, 1, 0, 0 })]
		private readonly List<LazyComponentRegistration> entries = new List<LazyComponentRegistration>();

		public int Count => entries.Count;

		public IEnumerable<Func<TArgument, TComponent>> InReverseOrder
		{
			get
			{
				int i = entries.Count - 1;
				while (i >= 0)
				{
					yield return entries[i].Factory;
					int num = i - 1;
					i = num;
				}
			}
		}

		public <0851c6f3-bd51-4b06-b83a-76c347b4c552>LazyComponentRegistrationList<TArgument, TComponent> Clone()
		{
			<0851c6f3-bd51-4b06-b83a-76c347b4c552>LazyComponentRegistrationList<TArgument, TComponent> <0851c6f3-bd51-4b06-b83a-76c347b4c552>LazyComponentRegistrationList2 = new <0851c6f3-bd51-4b06-b83a-76c347b4c552>LazyComponentRegistrationList<TArgument, TComponent>();
			foreach (LazyComponentRegistration entry in entries)
			{
				<0851c6f3-bd51-4b06-b83a-76c347b4c552>LazyComponentRegistrationList2.entries.Add(entry);
			}
			return <0851c6f3-bd51-4b06-b83a-76c347b4c552>LazyComponentRegistrationList2;
		}

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

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

		public <7b8f4d6f-23fa-4250-bb5b-756dd5fdcab1>IRegistrationLocationSelectionSyntax<TComponent> CreateRegistrationLocationSelector(Type componentType, Func<TArgument, TComponent> factory)
		{
			return new RegistrationLocationSelector(this, new LazyComponentRegistration(componentType, factory));
		}

		public <cd763450-8c46-49cf-8c3f-f338650c0fda>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([<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(0)] (LazyComponentRegistration e) => e.Factory).GetEnumerator();
		}

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

		private int IndexOfRegistration(Type registrationType)
		{
			for (int i = 0; i < entries.Count; i++)
			{
				if (registrationType == entries[i].ComponentType)
				{
					return i;
				}
			}
			return -1;
		}

		private void EnsureNoDuplicateRegistrationType(Type componentType)
		{
			if (IndexOfRegistration(componentType) != -1)
			{
				throw new InvalidOperationException("A component of type '" + componentType.FullName + "' has already been registered.");
			}
		}

		[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(2)]
		private int EnsureRegistrationExists<TRegistrationType>()
		{
			int num = IndexOfRegistration(typeof(TRegistrationType));
			if (num == -1)
			{
				throw new InvalidOperationException("A component of type '" + typeof(TRegistrationType).FullName + "' has not been registered.");
			}
			return num;
		}
	}
	[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)]
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal static class <0dd603b8-e9ee-4681-a36e-8b998025778c>LazyComponentRegistrationListExtensions
	{
		public static TComponent BuildComponentChain<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] TComponent>(this <0851c6f3-bd51-4b06-b83a-76c347b4c552>LazyComponentRegistrationList<TComponent, TComponent> registrations, TComponent innerComponent)
		{
			return registrations.InReverseOrder.Aggregate(innerComponent, [<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(0)] (TComponent inner, Func<TComponent, TComponent> factory) => factory(inner));
		}

		public static TComponent BuildComponentChain<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] TArgument, [<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] TComponent>(this <0851c6f3-bd51-4b06-b83a-76c347b4c552>LazyComponentRegistrationList<TArgument, TComponent> registrations, TComponent innerComponent, Func<TComponent, TArgument> argumentBuilder)
		{
			return registrations.InReverseOrder.Aggregate(innerComponent, [<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(0)] (TComponent inner, Func<TArgument, TComponent> factory) => factory(argumentBuilder(inner)));
		}

		public static List<TComponent> BuildComponentList<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] TComponent>(this <0851c6f3-bd51-4b06-b83a-76c347b4c552>LazyComponentRegistrationList<<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing, TComponent> registrations)
		{
			return registrations.Select([<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(0)] (Func<<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing, TComponent> factory) => factory(default(<d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing))).ToList();
		}

		public static List<TComponent> BuildComponentList<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] TArgument, [<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] TComponent>(this <0851c6f3-bd51-4b06-b83a-76c347b4c552>LazyComponentRegistrationList<TArgument, TComponent> registrations, TArgument argument)
		{
			return registrations.Select([<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(0)] (Func<TArgument, TComponent> factory) => factory(argument)).ToList();
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	internal struct <d08b155b-9b2b-4ee0-ba7c-45a7385cbb49>Nothing
	{
	}
	[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)]
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal sealed class <87745510-c8eb-4028-8721-d0e01d7a26e5>ObjectDescriptor : <b1d48846-afd0-45b2-a37b-baab73f095f2>IObjectDescriptor
	{
		[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
		[field: <c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
		public object Value
		{
			[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(2)]
			get;
			[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(2)]
			private set;
		}

		public Type Type { get; private set; }

		public Type StaticType { get; private set; }

		public <2de7437f-a0df-44a3-8126-c1e54322fdf7>ScalarStyle ScalarStyle { get; private set; }

		public <87745510-c8eb-4028-8721-d0e01d7a26e5>ObjectDescriptor([<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] object value, Type type, Type staticType)
			: this(value, type, staticType, <2de7437f-a0df-44a3-8126-c1e54322fdf7>ScalarStyle.Any)
		{
		}

		public <87745510-c8eb-4028-8721-d0e01d7a26e5>ObjectDescriptor([<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] object value, Type type, Type staticType, <2de7437f-a0df-44a3-8126-c1e54322fdf7>ScalarStyle scalarStyle)
		{
			Value = value;
			Type = type ?? throw new ArgumentNullException("type");
			StaticType = staticType ?? throw new ArgumentNullException("staticType");
			ScalarStyle = scalarStyle;
		}
	}
	internal delegate <804be736-650f-4e9b-9823-8b06b58099e3>IObjectGraphTraversalStrategy <03f49a88-cc0b-4833-8481-183ef01dc68e>ObjectGraphTraversalStrategyFactory(<df9aeddc-c543-4133-9335-1f73aa009a1b>ITypeInspector typeInspector, <1558472d-f28b-44f5-a675-6e51c1e82dc3>ITypeResolver typeResolver, IEnumerable<<187093e5-c080-43a9-b9a1-7ad75d7c68ce>IYamlTypeConverter> typeConverters, int maximumRecursion);
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)]
	internal sealed class <ecf87928-0441-45f9-ac40-f96ac8364acc>PropertyDescriptor : <e5161d61-33d3-4021-987b-59b9d04be268>IPropertyDescriptor
	{
		private readonly <e5161d61-33d3-4021-987b-59b9d04be268>IPropertyDescriptor baseDescriptor;

		public string Name { get; set; }

		public Type Type => baseDescriptor.Type;

		[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)]
		public Type TypeOverride
		{
			[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(2)]
			get
			{
				return baseDescriptor.TypeOverride;
			}
			[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(2)]
			set
			{
				baseDescriptor.TypeOverride = value;
			}
		}

		public int Order { get; set; }

		public <2de7437f-a0df-44a3-8126-c1e54322fdf7>ScalarStyle ScalarStyle
		{
			get
			{
				return baseDescriptor.ScalarStyle;
			}
			set
			{
				baseDescriptor.ScalarStyle = value;
			}
		}

		public bool CanWrite => baseDescriptor.CanWrite;

		public <ecf87928-0441-45f9-ac40-f96ac8364acc>PropertyDescriptor(<e5161d61-33d3-4021-987b-59b9d04be268>IPropertyDescriptor baseDescriptor)
		{
			this.baseDescriptor = baseDescriptor;
			Name = baseDescriptor.Name;
		}

		public void Write(object target, [<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] object value)
		{
			baseDescriptor.Write(target, value);
		}

		public T GetCustomAttribute<[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)] T>() where T : Attribute
		{
			return baseDescriptor.GetCustomAttribute<T>();
		}

		public <b1d48846-afd0-45b2-a37b-baab73f095f2>IObjectDescriptor Read(object target)
		{
			return baseDescriptor.Read(target);
		}
	}
	[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(0)]
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	internal sealed class <771ba5f1-4c2a-486d-8f8e-55297d0c2962>Serializer : <411cf8ef-d3d5-4e42-a84f-f3732c0b4cc4>ISerializer
	{
		private readonly <399cf34c-b81b-43f0-8f7a-0487e9bd807c>IValueSerializer valueSerializer;

		private readonly <f4fd8c2c-982b-4028-b783-430cbabb0b83>EmitterSettings emitterSettings;

		public <771ba5f1-4c2a-486d-8f8e-55297d0c2962>Serializer()
			: this(new <63be58e1-ad4e-4df0-900c-760a205333c1>SerializerBuilder().BuildValueSerializer(), <f4fd8c2c-982b-4028-b783-430cbabb0b83>EmitterSettings.Default)
		{
		}

		private <771ba5f1-4c2a-486d-8f8e-55297d0c2962>Serializer(<399cf34c-b81b-43f0-8f7a-0487e9bd807c>IValueSerializer valueSerializer, <f4fd8c2c-982b-4028-b783-430cbabb0b83>EmitterSettings emitterSettings)
		{
			this.valueSerializer = valueSerializer ?? throw new ArgumentNullException("valueSerializer");
			this.emitterSettings = emitterSettings ?? throw new ArgumentNullException("emitterSettings");
		}

		public static <771ba5f1-4c2a-486d-8f8e-55297d0c2962>Serializer FromValueSerializer(<399cf34c-b81b-43f0-8f7a-0487e9bd807c>IValueSerializer valueSerializer, <f4fd8c2c-982b-4028-b783-430cbabb0b83>EmitterSettings emitterSettings)
		{
			return new <771ba5f1-4c2a-486d-8f8e-55297d0c2962>Serializer(valueSerializer, emitterSettings);
		}

		public void Serialize(TextWriter writer, object graph)
		{
			Serialize(new <c73022d7-fb3a-4e55-8028-3b75b722cb64>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 <c73022d7-fb3a-4e55-8028-3b75b722cb64>Emitter(writer, emitterSettings), graph, type);
		}

		public void Serialize(<b591118d-ce1d-43f0-92dc-f53ac21f4701>IEmitter emitter, object graph)
		{
			if (emitter == null)
			{
				throw new ArgumentNullException("emitter");
			}
			EmitDocument(emitter, graph, null);
		}

		public void Serialize(<b591118d-ce1d-43f0-92dc-f53ac21f4701>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(<b591118d-ce1d-43f0-92dc-f53ac21f4701>IEmitter emitter, object graph, [<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(2)] Type type)
		{
			emitter.Emit(new <696848f4-0348-48a4-b0b9-84326992eb76>StreamStart());
			emitter.Emit(new <ce1cb708-9063-4b2d-9c02-8cb5e66d62af>DocumentStart());
			valueSerializer.SerializeValue(emitter, graph, type);
			emitter.Emit(new <6d78caa8-9cee-4de6-a45b-21d5d7113d2b>DocumentEnd(isImplicit: true));
			emitter.Emit(new <84202f61-a58e-430e-a444-65ecc6555a62>StreamEnd());
		}
	}
	[<22bce77b-269a-4949-8349-e960e814e7fa>NullableContext(1)]
	[<c579b67b-4451-40fb-877c-98f898a17f45>Nullable(new byte[] { 0, 1 })]
	internal sealed class <63be58e1-ad4e-4df0-900c-760a205333c1>SerializerBuilder : <d88fecbd-100f-4182-8fa8-48caa1975340>BuilderSkeleton<<63be58e1-ad4e-4df0-900c-760a205333c1>SerializerBuilder>
	{
		[<c579b67b-4451-40fb-877c-98f898a17f45>Nullabl