using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using HarmonyLib;
using ItemManager;
using JetBrains.Annotations;
using LocalizationManager;
using Microsoft.CodeAnalysis;
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.Converters;
using YamlDotNet.Serialization.EventEmitters;
using YamlDotNet.Serialization.NamingConventions;
using YamlDotNet.Serialization.NodeDeserializers;
using YamlDotNet.Serialization.NodeTypeResolvers;
using YamlDotNet.Serialization.ObjectFactories;
using YamlDotNet.Serialization.ObjectGraphTraversalStrategies;
using YamlDotNet.Serialization.ObjectGraphVisitors;
using YamlDotNet.Serialization.Schemas;
using YamlDotNet.Serialization.TypeInspectors;
using YamlDotNet.Serialization.TypeResolvers;
using YamlDotNet.Serialization.Utilities;
using YamlDotNet.Serialization.ValueDeserializers;

[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: Guid("D181CDA7-EF07-4BBC-B975-2B80FC6BBFAE")]
[assembly: ComVisible(false)]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyProduct("CrystalArrows")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyTitle("CrystalArrows")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace CrystalArrows
{
	[BepInPlugin("org.bepinex.plugins.crystalarrows", "CrystalArrows", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class CrystalArrows : BaseUnityPlugin
	{
		private enum Toggle
		{
			On = 1,
			Off = 0
		}

		private const string ModName = "CrystalArrows";

		private const string ModVersion = "1.0.0";

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

		private static readonly ConfigSync configSync = new ConfigSync("CrystalArrows")
		{
			DisplayName = "CrystalArrows",
			CurrentVersion = "1.0.0",
			MinimumRequiredVersion = "1.0.0"
		};

		private static ConfigEntry<Toggle> serverConfigLocked = null;

		private static readonly Dictionary<string, ConfigEntry<float>> lightIntensities = new Dictionary<string, ConfigEntry<float>>();

		private static AssetBundle assets = null;

		private static Localization english = null;

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

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

		public void Awake()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0975: Unknown result type (might be due to invalid IL or missing references)
			//IL_097c: Expected O, but got Unknown
			Localizer.Load();
			english = new Localization();
			english.SetupLanguage("English");
			serverConfigLocked = config("1 - General", "Lock Configuration", Toggle.On, "If on, the configuration is locked and can be changed by server admins only.");
			configSync.AddLockingConfigEntry<Toggle>(serverConfigLocked);
			Item item = new Item("jewelarrows", "JC_Crystal_Arrow_Black");
			item.Configurable = Configurability.Full;
			item["Shard Recipe"].Crafting.Add("op_transmution_table", 3);
			item["Shard Recipe"].RequiredItems.Add("Shattered_Black_Crystal", 10);
			item["Shard Recipe"].RequiredItems.Add("Wood", 5);
			item["Shard Recipe"].RequiredItems.Add("Feathers", 2);
			item["Shard Recipe"].CraftAmount = 20;
			item["Crystal Recipe"].Crafting.Add("op_transmution_table", 3);
			item["Crystal Recipe"].RequiredItems.Add("Simple_Black_Socket", 1);
			item["Crystal Recipe"].RequiredItems.Add("Wood", 5);
			item["Crystal Recipe"].RequiredItems.Add("Feathers", 2);
			item["Crystal Recipe"].CraftAmount = 20;
			PrefabManager.RegisterPrefab("jewelarrows", "JC_Projectile_Black");
			Item item2 = new Item("jewelarrows", "JC_Crystal_Arrow_Blue");
			item2.Configurable = Configurability.Full;
			item2["Shard Recipe"].Crafting.Add("op_transmution_table", 3);
			item2["Shard Recipe"].RequiredItems.Add("Shattered_Blue_Crystal", 10);
			item2["Shard Recipe"].RequiredItems.Add("Wood", 5);
			item2["Shard Recipe"].RequiredItems.Add("Feathers", 2);
			item2["Shard Recipe"].CraftAmount = 20;
			item2["Crystal Recipe"].Crafting.Add("op_transmution_table", 3);
			item2["Crystal Recipe"].RequiredItems.Add("Simple_Blue_Socket", 1);
			item2["Crystal Recipe"].RequiredItems.Add("Wood", 5);
			item2["Crystal Recipe"].RequiredItems.Add("Feathers", 2);
			item2["Crystal Recipe"].CraftAmount = 20;
			PrefabManager.RegisterPrefab("jewelarrows", "JC_Projectile_Blue");
			Item item3 = new Item("jewelarrows", "JC_Crystal_Arrow_Green");
			item3.Configurable = Configurability.Full;
			item3["Shard Recipe"].Crafting.Add("op_transmution_table", 3);
			item3["Shard Recipe"].RequiredItems.Add("Shattered_Green_Crystal", 10);
			item3["Shard Recipe"].RequiredItems.Add("Wood", 5);
			item3["Shard Recipe"].RequiredItems.Add("Feathers", 2);
			item3["Shard Recipe"].CraftAmount = 20;
			item3["Crystal Recipe"].Crafting.Add("op_transmution_table", 3);
			item3["Crystal Recipe"].RequiredItems.Add("Simple_Green_Socket", 1);
			item3["Crystal Recipe"].RequiredItems.Add("Wood", 5);
			item3["Crystal Recipe"].RequiredItems.Add("Feathers", 2);
			item3["Crystal Recipe"].CraftAmount = 20;
			PrefabManager.RegisterPrefab("jewelarrows", "JC_Projectile_Green");
			Item item4 = new Item("jewelarrows", "JC_Crystal_Arrow_Orange");
			item4.Configurable = Configurability.Full;
			item4["Shard Recipe"].Crafting.Add("op_transmution_table", 3);
			item4["Shard Recipe"].RequiredItems.Add("Shattered_Orange_Crystal", 10);
			item4["Shard Recipe"].RequiredItems.Add("Wood", 5);
			item4["Shard Recipe"].RequiredItems.Add("Feathers", 2);
			item4["Shard Recipe"].CraftAmount = 20;
			item4["Crystal Recipe"].Crafting.Add("op_transmution_table", 3);
			item4["Crystal Recipe"].RequiredItems.Add("Simple_Orange_Socket", 1);
			item4["Crystal Recipe"].RequiredItems.Add("Wood", 5);
			item4["Crystal Recipe"].RequiredItems.Add("Feathers", 2);
			item4["Crystal Recipe"].CraftAmount = 20;
			PrefabManager.RegisterPrefab("jewelarrows", "JC_Projectile_Orange");
			Item item5 = new Item("jewelarrows", "JC_Crystal_Arrow_Purple");
			item5.Configurable = Configurability.Full;
			item5["Shard Recipe"].Crafting.Add("op_transmution_table", 3);
			item5["Shard Recipe"].RequiredItems.Add("Shattered_Purple_Crystal", 10);
			item5["Shard Recipe"].RequiredItems.Add("Wood", 5);
			item5["Shard Recipe"].RequiredItems.Add("Feathers", 2);
			item5["Shard Recipe"].CraftAmount = 20;
			item5["Crystal Recipe"].Crafting.Add("op_transmution_table", 3);
			item5["Crystal Recipe"].RequiredItems.Add("Simple_Purple_Socket", 1);
			item5["Crystal Recipe"].RequiredItems.Add("Wood", 5);
			item5["Crystal Recipe"].RequiredItems.Add("Feathers", 2);
			item5["Crystal Recipe"].CraftAmount = 20;
			PrefabManager.RegisterPrefab("jewelarrows", "JC_Projectile_Purple");
			Item item6 = new Item("jewelarrows", "JC_Crystal_Arrow_Red");
			item6.Configurable = Configurability.Full;
			item6["Shard Recipe"].Crafting.Add("op_transmution_table", 3);
			item6["Shard Recipe"].RequiredItems.Add("Shattered_Red_Crystal", 10);
			item6["Shard Recipe"].RequiredItems.Add("Wood", 5);
			item6["Shard Recipe"].RequiredItems.Add("Feathers", 2);
			item6["Shard Recipe"].CraftAmount = 20;
			item6["Crystal Recipe"].Crafting.Add("op_transmution_table", 3);
			item6["Crystal Recipe"].RequiredItems.Add("Simple_Red_Socket", 1);
			item6["Crystal Recipe"].RequiredItems.Add("Wood", 5);
			item6["Crystal Recipe"].RequiredItems.Add("Feathers", 2);
			item6["Crystal Recipe"].CraftAmount = 20;
			PrefabManager.RegisterPrefab("jewelarrows", "JC_Projectile_Red");
			Item item7 = new Item("jewelarrows", "JC_Crystal_Arrow_Yellow");
			item7.Configurable = Configurability.Full;
			item7["Shard Recipe"].Crafting.Add("op_transmution_table", 3);
			item7["Shard Recipe"].RequiredItems.Add("Shattered_Yellow_Crystal", 10);
			item7["Shard Recipe"].RequiredItems.Add("Wood", 5);
			item7["Shard Recipe"].RequiredItems.Add("Feathers", 2);
			item7["Shard Recipe"].CraftAmount = 20;
			item7["Crystal Recipe"].Crafting.Add("op_transmution_table", 3);
			item7["Crystal Recipe"].RequiredItems.Add("Simple_Yellow_Socket", 1);
			item7["Crystal Recipe"].RequiredItems.Add("Wood", 5);
			item7["Crystal Recipe"].RequiredItems.Add("Feathers", 2);
			item7["Crystal Recipe"].CraftAmount = 20;
			PrefabManager.RegisterPrefab("jewelarrows", "JC_Projectile_Yellow");
			PrefabManager.RegisterPrefab("jewelarrows", "sfx_jc_arrow_hit");
			PrefabManager.RegisterPrefab("jewelarrows", "VFX_JC_Arrow_Hit");
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			Harmony val = new Harmony("org.bepinex.plugins.crystalarrows");
			val.PatchAll(executingAssembly);
		}
	}
}
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
{
	[<bb5e3e5e-5c47-485a-88ef-ea5afd7f01c7>NullableContext(1)]
	[PublicAPI]
	[<f6f8ff5f-fa45-43ba-9489-b740a9e7c98b>Nullable(0)]
	internal class Localizer
	{
		private static readonly Dictionary<string, Dictionary<string, Func<string>>> PlaceholderProcessors;

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

		private static readonly ConditionalWeakTable<Localization, string> localizationLanguage;

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

		[<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 <69e87573-82aa-4993-95cf-a3c93c75a38f>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 <69e87573-82aa-4993-95cf-a3c93c75a38f>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]
	[<26081615-c12a-4a8f-8843-4860be1c3ca3>Embedded]
	internal sealed class <26081615-c12a-4a8f-8843-4860be1c3ca3>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]
	[<26081615-c12a-4a8f-8843-4860be1c3ca3>Embedded]
	internal sealed class <4d10a6e1-47c7-46a6-afc0-7c285a49069c>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <4d10a6e1-47c7-46a6-afc0-7c285a49069c>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <4d10a6e1-47c7-46a6-afc0-7c285a49069c>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[<26081615-c12a-4a8f-8843-4860be1c3ca3>Embedded]
	[CompilerGenerated]
	internal sealed class <32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	internal sealed class <4696f677-ea8c-4a3c-af13-438e19e5cdde>AllowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	internal sealed class <53efa7ac-51b4-47ae-b39b-03f1783df120>DisallowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	internal sealed class <e3e3e55f-3e18-4636-9b57-296f24b69327>DoesNotReturnAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class <bde397c6-55c8-4abc-83cc-379313379a78>DoesNotReturnIfAttribute : Attribute
	{
		public bool ParameterValue { get; }

		public <bde397c6-55c8-4abc-83cc-379313379a78>DoesNotReturnIfAttribute(bool parameterValue)
		{
			ParameterValue = parameterValue;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	internal sealed class <25f324bd-84f0-415f-82de-7fb568c99fdd>MaybeNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class <6ca662db-3f4e-430d-918a-ce522cfd9610>MaybeNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public <6ca662db-3f4e-430d-918a-ce522cfd9610>MaybeNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	internal sealed class <285063f5-f1d5-47d1-87a4-730175e60490>NotNullAttribute : Attribute
	{
	}
	[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)]
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	internal sealed class <2394ef7b-1271-4132-8bcf-fe8774ea2d93>NotNullIfNotNullAttribute : Attribute
	{
		public string ParameterName { get; }

		public <2394ef7b-1271-4132-8bcf-fe8774ea2d93>NotNullIfNotNullAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class <6ebe61e2-9d83-4d64-bede-6d499c8cd526>NotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public <6ebe61e2-9d83-4d64-bede-6d499c8cd526>NotNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
}
namespace System.Collections.Generic
{
	internal static class <e97e0866-f196-42da-ae93-d80132c04d9b>DeconstructionExtensions
	{
		[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
		public static void Deconstruct<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] TKey, [<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] TValue>([<4d10a6e1-47c7-46a6-afc0-7c285a49069c>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
{
	[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)]
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	internal sealed class <ae6e5c4b-4198-4e1e-bdf6-4599aeca11bd>CultureInfoAdapter : CultureInfo
	{
		private readonly IFormatProvider provider;

		public <ae6e5c4b-4198-4e1e-bdf6-4599aeca11bd>CultureInfoAdapter(CultureInfo baseCulture, IFormatProvider provider)
			: base(baseCulture.LCID)
		{
			this.provider = provider;
		}

		[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(2)]
		public override object GetFormat(Type formatType)
		{
			return provider.GetFormat(formatType);
		}
	}
	[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)]
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	internal static class <5f0bc0eb-97ef-4762-ba36-7cb141456eef>ReflectionExtensions
	{
		[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)]
		private static readonly FieldInfo RemoteStackTraceField = typeof(Exception).GetField("_remoteStackTraceString", BindingFlags.Instance | BindingFlags.NonPublic);

		[return: <4d10a6e1-47c7-46a6-afc0-7c285a49069c>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: <4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)]
		public static PropertyInfo GetPublicProperty(this Type type, string name)
		{
			return type.GetProperty(name);
		}

		[return: <4d10a6e1-47c7-46a6-afc0-7c285a49069c>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([<32eaa292-3ef3-4478-a815-82e63cefa21a>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: <4d10a6e1-47c7-46a6-afc0-7c285a49069c>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: <4d10a6e1-47c7-46a6-afc0-7c285a49069c>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<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] TAttribute>(this PropertyInfo property)
		{
			return Attribute.GetCustomAttributes(property, typeof(TAttribute));
		}
	}
	internal static class <941ec5ac-4d40-4a7b-88b6-4f877516e3d9>PropertyInfoExtensions
	{
		[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
		[return: <4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)]
		public static object ReadValue(this PropertyInfo property, object target)
		{
			return property.GetValue(target, null);
		}
	}
	internal static class <7d5d9f1c-24b1-464e-968d-d193de442bbf>StandardRegexOptions
	{
		public const RegexOptions Compiled = RegexOptions.Compiled;
	}
}
namespace YamlDotNet.Serialization
{
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)]
	internal abstract class <eb76b609-8df8-4534-9cae-26e509d10a4c>BuilderSkeleton<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)] TBuilder> where TBuilder : <eb76b609-8df8-4534-9cae-26e509d10a4c>BuilderSkeleton<TBuilder>
	{
		internal <cea7928e-fe3f-4a18-b006-3d3b3a7e92fb>INamingConvention namingConvention = <8995e1d3-0b7b-408a-a972-e2bbf3a9392c>NullNamingConvention.Instance;

		internal <95aeb65b-0659-47c0-bf00-63f06be92a43>ITypeResolver typeResolver;

		internal readonly <fb4b7fa1-8441-4bf5-b1c6-2eb9f5fc4f6f>YamlAttributeOverrides overrides;

		internal readonly <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing, <ded18eab-164c-46d9-9c89-720592ac6cec>IYamlTypeConverter> typeConverterFactories;

		internal readonly <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<<975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector, <975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector> typeInspectorFactories;

		private bool ignoreFields;

		private bool includeNonPublicProperties;

		protected abstract TBuilder Self { get; }

		internal <eb76b609-8df8-4534-9cae-26e509d10a4c>BuilderSkeleton(<95aeb65b-0659-47c0-bf00-63f06be92a43>ITypeResolver typeResolver)
		{
			overrides = new <fb4b7fa1-8441-4bf5-b1c6-2eb9f5fc4f6f>YamlAttributeOverrides();
			typeConverterFactories = new <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing, <ded18eab-164c-46d9-9c89-720592ac6cec>IYamlTypeConverter>
			{
				{
					typeof(<bef5a930-da6c-49ec-999f-112900ef45af>GuidConverter),
					(<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing _) => new <bef5a930-da6c-49ec-999f-112900ef45af>GuidConverter(jsonCompatible: false)
				},
				{
					typeof(<9c5db012-612c-4313-8ddd-298b51e82540>SystemTypeConverter),
					(<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing _) => new <9c5db012-612c-4313-8ddd-298b51e82540>SystemTypeConverter()
				}
			};
			typeInspectorFactories = new <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<<975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector, <975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector>();
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
		}

		internal <975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector BuildTypeInspector()
		{
			<975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector <975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector2 = new <e2e8d4bb-aa86-4537-a592-da0771d341b7>ReadablePropertiesTypeInspector(typeResolver, includeNonPublicProperties);
			if (!ignoreFields)
			{
				<975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector2 = new <c2c7f2cd-1fe4-46db-ab6b-c59e145f78cb>CompositeTypeInspector(new <de1b2f15-73cc-450b-9516-994c0414e337>ReadableFieldsTypeInspector(typeResolver), <975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector2);
			}
			return typeInspectorFactories.BuildComponentChain(<975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector2);
		}

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

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

		public TBuilder WithNamingConvention(<cea7928e-fe3f-4a18-b006-3d3b3a7e92fb>INamingConvention namingConvention)
		{
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
			return Self;
		}

		public TBuilder WithTypeResolver(<95aeb65b-0659-47c0-bf00-63f06be92a43>ITypeResolver typeResolver)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			return Self;
		}

		public abstract TBuilder WithTagMapping(<1f53c61d-84f5-44c6-a5c0-d72a1b28fcb4>TagName tag, Type type);

		public TBuilder WithAttributeOverride<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>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(<ded18eab-164c-46d9-9c89-720592ac6cec>IYamlTypeConverter typeConverter)
		{
			return WithTypeConverter(typeConverter, delegate(<de51bdf4-ed3c-4040-8466-53b18ca350fd>IRegistrationLocationSelectionSyntax<<ded18eab-164c-46d9-9c89-720592ac6cec>IYamlTypeConverter> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeConverter(<ded18eab-164c-46d9-9c89-720592ac6cec>IYamlTypeConverter typeConverter, Action<<de51bdf4-ed3c-4040-8466-53b18ca350fd>IRegistrationLocationSelectionSyntax<<ded18eab-164c-46d9-9c89-720592ac6cec>IYamlTypeConverter>> where)
		{
			if (typeConverter == null)
			{
				throw new ArgumentNullException("typeConverter");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter.GetType(), (<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing _) => typeConverter));
			return Self;
		}

		public TBuilder WithTypeConverter<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)] TYamlTypeConverter>(<3fa6f375-445f-4dee-a26b-bc8d17f188f3>WrapperFactory<<ded18eab-164c-46d9-9c89-720592ac6cec>IYamlTypeConverter, <ded18eab-164c-46d9-9c89-720592ac6cec>IYamlTypeConverter> typeConverterFactory, Action<<73211ad1-0087-4f6e-a370-26e8ab9ec9b7>ITrackingRegistrationLocationSelectionSyntax<<ded18eab-164c-46d9-9c89-720592ac6cec>IYamlTypeConverter>> where) where TYamlTypeConverter : <ded18eab-164c-46d9-9c89-720592ac6cec>IYamlTypeConverter
		{
			if (typeConverterFactory == null)
			{
				throw new ArgumentNullException("typeConverterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (<ded18eab-164c-46d9-9c89-720592ac6cec>IYamlTypeConverter wrapped, <f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing _) => typeConverterFactory(wrapped)));
			return Self;
		}

		public TBuilder WithoutTypeConverter<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)] TYamlTypeConverter>() where TYamlTypeConverter : <ded18eab-164c-46d9-9c89-720592ac6cec>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<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)] TTypeInspector>(Func<<975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : <975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector
		{
			return WithTypeInspector(typeInspectorFactory, delegate(<de51bdf4-ed3c-4040-8466-53b18ca350fd>IRegistrationLocationSelectionSyntax<<975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeInspector<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)] TTypeInspector>(Func<<975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector, TTypeInspector> typeInspectorFactory, Action<<de51bdf4-ed3c-4040-8466-53b18ca350fd>IRegistrationLocationSelectionSyntax<<975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector>> where) where TTypeInspector : <975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector
		{
			if (typeInspectorFactory == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (<975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector inner) => typeInspectorFactory(inner)));
			return Self;
		}

		public TBuilder WithTypeInspector<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)] TTypeInspector>(<6d6abc7c-5289-4261-ac18-729190ae0404>WrapperFactory<<975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector, <975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector, TTypeInspector> typeInspectorFactory, Action<<73211ad1-0087-4f6e-a370-26e8ab9ec9b7>ITrackingRegistrationLocationSelectionSyntax<<975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector>> where) where TTypeInspector : <975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector
		{
			if (typeInspectorFactory == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (<975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector wrapped, <975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector inner) => typeInspectorFactory(wrapped, inner)));
			return Self;
		}

		public TBuilder WithoutTypeInspector<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)] TTypeInspector>() where TTypeInspector : <975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector
		{
			return WithoutTypeInspector(typeof(TTypeInspector));
		}

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

		protected IEnumerable<<ded18eab-164c-46d9-9c89-720592ac6cec>IYamlTypeConverter> BuildTypeConverters()
		{
			return typeConverterFactories.BuildComponentList();
		}
	}
	internal delegate TComponent <3fa6f375-445f-4dee-a26b-bc8d17f188f3>WrapperFactory<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] TComponentBase, TComponent>(TComponentBase wrapped) where TComponent : TComponentBase;
	internal delegate TComponent <6d6abc7c-5289-4261-ac18-729190ae0404>WrapperFactory<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] TArgument, [<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] TComponentBase, TComponent>(TComponentBase wrapped, TArgument argument) where TComponent : TComponentBase;
	[Flags]
	internal enum <ead2ece9-4510-4d84-97d5-e12dce07b06b>DefaultValuesHandling
	{
		Preserve = 0,
		OmitNull = 1,
		OmitDefaults = 2,
		OmitEmptyCollections = 4
	}
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)]
	internal sealed class <88eb5da2-a723-45d7-9aff-987318adaf58>Deserializer : <6b246365-1057-46c5-828c-f59dafdc5010>IDeserializer
	{
		private readonly <47dd0fff-1c0b-4784-8b57-e33260a747a2>IValueDeserializer valueDeserializer;

		public <88eb5da2-a723-45d7-9aff-987318adaf58>Deserializer()
			: this(new <69e87573-82aa-4993-95cf-a3c93c75a38f>DeserializerBuilder().BuildValueDeserializer())
		{
		}

		private <88eb5da2-a723-45d7-9aff-987318adaf58>Deserializer(<47dd0fff-1c0b-4784-8b57-e33260a747a2>IValueDeserializer valueDeserializer)
		{
			this.valueDeserializer = valueDeserializer ?? throw new ArgumentNullException("valueDeserializer");
		}

		public static <88eb5da2-a723-45d7-9aff-987318adaf58>Deserializer FromValueDeserializer(<47dd0fff-1c0b-4784-8b57-e33260a747a2>IValueDeserializer valueDeserializer)
		{
			return new <88eb5da2-a723-45d7-9aff-987318adaf58>Deserializer(valueDeserializer);
		}

		public T Deserialize<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] T>(string input)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize<T>(input2);
		}

		public T Deserialize<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] T>(TextReader input)
		{
			return Deserialize<T>(new <7739f480-c834-4af0-a816-b3dd934e4408>Parser(input));
		}

		[return: <4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)]
		public object Deserialize(TextReader input)
		{
			return Deserialize(input, typeof(object));
		}

		[return: <4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)]
		public object Deserialize(string input, Type type)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize(input2, type);
		}

		[return: <4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)]
		public object Deserialize(TextReader input, Type type)
		{
			return Deserialize(new <7739f480-c834-4af0-a816-b3dd934e4408>Parser(input), type);
		}

		public T Deserialize<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] T>(<d50255a4-3a78-4c01-acc7-0844c8fe08e3>IParser parser)
		{
			return (T)Deserialize(parser, typeof(T));
		}

		[return: <4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)]
		public object Deserialize(<d50255a4-3a78-4c01-acc7-0844c8fe08e3>IParser parser)
		{
			return Deserialize(parser, typeof(object));
		}

		[return: <4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)]
		public object Deserialize(<d50255a4-3a78-4c01-acc7-0844c8fe08e3>IParser parser, Type type)
		{
			if (parser == null)
			{
				throw new ArgumentNullException("parser");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			<b3eb4aca-80a3-482b-8b36-f3f008053e8b>StreamStart @event;
			bool flag = parser.TryConsume<<b3eb4aca-80a3-482b-8b36-f3f008053e8b>StreamStart>(out @event);
			<9fbf4e5f-67bb-4314-8b03-969808b34138>DocumentStart event2;
			bool flag2 = parser.TryConsume<<9fbf4e5f-67bb-4314-8b03-969808b34138>DocumentStart>(out event2);
			object result = null;
			if (!parser.Accept<<105f0d70-f8fc-4dd4-aa99-8e124704e422>DocumentEnd>(out var _) && !parser.Accept<<93361d76-563b-406d-acce-d50f1ad05428>StreamEnd>(out var _))
			{
				using <6fdb204c-564c-4551-89bb-ab9e8f3215c4>SerializerState <6fdb204c-564c-4551-89bb-ab9e8f3215c4>SerializerState = new <6fdb204c-564c-4551-89bb-ab9e8f3215c4>SerializerState();
				result = valueDeserializer.DeserializeValue(parser, type, <6fdb204c-564c-4551-89bb-ab9e8f3215c4>SerializerState, valueDeserializer);
				<6fdb204c-564c-4551-89bb-ab9e8f3215c4>SerializerState.OnDeserialization();
			}
			if (flag2)
			{
				parser.Consume<<105f0d70-f8fc-4dd4-aa99-8e124704e422>DocumentEnd>();
			}
			if (flag)
			{
				parser.Consume<<93361d76-563b-406d-acce-d50f1ad05428>StreamEnd>();
			}
			return result;
		}
	}
	[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(new byte[] { 0, 1 })]
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	internal sealed class <69e87573-82aa-4993-95cf-a3c93c75a38f>DeserializerBuilder : <eb76b609-8df8-4534-9cae-26e509d10a4c>BuilderSkeleton<<69e87573-82aa-4993-95cf-a3c93c75a38f>DeserializerBuilder>
	{
		private Lazy<<8c05df18-f4e3-409d-ba14-2bdd06c5f32d>IObjectFactory> objectFactory;

		private readonly <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing, <5225cb4c-05fc-402f-a710-0834c646ceaf>INodeDeserializer> nodeDeserializerFactories;

		private readonly <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing, <6d760d82-35d4-4450-8f7a-c06158df855e>INodeTypeResolver> nodeTypeResolverFactories;

		private readonly Dictionary<<1f53c61d-84f5-44c6-a5c0-d72a1b28fcb4>TagName, Type> tagMappings;

		private readonly Dictionary<Type, Type> typeMappings;

		private bool ignoreUnmatched;

		protected override <69e87573-82aa-4993-95cf-a3c93c75a38f>DeserializerBuilder Self => this;

		public <69e87573-82aa-4993-95cf-a3c93c75a38f>DeserializerBuilder()
			: base((<95aeb65b-0659-47c0-bf00-63f06be92a43>ITypeResolver)new <fc9899b9-0df7-45ca-86cd-934fbd4ed7b2>StaticTypeResolver())
		{
			typeMappings = new Dictionary<Type, Type>();
			objectFactory = new Lazy<<8c05df18-f4e3-409d-ba14-2bdd06c5f32d>IObjectFactory>(() => new <0d822e01-7d3c-4561-968e-5f999a125437>DefaultObjectFactory(typeMappings), isThreadSafe: true);
			tagMappings = new Dictionary<<1f53c61d-84f5-44c6-a5c0-d72a1b28fcb4>TagName, Type>
			{
				{
					<f47530d5-cc5d-49cc-afaa-282f44690355>FailsafeSchema.Tags.Map,
					typeof(Dictionary<object, object>)
				},
				{
					<f47530d5-cc5d-49cc-afaa-282f44690355>FailsafeSchema.Tags.Str,
					typeof(string)
				},
				{
					<5e128070-7a91-41f3-b99f-8b4c157555ba>JsonSchema.Tags.Bool,
					typeof(bool)
				},
				{
					<5e128070-7a91-41f3-b99f-8b4c157555ba>JsonSchema.Tags.Float,
					typeof(double)
				},
				{
					<5e128070-7a91-41f3-b99f-8b4c157555ba>JsonSchema.Tags.Int,
					typeof(int)
				},
				{
					<242f524b-807e-40b0-9545-abeadea65fca>DefaultSchema.Tags.Timestamp,
					typeof(DateTime)
				}
			};
			typeInspectorFactories.Add(typeof(<85d7c3eb-1c61-4d24-9e22-0ca9d5872596>CachedTypeInspector), (<975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector inner) => new <85d7c3eb-1c61-4d24-9e22-0ca9d5872596>CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(<b442eb4b-7629-400e-8211-a2c8f3f1f107>NamingConventionTypeInspector), (<975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector inner) => (!(namingConvention is <8995e1d3-0b7b-408a-a972-e2bbf3a9392c>NullNamingConvention)) ? new <b442eb4b-7629-400e-8211-a2c8f3f1f107>NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(<0b6840a8-efd3-4aaf-a0a1-1e3fb5c5f889>YamlAttributesTypeInspector), (<975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector inner) => new <0b6840a8-efd3-4aaf-a0a1-1e3fb5c5f889>YamlAttributesTypeInspector(inner));
			typeInspectorFactories.Add(typeof(<fcfb1279-bc83-42ef-9d91-230d6caabfd0>YamlAttributeOverridesInspector), (<975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector inner) => (overrides == null) ? inner : new <fcfb1279-bc83-42ef-9d91-230d6caabfd0>YamlAttributeOverridesInspector(inner, overrides.Clone()));
			typeInspectorFactories.Add(typeof(<aed1b4d9-749b-4ec9-9324-788c517cd759>ReadableAndWritablePropertiesTypeInspector), (<975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector inner) => new <aed1b4d9-749b-4ec9-9324-788c517cd759>ReadableAndWritablePropertiesTypeInspector(inner));
			nodeDeserializerFactories = new <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing, <5225cb4c-05fc-402f-a710-0834c646ceaf>INodeDeserializer>
			{
				{
					typeof(<030c2902-22d2-41d5-9bd8-b99a9f48b7d3>YamlConvertibleNodeDeserializer),
					(<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing _) => new <030c2902-22d2-41d5-9bd8-b99a9f48b7d3>YamlConvertibleNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(<9876ce5b-52fa-4e63-ab0c-c395edcd2d2c>YamlSerializableNodeDeserializer),
					(<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing _) => new <9876ce5b-52fa-4e63-ab0c-c395edcd2d2c>YamlSerializableNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(<be7e65fb-bb7e-4552-be78-14d5fff9c2fe>TypeConverterNodeDeserializer),
					(<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing _) => new <be7e65fb-bb7e-4552-be78-14d5fff9c2fe>TypeConverterNodeDeserializer(BuildTypeConverters())
				},
				{
					typeof(<723fa565-2789-47ac-b1da-0727e5a43a90>NullNodeDeserializer),
					(<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing _) => new <723fa565-2789-47ac-b1da-0727e5a43a90>NullNodeDeserializer()
				},
				{
					typeof(<cf909ead-44ad-451f-b644-ea9d6a0bd7c5>ScalarNodeDeserializer),
					(<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing _) => new <cf909ead-44ad-451f-b644-ea9d6a0bd7c5>ScalarNodeDeserializer()
				},
				{
					typeof(<eaf09b87-49b8-4e0b-9823-96e57a36e0b1>ArrayNodeDeserializer),
					(<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing _) => new <eaf09b87-49b8-4e0b-9823-96e57a36e0b1>ArrayNodeDeserializer()
				},
				{
					typeof(<671594e3-c167-4821-b279-df603d0d93e5>DictionaryNodeDeserializer),
					(<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing _) => new <671594e3-c167-4821-b279-df603d0d93e5>DictionaryNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(<e2d77412-d178-43cb-94ad-7160c605e510>CollectionNodeDeserializer),
					(<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing _) => new <e2d77412-d178-43cb-94ad-7160c605e510>CollectionNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(<cefbf87f-7803-4b12-9f47-296187069263>EnumerableNodeDeserializer),
					(<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing _) => new <cefbf87f-7803-4b12-9f47-296187069263>EnumerableNodeDeserializer()
				},
				{
					typeof(<dad7ba90-61f5-4654-aa2b-c27989abec39>ObjectNodeDeserializer),
					(<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing _) => new <dad7ba90-61f5-4654-aa2b-c27989abec39>ObjectNodeDeserializer(objectFactory.Value, BuildTypeInspector(), ignoreUnmatched)
				}
			};
			nodeTypeResolverFactories = new <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing, <6d760d82-35d4-4450-8f7a-c06158df855e>INodeTypeResolver>
			{
				{
					typeof(<0584b5c3-9011-4d3d-bf53-cf9b9797d5da>MappingNodeTypeResolver),
					(<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing _) => new <0584b5c3-9011-4d3d-bf53-cf9b9797d5da>MappingNodeTypeResolver(typeMappings)
				},
				{
					typeof(<f1ec454d-55c1-4827-9df8-eb50cf535e55>YamlConvertibleTypeResolver),
					(<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing _) => new <f1ec454d-55c1-4827-9df8-eb50cf535e55>YamlConvertibleTypeResolver()
				},
				{
					typeof(<a4b40055-5c1f-4ec8-ac55-a91b478cd132>YamlSerializableTypeResolver),
					(<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing _) => new <a4b40055-5c1f-4ec8-ac55-a91b478cd132>YamlSerializableTypeResolver()
				},
				{
					typeof(<23b6e9e5-431b-4e08-9666-709ade47303b>TagNodeTypeResolver),
					(<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing _) => new <23b6e9e5-431b-4e08-9666-709ade47303b>TagNodeTypeResolver(tagMappings)
				},
				{
					typeof(<665371a7-ea92-4848-8119-2f3203aa6ea5>PreventUnknownTagsNodeTypeResolver),
					(<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing _) => new <665371a7-ea92-4848-8119-2f3203aa6ea5>PreventUnknownTagsNodeTypeResolver()
				},
				{
					typeof(<7ebdd401-39ea-4718-bfc0-c02ad35586ab>DefaultContainersNodeTypeResolver),
					(<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing _) => new <7ebdd401-39ea-4718-bfc0-c02ad35586ab>DefaultContainersNodeTypeResolver()
				}
			};
		}

		public <69e87573-82aa-4993-95cf-a3c93c75a38f>DeserializerBuilder WithObjectFactory(<8c05df18-f4e3-409d-ba14-2bdd06c5f32d>IObjectFactory objectFactory)
		{
			if (objectFactory == null)
			{
				throw new ArgumentNullException("objectFactory");
			}
			this.objectFactory = new Lazy<<8c05df18-f4e3-409d-ba14-2bdd06c5f32d>IObjectFactory>(() => objectFactory, isThreadSafe: true);
			return this;
		}

		public <69e87573-82aa-4993-95cf-a3c93c75a38f>DeserializerBuilder WithObjectFactory(Func<Type, object> objectFactory)
		{
			if (objectFactory == null)
			{
				throw new ArgumentNullException("objectFactory");
			}
			return WithObjectFactory(new <ed8841b3-fec7-4441-b427-87504c0b6ac7>LambdaObjectFactory(objectFactory));
		}

		public <69e87573-82aa-4993-95cf-a3c93c75a38f>DeserializerBuilder WithNodeDeserializer(<5225cb4c-05fc-402f-a710-0834c646ceaf>INodeDeserializer nodeDeserializer)
		{
			return WithNodeDeserializer(nodeDeserializer, delegate(<de51bdf4-ed3c-4040-8466-53b18ca350fd>IRegistrationLocationSelectionSyntax<<5225cb4c-05fc-402f-a710-0834c646ceaf>INodeDeserializer> w)
			{
				w.OnTop();
			});
		}

		public <69e87573-82aa-4993-95cf-a3c93c75a38f>DeserializerBuilder WithNodeDeserializer(<5225cb4c-05fc-402f-a710-0834c646ceaf>INodeDeserializer nodeDeserializer, Action<<de51bdf4-ed3c-4040-8466-53b18ca350fd>IRegistrationLocationSelectionSyntax<<5225cb4c-05fc-402f-a710-0834c646ceaf>INodeDeserializer>> where)
		{
			if (nodeDeserializer == null)
			{
				throw new ArgumentNullException("nodeDeserializer");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer.GetType(), (<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing _) => nodeDeserializer));
			return this;
		}

		public <69e87573-82aa-4993-95cf-a3c93c75a38f>DeserializerBuilder WithNodeDeserializer<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)] TNodeDeserializer>(<3fa6f375-445f-4dee-a26b-bc8d17f188f3>WrapperFactory<<5225cb4c-05fc-402f-a710-0834c646ceaf>INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<<73211ad1-0087-4f6e-a370-26e8ab9ec9b7>ITrackingRegistrationLocationSelectionSyntax<<5225cb4c-05fc-402f-a710-0834c646ceaf>INodeDeserializer>> where) where TNodeDeserializer : <5225cb4c-05fc-402f-a710-0834c646ceaf>INodeDeserializer
		{
			if (nodeDeserializerFactory == null)
			{
				throw new ArgumentNullException("nodeDeserializerFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (<5225cb4c-05fc-402f-a710-0834c646ceaf>INodeDeserializer wrapped, <f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing _) => nodeDeserializerFactory(wrapped)));
			return this;
		}

		public <69e87573-82aa-4993-95cf-a3c93c75a38f>DeserializerBuilder WithoutNodeDeserializer<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)] TNodeDeserializer>() where TNodeDeserializer : <5225cb4c-05fc-402f-a710-0834c646ceaf>INodeDeserializer
		{
			return WithoutNodeDeserializer(typeof(TNodeDeserializer));
		}

		public <69e87573-82aa-4993-95cf-a3c93c75a38f>DeserializerBuilder WithoutNodeDeserializer(Type nodeDeserializerType)
		{
			if (nodeDeserializerType == null)
			{
				throw new ArgumentNullException("nodeDeserializerType");
			}
			nodeDeserializerFactories.Remove(nodeDeserializerType);
			return this;
		}

		public <69e87573-82aa-4993-95cf-a3c93c75a38f>DeserializerBuilder WithNodeTypeResolver(<6d760d82-35d4-4450-8f7a-c06158df855e>INodeTypeResolver nodeTypeResolver)
		{
			return WithNodeTypeResolver(nodeTypeResolver, delegate(<de51bdf4-ed3c-4040-8466-53b18ca350fd>IRegistrationLocationSelectionSyntax<<6d760d82-35d4-4450-8f7a-c06158df855e>INodeTypeResolver> w)
			{
				w.OnTop();
			});
		}

		public <69e87573-82aa-4993-95cf-a3c93c75a38f>DeserializerBuilder WithNodeTypeResolver(<6d760d82-35d4-4450-8f7a-c06158df855e>INodeTypeResolver nodeTypeResolver, Action<<de51bdf4-ed3c-4040-8466-53b18ca350fd>IRegistrationLocationSelectionSyntax<<6d760d82-35d4-4450-8f7a-c06158df855e>INodeTypeResolver>> where)
		{
			if (nodeTypeResolver == null)
			{
				throw new ArgumentNullException("nodeTypeResolver");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver.GetType(), (<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing _) => nodeTypeResolver));
			return this;
		}

		public <69e87573-82aa-4993-95cf-a3c93c75a38f>DeserializerBuilder WithNodeTypeResolver<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)] TNodeTypeResolver>(<3fa6f375-445f-4dee-a26b-bc8d17f188f3>WrapperFactory<<6d760d82-35d4-4450-8f7a-c06158df855e>INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<<73211ad1-0087-4f6e-a370-26e8ab9ec9b7>ITrackingRegistrationLocationSelectionSyntax<<6d760d82-35d4-4450-8f7a-c06158df855e>INodeTypeResolver>> where) where TNodeTypeResolver : <6d760d82-35d4-4450-8f7a-c06158df855e>INodeTypeResolver
		{
			if (nodeTypeResolverFactory == null)
			{
				throw new ArgumentNullException("nodeTypeResolverFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (<6d760d82-35d4-4450-8f7a-c06158df855e>INodeTypeResolver wrapped, <f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing _) => nodeTypeResolverFactory(wrapped)));
			return this;
		}

		public <69e87573-82aa-4993-95cf-a3c93c75a38f>DeserializerBuilder WithoutNodeTypeResolver<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)] TNodeTypeResolver>() where TNodeTypeResolver : <6d760d82-35d4-4450-8f7a-c06158df855e>INodeTypeResolver
		{
			return WithoutNodeTypeResolver(typeof(TNodeTypeResolver));
		}

		public <69e87573-82aa-4993-95cf-a3c93c75a38f>DeserializerBuilder WithoutNodeTypeResolver(Type nodeTypeResolverType)
		{
			if (nodeTypeResolverType == null)
			{
				throw new ArgumentNullException("nodeTypeResolverType");
			}
			nodeTypeResolverFactories.Remove(nodeTypeResolverType);
			return this;
		}

		public override <69e87573-82aa-4993-95cf-a3c93c75a38f>DeserializerBuilder WithTagMapping(<1f53c61d-84f5-44c6-a5c0-d72a1b28fcb4>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 <69e87573-82aa-4993-95cf-a3c93c75a38f>DeserializerBuilder WithTypeMapping<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] TInterface, [<4d10a6e1-47c7-46a6-afc0-7c285a49069c>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 <69e87573-82aa-4993-95cf-a3c93c75a38f>DeserializerBuilder WithoutTagMapping(<1f53c61d-84f5-44c6-a5c0-d72a1b28fcb4>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 <69e87573-82aa-4993-95cf-a3c93c75a38f>DeserializerBuilder IgnoreUnmatchedProperties()
		{
			ignoreUnmatched = true;
			return this;
		}

		public <6b246365-1057-46c5-828c-f59dafdc5010>IDeserializer Build()
		{
			return <88eb5da2-a723-45d7-9aff-987318adaf58>Deserializer.FromValueDeserializer(BuildValueDeserializer());
		}

		public <47dd0fff-1c0b-4784-8b57-e33260a747a2>IValueDeserializer BuildValueDeserializer()
		{
			return new <0cbf1b01-d6cb-4b74-aba0-3920974ed699>AliasValueDeserializer(new <d66c7a5a-aad4-4776-9c95-73a9a8d6bb86>NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList()));
		}
	}
	[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)]
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	internal sealed class <ac4c0c44-6358-410b-aefe-1e1089b96aed>EmissionPhaseObjectGraphVisitorArgs
	{
		private readonly IEnumerable<<92aee588-b33c-4463-9466-9122baaeef73>IObjectGraphVisitor<<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing>> preProcessingPhaseVisitors;

		public <92aee588-b33c-4463-9466-9122baaeef73>IObjectGraphVisitor<<b96ede0e-ee5e-4739-a3da-760a5783be20>IEmitter> InnerVisitor { get; private set; }

		public <f5d078b1-e904-4f7e-89bd-00d5b3e36461>IEventEmitter EventEmitter { get; private set; }

		public <0a500f82-3f6b-4c1b-b75e-6f862e81dde7>ObjectSerializer NestedObjectSerializer { get; private set; }

		public IEnumerable<<ded18eab-164c-46d9-9c89-720592ac6cec>IYamlTypeConverter> TypeConverters { get; private set; }

		public <ac4c0c44-6358-410b-aefe-1e1089b96aed>EmissionPhaseObjectGraphVisitorArgs(<92aee588-b33c-4463-9466-9122baaeef73>IObjectGraphVisitor<<b96ede0e-ee5e-4739-a3da-760a5783be20>IEmitter> innerVisitor, <f5d078b1-e904-4f7e-89bd-00d5b3e36461>IEventEmitter eventEmitter, IEnumerable<<92aee588-b33c-4463-9466-9122baaeef73>IObjectGraphVisitor<<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing>> preProcessingPhaseVisitors, IEnumerable<<ded18eab-164c-46d9-9c89-720592ac6cec>IYamlTypeConverter> typeConverters, <0a500f82-3f6b-4c1b-b75e-6f862e81dde7>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<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)] T>() where T : <92aee588-b33c-4463-9466-9122baaeef73>IObjectGraphVisitor<<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing>
		{
			return preProcessingPhaseVisitors.OfType<T>().Single();
		}
	}
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)]
	internal abstract class <b42c5ccb-a7f0-4c75-ac5e-f8a07d6120a9>EventInfo
	{
		public <d4985626-cace-4d7f-a3b8-2030919ff611>IObjectDescriptor Source { get; }

		protected <b42c5ccb-a7f0-4c75-ac5e-f8a07d6120a9>EventInfo(<d4985626-cace-4d7f-a3b8-2030919ff611>IObjectDescriptor source)
		{
			Source = source ?? throw new ArgumentNullException("source");
		}
	}
	internal class <167ac6a1-5212-47f7-b090-71105f06b76a>AliasEventInfo : <b42c5ccb-a7f0-4c75-ac5e-f8a07d6120a9>EventInfo
	{
		public <dc4772a3-26a2-4d83-bfce-5ad4bb9cb912>AnchorName Alias { get; }

		public bool NeedsExpansion { get; set; }

		[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
		public <167ac6a1-5212-47f7-b090-71105f06b76a>AliasEventInfo(<d4985626-cace-4d7f-a3b8-2030919ff611>IObjectDescriptor source, <dc4772a3-26a2-4d83-bfce-5ad4bb9cb912>AnchorName alias)
			: base(source)
		{
			if (alias.IsEmpty)
			{
				throw new ArgumentNullException("alias");
			}
			Alias = alias;
		}
	}
	internal class <e0d1e0ad-2fd5-4393-8e96-cbec928e3616>ObjectEventInfo : <b42c5ccb-a7f0-4c75-ac5e-f8a07d6120a9>EventInfo
	{
		public <dc4772a3-26a2-4d83-bfce-5ad4bb9cb912>AnchorName Anchor { get; set; }

		public <1f53c61d-84f5-44c6-a5c0-d72a1b28fcb4>TagName Tag { get; set; }

		[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
		protected <e0d1e0ad-2fd5-4393-8e96-cbec928e3616>ObjectEventInfo(<d4985626-cace-4d7f-a3b8-2030919ff611>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)]
	internal sealed class <3aed835e-ae1e-4bce-a17c-7d76eeeb8bb5>ScalarEventInfo : <e0d1e0ad-2fd5-4393-8e96-cbec928e3616>ObjectEventInfo
	{
		public string RenderedValue { get; set; }

		public <4327de0e-6cac-46cd-8374-d6de04c1f86e>ScalarStyle Style { get; set; }

		public bool IsPlainImplicit { get; set; }

		public bool IsQuotedImplicit { get; set; }

		public <3aed835e-ae1e-4bce-a17c-7d76eeeb8bb5>ScalarEventInfo(<d4985626-cace-4d7f-a3b8-2030919ff611>IObjectDescriptor source)
			: base(source)
		{
			Style = source.ScalarStyle;
			RenderedValue = string.Empty;
		}
	}
	internal sealed class <9fe4e143-dcc7-402a-839d-21afcb6ec321>MappingStartEventInfo : <e0d1e0ad-2fd5-4393-8e96-cbec928e3616>ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public <5b181b63-f86f-440c-9be6-aedba44e1e8a>MappingStyle Style { get; set; }

		[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
		public <9fe4e143-dcc7-402a-839d-21afcb6ec321>MappingStartEventInfo(<d4985626-cace-4d7f-a3b8-2030919ff611>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class <b7508a28-8eea-4c05-a6df-18421bf732ce>MappingEndEventInfo : <b42c5ccb-a7f0-4c75-ac5e-f8a07d6120a9>EventInfo
	{
		[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
		public <b7508a28-8eea-4c05-a6df-18421bf732ce>MappingEndEventInfo(<d4985626-cace-4d7f-a3b8-2030919ff611>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class <979cc489-2316-4437-bc72-14e417d65f6d>SequenceStartEventInfo : <e0d1e0ad-2fd5-4393-8e96-cbec928e3616>ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public <39e00ea4-191d-4354-b2fc-5a5acb84e0f2>SequenceStyle Style { get; set; }

		[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
		public <979cc489-2316-4437-bc72-14e417d65f6d>SequenceStartEventInfo(<d4985626-cace-4d7f-a3b8-2030919ff611>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class <4d60a669-4ebc-4a72-bf8b-17b16b6fdcf7>SequenceEndEventInfo : <b42c5ccb-a7f0-4c75-ac5e-f8a07d6120a9>EventInfo
	{
		[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
		public <4d60a669-4ebc-4a72-bf8b-17b16b6fdcf7>SequenceEndEventInfo(<d4985626-cace-4d7f-a3b8-2030919ff611>IObjectDescriptor source)
			: base(source)
		{
		}
	}
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	internal interface <c3028081-325d-4e1e-9537-d7dd4eae7ce6>IAliasProvider
	{
		<dc4772a3-26a2-4d83-bfce-5ad4bb9cb912>AnchorName GetAlias(object target);
	}
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	internal interface <6b246365-1057-46c5-828c-f59dafdc5010>IDeserializer
	{
		T Deserialize<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] T>(string input);

		T Deserialize<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] T>(TextReader input);

		[return: <4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)]
		object Deserialize(TextReader input);

		[return: <4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)]
		object Deserialize(string input, Type type);

		[return: <4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)]
		object Deserialize(TextReader input, Type type);

		T Deserialize<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] T>(<d50255a4-3a78-4c01-acc7-0844c8fe08e3>IParser parser);

		[return: <4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)]
		object Deserialize(<d50255a4-3a78-4c01-acc7-0844c8fe08e3>IParser parser);

		[return: <4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)]
		object Deserialize(<d50255a4-3a78-4c01-acc7-0844c8fe08e3>IParser parser, Type type);
	}
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	internal interface <f5d078b1-e904-4f7e-89bd-00d5b3e36461>IEventEmitter
	{
		void Emit(<167ac6a1-5212-47f7-b090-71105f06b76a>AliasEventInfo eventInfo, <b96ede0e-ee5e-4739-a3da-760a5783be20>IEmitter emitter);

		void Emit(<3aed835e-ae1e-4bce-a17c-7d76eeeb8bb5>ScalarEventInfo eventInfo, <b96ede0e-ee5e-4739-a3da-760a5783be20>IEmitter emitter);

		void Emit(<9fe4e143-dcc7-402a-839d-21afcb6ec321>MappingStartEventInfo eventInfo, <b96ede0e-ee5e-4739-a3da-760a5783be20>IEmitter emitter);

		void Emit(<b7508a28-8eea-4c05-a6df-18421bf732ce>MappingEndEventInfo eventInfo, <b96ede0e-ee5e-4739-a3da-760a5783be20>IEmitter emitter);

		void Emit(<979cc489-2316-4437-bc72-14e417d65f6d>SequenceStartEventInfo eventInfo, <b96ede0e-ee5e-4739-a3da-760a5783be20>IEmitter emitter);

		void Emit(<4d60a669-4ebc-4a72-bf8b-17b16b6fdcf7>SequenceEndEventInfo eventInfo, <b96ede0e-ee5e-4739-a3da-760a5783be20>IEmitter emitter);
	}
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	internal interface <cea7928e-fe3f-4a18-b006-3d3b3a7e92fb>INamingConvention
	{
		string Apply(string value);
	}
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	internal interface <5225cb4c-05fc-402f-a710-0834c646ceaf>INodeDeserializer
	{
		bool Deserialize(<d50255a4-3a78-4c01-acc7-0844c8fe08e3>IParser reader, Type expectedType, [<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(new byte[] { 1, 1, 1, 2 })] Func<<d50255a4-3a78-4c01-acc7-0844c8fe08e3>IParser, Type, object> nestedObjectDeserializer, [<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] out object value);
	}
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	internal interface <6d760d82-35d4-4450-8f7a-c06158df855e>INodeTypeResolver
	{
		bool Resolve([<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] <0709b73f-68ff-4f31-be8f-0924231173a8>NodeEvent nodeEvent, ref Type currentType);
	}
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	internal interface <d4985626-cace-4d7f-a3b8-2030919ff611>IObjectDescriptor
	{
		[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)]
		object Value
		{
			[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(2)]
			get;
		}

		Type Type { get; }

		Type StaticType { get; }

		<4327de0e-6cac-46cd-8374-d6de04c1f86e>ScalarStyle ScalarStyle { get; }
	}
	internal static class <191d66f8-1474-442e-b0ce-14be81a0e40c>ObjectDescriptorExtensions
	{
		[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
		public static object NonNullValue(this <d4985626-cace-4d7f-a3b8-2030919ff611>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.");
		}
	}
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	internal interface <8c05df18-f4e3-409d-ba14-2bdd06c5f32d>IObjectFactory
	{
		object Create(Type type);
	}
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	internal interface <fd7d259c-0b9d-4721-afc6-9522c7eb433a>IObjectGraphTraversalStrategy
	{
		void Traverse<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] TContext>(<d4985626-cace-4d7f-a3b8-2030919ff611>IObjectDescriptor graph, <92aee588-b33c-4463-9466-9122baaeef73>IObjectGraphVisitor<TContext> visitor, TContext context);
	}
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	internal interface <92aee588-b33c-4463-9466-9122baaeef73>IObjectGraphVisitor<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] TContext>
	{
		bool Enter(<d4985626-cace-4d7f-a3b8-2030919ff611>IObjectDescriptor value, TContext context);

		bool EnterMapping(<d4985626-cace-4d7f-a3b8-2030919ff611>IObjectDescriptor key, <d4985626-cace-4d7f-a3b8-2030919ff611>IObjectDescriptor value, TContext context);

		bool EnterMapping(<68094b1d-c0ce-4fce-a4cc-5443efce5c2b>IPropertyDescriptor key, <d4985626-cace-4d7f-a3b8-2030919ff611>IObjectDescriptor value, TContext context);

		void VisitScalar(<d4985626-cace-4d7f-a3b8-2030919ff611>IObjectDescriptor scalar, TContext context);

		void VisitMappingStart(<d4985626-cace-4d7f-a3b8-2030919ff611>IObjectDescriptor mapping, Type keyType, Type valueType, TContext context);

		void VisitMappingEnd(<d4985626-cace-4d7f-a3b8-2030919ff611>IObjectDescriptor mapping, TContext context);

		void VisitSequenceStart(<d4985626-cace-4d7f-a3b8-2030919ff611>IObjectDescriptor sequence, Type elementType, TContext context);

		void VisitSequenceEnd(<d4985626-cace-4d7f-a3b8-2030919ff611>IObjectDescriptor sequence, TContext context);
	}
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	internal interface <68094b1d-c0ce-4fce-a4cc-5443efce5c2b>IPropertyDescriptor
	{
		string Name { get; }

		bool CanWrite { get; }

		Type Type { get; }

		[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)]
		Type TypeOverride
		{
			[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(2)]
			get;
			[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(2)]
			set;
		}

		int Order { get; set; }

		<4327de0e-6cac-46cd-8374-d6de04c1f86e>ScalarStyle ScalarStyle { get; set; }

		T GetCustomAttribute<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)] T>() where T : Attribute;

		<d4985626-cace-4d7f-a3b8-2030919ff611>IObjectDescriptor Read(object target);

		void Write(object target, [<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] object value);
	}
	internal interface <de51bdf4-ed3c-4040-8466-53b18ca350fd>IRegistrationLocationSelectionSyntax<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>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 <73211ad1-0087-4f6e-a370-26e8ab9ec9b7>ITrackingRegistrationLocationSelectionSyntax<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
	}
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	internal interface <a7d895ee-6851-41bf-b90d-7294efdeb9e2>ISerializer
	{
		void Serialize(TextWriter writer, object graph);

		string Serialize(object graph);

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

		void Serialize(<b96ede0e-ee5e-4739-a3da-760a5783be20>IEmitter emitter, object graph);

		void Serialize(<b96ede0e-ee5e-4739-a3da-760a5783be20>IEmitter emitter, object graph, Type type);
	}
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	internal interface <975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector
	{
		IEnumerable<<68094b1d-c0ce-4fce-a4cc-5443efce5c2b>IPropertyDescriptor> GetProperties(Type type, [<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] object container);

		<68094b1d-c0ce-4fce-a4cc-5443efce5c2b>IPropertyDescriptor GetProperty(Type type, [<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] object container, string name, [<6ca662db-3f4e-430d-918a-ce522cfd9610>MaybeNullWhen(true)] bool ignoreUnmatched);
	}
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	internal interface <95aeb65b-0659-47c0-bf00-63f06be92a43>ITypeResolver
	{
		Type Resolve(Type staticType, [<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] object actualValue);
	}
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	internal interface <47dd0fff-1c0b-4784-8b57-e33260a747a2>IValueDeserializer
	{
		[return: <4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)]
		object DeserializeValue(<d50255a4-3a78-4c01-acc7-0844c8fe08e3>IParser parser, Type expectedType, <6fdb204c-564c-4551-89bb-ab9e8f3215c4>SerializerState state, <47dd0fff-1c0b-4784-8b57-e33260a747a2>IValueDeserializer nestedObjectDeserializer);
	}
	internal interface <c8eb3a71-756a-49cc-ab44-7cd5353c0246>IValuePromise
	{
		[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(new byte[] { 1, 2 })]
		event Action<object> ValueAvailable;
	}
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(2)]
	internal interface <32b2645d-4a6d-42c7-bddc-9dc3f678802e>IValueSerializer
	{
		void SerializeValue([<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(1)] <b96ede0e-ee5e-4739-a3da-760a5783be20>IEmitter emitter, object value, Type type);
	}
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	internal interface <9bc416e5-09eb-4ab8-9dba-e3753333586d>IYamlConvertible
	{
		void Read(<d50255a4-3a78-4c01-acc7-0844c8fe08e3>IParser parser, Type expectedType, <e3ddad01-db8f-4c4f-885c-772ad0a1cecd>ObjectDeserializer nestedObjectDeserializer);

		void Write(<b96ede0e-ee5e-4739-a3da-760a5783be20>IEmitter emitter, <0a500f82-3f6b-4c1b-b75e-6f862e81dde7>ObjectSerializer nestedObjectSerializer);
	}
	[return: <4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)]
	internal delegate object <e3ddad01-db8f-4c4f-885c-772ad0a1cecd>ObjectDeserializer(Type type);
	internal delegate void <0a500f82-3f6b-4c1b-b75e-6f862e81dde7>ObjectSerializer(object value, Type type = null);
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	[Obsolete("Please use IYamlConvertible instead")]
	internal interface <82823eff-032b-4e4a-83ff-c39e87c788a9>IYamlSerializable
	{
		void ReadYaml(<d50255a4-3a78-4c01-acc7-0844c8fe08e3>IParser parser);

		void WriteYaml(<b96ede0e-ee5e-4739-a3da-760a5783be20>IEmitter emitter);
	}
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	internal interface <ded18eab-164c-46d9-9c89-720592ac6cec>IYamlTypeConverter
	{
		bool Accepts(Type type);

		[return: <4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)]
		object ReadYaml(<d50255a4-3a78-4c01-acc7-0844c8fe08e3>IParser parser, Type type);

		void WriteYaml(<b96ede0e-ee5e-4739-a3da-760a5783be20>IEmitter emitter, [<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] object value, Type type);
	}
	[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)]
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	internal sealed class <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] TArgument, [<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] TComponent> : IEnumerable<Func<TArgument, TComponent>>, IEnumerable
	{
		[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>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;
			}
		}

		[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>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;
			}
		}

		[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(0)]
		private class RegistrationLocationSelector : <de51bdf4-ed3c-4040-8466-53b18ca350fd>IRegistrationLocationSelectionSyntax<TComponent>
		{
			[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(1)]
			private readonly <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<TArgument, TComponent> registrations;

			[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(new byte[] { 1, 0, 0 })]
			private readonly LazyComponentRegistration newRegistration;

			[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
			public RegistrationLocationSelector(<4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<TArgument, TComponent> registrations, [<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(new byte[] { 1, 0, 0 })] LazyComponentRegistration newRegistration)
			{
				this.registrations = registrations;
				this.newRegistration = newRegistration;
			}

			void <de51bdf4-ed3c-4040-8466-53b18ca350fd>IRegistrationLocationSelectionSyntax<TComponent>.InsteadOf<TRegistrationType>()
			{
				if (newRegistration.ComponentType != typeof(TRegistrationType))
				{
					registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				}
				int index = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries[index] = newRegistration;
			}

			void <de51bdf4-ed3c-4040-8466-53b18ca350fd>IRegistrationLocationSelectionSyntax<TComponent>.After<TRegistrationType>()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				int num = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries.Insert(num + 1, newRegistration);
			}

			void <de51bdf4-ed3c-4040-8466-53b18ca350fd>IRegistrationLocationSelectionSyntax<TComponent>.Before<TRegistrationType>()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				int index = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries.Insert(index, newRegistration);
			}

			void <de51bdf4-ed3c-4040-8466-53b18ca350fd>IRegistrationLocationSelectionSyntax<TComponent>.OnBottom()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				registrations.entries.Add(newRegistration);
			}

			void <de51bdf4-ed3c-4040-8466-53b18ca350fd>IRegistrationLocationSelectionSyntax<TComponent>.OnTop()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				registrations.entries.Insert(0, newRegistration);
			}
		}

		[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(0)]
		private class TrackingRegistrationLocationSelector : <73211ad1-0087-4f6e-a370-26e8ab9ec9b7>ITrackingRegistrationLocationSelectionSyntax<TComponent>
		{
			[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(1)]
			private readonly <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<TArgument, TComponent> registrations;

			[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(new byte[] { 1, 0, 0 })]
			private readonly TrackingLazyComponentRegistration newRegistration;

			[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
			public TrackingRegistrationLocationSelector(<4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<TArgument, TComponent> registrations, [<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(new byte[] { 1, 0, 0 })] TrackingLazyComponentRegistration newRegistration)
			{
				this.registrations = registrations;
				this.newRegistration = newRegistration;
			}

			void <73211ad1-0087-4f6e-a370-26e8ab9ec9b7>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, [<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)] (TArgument arg) => newRegistration.Factory(innerComponentFactory(arg), arg));
			}
		}

		[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>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 <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<TArgument, TComponent> Clone()
		{
			<4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<TArgument, TComponent> <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList2 = new <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<TArgument, TComponent>();
			foreach (LazyComponentRegistration entry in entries)
			{
				<4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList2.entries.Add(entry);
			}
			return <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>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 <de51bdf4-ed3c-4040-8466-53b18ca350fd>IRegistrationLocationSelectionSyntax<TComponent> CreateRegistrationLocationSelector(Type componentType, Func<TArgument, TComponent> factory)
		{
			return new RegistrationLocationSelector(this, new LazyComponentRegistration(componentType, factory));
		}

		public <73211ad1-0087-4f6e-a370-26e8ab9ec9b7>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([<32eaa292-3ef3-4478-a815-82e63cefa21a>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.");
			}
		}

		[<32eaa292-3ef3-4478-a815-82e63cefa21a>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;
		}
	}
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)]
	internal static class <76043546-1b08-42c7-9678-3fc7a7bea858>LazyComponentRegistrationListExtensions
	{
		public static TComponent BuildComponentChain<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] TComponent>(this <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<TComponent, TComponent> registrations, TComponent innerComponent)
		{
			return registrations.InReverseOrder.Aggregate(innerComponent, [<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(0)] (TComponent inner, Func<TComponent, TComponent> factory) => factory(inner));
		}

		public static TComponent BuildComponentChain<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] TArgument, [<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] TComponent>(this <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<TArgument, TComponent> registrations, TComponent innerComponent, Func<TComponent, TArgument> argumentBuilder)
		{
			return registrations.InReverseOrder.Aggregate(innerComponent, [<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(0)] (TComponent inner, Func<TArgument, TComponent> factory) => factory(argumentBuilder(inner)));
		}

		public static List<TComponent> BuildComponentList<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] TComponent>(this <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing, TComponent> registrations)
		{
			return registrations.Select([<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(0)] (Func<<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing, TComponent> factory) => factory(default(<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing))).ToList();
		}

		public static List<TComponent> BuildComponentList<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] TArgument, [<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] TComponent>(this <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<TArgument, TComponent> registrations, TArgument argument)
		{
			return registrations.Select([<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(0)] (Func<TArgument, TComponent> factory) => factory(argument)).ToList();
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	internal struct <f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing
	{
	}
	[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)]
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	internal sealed class <b760bff9-887d-4663-80f8-53210bea311f>ObjectDescriptor : <d4985626-cace-4d7f-a3b8-2030919ff611>IObjectDescriptor
	{
		[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)]
		[field: <4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)]
		public object Value
		{
			[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(2)]
			get;
			[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(2)]
			private set;
		}

		public Type Type { get; private set; }

		public Type StaticType { get; private set; }

		public <4327de0e-6cac-46cd-8374-d6de04c1f86e>ScalarStyle ScalarStyle { get; private set; }

		public <b760bff9-887d-4663-80f8-53210bea311f>ObjectDescriptor([<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] object value, Type type, Type staticType)
			: this(value, type, staticType, <4327de0e-6cac-46cd-8374-d6de04c1f86e>ScalarStyle.Any)
		{
		}

		public <b760bff9-887d-4663-80f8-53210bea311f>ObjectDescriptor([<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] object value, Type type, Type staticType, <4327de0e-6cac-46cd-8374-d6de04c1f86e>ScalarStyle scalarStyle)
		{
			Value = value;
			Type = type ?? throw new ArgumentNullException("type");
			StaticType = staticType ?? throw new ArgumentNullException("staticType");
			ScalarStyle = scalarStyle;
		}
	}
	internal delegate <fd7d259c-0b9d-4721-afc6-9522c7eb433a>IObjectGraphTraversalStrategy <f25d4d27-ee31-44e2-8ba2-ca75d3802c4c>ObjectGraphTraversalStrategyFactory(<975db0b6-c39e-4d53-a09b-6a0833a3b846>ITypeInspector typeInspector, <95aeb65b-0659-47c0-bf00-63f06be92a43>ITypeResolver typeResolver, IEnumerable<<ded18eab-164c-46d9-9c89-720592ac6cec>IYamlTypeConverter> typeConverters, int maximumRecursion);
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)]
	internal sealed class <ebc265bc-cffc-4191-a0cf-c3918fc95275>PropertyDescriptor : <68094b1d-c0ce-4fce-a4cc-5443efce5c2b>IPropertyDescriptor
	{
		private readonly <68094b1d-c0ce-4fce-a4cc-5443efce5c2b>IPropertyDescriptor baseDescriptor;

		public string Name { get; set; }

		public Type Type => baseDescriptor.Type;

		[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)]
		public Type TypeOverride
		{
			[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(2)]
			get
			{
				return baseDescriptor.TypeOverride;
			}
			[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(2)]
			set
			{
				baseDescriptor.TypeOverride = value;
			}
		}

		public int Order { get; set; }

		public <4327de0e-6cac-46cd-8374-d6de04c1f86e>ScalarStyle ScalarStyle
		{
			get
			{
				return baseDescriptor.ScalarStyle;
			}
			set
			{
				baseDescriptor.ScalarStyle = value;
			}
		}

		public bool CanWrite => baseDescriptor.CanWrite;

		public <ebc265bc-cffc-4191-a0cf-c3918fc95275>PropertyDescriptor(<68094b1d-c0ce-4fce-a4cc-5443efce5c2b>IPropertyDescriptor baseDescriptor)
		{
			this.baseDescriptor = baseDescriptor;
			Name = baseDescriptor.Name;
		}

		public void Write(object target, [<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] object value)
		{
			baseDescriptor.Write(target, value);
		}

		public T GetCustomAttribute<[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)] T>() where T : Attribute
		{
			return baseDescriptor.GetCustomAttribute<T>();
		}

		public <d4985626-cace-4d7f-a3b8-2030919ff611>IObjectDescriptor Read(object target)
		{
			return baseDescriptor.Read(target);
		}
	}
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)]
	internal sealed class <5099a524-4b9e-444f-af8c-65d3bf86e73c>Serializer : <a7d895ee-6851-41bf-b90d-7294efdeb9e2>ISerializer
	{
		private readonly <32b2645d-4a6d-42c7-bddc-9dc3f678802e>IValueSerializer valueSerializer;

		private readonly <faa3db03-7faf-4112-ba83-f5953fff2205>EmitterSettings emitterSettings;

		public <5099a524-4b9e-444f-af8c-65d3bf86e73c>Serializer()
			: this(new <5d656743-2f9c-4877-8706-fa5888ff9038>SerializerBuilder().BuildValueSerializer(), <faa3db03-7faf-4112-ba83-f5953fff2205>EmitterSettings.Default)
		{
		}

		private <5099a524-4b9e-444f-af8c-65d3bf86e73c>Serializer(<32b2645d-4a6d-42c7-bddc-9dc3f678802e>IValueSerializer valueSerializer, <faa3db03-7faf-4112-ba83-f5953fff2205>EmitterSettings emitterSettings)
		{
			this.valueSerializer = valueSerializer ?? throw new ArgumentNullException("valueSerializer");
			this.emitterSettings = emitterSettings ?? throw new ArgumentNullException("emitterSettings");
		}

		public static <5099a524-4b9e-444f-af8c-65d3bf86e73c>Serializer FromValueSerializer(<32b2645d-4a6d-42c7-bddc-9dc3f678802e>IValueSerializer valueSerializer, <faa3db03-7faf-4112-ba83-f5953fff2205>EmitterSettings emitterSettings)
		{
			return new <5099a524-4b9e-444f-af8c-65d3bf86e73c>Serializer(valueSerializer, emitterSettings);
		}

		public void Serialize(TextWriter writer, object graph)
		{
			Serialize(new <b2674405-37d3-4d41-a72f-df28d9ab3ee7>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 <b2674405-37d3-4d41-a72f-df28d9ab3ee7>Emitter(writer, emitterSettings), graph, type);
		}

		public void Serialize(<b96ede0e-ee5e-4739-a3da-760a5783be20>IEmitter emitter, object graph)
		{
			if (emitter == null)
			{
				throw new ArgumentNullException("emitter");
			}
			EmitDocument(emitter, graph, null);
		}

		public void Serialize(<b96ede0e-ee5e-4739-a3da-760a5783be20>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(<b96ede0e-ee5e-4739-a3da-760a5783be20>IEmitter emitter, object graph, [<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(2)] Type type)
		{
			emitter.Emit(new <b3eb4aca-80a3-482b-8b36-f3f008053e8b>StreamStart());
			emitter.Emit(new <9fbf4e5f-67bb-4314-8b03-969808b34138>DocumentStart());
			valueSerializer.SerializeValue(emitter, graph, type);
			emitter.Emit(new <105f0d70-f8fc-4dd4-aa99-8e124704e422>DocumentEnd(isImplicit: true));
			emitter.Emit(new <93361d76-563b-406d-acce-d50f1ad05428>StreamEnd());
		}
	}
	[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(1)]
	[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(new byte[] { 0, 1 })]
	internal sealed class <5d656743-2f9c-4877-8706-fa5888ff9038>SerializerBuilder : <eb76b609-8df8-4534-9cae-26e509d10a4c>BuilderSkeleton<<5d656743-2f9c-4877-8706-fa5888ff9038>SerializerBuilder>
	{
		[<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(0)]
		private class ValueSerializer : <32b2645d-4a6d-42c7-bddc-9dc3f678802e>IValueSerializer
		{
			private readonly <fd7d259c-0b9d-4721-afc6-9522c7eb433a>IObjectGraphTraversalStrategy traversalStrategy;

			private readonly <f5d078b1-e904-4f7e-89bd-00d5b3e36461>IEventEmitter eventEmitter;

			private readonly IEnumerable<<ded18eab-164c-46d9-9c89-720592ac6cec>IYamlTypeConverter> typeConverters;

			private readonly <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<IEnumerable<<ded18eab-164c-46d9-9c89-720592ac6cec>IYamlTypeConverter>, <92aee588-b33c-4463-9466-9122baaeef73>IObjectGraphVisitor<<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

			private readonly <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<<ac4c0c44-6358-410b-aefe-1e1089b96aed>EmissionPhaseObjectGraphVisitorArgs, <92aee588-b33c-4463-9466-9122baaeef73>IObjectGraphVisitor<<b96ede0e-ee5e-4739-a3da-760a5783be20>IEmitter>> emissionPhaseObjectGraphVisitorFactories;

			public ValueSerializer(<fd7d259c-0b9d-4721-afc6-9522c7eb433a>IObjectGraphTraversalStrategy traversalStrategy, <f5d078b1-e904-4f7e-89bd-00d5b3e36461>IEventEmitter eventEmitter, IEnumerable<<ded18eab-164c-46d9-9c89-720592ac6cec>IYamlTypeConverter> typeConverters, <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<IEnumerable<<ded18eab-164c-46d9-9c89-720592ac6cec>IYamlTypeConverter>, <92aee588-b33c-4463-9466-9122baaeef73>IObjectGraphVisitor<<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing>> preProcessingPhaseObjectGraphVisitorFactories, <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<<ac4c0c44-6358-410b-aefe-1e1089b96aed>EmissionPhaseObjectGraphVisitorArgs, <92aee588-b33c-4463-9466-9122baaeef73>IObjectGraphVisitor<<b96ede0e-ee5e-4739-a3da-760a5783be20>IEmitter>> emissionPhaseObjectGraphVisitorFactories)
			{
				this.traversalStrategy = traversalStrategy;
				this.eventEmitter = eventEmitter;
				this.typeConverters = typeConverters;
				this.preProcessingPhaseObjectGraphVisitorFactories = preProcessingPhaseObjectGraphVisitorFactories;
				this.emissionPhaseObjectGraphVisitorFactories = emissionPhaseObjectGraphVisitorFactories;
			}

			[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(2)]
			public void SerializeValue([<4d10a6e1-47c7-46a6-afc0-7c285a49069c>Nullable(1)] <b96ede0e-ee5e-4739-a3da-760a5783be20>IEmitter emitter, object value, Type type)
			{
				Type type2 = type ?? ((value != null) ? value.GetType() : typeof(object));
				Type staticType = type ?? typeof(object);
				<b760bff9-887d-4663-80f8-53210bea311f>ObjectDescriptor graph = new <b760bff9-887d-4663-80f8-53210bea311f>ObjectDescriptor(value, type2, staticType);
				List<<92aee588-b33c-4463-9466-9122baaeef73>IObjectGraphVisitor<<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing>> preProcessingPhaseObjectGraphVisitors = preProcessingPhaseObjectGraphVisitorFactories.BuildComponentList(typeConverters);
				foreach (<92aee588-b33c-4463-9466-9122baaeef73>IObjectGraphVisitor<<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing> item in preProcessingPhaseObjectGraphVisitors)
				{
					traversalStrategy.Traverse(graph, item, default(<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing));
				}
				<92aee588-b33c-4463-9466-9122baaeef73>IObjectGraphVisitor<<b96ede0e-ee5e-4739-a3da-760a5783be20>IEmitter> visitor = emissionPhaseObjectGraphVisitorFactories.BuildComponentChain(new <5efaf176-afc8-44f5-8048-158418ae5e9c>EmittingObjectGraphVisitor(eventEmitter), [<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(0)] (<92aee588-b33c-4463-9466-9122baaeef73>IObjectGraphVisitor<<b96ede0e-ee5e-4739-a3da-760a5783be20>IEmitter> inner) => new <ac4c0c44-6358-410b-aefe-1e1089b96aed>EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
				traversalStrategy.Traverse(graph, visitor, emitter);
				[<32eaa292-3ef3-4478-a815-82e63cefa21a>NullableContext(2)]
				void NestedObjectSerializer(object v, Type t)
				{
					SerializeValue(emitter, v, t);
				}
			}
		}

		private <f25d4d27-ee31-44e2-8ba2-ca75d3802c4c>ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory;

		private readonly <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<IEnumerable<<ded18eab-164c-46d9-9c89-720592ac6cec>IYamlTypeConverter>, <92aee588-b33c-4463-9466-9122baaeef73>IObjectGraphVisitor<<f5db8e5f-881e-4b3a-b34e-794a050e6ba7>Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

		private readonly <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<<ac4c0c44-6358-410b-aefe-1e1089b96aed>EmissionPhaseObjectGraphVisitorArgs, <92aee588-b33c-4463-9466-9122baaeef73>IObjectGraphVisitor<<b96ede0e-ee5e-4739-a3da-760a5783be20>IEmitter>> emissionPhaseObjectGraphVisitorFactories;

		private readonly <4125db90-a072-4fa3-b5e3-c3e8ca4927b5>LazyComponentRegistrationList<<f5d078b1-e904-4f7e-89bd-00d5b3e36461>IEventEmitter, <f5d078b1-e904-4f7e-89bd-00d5b3e36461>IEventEmitter> eventEmitterFactories;

		private readonly IDictionary<Type, <1f53c61d-84f5-44c6-a5c0-d72a1b28fcb4>TagName> tagMappings = new Dictionary<Type, <1f53c61d-84f5-44c6-a5c0-d72a1b28fcb4>TagName>();

		private int maximumRecursion = 50;

		private <faa3db03-7faf-4112-ba83-f5953fff2205>EmitterSettings emitterSettings = <faa3db03-7faf-4112-ba83-f5953fff2205>EmitterSettings.Default;

		private <ead2ece9-4510-4d84-97d5-e12dce07b06b>DefaultValuesHandling defaultValuesHandlingConfiguration;

		protected override <5d6567